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  if (start > src || src > end) {
347  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
348  return;
349  }
350  mcdc(dst, src, log2w, h, stride, 1, 0);
351  }else if(code == 4){
352  src += f->mv[bytestream2_get_byte(&f->g)];
353  if(start > src || src > end){
354  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
355  return;
356  }
357  mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
358  }else if(code == 5){
359  if (start > src || src > end) {
360  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
361  return;
362  }
363  mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
364  }else if(code == 6){
365  if(log2w){
366  dst[0] = bytestream2_get_le16(&f->g2);
367  dst[1] = bytestream2_get_le16(&f->g2);
368  }else{
369  dst[0 ] = bytestream2_get_le16(&f->g2);
370  dst[stride] = bytestream2_get_le16(&f->g2);
371  }
372  }
373 }
374 
375 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
376  int x, y;
377  const int width= f->avctx->width;
378  const int height= f->avctx->height;
379  uint16_t *src= (uint16_t*)f->last_picture.data[0];
380  uint16_t *dst= (uint16_t*)f->current_picture.data[0];
381  const int stride= f->current_picture.linesize[0]>>1;
382  unsigned int bitstream_size, bytestream_size, wordstream_size, extra, bytestream_offset, wordstream_offset;
383 
384  if(f->version>1){
385  extra=20;
386  bitstream_size= AV_RL32(buf+8);
387  wordstream_size= AV_RL32(buf+12);
388  bytestream_size= AV_RL32(buf+16);
389  }else{
390  extra=0;
391  bitstream_size = AV_RL16(buf-4);
392  wordstream_size= AV_RL16(buf-2);
393  bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
394  }
395 
396  if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
397  || bitstream_size > (1<<26)
398  || bytestream_size > (1<<26)
399  || wordstream_size > (1<<26)
400  ){
401  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
402  bitstream_size+ bytestream_size+ wordstream_size - length);
403  return -1;
404  }
405 
407  if (!f->bitstream_buffer)
408  return AVERROR(ENOMEM);
409  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
410  memset((uint8_t*)f->bitstream_buffer + bitstream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
411  init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
412 
413  wordstream_offset = extra + bitstream_size;
414  bytestream_offset = extra + bitstream_size + wordstream_size;
415  bytestream2_init(&f->g2, buf + wordstream_offset, length - wordstream_offset);
416  bytestream2_init(&f->g, buf + bytestream_offset, length - bytestream_offset);
417 
418  init_mv(f);
419 
420  for(y=0; y<height; y+=8){
421  for(x=0; x<width; x+=8){
422  decode_p_block(f, dst + x, src + x, 3, 3, stride);
423  }
424  src += 8*stride;
425  dst += 8*stride;
426  }
427 
428  return 0;
429 }
430 
436  int code, i, j, level, val;
437 
438  /* DC coef */
439  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
440  if (val>>4){
441  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
442  }
443 
444  if(val)
445  val = get_xbits(&f->gb, val);
446 
447  val = val * dequant_table[0] + f->last_dc;
448  f->last_dc =
449  block[0] = val;
450  /* AC coefs */
451  i = 1;
452  for(;;) {
453  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
454 
455  /* EOB */
456  if (code == 0)
457  break;
458  if (code == 0xf0) {
459  i += 16;
460  } else {
461  level = get_xbits(&f->gb, code & 0xf);
462  i += code >> 4;
463  if (i >= 64) {
464  av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
465  return 0;
466  }
467 
468  j= ff_zigzag_direct[i];
469  block[j] = level * dequant_table[j];
470  i++;
471  if (i >= 64)
472  break;
473  }
474  }
475 
476  return 0;
477 }
478 
479 static inline void idct_put(FourXContext *f, int x, int y){
480  DCTELEM (*block)[64]= f->block;
481  int stride= f->current_picture.linesize[0]>>1;
482  int i;
483  uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
484 
485  for(i=0; i<4; i++){
486  block[i][0] += 0x80*8*8;
487  idct(block[i]);
488  }
489 
490  if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
491  for(i=4; i<6; i++) idct(block[i]);
492  }
493 
494 /* Note transform is:
495 y= ( 1b + 4g + 2r)/14
496 cb=( 3b - 2g - 1r)/14
497 cr=(-1b - 4g + 5r)/14
498 */
499  for(y=0; y<8; y++){
500  for(x=0; x<8; x++){
501  DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
502  int cb= block[4][x + 8*y];
503  int cr= block[5][x + 8*y];
504  int cg= (cb + cr)>>1;
505  int y;
506 
507  cb+=cb;
508 
509  y = temp[0];
510  dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
511  y = temp[1];
512  dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
513  y = temp[8];
514  dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
515  y = temp[9];
516  dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
517  dst += 2;
518  }
519  dst += 2*stride - 2*8;
520  }
521 }
522 
524  int i;
525 
526  f->dsp.clear_blocks(f->block[0]);
527 
528  for(i=0; i<6; i++){
529  if(decode_i_block(f, f->block[i]) < 0)
530  return -1;
531  }
532 
533  return 0;
534 }
535 
536 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
537  int frequency[512];
538  uint8_t flag[512];
539  int up[512];
540  uint8_t len_tab[257];
541  int bits_tab[257];
542  int start, end;
543  const uint8_t *ptr= buf;
544  int j;
545 
546  memset(frequency, 0, sizeof(frequency));
547  memset(up, -1, sizeof(up));
548 
549  start= *ptr++;
550  end= *ptr++;
551  for(;;){
552  int i;
553 
554  for(i=start; i<=end; i++){
555  frequency[i]= *ptr++;
556  }
557  start= *ptr++;
558  if(start==0) break;
559 
560  end= *ptr++;
561  }
562  frequency[256]=1;
563 
564  while((ptr - buf)&3) ptr++; // 4byte align
565 
566  for(j=257; j<512; j++){
567  int min_freq[2]= {256*256, 256*256};
568  int smallest[2]= {0, 0};
569  int i;
570  for(i=0; i<j; i++){
571  if(frequency[i] == 0) continue;
572  if(frequency[i] < min_freq[1]){
573  if(frequency[i] < min_freq[0]){
574  min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
575  min_freq[0]= frequency[i];smallest[0]= i;
576  }else{
577  min_freq[1]= frequency[i];smallest[1]= i;
578  }
579  }
580  }
581  if(min_freq[1] == 256*256) break;
582 
583  frequency[j]= min_freq[0] + min_freq[1];
584  flag[ smallest[0] ]= 0;
585  flag[ smallest[1] ]= 1;
586  up[ smallest[0] ]=
587  up[ smallest[1] ]= j;
588  frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
589  }
590 
591  for(j=0; j<257; j++){
592  int node;
593  int len=0;
594  int bits=0;
595 
596  for(node= j; up[node] != -1; node= up[node]){
597  bits += flag[node]<<len;
598  len++;
599  if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
600  }
601 
602  bits_tab[j]= bits;
603  len_tab[j]= len;
604  }
605 
606  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
607  len_tab , 1, 1,
608  bits_tab, 4, 4, 0))
609  return NULL;
610 
611  return ptr;
612 }
613 
614 static int mix(int c0, int c1){
615  int blue = 2*(c0&0x001F) + (c1&0x001F);
616  int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
617  int red = 2*(c0>>10) + (c1>>10);
618  return red/3*1024 + green/3*32 + blue/3;
619 }
620 
621 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
622  int x, y, x2, y2;
623  const int width= f->avctx->width;
624  const int height= f->avctx->height;
625  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
626  uint16_t *dst= (uint16_t*)f->current_picture.data[0];
627  const int stride= f->current_picture.linesize[0]>>1;
628  GetByteContext g3;
629 
630  if(length < mbs * 8) {
631  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
632  return AVERROR_INVALIDDATA;
633  }
634  bytestream2_init(&g3, buf, length);
635 
636  for(y=0; y<height; y+=16){
637  for(x=0; x<width; x+=16){
638  unsigned int color[4], bits;
639  memset(color, 0, sizeof(color));
640 //warning following is purely guessed ...
641  color[0]= bytestream2_get_le16u(&g3);
642  color[1]= bytestream2_get_le16u(&g3);
643 
644  if(color[0]&0x8000) av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
645  if(color[1]&0x8000) av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
646 
647  color[2]= mix(color[0], color[1]);
648  color[3]= mix(color[1], color[0]);
649 
650  bits= bytestream2_get_le32u(&g3);
651  for(y2=0; y2<16; y2++){
652  for(x2=0; x2<16; x2++){
653  int index= 2*(x2>>2) + 8*(y2>>2);
654  dst[y2*stride+x2]= color[(bits>>index)&3];
655  }
656  }
657  dst+=16;
658  }
659  dst += 16 * stride - x;
660  }
661 
662  return 0;
663 }
664 
665 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
666  int x, y;
667  const int width= f->avctx->width;
668  const int height= f->avctx->height;
669  const unsigned int bitstream_size= AV_RL32(buf);
670  int token_count av_unused;
671  unsigned int prestream_size;
672  const uint8_t *prestream;
673 
674  if (bitstream_size > (1 << 26))
675  return AVERROR_INVALIDDATA;
676 
677  if (length < bitstream_size + 12) {
678  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
679  return AVERROR_INVALIDDATA;
680  }
681 
682  token_count = AV_RL32(buf + bitstream_size + 8);
683  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
684  prestream = buf + bitstream_size + 12;
685 
686  if(prestream_size + bitstream_size + 12 != length
687  || prestream_size > (1<<26)){
688  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
689  return -1;
690  }
691 
692  prestream = read_huffman_tables(f, prestream);
693  if (!prestream) {
694  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
695  return AVERROR_INVALIDDATA;
696  }
697 
698  init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
699 
700  prestream_size= length + buf - prestream;
701 
703  if (!f->bitstream_buffer)
704  return AVERROR(ENOMEM);
705  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
706  memset((uint8_t*)f->bitstream_buffer + prestream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
707  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
708 
709  f->last_dc= 0*128*8*8;
710 
711  for(y=0; y<height; y+=16){
712  for(x=0; x<width; x+=16){
713  if(decode_i_mb(f) < 0)
714  return -1;
715 
716  idct_put(f, x, y);
717  }
718  }
719 
720  if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
721  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
722 
723  return 0;
724 }
725 
726 static int decode_frame(AVCodecContext *avctx,
727  void *data, int *data_size,
728  AVPacket *avpkt)
729 {
730  const uint8_t *buf = avpkt->data;
731  int buf_size = avpkt->size;
732  FourXContext * const f = avctx->priv_data;
733  AVFrame *picture = data;
734  AVFrame *p, temp;
735  int i, frame_4cc, frame_size;
736 
737  frame_4cc= AV_RL32(buf);
738  if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
739  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
740  }
741 
742  if(frame_4cc == AV_RL32("cfrm")){
743  int free_index=-1;
744  const int data_size= buf_size - 20;
745  const int id= AV_RL32(buf+12);
746  const int whole_size= AV_RL32(buf+16);
747  CFrameBuffer *cfrm;
748 
749  for(i=0; i<CFRAME_BUFFER_COUNT; i++){
750  if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
751  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
752  }
753 
754  for(i=0; i<CFRAME_BUFFER_COUNT; i++){
755  if(f->cfrm[i].id == id) break;
756  if(f->cfrm[i].size == 0 ) free_index= i;
757  }
758 
759  if(i>=CFRAME_BUFFER_COUNT){
760  i= free_index;
761  f->cfrm[i].id= id;
762  }
763  cfrm= &f->cfrm[i];
764 
765  cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
766  if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
767  av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
768  return -1;
769  }
770 
771  memcpy(cfrm->data + cfrm->size, buf+20, data_size);
772  cfrm->size += data_size;
773 
774  if(cfrm->size >= whole_size){
775  buf= cfrm->data;
776  frame_size= cfrm->size;
777 
778  if(id != avctx->frame_number){
779  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
780  }
781 
782  if (f->version <= 1)
783  return AVERROR_INVALIDDATA;
784 
785  cfrm->size= cfrm->id= 0;
786  frame_4cc= AV_RL32("pfrm");
787  }else
788  return buf_size;
789  }else{
790  buf= buf + 12;
791  frame_size= buf_size - 12;
792  }
793 
794  temp= f->current_picture;
796  f->last_picture= temp;
797 
798  p= &f->current_picture;
799  avctx->coded_frame= p;
800 
801  avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
802 
803  if(p->data[0])
804  avctx->release_buffer(avctx, p);
805 
806  p->reference= 1;
807  if(avctx->get_buffer(avctx, p) < 0){
808  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
809  return -1;
810  }
811 
812  if(frame_4cc == AV_RL32("ifr2")){
814  if(decode_i2_frame(f, buf-4, frame_size + 4) < 0)
815  return -1;
816  }else if(frame_4cc == AV_RL32("ifrm")){
818  if(decode_i_frame(f, buf, frame_size) < 0)
819  return -1;
820  }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
821  if(!f->last_picture.data[0]){
822  f->last_picture.reference= 1;
823  if(avctx->get_buffer(avctx, &f->last_picture) < 0){
824  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
825  return -1;
826  }
827  memset(f->last_picture.data[0], 0, avctx->height * FFABS(f->last_picture.linesize[0]));
828  }
829 
831  if(decode_p_frame(f, buf, frame_size) < 0)
832  return -1;
833  }else if(frame_4cc == AV_RL32("snd_")){
834  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
835  }else{
836  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
837  }
838 
840 
841  *picture= *p;
842  *data_size = sizeof(AVPicture);
843 
844  emms_c();
845 
846  return buf_size;
847 }
848 
849 
850 static av_cold void common_init(AVCodecContext *avctx){
851  FourXContext * const f = avctx->priv_data;
852 
853  dsputil_init(&f->dsp, avctx);
854 
855  f->avctx= avctx;
856 }
857 
858 static av_cold int decode_init(AVCodecContext *avctx){
859  FourXContext * const f = avctx->priv_data;
860 
861  if(avctx->extradata_size != 4 || !avctx->extradata) {
862  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
863  return 1;
864  }
865 
866  f->version= AV_RL32(avctx->extradata)>>16;
867  common_init(avctx);
868  init_vlcs(f);
869 
870  if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
871  else avctx->pix_fmt= PIX_FMT_BGR555;
872 
873  return 0;
874 }
875 
876 
877 static av_cold int decode_end(AVCodecContext *avctx){
878  FourXContext * const f = avctx->priv_data;
879  int i;
880 
883  for(i=0; i<CFRAME_BUFFER_COUNT; i++){
884  av_freep(&f->cfrm[i].data);
885  f->cfrm[i].allocated_size= 0;
886  }
887  ff_free_vlc(&f->pre_vlc);
888  if(f->current_picture.data[0])
889  avctx->release_buffer(avctx, &f->current_picture);
890  if(f->last_picture.data[0])
891  avctx->release_buffer(avctx, &f->last_picture);
892 
893  return 0;
894 }
895 
897  .name = "4xm",
898  .type = AVMEDIA_TYPE_VIDEO,
899  .id = CODEC_ID_4XM,
900  .priv_data_size = sizeof(FourXContext),
901  .init = decode_init,
902  .close = decode_end,
903  .decode = decode_frame,
904  .capabilities = CODEC_CAP_DR1,
905  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
906 };
907