Libav
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/frame.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/intreadwrite.h"
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "dsputil.h"
33 #include "get_bits.h"
34 #include "internal.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 } x 1
46  { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
47  }, { // 1 x { 8, 4 }
48  { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49  }, { // 1 x 2, 2 x 1
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 } x 1
56  { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57  }, {// 1 x { 8, 4 }
58  { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59  }, {// 1 x 2, 2 x 1
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
108  * quantizer table and the AAN premul table. */
109 static const uint8_t dequant_table[64] = {
110  16, 15, 13, 19, 24, 31, 28, 17,
111  17, 23, 25, 31, 36, 63, 45, 21,
112  18, 24, 27, 37, 52, 59, 49, 20,
113  16, 28, 34, 40, 60, 80, 51, 20,
114  18, 31, 48, 66, 68, 86, 56, 21,
115  19, 38, 56, 59, 64, 64, 48, 20,
116  27, 48, 55, 55, 56, 51, 35, 15,
117  20, 35, 34, 32, 31, 22, 15, 8,
118 };
119 
120 static VLC block_type_vlc[2][4];
121 
122 
123 typedef struct CFrameBuffer {
124  unsigned int allocated_size;
125  unsigned int size;
126  int id;
128 } CFrameBuffer;
129 
130 typedef struct FourXContext {
133  uint16_t *frame_buffer;
134  uint16_t *last_frame_buffer;
139  int mv[256];
141  int last_dc;
142  DECLARE_ALIGNED(16, int16_t, block)[6][64];
144  unsigned int bitstream_buffer_size;
145  int version;
147 } FourXContext;
148 
149 
150 #define FIX_1_082392200 70936
151 #define FIX_1_414213562 92682
152 #define FIX_1_847759065 121095
153 #define FIX_2_613125930 171254
154 
155 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
156 
157 static void idct(int16_t block[64])
158 {
159  int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
160  int tmp10, tmp11, tmp12, tmp13;
161  int z5, z10, z11, z12, z13;
162  int i;
163  int temp[64];
164 
165  for (i = 0; i < 8; i++) {
166  tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
167  tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
168 
169  tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
170  tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
171 
172  tmp0 = tmp10 + tmp13;
173  tmp3 = tmp10 - tmp13;
174  tmp1 = tmp11 + tmp12;
175  tmp2 = tmp11 - tmp12;
176 
177  z13 = block[8 * 5 + i] + block[8 * 3 + i];
178  z10 = block[8 * 5 + i] - block[8 * 3 + i];
179  z11 = block[8 * 1 + i] + block[8 * 7 + i];
180  z12 = block[8 * 1 + i] - block[8 * 7 + i];
181 
182  tmp7 = z11 + z13;
183  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
184 
185  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
186  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
187  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
188 
189  tmp6 = tmp12 - tmp7;
190  tmp5 = tmp11 - tmp6;
191  tmp4 = tmp10 + tmp5;
192 
193  temp[8 * 0 + i] = tmp0 + tmp7;
194  temp[8 * 7 + i] = tmp0 - tmp7;
195  temp[8 * 1 + i] = tmp1 + tmp6;
196  temp[8 * 6 + i] = tmp1 - tmp6;
197  temp[8 * 2 + i] = tmp2 + tmp5;
198  temp[8 * 5 + i] = tmp2 - tmp5;
199  temp[8 * 4 + i] = tmp3 + tmp4;
200  temp[8 * 3 + i] = tmp3 - tmp4;
201  }
202 
203  for (i = 0; i < 8 * 8; i += 8) {
204  tmp10 = temp[0 + i] + temp[4 + i];
205  tmp11 = temp[0 + i] - temp[4 + i];
206 
207  tmp13 = temp[2 + i] + temp[6 + i];
208  tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
209 
210  tmp0 = tmp10 + tmp13;
211  tmp3 = tmp10 - tmp13;
212  tmp1 = tmp11 + tmp12;
213  tmp2 = tmp11 - tmp12;
214 
215  z13 = temp[5 + i] + temp[3 + i];
216  z10 = temp[5 + i] - temp[3 + i];
217  z11 = temp[1 + i] + temp[7 + i];
218  z12 = temp[1 + i] - temp[7 + i];
219 
220  tmp7 = z11 + z13;
221  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
222 
223  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
224  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
225  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
226 
227  tmp6 = tmp12 - tmp7;
228  tmp5 = tmp11 - tmp6;
229  tmp4 = tmp10 + tmp5;
230 
231  block[0 + i] = (tmp0 + tmp7) >> 6;
232  block[7 + i] = (tmp0 - tmp7) >> 6;
233  block[1 + i] = (tmp1 + tmp6) >> 6;
234  block[6 + i] = (tmp1 - tmp6) >> 6;
235  block[2 + i] = (tmp2 + tmp5) >> 6;
236  block[5 + i] = (tmp2 - tmp5) >> 6;
237  block[4 + i] = (tmp3 + tmp4) >> 6;
238  block[3 + i] = (tmp3 - tmp4) >> 6;
239  }
240 }
241 
243 {
244  static VLC_TYPE table[2][4][32][2];
245  int i, j;
246 
247  for (i = 0; i < 2; i++) {
248  for (j = 0; j < 4; j++) {
249  block_type_vlc[i][j].table = table[i][j];
250  block_type_vlc[i][j].table_allocated = 32;
251  init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
252  &block_type_tab[i][j][0][1], 2, 1,
253  &block_type_tab[i][j][0][0], 2, 1,
255  }
256  }
257 }
258 
259 static void init_mv(FourXContext *f, int linesize)
260 {
261  int i;
262 
263  for (i = 0; i < 256; i++) {
264  if (f->version > 1)
265  f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
266  else
267  f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
268  }
269 }
270 
271 #if HAVE_BIGENDIAN
272 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
273  { \
274  unsigned tmpval = AV_RN32(src); \
275  tmpval = (tmpval << 16) | (tmpval >> 16); \
276  tmpval = tmpval * (scale) + (dc); \
277  tmpval = (tmpval << 16) | (tmpval >> 16); \
278  AV_WN32A(dst, tmpval); \
279  }
280 #else
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
282  { \
283  unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
284  AV_WN32A(dst, tmpval); \
285  }
286 #endif
287 
288 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w,
289  int h, int stride, int scale, unsigned dc)
290 {
291  int i;
292  dc *= 0x10001;
293 
294  switch (log2w) {
295  case 0:
296  for (i = 0; i < h; i++) {
297  dst[0] = scale * src[0] + dc;
298  if (scale)
299  src += stride;
300  dst += stride;
301  }
302  break;
303  case 1:
304  for (i = 0; i < h; i++) {
305  LE_CENTRIC_MUL(dst, src, scale, dc);
306  if (scale)
307  src += stride;
308  dst += stride;
309  }
310  break;
311  case 2:
312  for (i = 0; i < h; i++) {
313  LE_CENTRIC_MUL(dst, src, scale, dc);
314  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
315  if (scale)
316  src += stride;
317  dst += stride;
318  }
319  break;
320  case 3:
321  for (i = 0; i < h; i++) {
322  LE_CENTRIC_MUL(dst, src, scale, dc);
323  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
324  LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
325  LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
326  if (scale)
327  src += stride;
328  dst += stride;
329  }
330  break;
331  default:
332  break;
333  }
334 }
335 
336 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
337  int log2w, int log2h, int stride)
338 {
339  const int index = size2index[log2h][log2w];
340  const int h = 1 << log2h;
341  int code = get_vlc2(&f->gb,
342  block_type_vlc[1 - (f->version > 1)][index].table,
344  uint16_t *start = f->last_frame_buffer;
345  uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
346  int ret;
347  int scale = 1;
348  unsigned dc = 0;
349 
350  if (code < 0 || code > 6 || log2w < 0)
351  return AVERROR_INVALIDDATA;
352 
353  if (code == 1) {
354  log2h--;
355  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
356  return ret;
357  return decode_p_block(f, dst + (stride << log2h),
358  src + (stride << log2h),
359  log2w, log2h, stride);
360  } else if (code == 2) {
361  log2w--;
362  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
363  return ret;
364  return decode_p_block(f, dst + (1 << log2w),
365  src + (1 << log2w),
366  log2w, log2h, stride);
367  } else if (code == 6) {
368  if (log2w) {
369  dst[0] = bytestream2_get_le16(&f->g2);
370  dst[1] = bytestream2_get_le16(&f->g2);
371  } else {
372  dst[0] = bytestream2_get_le16(&f->g2);
373  dst[stride] = bytestream2_get_le16(&f->g2);
374  }
375  return 0;
376  }
377 
378  if (code == 0) {
379  src += f->mv[bytestream2_get_byte(&f->g)];
380  } else if (code == 3 && f->version >= 2) {
381  return 0;
382  } else if (code == 4) {
383  src += f->mv[bytestream2_get_byte(&f->g)];
384  dc = bytestream2_get_le16(&f->g2);
385  } else if (code == 5) {
386  scale = 0;
387  dc = bytestream2_get_le16(&f->g2);
388  }
389 
390  if (start > src || src > end) {
391  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
392  return AVERROR_INVALIDDATA;
393  }
394 
395  mcdc(dst, src, log2w, h, stride, scale, dc);
396 
397  return 0;
398 }
399 
400 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
401 {
402  int x, y;
403  const int width = f->avctx->width;
404  const int height = f->avctx->height;
405  uint16_t *dst = f->frame_buffer;
406  uint16_t *src;
407  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
408  bytestream_offset, wordstream_offset;
409  int ret;
410 
411  src = f->last_frame_buffer;
412 
413  if (f->version > 1) {
414  if (length < 20)
415  return AVERROR_INVALIDDATA;
416  extra = 20;
417  bitstream_size = AV_RL32(buf + 8);
418  wordstream_size = AV_RL32(buf + 12);
419  bytestream_size = AV_RL32(buf + 16);
420  } else {
421  extra = 0;
422  bitstream_size = AV_RL16(buf - 4);
423  wordstream_size = AV_RL16(buf - 2);
424  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
425  }
426 
427  if (bitstream_size + bytestream_size + wordstream_size + extra != length
428  || bitstream_size > (1 << 26)
429  || bytestream_size > (1 << 26)
430  || wordstream_size > (1 << 26)) {
431  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
432  bitstream_size, bytestream_size, wordstream_size,
433  bitstream_size + bytestream_size + wordstream_size - length);
434  return AVERROR_INVALIDDATA;
435  }
436 
438  bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
439  if (!f->bitstream_buffer)
440  return AVERROR(ENOMEM);
441  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
442  bitstream_size / 4);
443  memset((uint8_t*)f->bitstream_buffer + bitstream_size,
445  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
446 
447  wordstream_offset = extra + bitstream_size;
448  bytestream_offset = extra + bitstream_size + wordstream_size;
449  bytestream2_init(&f->g2, buf + wordstream_offset,
450  length - wordstream_offset);
451  bytestream2_init(&f->g, buf + bytestream_offset,
452  length - bytestream_offset);
453 
454  init_mv(f, width * 2);
455 
456  for (y = 0; y < height; y += 8) {
457  for (x = 0; x < width; x += 8)
458  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
459  return ret;
460  src += 8 * width;
461  dst += 8 * width;
462  }
463 
464  return 0;
465 }
466 
471 static int decode_i_block(FourXContext *f, int16_t *block)
472 {
473  int code, i, j, level, val;
474 
475  /* DC coef */
476  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
477  if (val >> 4)
478  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
479 
480  if (val)
481  val = get_xbits(&f->gb, val);
482 
483  val = val * dequant_table[0] + f->last_dc;
484  f->last_dc = block[0] = val;
485  /* AC coefs */
486  i = 1;
487  for (;;) {
488  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
489 
490  /* EOB */
491  if (code == 0)
492  break;
493  if (code == 0xf0) {
494  i += 16;
495  } else {
496  level = get_xbits(&f->gb, code & 0xf);
497  i += code >> 4;
498  if (i >= 64) {
499  av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
500  return 0;
501  }
502 
503  j = ff_zigzag_direct[i];
504  block[j] = level * dequant_table[j];
505  i++;
506  if (i >= 64)
507  break;
508  }
509  }
510 
511  return 0;
512 }
513 
514 static inline void idct_put(FourXContext *f, int x, int y)
515 {
516  int16_t (*block)[64] = f->block;
517  int stride = f->avctx->width;
518  int i;
519  uint16_t *dst = f->frame_buffer + y * stride + x;
520 
521  for (i = 0; i < 4; i++) {
522  block[i][0] += 0x80 * 8 * 8;
523  idct(block[i]);
524  }
525 
526  if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
527  for (i = 4; i < 6; i++)
528  idct(block[i]);
529  }
530 
531  /* Note transform is:
532  * y = ( 1b + 4g + 2r) / 14
533  * cb = ( 3b - 2g - 1r) / 14
534  * cr = (-1b - 4g + 5r) / 14 */
535  for (y = 0; y < 8; y++) {
536  for (x = 0; x < 8; x++) {
537  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
538  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
539  int cb = block[4][x + 8 * y];
540  int cr = block[5][x + 8 * y];
541  int cg = (cb + cr) >> 1;
542  int y;
543 
544  cb += cb;
545 
546  y = temp[0];
547  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
548  y = temp[1];
549  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
550  y = temp[8];
551  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
552  y = temp[9];
553  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
554  dst += 2;
555  }
556  dst += 2 * stride - 2 * 8;
557  }
558 }
559 
560 static int decode_i_mb(FourXContext *f)
561 {
562  int ret;
563  int i;
564 
565  f->dsp.clear_blocks(f->block[0]);
566 
567  for (i = 0; i < 6; i++)
568  if ((ret = decode_i_block(f, f->block[i])) < 0)
569  return ret;
570 
571  return 0;
572 }
573 
575  const uint8_t * const buf,
576  int len)
577 {
578  int frequency[512] = { 0 };
579  uint8_t flag[512];
580  int up[512];
581  uint8_t len_tab[257];
582  int bits_tab[257];
583  int start, end;
584  const uint8_t *ptr = buf;
585  int j;
586 
587  memset(up, -1, sizeof(up));
588 
589  start = *ptr++;
590  end = *ptr++;
591  for (;;) {
592  int i;
593 
594  len -= end - start + 1;
595 
596  if (end < start || len < 0)
597  return NULL;
598 
599  for (i = start; i <= end; i++)
600  frequency[i] = *ptr++;
601  start = *ptr++;
602  if (start == 0)
603  break;
604 
605  if (--len < 0)
606  return NULL;
607 
608  end = *ptr++;
609  }
610  frequency[256] = 1;
611 
612  while ((ptr - buf) & 3)
613  ptr++; // 4byte align
614 
615  for (j = 257; j < 512; j++) {
616  int min_freq[2] = { 256 * 256, 256 * 256 };
617  int smallest[2] = { 0, 0 };
618  int i;
619  for (i = 0; i < j; i++) {
620  if (frequency[i] == 0)
621  continue;
622  if (frequency[i] < min_freq[1]) {
623  if (frequency[i] < min_freq[0]) {
624  min_freq[1] = min_freq[0];
625  smallest[1] = smallest[0];
626  min_freq[0] = frequency[i];
627  smallest[0] = i;
628  } else {
629  min_freq[1] = frequency[i];
630  smallest[1] = i;
631  }
632  }
633  }
634  if (min_freq[1] == 256 * 256)
635  break;
636 
637  frequency[j] = min_freq[0] + min_freq[1];
638  flag[smallest[0]] = 0;
639  flag[smallest[1]] = 1;
640  up[smallest[0]] =
641  up[smallest[1]] = j;
642  frequency[smallest[0]] = frequency[smallest[1]] = 0;
643  }
644 
645  for (j = 0; j < 257; j++) {
646  int node, len = 0, bits = 0;
647 
648  for (node = j; up[node] != -1; node = up[node]) {
649  bits += flag[node] << len;
650  len++;
651  if (len > 31)
652  // can this happen at all ?
654  "vlc length overflow\n");
655  }
656 
657  bits_tab[j] = bits;
658  len_tab[j] = len;
659  }
660 
661  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
662  bits_tab, 4, 4, 0))
663  return NULL;
664 
665  return ptr;
666 }
667 
668 static int mix(int c0, int c1)
669 {
670  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
671  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
672  int red = 2 * (c0 >> 10) + (c1 >> 10);
673  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
674 }
675 
676 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
677 {
678  int x, y, x2, y2;
679  const int width = f->avctx->width;
680  const int height = f->avctx->height;
681  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
682  uint16_t *dst = f->frame_buffer;
683  GetByteContext g3;
684 
685  if (length < mbs * 8) {
686  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
687  return AVERROR_INVALIDDATA;
688  }
689  bytestream2_init(&g3, buf, length);
690 
691  for (y = 0; y < height; y += 16) {
692  for (x = 0; x < width; x += 16) {
693  unsigned int color[4] = { 0 }, bits;
694  // warning following is purely guessed ...
695  color[0] = bytestream2_get_le16u(&g3);
696  color[1] = bytestream2_get_le16u(&g3);
697 
698  if (color[0] & 0x8000)
699  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
700  if (color[1] & 0x8000)
701  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
702 
703  color[2] = mix(color[0], color[1]);
704  color[3] = mix(color[1], color[0]);
705 
706  bits = bytestream2_get_le32u(&g3);
707  for (y2 = 0; y2 < 16; y2++) {
708  for (x2 = 0; x2 < 16; x2++) {
709  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
710  dst[y2 * width + x2] = color[(bits >> index) & 3];
711  }
712  }
713  dst += 16;
714  }
715  dst += 16 * width - x;
716  }
717 
718  return 0;
719 }
720 
721 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
722 {
723  int x, y, ret;
724  const int width = f->avctx->width;
725  const int height = f->avctx->height;
726  const unsigned int bitstream_size = AV_RL32(buf);
727  int token_count av_unused;
728  unsigned int prestream_size;
729  const uint8_t *prestream;
730 
731  if (bitstream_size > (1 << 26))
732  return AVERROR_INVALIDDATA;
733 
734  if (length < bitstream_size + 12) {
735  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
736  return AVERROR_INVALIDDATA;
737  }
738 
739  token_count = AV_RL32(buf + bitstream_size + 8);
740  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
741  prestream = buf + bitstream_size + 12;
742 
743  if (prestream_size + bitstream_size + 12 != length
744  || prestream_size > (1 << 26)) {
745  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
746  prestream_size, bitstream_size, length);
747  return AVERROR_INVALIDDATA;
748  }
749 
750  prestream = read_huffman_tables(f, prestream, prestream_size);
751  if (!prestream) {
752  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
753  return AVERROR_INVALIDDATA;
754  }
755 
756  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
757 
758  prestream_size = length + buf - prestream;
759 
761  prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
762  if (!f->bitstream_buffer)
763  return AVERROR(ENOMEM);
764  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
765  prestream_size / 4);
766  memset((uint8_t*)f->bitstream_buffer + prestream_size,
768  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
769 
770  f->last_dc = 0 * 128 * 8 * 8;
771 
772  for (y = 0; y < height; y += 16) {
773  for (x = 0; x < width; x += 16) {
774  if ((ret = decode_i_mb(f)) < 0)
775  return ret;
776 
777  idct_put(f, x, y);
778  }
779  }
780 
781  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
782  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
783 
784  return 0;
785 }
786 
787 static int decode_frame(AVCodecContext *avctx, void *data,
788  int *got_frame, AVPacket *avpkt)
789 {
790  const uint8_t *buf = avpkt->data;
791  int buf_size = avpkt->size;
792  FourXContext *const f = avctx->priv_data;
793  AVFrame *picture = data;
794  int i, frame_4cc, frame_size, ret;
795 
796  if (buf_size < 20)
797  return AVERROR_INVALIDDATA;
798 
799  if (avctx->width % 16 || avctx->height % 16) {
800  av_log(avctx, AV_LOG_ERROR,
801  "Dimensions non-multiple of 16 are invalid.\n");
802  return AVERROR_INVALIDDATA;
803  }
804 
805  if (buf_size < AV_RL32(buf + 4) + 8) {
806  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
807  buf_size, AV_RL32(buf + 4));
808  return AVERROR_INVALIDDATA;
809  }
810 
811  frame_4cc = AV_RL32(buf);
812 
813  if (frame_4cc == AV_RL32("cfrm")) {
814  int free_index = -1;
815  int id, whole_size;
816  const int data_size = buf_size - 20;
817  CFrameBuffer *cfrm;
818 
819  if (data_size < 0)
820  return AVERROR_INVALIDDATA;
821 
822  id = AV_RL32(buf + 12);
823  whole_size = AV_RL32(buf + 16);
824 
825  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
826  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
827  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
828  f->cfrm[i].id);
829 
830  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
831  if (f->cfrm[i].id == id)
832  break;
833  if (f->cfrm[i].size == 0)
834  free_index = i;
835  }
836 
837  if (i >= CFRAME_BUFFER_COUNT) {
838  i = free_index;
839  f->cfrm[i].id = id;
840  }
841  cfrm = &f->cfrm[i];
842 
843  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
844  cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
845  // explicit check needed as memcpy below might not catch a NULL
846  if (!cfrm->data) {
847  av_log(f->avctx, AV_LOG_ERROR, "realloc failure");
848  return AVERROR(ENOMEM);
849  }
850 
851  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
852  cfrm->size += data_size;
853 
854  if (cfrm->size >= whole_size) {
855  buf = cfrm->data;
856  frame_size = cfrm->size;
857 
858  if (id != avctx->frame_number)
859  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
860  id, avctx->frame_number);
861 
862  if (f->version <= 1)
863  return AVERROR_INVALIDDATA;
864 
865  cfrm->size = cfrm->id = 0;
866  frame_4cc = AV_RL32("pfrm");
867  } else
868  return buf_size;
869  } else {
870  buf = buf + 12;
871  frame_size = buf_size - 12;
872  }
873 
874 
875  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0) {
876  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
877  return ret;
878  }
879 
880  if (frame_4cc == AV_RL32("ifr2")) {
881  picture->pict_type = AV_PICTURE_TYPE_I;
882  if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0)
883  return ret;
884  } else if (frame_4cc == AV_RL32("ifrm")) {
885  picture->pict_type = AV_PICTURE_TYPE_I;
886  if ((ret = decode_i_frame(f, buf, frame_size)) < 0)
887  return ret;
888  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
889  picture->pict_type = AV_PICTURE_TYPE_P;
890  if ((ret = decode_p_frame(f, buf, frame_size)) < 0)
891  return ret;
892  } else if (frame_4cc == AV_RL32("snd_")) {
893  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
894  buf_size);
895  } else {
896  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
897  buf_size);
898  }
899 
900  picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
901 
902  av_image_copy_plane(picture->data[0], picture->linesize[0],
903  (const uint8_t*)f->frame_buffer, avctx->width * 2,
904  avctx->width * 2, avctx->height);
905  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
906 
907  *got_frame = 1;
908 
909  emms_c();
910 
911  return buf_size;
912 }
913 
915 {
916  FourXContext * const f = avctx->priv_data;
917  int i;
918 
919  av_freep(&f->frame_buffer);
922  f->bitstream_buffer_size = 0;
923  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
924  av_freep(&f->cfrm[i].data);
925  f->cfrm[i].allocated_size = 0;
926  }
927  ff_free_vlc(&f->pre_vlc);
928 
929  return 0;
930 }
931 
933 {
934  FourXContext * const f = avctx->priv_data;
935  int ret;
936 
937  if (avctx->extradata_size != 4 || !avctx->extradata) {
938  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
939  return AVERROR_INVALIDDATA;
940  }
941 
942  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
943  if (ret < 0)
944  return ret;
945 
946  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
947  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
948  if (!f->frame_buffer || !f->last_frame_buffer) {
949  decode_end(avctx);
950  return AVERROR(ENOMEM);
951  }
952 
953  f->version = AV_RL32(avctx->extradata) >> 16;
954  ff_dsputil_init(&f->dsp, avctx);
955  f->avctx = avctx;
956  init_vlcs(f);
957 
958  if (f->version > 2)
959  avctx->pix_fmt = AV_PIX_FMT_RGB565;
960  else
961  avctx->pix_fmt = AV_PIX_FMT_BGR555;
962 
963  return 0;
964 }
965 
967  .name = "4xm",
968  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
969  .type = AVMEDIA_TYPE_VIDEO,
970  .id = AV_CODEC_ID_4XM,
971  .priv_data_size = sizeof(FourXContext),
972  .init = decode_init,
973  .close = decode_end,
974  .decode = decode_frame,
975  .capabilities = CODEC_CAP_DR1,
976 };