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