4xm.c
Go to the documentation of this file.
1 /*
2  * 4XM codec
3  * Copyright (c) 2003 Michael Niedermayer
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
27 #include "libavutil/intreadwrite.h"
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "get_bits.h"
31 #include "bytestream.h"
32 
33 //#undef NDEBUG
34 //#include <assert.h>
35 
36 #define BLOCK_TYPE_VLC_BITS 5
37 #define ACDC_VLC_BITS 9
38 
39 #define CFRAME_BUFFER_COUNT 100
40 
41 static const uint8_t block_type_tab[2][4][8][2]={
42  {
43  { //{8,4,2}x{8,4,2}
44  { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
45  },{ //{8,4}x1
46  { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
47  },{ //1x{8,4}
48  { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
49  },{ //1x2, 2x1
50  { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
51  }
52  },{
53  { //{8,4,2}x{8,4,2}
54  { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0}
55  },{//{8,4}x1
56  { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0}
57  },{//1x{8,4}
58  { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0}
59  },{//1x2, 2x1
60  { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3}
61  }
62  }
63 };
64 
65 static const uint8_t size2index[4][4]={
66  {-1, 3, 1, 1},
67  { 3, 0, 0, 0},
68  { 2, 0, 0, 0},
69  { 2, 0, 0, 0},
70 };
71 
72 static const int8_t mv[256][2]={
73 { 0, 0},{ 0, -1},{ -1, 0},{ 1, 0},{ 0, 1},{ -1, -1},{ 1, -1},{ -1, 1},
74 { 1, 1},{ 0, -2},{ -2, 0},{ 2, 0},{ 0, 2},{ -1, -2},{ 1, -2},{ -2, -1},
75 { 2, -1},{ -2, 1},{ 2, 1},{ -1, 2},{ 1, 2},{ -2, -2},{ 2, -2},{ -2, 2},
76 { 2, 2},{ 0, -3},{ -3, 0},{ 3, 0},{ 0, 3},{ -1, -3},{ 1, -3},{ -3, -1},
77 { 3, -1},{ -3, 1},{ 3, 1},{ -1, 3},{ 1, 3},{ -2, -3},{ 2, -3},{ -3, -2},
78 { 3, -2},{ -3, 2},{ 3, 2},{ -2, 3},{ 2, 3},{ 0, -4},{ -4, 0},{ 4, 0},
79 { 0, 4},{ -1, -4},{ 1, -4},{ -4, -1},{ 4, -1},{ 4, 1},{ -1, 4},{ 1, 4},
80 { -3, -3},{ -3, 3},{ 3, 3},{ -2, -4},{ -4, -2},{ 4, -2},{ -4, 2},{ -2, 4},
81 { 2, 4},{ -3, -4},{ 3, -4},{ 4, -3},{ -5, 0},{ -4, 3},{ -3, 4},{ 3, 4},
82 { -1, -5},{ -5, -1},{ -5, 1},{ -1, 5},{ -2, -5},{ 2, -5},{ 5, -2},{ 5, 2},
83 { -4, -4},{ -4, 4},{ -3, -5},{ -5, -3},{ -5, 3},{ 3, 5},{ -6, 0},{ 0, 6},
84 { -6, -1},{ -6, 1},{ 1, 6},{ 2, -6},{ -6, 2},{ 2, 6},{ -5, -4},{ 5, 4},
85 { 4, 5},{ -6, -3},{ 6, 3},{ -7, 0},{ -1, -7},{ 5, -5},{ -7, 1},{ -1, 7},
86 { 4, -6},{ 6, 4},{ -2, -7},{ -7, 2},{ -3, -7},{ 7, -3},{ 3, 7},{ 6, -5},
87 { 0, -8},{ -1, -8},{ -7, -4},{ -8, 1},{ 4, 7},{ 2, -8},{ -2, 8},{ 6, 6},
88 { -8, 3},{ 5, -7},{ -5, 7},{ 8, -4},{ 0, -9},{ -9, -1},{ 1, 9},{ 7, -6},
89 { -7, 6},{ -5, -8},{ -5, 8},{ -9, 3},{ 9, -4},{ 7, -7},{ 8, -6},{ 6, 8},
90 { 10, 1},{-10, 2},{ 9, -5},{ 10, -3},{ -8, -7},{-10, -4},{ 6, -9},{-11, 0},
91 { 11, 1},{-11, -2},{ -2, 11},{ 7, -9},{ -7, 9},{ 10, 6},{ -4, 11},{ 8, -9},
92 { 8, 9},{ 5, 11},{ 7,-10},{ 12, -3},{ 11, 6},{ -9, -9},{ 8, 10},{ 5, 12},
93 {-11, 7},{ 13, 2},{ 6,-12},{ 10, 9},{-11, 8},{ -7, 12},{ 0, 14},{ 14, -2},
94 { -9, 11},{ -6, 13},{-14, -4},{ -5,-14},{ 5, 14},{-15, -1},{-14, -6},{ 3,-15},
95 { 11,-11},{ -7, 14},{ -5, 15},{ 8,-14},{ 15, 6},{ 3, 16},{ 7,-15},{-16, 5},
96 { 0, 17},{-16, -6},{-10, 14},{-16, 7},{ 12, 13},{-16, 8},{-17, 6},{-18, 3},
97 { -7, 17},{ 15, 11},{ 16, 10},{ 2,-19},{ 3,-19},{-11,-16},{-18, 8},{-19, -6},
98 { 2,-20},{-17,-11},{-10,-18},{ 8, 19},{-21, -1},{-20, 7},{ -4, 21},{ 21, 5},
99 { 15, 16},{ 2,-22},{-10,-20},{-22, 5},{ 20,-11},{ -7,-22},{-12, 20},{ 23, -5},
100 { 13,-20},{ 24, -2},{-15, 19},{-11, 22},{ 16, 19},{ 23,-10},{-18,-18},{ -9,-24},
101 { 24,-10},{ -3, 26},{-23, 13},{-18,-20},{ 17, 21},{ -4, 27},{ 27, 6},{ 1,-28},
102 {-11, 26},{-17,-23},{ 7, 28},{ 11,-27},{ 29, 5},{-23,-19},{-28,-11},{-21, 22},
103 {-30, 7},{-17, 26},{-27, 16},{ 13, 29},{ 19,-26},{ 10,-31},{-14,-30},{ 20,-27},
104 {-29, 18},{-16,-31},{-28,-22},{ 21,-30},{-25, 28},{ 26,-29},{ 25,-32},{-32,-32}
105 };
106 
107 // this is simply the scaled down elementwise product of the standard jpeg quantizer table and the AAN premul table
108 static const uint8_t dequant_table[64]={
109  16, 15, 13, 19, 24, 31, 28, 17,
110  17, 23, 25, 31, 36, 63, 45, 21,
111  18, 24, 27, 37, 52, 59, 49, 20,
112  16, 28, 34, 40, 60, 80, 51, 20,
113  18, 31, 48, 66, 68, 86, 56, 21,
114  19, 38, 56, 59, 64, 64, 48, 20,
115  27, 48, 55, 55, 56, 51, 35, 15,
116  20, 35, 34, 32, 31, 22, 15, 8,
117 };
118 
119 static VLC block_type_vlc[2][4];
120 
121 
122 typedef struct CFrameBuffer{
123  unsigned int allocated_size;
124  unsigned int size;
125  int id;
126  uint8_t *data;
127 }CFrameBuffer;
128 
129 typedef struct FourXContext{
137  int mv[256];
139  int last_dc;
142  unsigned int bitstream_buffer_size;
143  int version;
145 } FourXContext;
146 
147 
148 #define FIX_1_082392200 70936
149 #define FIX_1_414213562 92682
150 #define FIX_1_847759065 121095
151 #define FIX_2_613125930 171254
152 
153 #define MULTIPLY(var,const) (((var)*(const)) >> 16)
154 
155 static void idct(DCTELEM block[64]){
156  int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
157  int tmp10, tmp11, tmp12, tmp13;
158  int z5, z10, z11, z12, z13;
159  int i;
160  int temp[64];
161 
162  for(i=0; i<8; i++){
163  tmp10 = block[8*0 + i] + block[8*4 + i];
164  tmp11 = block[8*0 + i] - block[8*4 + i];
165 
166  tmp13 = block[8*2 + i] + block[8*6 + i];
167  tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
168 
169  tmp0 = tmp10 + tmp13;
170  tmp3 = tmp10 - tmp13;
171  tmp1 = tmp11 + tmp12;
172  tmp2 = tmp11 - tmp12;
173 
174  z13 = block[8*5 + i] + block[8*3 + i];
175  z10 = block[8*5 + i] - block[8*3 + i];
176  z11 = block[8*1 + i] + block[8*7 + i];
177  z12 = block[8*1 + i] - block[8*7 + i];
178 
179  tmp7 = z11 + z13;
180  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
181 
182  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
183  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
184  tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
185 
186  tmp6 = tmp12 - tmp7;
187  tmp5 = tmp11 - tmp6;
188  tmp4 = tmp10 + tmp5;
189 
190  temp[8*0 + i] = tmp0 + tmp7;
191  temp[8*7 + i] = tmp0 - tmp7;
192  temp[8*1 + i] = tmp1 + tmp6;
193  temp[8*6 + i] = tmp1 - tmp6;
194  temp[8*2 + i] = tmp2 + tmp5;
195  temp[8*5 + i] = tmp2 - tmp5;
196  temp[8*4 + i] = tmp3 + tmp4;
197  temp[8*3 + i] = tmp3 - tmp4;
198  }
199 
200  for(i=0; i<8*8; i+=8){
201  tmp10 = temp[0 + i] + temp[4 + i];
202  tmp11 = temp[0 + i] - temp[4 + i];
203 
204  tmp13 = temp[2 + i] + temp[6 + i];
205  tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
206 
207  tmp0 = tmp10 + tmp13;
208  tmp3 = tmp10 - tmp13;
209  tmp1 = tmp11 + tmp12;
210  tmp2 = tmp11 - tmp12;
211 
212  z13 = temp[5 + i] + temp[3 + i];
213  z10 = temp[5 + i] - temp[3 + i];
214  z11 = temp[1 + i] + temp[7 + i];
215  z12 = temp[1 + i] - temp[7 + i];
216 
217  tmp7 = z11 + z13;
218  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
219 
220  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
221  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
222  tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
223 
224  tmp6 = tmp12 - tmp7;
225  tmp5 = tmp11 - tmp6;
226  tmp4 = tmp10 + tmp5;
227 
228  block[0 + i] = (tmp0 + tmp7)>>6;
229  block[7 + i] = (tmp0 - tmp7)>>6;
230  block[1 + i] = (tmp1 + tmp6)>>6;
231  block[6 + i] = (tmp1 - tmp6)>>6;
232  block[2 + i] = (tmp2 + tmp5)>>6;
233  block[5 + i] = (tmp2 - tmp5)>>6;
234  block[4 + i] = (tmp3 + tmp4)>>6;
235  block[3 + i] = (tmp3 - tmp4)>>6;
236  }
237 }
238 
240  static VLC_TYPE table[8][32][2];
241  int i;
242 
243  for(i=0; i<8; i++){
244  block_type_vlc[0][i].table= table[i];
245  block_type_vlc[0][i].table_allocated= 32;
246  init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
247  &block_type_tab[0][i][0][1], 2, 1,
248  &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
249  }
250 }
251 
252 static void init_mv(FourXContext *f){
253  int i;
254 
255  for(i=0; i<256; i++){
256  if(f->version>1)
257  f->mv[i] = mv[i][0] + mv[i][1] *f->current_picture.linesize[0]/2;
258  else
259  f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
260  }
261 }
262 
263 #if HAVE_BIGENDIAN
264 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
265  { \
266  unsigned tmpval = AV_RN32(src); \
267  tmpval = (tmpval << 16) | (tmpval >> 16); \
268  tmpval = tmpval * (scale) + (dc); \
269  tmpval = (tmpval << 16) | (tmpval >> 16); \
270  AV_WN32A(dst, tmpval); \
271  }
272 #else
273 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
274  { \
275  unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
276  AV_WN32A(dst, tmpval); \
277  }
278 #endif
279 
280 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc){
281  int i;
282  dc*= 0x10001;
283 
284  switch(log2w){
285  case 0:
286  for(i=0; i<h; i++){
287  dst[0] = scale*src[0] + dc;
288  if(scale) src += stride;
289  dst += stride;
290  }
291  break;
292  case 1:
293  for(i=0; i<h; i++){
294  LE_CENTRIC_MUL(dst, src, scale, dc);
295  if(scale) src += stride;
296  dst += stride;
297  }
298  break;
299  case 2:
300  for(i=0; i<h; i++){
301  LE_CENTRIC_MUL(dst, src, scale, dc);
302  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
303  if(scale) src += stride;
304  dst += stride;
305  }
306  break;
307  case 3:
308  for(i=0; i<h; i++){
309  LE_CENTRIC_MUL(dst, src, scale, dc);
310  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
311  LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
312  LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
313  if(scale) src += stride;
314  dst += stride;
315  }
316  break;
317  default: assert(0);
318  }
319 }
320 
321 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
322  const int index= size2index[log2h][log2w];
323  const int h= 1<<log2h;
324  int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
325  uint16_t *start= (uint16_t*)f->last_picture.data[0];
326  uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
327 
328  assert(code>=0 && code<=6);
329 
330  if(code == 0){
331  src += f->mv[bytestream2_get_byte(&f->g)];
332  if(start > src || src > end){
333  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
334  return;
335  }
336  mcdc(dst, src, log2w, h, stride, 1, 0);
337  }else if(code == 1){
338  log2h--;
339  decode_p_block(f, dst , src , log2w, log2h, stride);
340  decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
341  }else if(code == 2){
342  log2w--;
343  decode_p_block(f, dst , src , log2w, log2h, stride);
344  decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
345  }else if(code == 3 && f->version<2){
346  mcdc(dst, src, log2w, h, stride, 1, 0);
347  }else if(code == 4){
348  src += f->mv[bytestream2_get_byte(&f->g)];
349  if(start > src || src > end){
350  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
351  return;
352  }
353  mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
354  }else if(code == 5){
355  mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
356  }else if(code == 6){
357  if(log2w){
358  dst[0] = bytestream2_get_le16(&f->g2);
359  dst[1] = bytestream2_get_le16(&f->g2);
360  }else{
361  dst[0 ] = bytestream2_get_le16(&f->g2);
362  dst[stride] = bytestream2_get_le16(&f->g2);
363  }
364  }
365 }
366 
367 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
368  int x, y;
369  const int width= f->avctx->width;
370  const int height= f->avctx->height;
371  uint16_t *src= (uint16_t*)f->last_picture.data[0];
372  uint16_t *dst= (uint16_t*)f->current_picture.data[0];
373  const int stride= f->current_picture.linesize[0]>>1;
374  unsigned int bitstream_size, bytestream_size, wordstream_size, extra, bytestream_offset, wordstream_offset;
375 
376  if(f->version>1){
377  extra=20;
378  bitstream_size= AV_RL32(buf+8);
379  wordstream_size= AV_RL32(buf+12);
380  bytestream_size= AV_RL32(buf+16);
381  }else{
382  extra=0;
383  bitstream_size = AV_RL16(buf-4);
384  wordstream_size= AV_RL16(buf-2);
385  bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
386  }
387 
388  if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
389  || bitstream_size > (1<<26)
390  || bytestream_size > (1<<26)
391  || wordstream_size > (1<<26)
392  ){
393  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
394  bitstream_size+ bytestream_size+ wordstream_size - length);
395  return -1;
396  }
397 
399  if (!f->bitstream_buffer)
400  return AVERROR(ENOMEM);
401  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
402  memset((uint8_t*)f->bitstream_buffer + bitstream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
403  init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
404 
405  wordstream_offset = extra + bitstream_size;
406  bytestream_offset = extra + bitstream_size + wordstream_size;
407  bytestream2_init(&f->g2, buf + wordstream_offset, length - wordstream_offset);
408  bytestream2_init(&f->g, buf + bytestream_offset, length - bytestream_offset);
409 
410  init_mv(f);
411 
412  for(y=0; y<height; y+=8){
413  for(x=0; x<width; x+=8){
414  decode_p_block(f, dst + x, src + x, 3, 3, stride);
415  }
416  src += 8*stride;
417  dst += 8*stride;
418  }
419 
420  return 0;
421 }
422 
428  int code, i, j, level, val;
429 
430  /* DC coef */
431  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
432  if (val>>4){
433  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
434  }
435 
436  if(val)
437  val = get_xbits(&f->gb, val);
438 
439  val = val * dequant_table[0] + f->last_dc;
440  f->last_dc =
441  block[0] = val;
442  /* AC coefs */
443  i = 1;
444  for(;;) {
445  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
446 
447  /* EOB */
448  if (code == 0)
449  break;
450  if (code == 0xf0) {
451  i += 16;
452  } else {
453  level = get_xbits(&f->gb, code & 0xf);
454  i += code >> 4;
455  if (i >= 64) {
456  av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
457  return 0;
458  }
459 
460  j= ff_zigzag_direct[i];
461  block[j] = level * dequant_table[j];
462  i++;
463  if (i >= 64)
464  break;
465  }
466  }
467 
468  return 0;
469 }
470 
471 static inline void idct_put(FourXContext *f, int x, int y){
472  DCTELEM (*block)[64]= f->block;
473  int stride= f->current_picture.linesize[0]>>1;
474  int i;
475  uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
476 
477  for(i=0; i<4; i++){
478  block[i][0] += 0x80*8*8;
479  idct(block[i]);
480  }
481 
482  if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
483  for(i=4; i<6; i++) idct(block[i]);
484  }
485 
486 /* Note transform is:
487 y= ( 1b + 4g + 2r)/14
488 cb=( 3b - 2g - 1r)/14
489 cr=(-1b - 4g + 5r)/14
490 */
491  for(y=0; y<8; y++){
492  for(x=0; x<8; x++){
493  DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
494  int cb= block[4][x + 8*y];
495  int cr= block[5][x + 8*y];
496  int cg= (cb + cr)>>1;
497  int y;
498 
499  cb+=cb;
500 
501  y = temp[0];
502  dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
503  y = temp[1];
504  dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
505  y = temp[8];
506  dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
507  y = temp[9];
508  dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
509  dst += 2;
510  }
511  dst += 2*stride - 2*8;
512  }
513 }
514 
516  int i;
517 
518  f->dsp.clear_blocks(f->block[0]);
519 
520  for(i=0; i<6; i++){
521  if(decode_i_block(f, f->block[i]) < 0)
522  return -1;
523  }
524 
525  return 0;
526 }
527 
528 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
529  int frequency[512];
530  uint8_t flag[512];
531  int up[512];
532  uint8_t len_tab[257];
533  int bits_tab[257];
534  int start, end;
535  const uint8_t *ptr= buf;
536  int j;
537 
538  memset(frequency, 0, sizeof(frequency));
539  memset(up, -1, sizeof(up));
540 
541  start= *ptr++;
542  end= *ptr++;
543  for(;;){
544  int i;
545 
546  for(i=start; i<=end; i++){
547  frequency[i]= *ptr++;
548  }
549  start= *ptr++;
550  if(start==0) break;
551 
552  end= *ptr++;
553  }
554  frequency[256]=1;
555 
556  while((ptr - buf)&3) ptr++; // 4byte align
557 
558  for(j=257; j<512; j++){
559  int min_freq[2]= {256*256, 256*256};
560  int smallest[2]= {0, 0};
561  int i;
562  for(i=0; i<j; i++){
563  if(frequency[i] == 0) continue;
564  if(frequency[i] < min_freq[1]){
565  if(frequency[i] < min_freq[0]){
566  min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
567  min_freq[0]= frequency[i];smallest[0]= i;
568  }else{
569  min_freq[1]= frequency[i];smallest[1]= i;
570  }
571  }
572  }
573  if(min_freq[1] == 256*256) break;
574 
575  frequency[j]= min_freq[0] + min_freq[1];
576  flag[ smallest[0] ]= 0;
577  flag[ smallest[1] ]= 1;
578  up[ smallest[0] ]=
579  up[ smallest[1] ]= j;
580  frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
581  }
582 
583  for(j=0; j<257; j++){
584  int node;
585  int len=0;
586  int bits=0;
587 
588  for(node= j; up[node] != -1; node= up[node]){
589  bits += flag[node]<<len;
590  len++;
591  if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
592  }
593 
594  bits_tab[j]= bits;
595  len_tab[j]= len;
596  }
597 
598  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
599  len_tab , 1, 1,
600  bits_tab, 4, 4, 0))
601  return NULL;
602 
603  return ptr;
604 }
605 
606 static int mix(int c0, int c1){
607  int blue = 2*(c0&0x001F) + (c1&0x001F);
608  int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
609  int red = 2*(c0>>10) + (c1>>10);
610  return red/3*1024 + green/3*32 + blue/3;
611 }
612 
613 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
614  int x, y, x2, y2;
615  const int width= f->avctx->width;
616  const int height= f->avctx->height;
617  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
618  uint16_t *dst= (uint16_t*)f->current_picture.data[0];
619  const int stride= f->current_picture.linesize[0]>>1;
620  GetByteContext g3;
621 
622  if(length < mbs * 8) {
623  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
624  return AVERROR_INVALIDDATA;
625  }
626  bytestream2_init(&g3, buf, length);
627 
628  for(y=0; y<height; y+=16){
629  for(x=0; x<width; x+=16){
630  unsigned int color[4], bits;
631  memset(color, 0, sizeof(color));
632 //warning following is purely guessed ...
633  color[0]= bytestream2_get_le16u(&g3);
634  color[1]= bytestream2_get_le16u(&g3);
635 
636  if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
637  if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
638 
639  color[2]= mix(color[0], color[1]);
640  color[3]= mix(color[1], color[0]);
641 
642  bits= bytestream2_get_le32u(&g3);
643  for(y2=0; y2<16; y2++){
644  for(x2=0; x2<16; x2++){
645  int index= 2*(x2>>2) + 8*(y2>>2);
646  dst[y2*stride+x2]= color[(bits>>index)&3];
647  }
648  }
649  dst+=16;
650  }
651  dst += 16 * stride - x;
652  }
653 
654  return 0;
655 }
656 
657 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
658  int x, y;
659  const int width= f->avctx->width;
660  const int height= f->avctx->height;
661  const unsigned int bitstream_size= AV_RL32(buf);
662  int token_count av_unused;
663  unsigned int prestream_size;
664  const uint8_t *prestream;
665 
666  if (length < bitstream_size + 12) {
667  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
668  return AVERROR_INVALIDDATA;
669  }
670 
671  token_count = AV_RL32(buf + bitstream_size + 8);
672  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
673  prestream = buf + bitstream_size + 12;
674 
675  if(prestream_size + bitstream_size + 12 != length
676  || bitstream_size > (1<<26)
677  || prestream_size > (1<<26)){
678  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
679  return -1;
680  }
681 
682  prestream= read_huffman_tables(f, prestream);
683 
684  init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
685 
686  prestream_size= length + buf - prestream;
687 
689  if (!f->bitstream_buffer)
690  return AVERROR(ENOMEM);
691  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
692  memset((uint8_t*)f->bitstream_buffer + prestream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
693  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
694 
695  f->last_dc= 0*128*8*8;
696 
697  for(y=0; y<height; y+=16){
698  for(x=0; x<width; x+=16){
699  if(decode_i_mb(f) < 0)
700  return -1;
701 
702  idct_put(f, x, y);
703  }
704  }
705 
706  if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
707  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
708 
709  return 0;
710 }
711 
712 static int decode_frame(AVCodecContext *avctx,
713  void *data, int *data_size,
714  AVPacket *avpkt)
715 {
716  const uint8_t *buf = avpkt->data;
717  int buf_size = avpkt->size;
718  FourXContext * const f = avctx->priv_data;
719  AVFrame *picture = data;
720  AVFrame *p, temp;
721  int i, frame_4cc, frame_size;
722 
723  frame_4cc= AV_RL32(buf);
724  if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
725  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
726  }
727 
728  if(frame_4cc == AV_RL32("cfrm")){
729  int free_index=-1;
730  const int data_size= buf_size - 20;
731  const int id= AV_RL32(buf+12);
732  const int whole_size= AV_RL32(buf+16);
733  CFrameBuffer *cfrm;
734 
735  for(i=0; i<CFRAME_BUFFER_COUNT; i++){
736  if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
737  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
738  }
739 
740  for(i=0; i<CFRAME_BUFFER_COUNT; i++){
741  if(f->cfrm[i].id == id) break;
742  if(f->cfrm[i].size == 0 ) free_index= i;
743  }
744 
745  if(i>=CFRAME_BUFFER_COUNT){
746  i= free_index;
747  f->cfrm[i].id= id;
748  }
749  cfrm= &f->cfrm[i];
750 
751  cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
752  if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
753  av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
754  return -1;
755  }
756 
757  memcpy(cfrm->data + cfrm->size, buf+20, data_size);
758  cfrm->size += data_size;
759 
760  if(cfrm->size >= whole_size){
761  buf= cfrm->data;
762  frame_size= cfrm->size;
763 
764  if(id != avctx->frame_number){
765  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
766  }
767 
768  cfrm->size= cfrm->id= 0;
769  frame_4cc= AV_RL32("pfrm");
770  }else
771  return buf_size;
772  }else{
773  buf= buf + 12;
774  frame_size= buf_size - 12;
775  }
776 
777  temp= f->current_picture;
779  f->last_picture= temp;
780 
781  p= &f->current_picture;
782  avctx->coded_frame= p;
783 
784  avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
785 
786  if(p->data[0])
787  avctx->release_buffer(avctx, p);
788 
789  p->reference= 1;
790  if(avctx->get_buffer(avctx, p) < 0){
791  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
792  return -1;
793  }
794 
795  if(frame_4cc == AV_RL32("ifr2")){
797  if(decode_i2_frame(f, buf-4, frame_size + 4) < 0)
798  return -1;
799  }else if(frame_4cc == AV_RL32("ifrm")){
801  if(decode_i_frame(f, buf, frame_size) < 0)
802  return -1;
803  }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
804  if(!f->last_picture.data[0]){
805  f->last_picture.reference= 1;
806  if(avctx->get_buffer(avctx, &f->last_picture) < 0){
807  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
808  return -1;
809  }
810  }
811 
813  if(decode_p_frame(f, buf, frame_size) < 0)
814  return -1;
815  }else if(frame_4cc == AV_RL32("snd_")){
816  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
817  }else{
818  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
819  }
820 
822 
823  *picture= *p;
824  *data_size = sizeof(AVPicture);
825 
826  emms_c();
827 
828  return buf_size;
829 }
830 
831 
832 static av_cold void common_init(AVCodecContext *avctx){
833  FourXContext * const f = avctx->priv_data;
834 
835  dsputil_init(&f->dsp, avctx);
836 
837  f->avctx= avctx;
838 }
839 
840 static av_cold int decode_init(AVCodecContext *avctx){
841  FourXContext * const f = avctx->priv_data;
842 
843  if(avctx->extradata_size != 4 || !avctx->extradata) {
844  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
845  return 1;
846  }
847 
848  f->version= AV_RL32(avctx->extradata)>>16;
849  common_init(avctx);
850  init_vlcs(f);
851 
852  if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
853  else avctx->pix_fmt= PIX_FMT_BGR555;
854 
855  return 0;
856 }
857 
858 
859 static av_cold int decode_end(AVCodecContext *avctx){
860  FourXContext * const f = avctx->priv_data;
861  int i;
862 
865  for(i=0; i<CFRAME_BUFFER_COUNT; i++){
866  av_freep(&f->cfrm[i].data);
867  f->cfrm[i].allocated_size= 0;
868  }
869  free_vlc(&f->pre_vlc);
870  if(f->current_picture.data[0])
871  avctx->release_buffer(avctx, &f->current_picture);
872  if(f->last_picture.data[0])
873  avctx->release_buffer(avctx, &f->last_picture);
874 
875  return 0;
876 }
877 
879  .name = "4xm",
880  .type = AVMEDIA_TYPE_VIDEO,
881  .id = CODEC_ID_4XM,
882  .priv_data_size = sizeof(FourXContext),
883  .init = decode_init,
884  .close = decode_end,
885  .decode = decode_frame,
886  .capabilities = CODEC_CAP_DR1,
887  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
888 };
889