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;
128  uint8_t *data;
129 } CFrameBuffer;
130 
131 typedef struct FourXContext {
132  AVCodecContext *avctx;
133  DSPContext dsp;
134  AVFrame *current_picture, *last_picture;
135  GetBitContext pre_gb; ///< ac/dc prefix
136  GetBitContext gb;
137  GetByteContext g;
138  GetByteContext g2;
139  int mv[256];
140  VLC pre_vlc;
141  int last_dc;
142  DECLARE_ALIGNED(16, int16_t, block)[6][64];
143  void *bitstream_buffer;
144  unsigned int bitstream_buffer_size;
145  int version;
146  CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
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 
242 static av_cold void init_vlcs(FourXContext *f)
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,
254  INIT_VLC_USE_NEW_STATIC);
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,
343  BLOCK_TYPE_VLC_BITS, 1);
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 
417 static int decode_p_frame(FourXContext *f, AVFrame *frame,
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 
464  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
465  bitstream_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  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
471 
472  wordstream_offset = extra + bitstream_size;
473  bytestream_offset = extra + bitstream_size + wordstream_size;
474  bytestream2_init(&f->g2, buf + wordstream_offset,
475  length - wordstream_offset);
476  bytestream2_init(&f->g, buf + bytestream_offset,
477  length - bytestream_offset);
478 
479  init_mv(f, frame->linesize[0]);
480 
481  for (y = 0; y < height; y += 8) {
482  for (x = 0; x < width; x += 8)
483  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
484  return ret;
485  src += 8 * stride;
486  dst += 8 * stride;
487  }
488 
489  return 0;
490 }
491 
492 /**
493  * decode block and dequantize.
494  * Note this is almost identical to MJPEG.
495  */
496 static int decode_i_block(FourXContext *f, int16_t *block)
497 {
498  int code, i, j, level, val;
499 
500  if (get_bits_left(&f->gb) < 2){
501  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
502  return -1;
503  }
504 
505  /* DC coef */
506  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
507  if (val >> 4) {
508  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
509  return AVERROR_INVALIDDATA;
510  }
511 
512  if (val)
513  val = get_xbits(&f->gb, val);
514 
515  val = val * dequant_table[0] + f->last_dc;
516  f->last_dc = block[0] = val;
517  /* AC coefs */
518  i = 1;
519  for (;;) {
520  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
521 
522  /* EOB */
523  if (code == 0)
524  break;
525  if (code == 0xf0) {
526  i += 16;
527  } else {
528  if (code & 0xf) {
529  level = get_xbits(&f->gb, code & 0xf);
530  } else {
531  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
532  return AVERROR_INVALIDDATA;
533  }
534  i += code >> 4;
535  if (i >= 64) {
536  av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
537  return 0;
538  }
539 
540  j = ff_zigzag_direct[i];
541  block[j] = level * dequant_table[j];
542  i++;
543  if (i >= 64)
544  break;
545  }
546  }
547 
548  return 0;
549 }
550 
551 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
552 {
553  int16_t (*block)[64] = f->block;
554  int stride = frame->linesize[0] >> 1;
555  int i;
556  uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
557 
558  for (i = 0; i < 4; i++) {
559  block[i][0] += 0x80 * 8 * 8;
560  idct(block[i]);
561  }
562 
563  if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
564  for (i = 4; i < 6; i++)
565  idct(block[i]);
566  }
567 
568  /* Note transform is:
569  * y = ( 1b + 4g + 2r) / 14
570  * cb = ( 3b - 2g - 1r) / 14
571  * cr = (-1b - 4g + 5r) / 14 */
572  for (y = 0; y < 8; y++) {
573  for (x = 0; x < 8; x++) {
574  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
575  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
576  int cb = block[4][x + 8 * y];
577  int cr = block[5][x + 8 * y];
578  int cg = (cb + cr) >> 1;
579  int y;
580 
581  cb += cb;
582 
583  y = temp[0];
584  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
585  y = temp[1];
586  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
587  y = temp[8];
588  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
589  y = temp[9];
590  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
591  dst += 2;
592  }
593  dst += 2 * stride - 2 * 8;
594  }
595 }
596 
597 static int decode_i_mb(FourXContext *f)
598 {
599  int ret;
600  int i;
601 
602  f->dsp.clear_blocks(f->block[0]);
603 
604  for (i = 0; i < 6; i++)
605  if ((ret = decode_i_block(f, f->block[i])) < 0)
606  return ret;
607 
608  return 0;
609 }
610 
611 static const uint8_t *read_huffman_tables(FourXContext *f,
612  const uint8_t * const buf,
613  int buf_size)
614 {
615  int frequency[512] = { 0 };
616  uint8_t flag[512];
617  int up[512];
618  uint8_t len_tab[257];
619  int bits_tab[257];
620  int start, end;
621  const uint8_t *ptr = buf;
622  const uint8_t *ptr_end = buf + buf_size;
623  int j;
624 
625  memset(up, -1, sizeof(up));
626 
627  start = *ptr++;
628  end = *ptr++;
629  for (;;) {
630  int i;
631 
632  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
633  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
634  return NULL;
635  }
636 
637  for (i = start; i <= end; i++)
638  frequency[i] = *ptr++;
639  start = *ptr++;
640  if (start == 0)
641  break;
642 
643  end = *ptr++;
644  }
645  frequency[256] = 1;
646 
647  while ((ptr - buf) & 3)
648  ptr++; // 4byte align
649 
650  if (ptr > ptr_end) {
651  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
652  return NULL;
653  }
654 
655  for (j = 257; j < 512; j++) {
656  int min_freq[2] = { 256 * 256, 256 * 256 };
657  int smallest[2] = { 0, 0 };
658  int i;
659  for (i = 0; i < j; i++) {
660  if (frequency[i] == 0)
661  continue;
662  if (frequency[i] < min_freq[1]) {
663  if (frequency[i] < min_freq[0]) {
664  min_freq[1] = min_freq[0];
665  smallest[1] = smallest[0];
666  min_freq[0] = frequency[i];
667  smallest[0] = i;
668  } else {
669  min_freq[1] = frequency[i];
670  smallest[1] = i;
671  }
672  }
673  }
674  if (min_freq[1] == 256 * 256)
675  break;
676 
677  frequency[j] = min_freq[0] + min_freq[1];
678  flag[smallest[0]] = 0;
679  flag[smallest[1]] = 1;
680  up[smallest[0]] =
681  up[smallest[1]] = j;
682  frequency[smallest[0]] = frequency[smallest[1]] = 0;
683  }
684 
685  for (j = 0; j < 257; j++) {
686  int node, len = 0, bits = 0;
687 
688  for (node = j; up[node] != -1; node = up[node]) {
689  bits += flag[node] << len;
690  len++;
691  if (len > 31)
692  // can this happen at all ?
693  av_log(f->avctx, AV_LOG_ERROR,
694  "vlc length overflow\n");
695  }
696 
697  bits_tab[j] = bits;
698  len_tab[j] = len;
699  }
700 
701  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
702  bits_tab, 4, 4, 0))
703  return NULL;
704 
705  return ptr;
706 }
707 
708 static int mix(int c0, int c1)
709 {
710  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
711  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
712  int red = 2 * (c0 >> 10) + (c1 >> 10);
713  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
714 }
715 
716 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
717 {
718  int x, y, x2, y2;
719  const int width = f->avctx->width;
720  const int height = f->avctx->height;
721  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
722  uint16_t *dst = (uint16_t*)frame->data[0];
723  const int stride = frame->linesize[0]>>1;
724  const uint8_t *buf_end = buf + length;
725  GetByteContext g3;
726 
727  if (length < mbs * 8) {
728  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
729  return AVERROR_INVALIDDATA;
730  }
731  bytestream2_init(&g3, buf, length);
732 
733  for (y = 0; y < height; y += 16) {
734  for (x = 0; x < width; x += 16) {
735  unsigned int color[4] = { 0 }, bits;
736  if (buf_end - buf < 8)
737  return -1;
738  // warning following is purely guessed ...
739  color[0] = bytestream2_get_le16u(&g3);
740  color[1] = bytestream2_get_le16u(&g3);
741 
742  if (color[0] & 0x8000)
743  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
744  if (color[1] & 0x8000)
745  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
746 
747  color[2] = mix(color[0], color[1]);
748  color[3] = mix(color[1], color[0]);
749 
750  bits = bytestream2_get_le32u(&g3);
751  for (y2 = 0; y2 < 16; y2++) {
752  for (x2 = 0; x2 < 16; x2++) {
753  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
754  dst[y2 * stride + x2] = color[(bits >> index) & 3];
755  }
756  }
757  dst += 16;
758  }
759  dst += 16 * stride - x;
760  }
761 
762  return 0;
763 }
764 
765 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
766 {
767  int x, y, ret;
768  const int width = f->avctx->width;
769  const int height = f->avctx->height;
770  const unsigned int bitstream_size = AV_RL32(buf);
771  unsigned int prestream_size;
772  const uint8_t *prestream;
773 
774  if (bitstream_size > (1 << 26))
775  return AVERROR_INVALIDDATA;
776 
777  if (length < bitstream_size + 12) {
778  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
779  return AVERROR_INVALIDDATA;
780  }
781 
782  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
783  prestream = buf + bitstream_size + 12;
784 
785  if (prestream_size + bitstream_size + 12 != length
786  || prestream_size > (1 << 26)) {
787  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
788  prestream_size, bitstream_size, length);
789  return AVERROR_INVALIDDATA;
790  }
791 
792  prestream = read_huffman_tables(f, prestream, prestream_size);
793  if (!prestream) {
794  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
795  return AVERROR_INVALIDDATA;
796  }
797 
798  av_assert0(prestream <= buf + length);
799 
800  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
801 
802  prestream_size = length + buf - prestream;
803 
804  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
805  prestream_size);
806  if (!f->bitstream_buffer)
807  return AVERROR(ENOMEM);
808  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
809  prestream_size / 4);
810  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
811 
812  f->last_dc = 0 * 128 * 8 * 8;
813 
814  for (y = 0; y < height; y += 16) {
815  for (x = 0; x < width; x += 16) {
816  if ((ret = decode_i_mb(f)) < 0)
817  return ret;
818 
819  idct_put(f, frame, x, y);
820  }
821  }
822 
823  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
824  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
825 
826  return 0;
827 }
828 
829 static int decode_frame(AVCodecContext *avctx, void *data,
830  int *got_frame, AVPacket *avpkt)
831 {
832  const uint8_t *buf = avpkt->data;
833  int buf_size = avpkt->size;
834  FourXContext *const f = avctx->priv_data;
835  AVFrame *picture = data;
836  int i, frame_4cc, frame_size, ret;
837 
838  if (buf_size < 20)
839  return AVERROR_INVALIDDATA;
840 
841  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
842 
843  if (buf_size < AV_RL32(buf + 4) + 8) {
844  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
845  buf_size, AV_RL32(buf + 4));
846  return AVERROR_INVALIDDATA;
847  }
848 
849  frame_4cc = AV_RL32(buf);
850 
851  if (frame_4cc == AV_RL32("cfrm")) {
852  int free_index = -1;
853  int id, whole_size;
854  const int data_size = buf_size - 20;
855  CFrameBuffer *cfrm;
856 
857  if (f->version <= 1) {
858  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
859  return AVERROR_INVALIDDATA;
860  }
861 
862  id = AV_RL32(buf + 12);
863  whole_size = AV_RL32(buf + 16);
864 
865  if (data_size < 0 || whole_size < 0) {
866  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
867  return AVERROR_INVALIDDATA;
868  }
869 
870  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
871  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
872  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
873  f->cfrm[i].id);
874 
875  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
876  if (f->cfrm[i].id == id)
877  break;
878  if (f->cfrm[i].size == 0)
879  free_index = i;
880  }
881 
882  if (i >= CFRAME_BUFFER_COUNT) {
883  i = free_index;
884  f->cfrm[i].id = id;
885  }
886  cfrm = &f->cfrm[i];
887 
888  if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
889  return AVERROR_INVALIDDATA;
890 
891  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
892  cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
893  // explicit check needed as memcpy below might not catch a NULL
894  if (!cfrm->data) {
895  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
896  return AVERROR(ENOMEM);
897  }
898 
899  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
900  cfrm->size += data_size;
901 
902  if (cfrm->size >= whole_size) {
903  buf = cfrm->data;
904  frame_size = cfrm->size;
905 
906  if (id != avctx->frame_number)
907  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
908  id, avctx->frame_number);
909 
910  if (f->version <= 1)
911  return AVERROR_INVALIDDATA;
912 
913  cfrm->size = cfrm->id = 0;
914  frame_4cc = AV_RL32("pfrm");
915  } else
916  return buf_size;
917  } else {
918  buf = buf + 12;
919  frame_size = buf_size - 12;
920  }
921 
922  FFSWAP(AVFrame*, f->current_picture, f->last_picture);
923 
924  // alternatively we would have to use our own buffer management
925  avctx->flags |= CODEC_FLAG_EMU_EDGE;
926 
927  if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
928  return ret;
929 
930  if (frame_4cc == AV_RL32("ifr2")) {
931  f->current_picture->pict_type = AV_PICTURE_TYPE_I;
932  if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
933  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
934  return ret;
935  }
936  } else if (frame_4cc == AV_RL32("ifrm")) {
937  f->current_picture->pict_type = AV_PICTURE_TYPE_I;
938  if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
939  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
940  return ret;
941  }
942  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
943  f->current_picture->pict_type = AV_PICTURE_TYPE_P;
944  if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
945  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
946  return ret;
947  }
948  } else if (frame_4cc == AV_RL32("snd_")) {
949  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
950  buf_size);
951  } else {
952  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
953  buf_size);
954  }
955 
956  f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
957 
958  if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
959  return ret;
960  *got_frame = 1;
961 
962  emms_c();
963 
964  return buf_size;
965 }
966 
967 static av_cold int decode_init(AVCodecContext *avctx)
968 {
969  FourXContext * const f = avctx->priv_data;
970 
971  if (avctx->extradata_size != 4 || !avctx->extradata) {
972  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
973  return AVERROR_INVALIDDATA;
974  }
975  if((avctx->width % 16) || (avctx->height % 16)) {
976  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
977  return AVERROR_INVALIDDATA;
978  }
979 
980  f->version = AV_RL32(avctx->extradata) >> 16;
981  ff_dsputil_init(&f->dsp, avctx);
982  f->avctx = avctx;
983  init_vlcs(f);
984 
985  if (f->version > 2)
986  avctx->pix_fmt = AV_PIX_FMT_RGB565;
987  else
988  avctx->pix_fmt = AV_PIX_FMT_BGR555;
989 
990  f->current_picture = av_frame_alloc();
991  f->last_picture = av_frame_alloc();
992  if (!f->current_picture || !f->last_picture)
993  return AVERROR(ENOMEM);
994 
995  return 0;
996 }
997 
998 
999 static av_cold int decode_end(AVCodecContext *avctx)
1000 {
1001  FourXContext * const f = avctx->priv_data;
1002  int i;
1003 
1004  av_freep(&f->bitstream_buffer);
1005  f->bitstream_buffer_size = 0;
1006  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1007  av_freep(&f->cfrm[i].data);
1008  f->cfrm[i].allocated_size = 0;
1009  }
1010  ff_free_vlc(&f->pre_vlc);
1011  av_frame_free(&f->current_picture);
1012  av_frame_free(&f->last_picture);
1013 
1014  return 0;
1015 }
1016 
1017 AVCodec ff_fourxm_decoder = {
1018  .name = "4xm",
1019  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1020  .type = AVMEDIA_TYPE_VIDEO,
1021  .id = AV_CODEC_ID_4XM,
1022  .priv_data_size = sizeof(FourXContext),
1023  .init = decode_init,
1024  .close = decode_end,
1025  .decode = decode_frame,
1026  .capabilities = CODEC_CAP_DR1,
1027 };
Generated on Sun Dec 8 2013 19:20:51 for FFmpeg by   doxygen 1.8.2