00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00047 #include <stdio.h>
00048 #include <stdlib.h>
00049 #include <string.h>
00050 #include <unistd.h>
00051
00052 #include "avcodec.h"
00053
00054 #define HUFFMAN_TABLE_SIZE 64 * 1024
00055 #define HUF_TOKENS 256
00056 #define PALETTE_COUNT 256
00057
00058 typedef struct
00059 {
00060 int count;
00061 unsigned char used;
00062 int children[2];
00063 } hnode;
00064
00065 typedef struct IdcinContext {
00066
00067 AVCodecContext *avctx;
00068 AVFrame frame;
00069
00070 const unsigned char *buf;
00071 int size;
00072
00073 hnode huff_nodes[256][HUF_TOKENS*2];
00074 int num_huff_nodes[256];
00075
00076 } IdcinContext;
00077
00078
00079
00080
00081
00082
00083
00084 static int huff_smallest_node(hnode *hnodes, int num_hnodes) {
00085 int i;
00086 int best, best_node;
00087
00088 best = 99999999;
00089 best_node = -1;
00090 for(i = 0; i < num_hnodes; i++) {
00091 if(hnodes[i].used)
00092 continue;
00093 if(!hnodes[i].count)
00094 continue;
00095 if(hnodes[i].count < best) {
00096 best = hnodes[i].count;
00097 best_node = i;
00098 }
00099 }
00100
00101 if(best_node == -1)
00102 return -1;
00103 hnodes[best_node].used = 1;
00104 return best_node;
00105 }
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116 static av_cold void huff_build_tree(IdcinContext *s, int prev) {
00117 hnode *node, *hnodes;
00118 int num_hnodes, i;
00119
00120 num_hnodes = HUF_TOKENS;
00121 hnodes = s->huff_nodes[prev];
00122 for(i = 0; i < HUF_TOKENS * 2; i++)
00123 hnodes[i].used = 0;
00124
00125 while (1) {
00126 node = &hnodes[num_hnodes];
00127
00128
00129 node->children[0] = huff_smallest_node(hnodes, num_hnodes);
00130 if(node->children[0] == -1)
00131 break;
00132
00133 node->children[1] = huff_smallest_node(hnodes, num_hnodes);
00134 if(node->children[1] == -1)
00135 break;
00136
00137
00138 node->count = hnodes[node->children[0]].count +
00139 hnodes[node->children[1]].count;
00140 num_hnodes++;
00141 }
00142
00143 s->num_huff_nodes[prev] = num_hnodes - 1;
00144 }
00145
00146 static av_cold int idcin_decode_init(AVCodecContext *avctx)
00147 {
00148 IdcinContext *s = avctx->priv_data;
00149 int i, j, histogram_index = 0;
00150 unsigned char *histograms;
00151
00152 s->avctx = avctx;
00153 avctx->pix_fmt = PIX_FMT_PAL8;
00154
00155
00156 if (s->avctx->extradata_size != HUFFMAN_TABLE_SIZE) {
00157 av_log(s->avctx, AV_LOG_ERROR, " id CIN video: expected extradata size of %d\n", HUFFMAN_TABLE_SIZE);
00158 return -1;
00159 }
00160
00161
00162 histograms = (unsigned char *)s->avctx->extradata;
00163 for (i = 0; i < 256; i++) {
00164 for(j = 0; j < HUF_TOKENS; j++)
00165 s->huff_nodes[i][j].count = histograms[histogram_index++];
00166 huff_build_tree(s, i);
00167 }
00168
00169 s->frame.data[0] = NULL;
00170
00171 return 0;
00172 }
00173
00174 static void idcin_decode_vlcs(IdcinContext *s)
00175 {
00176 hnode *hnodes;
00177 long x, y;
00178 int prev;
00179 unsigned char v = 0;
00180 int bit_pos, node_num, dat_pos;
00181
00182 prev = bit_pos = dat_pos = 0;
00183 for (y = 0; y < (s->frame.linesize[0] * s->avctx->height);
00184 y += s->frame.linesize[0]) {
00185 for (x = y; x < y + s->avctx->width; x++) {
00186 node_num = s->num_huff_nodes[prev];
00187 hnodes = s->huff_nodes[prev];
00188
00189 while(node_num >= HUF_TOKENS) {
00190 if(!bit_pos) {
00191 if(dat_pos >= s->size) {
00192 av_log(s->avctx, AV_LOG_ERROR, "Huffman decode error.\n");
00193 return;
00194 }
00195 bit_pos = 8;
00196 v = s->buf[dat_pos++];
00197 }
00198
00199 node_num = hnodes[node_num].children[v & 0x01];
00200 v = v >> 1;
00201 bit_pos--;
00202 }
00203
00204 s->frame.data[0][x] = node_num;
00205 prev = node_num;
00206 }
00207 }
00208 }
00209
00210 static int idcin_decode_frame(AVCodecContext *avctx,
00211 void *data, int *data_size,
00212 const uint8_t *buf, int buf_size)
00213 {
00214 IdcinContext *s = avctx->priv_data;
00215 AVPaletteControl *palette_control = avctx->palctrl;
00216
00217 s->buf = buf;
00218 s->size = buf_size;
00219
00220 if (s->frame.data[0])
00221 avctx->release_buffer(avctx, &s->frame);
00222
00223 if (avctx->get_buffer(avctx, &s->frame)) {
00224 av_log(avctx, AV_LOG_ERROR, " id CIN Video: get_buffer() failed\n");
00225 return -1;
00226 }
00227
00228 idcin_decode_vlcs(s);
00229
00230
00231 memcpy(s->frame.data[1], palette_control->palette, PALETTE_COUNT * 4);
00232
00233 if (palette_control->palette_changed) {
00234 palette_control->palette_changed = 0;
00235 s->frame.palette_has_changed = 1;
00236 }
00237
00238 *data_size = sizeof(AVFrame);
00239 *(AVFrame*)data = s->frame;
00240
00241
00242 return buf_size;
00243 }
00244
00245 static av_cold int idcin_decode_end(AVCodecContext *avctx)
00246 {
00247 IdcinContext *s = avctx->priv_data;
00248
00249 if (s->frame.data[0])
00250 avctx->release_buffer(avctx, &s->frame);
00251
00252 return 0;
00253 }
00254
00255 AVCodec idcin_decoder = {
00256 "idcinvideo",
00257 CODEC_TYPE_VIDEO,
00258 CODEC_ID_IDCIN,
00259 sizeof(IdcinContext),
00260 idcin_decode_init,
00261 NULL,
00262 idcin_decode_end,
00263 idcin_decode_frame,
00264 CODEC_CAP_DR1,
00265 .long_name = NULL_IF_CONFIG_SMALL("id Quake II CIN video"),
00266 };
00267