FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * 4XM codec.
25  */
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/frame.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 
37 #define BLOCK_TYPE_VLC_BITS 5
38 #define ACDC_VLC_BITS 9
39 
40 #define CFRAME_BUFFER_COUNT 100
41 
42 static const uint8_t block_type_tab[2][4][8][2] = {
43  {
44  { // { 8, 4, 2 } x { 8, 4, 2}
45  { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
46  }, { // { 8, 4 } x 1
47  { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
48  }, { // 1 x { 8, 4 }
49  { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
50  }, { // 1 x 2, 2 x 1
51  { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
52  }
53  }, {
54  { // { 8, 4, 2 } x { 8, 4, 2}
55  { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
56  }, {// { 8, 4 } x 1
57  { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
58  }, {// 1 x { 8, 4 }
59  { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60  }, {// 1 x 2, 2 x 1
61  { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
62  }
63  }
64 };
65 
66 static const uint8_t size2index[4][4] = {
67  { -1, 3, 1, 1 },
68  { 3, 0, 0, 0 },
69  { 2, 0, 0, 0 },
70  { 2, 0, 0, 0 },
71 };
72 
73 static const int8_t mv[256][2] = {
74  { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
75  { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
76  { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
77  { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
78  { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
79  { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
80  { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
81  { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
82  { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
83  { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
84  { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
85  { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
86  { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
87  { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
88  { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
89  { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
90  { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
91  { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
92  { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
93  { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
94  { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
95  { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
96  { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
97  { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
98  { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
99  { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
100  { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
101  { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
102  { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
103  { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
104  { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
105  { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
106 };
107 
108 /* This is simply the scaled down elementwise product of the standard JPEG
109  * quantizer table and the AAN premul table. */
110 static const uint8_t dequant_table[64] = {
111  16, 15, 13, 19, 24, 31, 28, 17,
112  17, 23, 25, 31, 36, 63, 45, 21,
113  18, 24, 27, 37, 52, 59, 49, 20,
114  16, 28, 34, 40, 60, 80, 51, 20,
115  18, 31, 48, 66, 68, 86, 56, 21,
116  19, 38, 56, 59, 64, 64, 48, 20,
117  27, 48, 55, 55, 56, 51, 35, 15,
118  20, 35, 34, 32, 31, 22, 15, 8,
119 };
120 
121 static VLC block_type_vlc[2][4];
122 
123 
124 typedef struct CFrameBuffer {
125  unsigned int allocated_size;
126  unsigned int size;
127  int id;
129 } CFrameBuffer;
130 
131 typedef struct FourXContext {
135  GetBitContext pre_gb; ///< ac/dc prefix
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, const 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  av_assert0(0);
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 = (uint16_t *)f->last_picture->data[0];
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  av_assert0(code >= 0 && code <= 6 && log2w >= 0);
351 
352  if (code == 1) {
353  log2h--;
354  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
355  return ret;
356  return decode_p_block(f, dst + (stride << log2h),
357  src + (stride << log2h),
358  log2w, log2h, stride);
359  } else if (code == 2) {
360  log2w--;
361  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
362  return ret;
363  return decode_p_block(f, dst + (1 << log2w),
364  src + (1 << log2w),
365  log2w, log2h, stride);
366  } else if (code == 6) {
367  if (bytestream2_get_bytes_left(&f->g2) < 4) {
368  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
369  return AVERROR_INVALIDDATA;
370  }
371  if (log2w) {
372  dst[0] = bytestream2_get_le16u(&f->g2);
373  dst[1] = bytestream2_get_le16u(&f->g2);
374  } else {
375  dst[0] = bytestream2_get_le16u(&f->g2);
376  dst[stride] = bytestream2_get_le16u(&f->g2);
377  }
378  return 0;
379  }
380 
381  if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
382  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
383  return AVERROR_INVALIDDATA;
384  }
385 
386  if (code == 0) {
387  src += f->mv[bytestream2_get_byte(&f->g)];
388  } else if (code == 3 && f->version >= 2) {
389  return 0;
390  } else if (code == 4) {
391  src += f->mv[bytestream2_get_byte(&f->g)];
392  if (bytestream2_get_bytes_left(&f->g2) < 2){
393  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
394  return AVERROR_INVALIDDATA;
395  }
396  dc = bytestream2_get_le16(&f->g2);
397  } else if (code == 5) {
398  if (bytestream2_get_bytes_left(&f->g2) < 2){
399  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
400  return AVERROR_INVALIDDATA;
401  }
402  av_assert0(start <= src && src <= end);
403  scale = 0;
404  dc = bytestream2_get_le16(&f->g2);
405  }
406 
407  if (start > src || src > end) {
408  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
409  return AVERROR_INVALIDDATA;
410  }
411 
412  mcdc(dst, src, log2w, h, stride, scale, dc);
413 
414  return 0;
415 }
416 
418  const uint8_t *buf, int length)
419 {
420  int x, y;
421  const int width = f->avctx->width;
422  const int height = f->avctx->height;
423  uint16_t *dst = (uint16_t *)frame->data[0];
424  const int stride = frame->linesize[0] >> 1;
425  uint16_t *src;
426  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
427  bytestream_offset, wordstream_offset;
428  int ret;
429 
430  if (!f->last_picture->data[0]) {
431  if ((ret = ff_get_buffer(f->avctx, f->last_picture,
432  AV_GET_BUFFER_FLAG_REF)) < 0) {
433  return ret;
434  }
435  for (y=0; y<f->avctx->height; y++)
436  memset(f->last_picture->data[0] + y*f->last_picture->linesize[0], 0, 2*f->avctx->width);
437  }
438 
439  src = (uint16_t *)f->last_picture->data[0];
440 
441  if (f->version > 1) {
442  extra = 20;
443  if (length < extra)
444  return AVERROR_INVALIDDATA;
445  bitstream_size = AV_RL32(buf + 8);
446  wordstream_size = AV_RL32(buf + 12);
447  bytestream_size = AV_RL32(buf + 16);
448  } else {
449  extra = 0;
450  bitstream_size = AV_RL16(buf - 4);
451  wordstream_size = AV_RL16(buf - 2);
452  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
453  }
454 
455  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
456  bytestream_size > length - bitstream_size ||
457  wordstream_size > length - bytestream_size - bitstream_size ||
458  extra > length - bytestream_size - bitstream_size - wordstream_size) {
459  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
460  bitstream_size+ bytestream_size+ wordstream_size - length);
461  return AVERROR_INVALIDDATA;
462  }
463 
465  bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
466  if (!f->bitstream_buffer)
467  return AVERROR(ENOMEM);
468  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
469  bitstream_size / 4);
470  memset((uint8_t*)f->bitstream_buffer + bitstream_size,
472  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
473 
474  wordstream_offset = extra + bitstream_size;
475  bytestream_offset = extra + bitstream_size + wordstream_size;
476  bytestream2_init(&f->g2, buf + wordstream_offset,
477  length - wordstream_offset);
478  bytestream2_init(&f->g, buf + bytestream_offset,
479  length - bytestream_offset);
480 
481  init_mv(f, frame->linesize[0]);
482 
483  for (y = 0; y < height; y += 8) {
484  for (x = 0; x < width; x += 8)
485  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
486  return ret;
487  src += 8 * stride;
488  dst += 8 * stride;
489  }
490 
491  return 0;
492 }
493 
494 /**
495  * decode block and dequantize.
496  * Note this is almost identical to MJPEG.
497  */
498 static int decode_i_block(FourXContext *f, int16_t *block)
499 {
500  int code, i, j, level, val;
501 
502  if (get_bits_left(&f->gb) < 2){
503  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
504  return -1;
505  }
506 
507  /* DC coef */
508  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
509  if (val >> 4) {
510  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
511  return AVERROR_INVALIDDATA;
512  }
513 
514  if (val)
515  val = get_xbits(&f->gb, val);
516 
517  val = val * dequant_table[0] + f->last_dc;
518  f->last_dc = block[0] = val;
519  /* AC coefs */
520  i = 1;
521  for (;;) {
522  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
523 
524  /* EOB */
525  if (code == 0)
526  break;
527  if (code == 0xf0) {
528  i += 16;
529  } else {
530  if (code & 0xf) {
531  level = get_xbits(&f->gb, code & 0xf);
532  } else {
533  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
534  return AVERROR_INVALIDDATA;
535  }
536  i += code >> 4;
537  if (i >= 64) {
538  av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
539  return 0;
540  }
541 
542  j = ff_zigzag_direct[i];
543  block[j] = level * dequant_table[j];
544  i++;
545  if (i >= 64)
546  break;
547  }
548  }
549 
550  return 0;
551 }
552 
553 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
554 {
555  int16_t (*block)[64] = f->block;
556  int stride = frame->linesize[0] >> 1;
557  int i;
558  uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
559 
560  for (i = 0; i < 4; i++) {
561  block[i][0] += 0x80 * 8 * 8;
562  idct(block[i]);
563  }
564 
565  if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
566  for (i = 4; i < 6; i++)
567  idct(block[i]);
568  }
569 
570  /* Note transform is:
571  * y = ( 1b + 4g + 2r) / 14
572  * cb = ( 3b - 2g - 1r) / 14
573  * cr = (-1b - 4g + 5r) / 14 */
574  for (y = 0; y < 8; y++) {
575  for (x = 0; x < 8; x++) {
576  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
577  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
578  int cb = block[4][x + 8 * y];
579  int cr = block[5][x + 8 * y];
580  int cg = (cb + cr) >> 1;
581  int y;
582 
583  cb += cb;
584 
585  y = temp[0];
586  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
587  y = temp[1];
588  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
589  y = temp[8];
590  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
591  y = temp[9];
592  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593  dst += 2;
594  }
595  dst += 2 * stride - 2 * 8;
596  }
597 }
598 
599 static int decode_i_mb(FourXContext *f)
600 {
601  int ret;
602  int i;
603 
604  f->dsp.clear_blocks(f->block[0]);
605 
606  for (i = 0; i < 6; i++)
607  if ((ret = decode_i_block(f, f->block[i])) < 0)
608  return ret;
609 
610  return 0;
611 }
612 
614  const uint8_t * const buf,
615  int buf_size)
616 {
617  int frequency[512] = { 0 };
618  uint8_t flag[512];
619  int up[512];
620  uint8_t len_tab[257];
621  int bits_tab[257];
622  int start, end;
623  const uint8_t *ptr = buf;
624  const uint8_t *ptr_end = buf + buf_size;
625  int j;
626 
627  memset(up, -1, sizeof(up));
628 
629  start = *ptr++;
630  end = *ptr++;
631  for (;;) {
632  int i;
633 
634  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
635  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
636  return NULL;
637  }
638 
639  for (i = start; i <= end; i++)
640  frequency[i] = *ptr++;
641  start = *ptr++;
642  if (start == 0)
643  break;
644 
645  end = *ptr++;
646  }
647  frequency[256] = 1;
648 
649  while ((ptr - buf) & 3)
650  ptr++; // 4byte align
651 
652  if (ptr > ptr_end) {
653  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
654  return NULL;
655  }
656 
657  for (j = 257; j < 512; j++) {
658  int min_freq[2] = { 256 * 256, 256 * 256 };
659  int smallest[2] = { 0, 0 };
660  int i;
661  for (i = 0; i < j; i++) {
662  if (frequency[i] == 0)
663  continue;
664  if (frequency[i] < min_freq[1]) {
665  if (frequency[i] < min_freq[0]) {
666  min_freq[1] = min_freq[0];
667  smallest[1] = smallest[0];
668  min_freq[0] = frequency[i];
669  smallest[0] = i;
670  } else {
671  min_freq[1] = frequency[i];
672  smallest[1] = i;
673  }
674  }
675  }
676  if (min_freq[1] == 256 * 256)
677  break;
678 
679  frequency[j] = min_freq[0] + min_freq[1];
680  flag[smallest[0]] = 0;
681  flag[smallest[1]] = 1;
682  up[smallest[0]] =
683  up[smallest[1]] = j;
684  frequency[smallest[0]] = frequency[smallest[1]] = 0;
685  }
686 
687  for (j = 0; j < 257; j++) {
688  int node, len = 0, bits = 0;
689 
690  for (node = j; up[node] != -1; node = up[node]) {
691  bits += flag[node] << len;
692  len++;
693  if (len > 31)
694  // can this happen at all ?
696  "vlc length overflow\n");
697  }
698 
699  bits_tab[j] = bits;
700  len_tab[j] = len;
701  }
702 
703  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
704  bits_tab, 4, 4, 0))
705  return NULL;
706 
707  return ptr;
708 }
709 
710 static int mix(int c0, int c1)
711 {
712  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
713  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
714  int red = 2 * (c0 >> 10) + (c1 >> 10);
715  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
716 }
717 
719 {
720  int x, y, x2, y2;
721  const int width = f->avctx->width;
722  const int height = f->avctx->height;
723  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
724  uint16_t *dst = (uint16_t*)frame->data[0];
725  const int stride = frame->linesize[0]>>1;
726  const uint8_t *buf_end = buf + length;
727  GetByteContext g3;
728 
729  if (length < mbs * 8) {
730  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
731  return AVERROR_INVALIDDATA;
732  }
733  bytestream2_init(&g3, buf, length);
734 
735  for (y = 0; y < height; y += 16) {
736  for (x = 0; x < width; x += 16) {
737  unsigned int color[4] = { 0 }, bits;
738  if (buf_end - buf < 8)
739  return -1;
740  // warning following is purely guessed ...
741  color[0] = bytestream2_get_le16u(&g3);
742  color[1] = bytestream2_get_le16u(&g3);
743 
744  if (color[0] & 0x8000)
745  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
746  if (color[1] & 0x8000)
747  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
748 
749  color[2] = mix(color[0], color[1]);
750  color[3] = mix(color[1], color[0]);
751 
752  bits = bytestream2_get_le32u(&g3);
753  for (y2 = 0; y2 < 16; y2++) {
754  for (x2 = 0; x2 < 16; x2++) {
755  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
756  dst[y2 * stride + x2] = color[(bits >> index) & 3];
757  }
758  }
759  dst += 16;
760  }
761  dst += 16 * stride - x;
762  }
763 
764  return 0;
765 }
766 
768 {
769  int x, y, ret;
770  const int width = f->avctx->width;
771  const int height = f->avctx->height;
772  const unsigned int bitstream_size = AV_RL32(buf);
773  unsigned int prestream_size;
774  const uint8_t *prestream;
775 
776  if (bitstream_size > (1 << 26))
777  return AVERROR_INVALIDDATA;
778 
779  if (length < bitstream_size + 12) {
780  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
781  return AVERROR_INVALIDDATA;
782  }
783 
784  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
785  prestream = buf + bitstream_size + 12;
786 
787  if (prestream_size + bitstream_size + 12 != length
788  || prestream_size > (1 << 26)) {
789  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
790  prestream_size, bitstream_size, length);
791  return AVERROR_INVALIDDATA;
792  }
793 
794  prestream = read_huffman_tables(f, prestream, prestream_size);
795  if (!prestream) {
796  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
797  return AVERROR_INVALIDDATA;
798  }
799 
800  av_assert0(prestream <= buf + length);
801 
802  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
803 
804  prestream_size = length + buf - prestream;
805 
807  prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
808  if (!f->bitstream_buffer)
809  return AVERROR(ENOMEM);
810  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
811  prestream_size / 4);
812  memset((uint8_t*)f->bitstream_buffer + prestream_size,
814  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
815 
816  f->last_dc = 0 * 128 * 8 * 8;
817 
818  for (y = 0; y < height; y += 16) {
819  for (x = 0; x < width; x += 16) {
820  if ((ret = decode_i_mb(f)) < 0)
821  return ret;
822 
823  idct_put(f, frame, x, y);
824  }
825  }
826 
827  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
828  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
829 
830  return 0;
831 }
832 
833 static int decode_frame(AVCodecContext *avctx, void *data,
834  int *got_frame, AVPacket *avpkt)
835 {
836  const uint8_t *buf = avpkt->data;
837  int buf_size = avpkt->size;
838  FourXContext *const f = avctx->priv_data;
839  AVFrame *picture = data;
840  int i, frame_4cc, frame_size, ret;
841 
842  if (buf_size < 20)
843  return AVERROR_INVALIDDATA;
844 
845  if (buf_size < AV_RL32(buf + 4) + 8) {
846  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
847  buf_size, AV_RL32(buf + 4));
848  return AVERROR_INVALIDDATA;
849  }
850 
851  frame_4cc = AV_RL32(buf);
852 
853  if (frame_4cc == AV_RL32("cfrm")) {
854  int free_index = -1;
855  int id, whole_size;
856  const int data_size = buf_size - 20;
857  CFrameBuffer *cfrm;
858 
859  if (f->version <= 1) {
860  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
861  return AVERROR_INVALIDDATA;
862  }
863 
864  id = AV_RL32(buf + 12);
865  whole_size = AV_RL32(buf + 16);
866 
867  if (data_size < 0 || whole_size < 0) {
868  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
869  return AVERROR_INVALIDDATA;
870  }
871 
872  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
873  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
874  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
875  f->cfrm[i].id);
876 
877  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
878  if (f->cfrm[i].id == id)
879  break;
880  if (f->cfrm[i].size == 0)
881  free_index = i;
882  }
883 
884  if (i >= CFRAME_BUFFER_COUNT) {
885  i = free_index;
886  f->cfrm[i].id = id;
887  }
888  cfrm = &f->cfrm[i];
889 
890  if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
891  return AVERROR_INVALIDDATA;
892 
893  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
894  cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
895  // explicit check needed as memcpy below might not catch a NULL
896  if (!cfrm->data) {
897  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
898  return AVERROR(ENOMEM);
899  }
900 
901  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
902  cfrm->size += data_size;
903 
904  if (cfrm->size >= whole_size) {
905  buf = cfrm->data;
906  frame_size = cfrm->size;
907 
908  if (id != avctx->frame_number)
909  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
910  id, avctx->frame_number);
911 
912  if (f->version <= 1)
913  return AVERROR_INVALIDDATA;
914 
915  cfrm->size = cfrm->id = 0;
916  frame_4cc = AV_RL32("pfrm");
917  } else
918  return buf_size;
919  } else {
920  buf = buf + 12;
921  frame_size = buf_size - 12;
922  }
923 
925 
926  // alternatively we would have to use our own buffer management
927  avctx->flags |= CODEC_FLAG_EMU_EDGE;
928 
929  if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
930  return ret;
931 
932  if (frame_4cc == AV_RL32("ifr2")) {
934  if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
935  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
936  return ret;
937  }
938  } else if (frame_4cc == AV_RL32("ifrm")) {
940  if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
941  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
942  return ret;
943  }
944  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
946  if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
947  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
948  return ret;
949  }
950  } else if (frame_4cc == AV_RL32("snd_")) {
951  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
952  buf_size);
953  } else {
954  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
955  buf_size);
956  }
957 
959 
960  if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
961  return ret;
962  *got_frame = 1;
963 
964  emms_c();
965 
966  return buf_size;
967 }
968 
970 {
971  FourXContext * const f = avctx->priv_data;
972 
973  if (avctx->extradata_size != 4 || !avctx->extradata) {
974  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
975  return AVERROR_INVALIDDATA;
976  }
977  if((avctx->width % 16) || (avctx->height % 16)) {
978  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
979  return AVERROR_INVALIDDATA;
980  }
981 
982  f->version = AV_RL32(avctx->extradata) >> 16;
983  ff_dsputil_init(&f->dsp, avctx);
984  f->avctx = avctx;
985  init_vlcs(f);
986 
987  if (f->version > 2)
988  avctx->pix_fmt = AV_PIX_FMT_RGB565;
989  else
990  avctx->pix_fmt = AV_PIX_FMT_BGR555;
991 
994  if (!f->current_picture || !f->last_picture)
995  return AVERROR(ENOMEM);
996 
997  return 0;
998 }
999 
1000 
1002 {
1003  FourXContext * const f = avctx->priv_data;
1004  int i;
1005 
1007  f->bitstream_buffer_size = 0;
1008  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1009  av_freep(&f->cfrm[i].data);
1010  f->cfrm[i].allocated_size = 0;
1011  }
1012  ff_free_vlc(&f->pre_vlc);
1015 
1016  return 0;
1017 }
1018 
1020  .name = "4xm",
1021  .type = AVMEDIA_TYPE_VIDEO,
1022  .id = AV_CODEC_ID_4XM,
1023  .priv_data_size = sizeof(FourXContext),
1024  .init = decode_init,
1025  .close = decode_end,
1026  .decode = decode_frame,
1027  .capabilities = CODEC_CAP_DR1,
1028  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1029 };