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_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
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,
471  0, FF_INPUT_BUFFER_PADDING_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 
613 static const uint8_t *read_huffman_tables(FourXContext *f,
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 ?
695  av_log(f->avctx, AV_LOG_ERROR,
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 
718 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
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 
767 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
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 
806  av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
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,
813  0, FF_INPUT_BUFFER_PADDING_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  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
846 
847  if (buf_size < AV_RL32(buf + 4) + 8) {
848  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
849  buf_size, AV_RL32(buf + 4));
850  return AVERROR_INVALIDDATA;
851  }
852 
853  frame_4cc = AV_RL32(buf);
854 
855  if (frame_4cc == AV_RL32("cfrm")) {
856  int free_index = -1;
857  int id, whole_size;
858  const int data_size = buf_size - 20;
859  CFrameBuffer *cfrm;
860 
861  if (f->version <= 1) {
862  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
863  return AVERROR_INVALIDDATA;
864  }
865 
866  id = AV_RL32(buf + 12);
867  whole_size = AV_RL32(buf + 16);
868 
869  if (data_size < 0 || whole_size < 0) {
870  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
871  return AVERROR_INVALIDDATA;
872  }
873 
874  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
875  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
876  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
877  f->cfrm[i].id);
878 
879  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
880  if (f->cfrm[i].id == id)
881  break;
882  if (f->cfrm[i].size == 0)
883  free_index = i;
884  }
885 
886  if (i >= CFRAME_BUFFER_COUNT) {
887  i = free_index;
888  f->cfrm[i].id = id;
889  }
890  cfrm = &f->cfrm[i];
891 
892  if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
893  return AVERROR_INVALIDDATA;
894 
895  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
896  cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
897  // explicit check needed as memcpy below might not catch a NULL
898  if (!cfrm->data) {
899  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
900  return AVERROR(ENOMEM);
901  }
902 
903  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
904  cfrm->size += data_size;
905 
906  if (cfrm->size >= whole_size) {
907  buf = cfrm->data;
908  frame_size = cfrm->size;
909 
910  if (id != avctx->frame_number)
911  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
912  id, avctx->frame_number);
913 
914  if (f->version <= 1)
915  return AVERROR_INVALIDDATA;
916 
917  cfrm->size = cfrm->id = 0;
918  frame_4cc = AV_RL32("pfrm");
919  } else
920  return buf_size;
921  } else {
922  buf = buf + 12;
923  frame_size = buf_size - 12;
924  }
925 
926  FFSWAP(AVFrame*, f->current_picture, f->last_picture);
927 
928  // alternatively we would have to use our own buffer management
929  avctx->flags |= CODEC_FLAG_EMU_EDGE;
930 
931  if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
932  return ret;
933 
934  if (frame_4cc == AV_RL32("ifr2")) {
935  f->current_picture->pict_type = AV_PICTURE_TYPE_I;
936  if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
937  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
938  return ret;
939  }
940  } else if (frame_4cc == AV_RL32("ifrm")) {
941  f->current_picture->pict_type = AV_PICTURE_TYPE_I;
942  if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
943  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
944  return ret;
945  }
946  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
947  f->current_picture->pict_type = AV_PICTURE_TYPE_P;
948  if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
949  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
950  return ret;
951  }
952  } else if (frame_4cc == AV_RL32("snd_")) {
953  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
954  buf_size);
955  } else {
956  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
957  buf_size);
958  }
959 
960  f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
961 
962  if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
963  return ret;
964  *got_frame = 1;
965 
966  emms_c();
967 
968  return buf_size;
969 }
970 
971 static av_cold int decode_init(AVCodecContext *avctx)
972 {
973  FourXContext * const f = avctx->priv_data;
974 
975  if (avctx->extradata_size != 4 || !avctx->extradata) {
976  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
977  return AVERROR_INVALIDDATA;
978  }
979  if((avctx->width % 16) || (avctx->height % 16)) {
980  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
981  return AVERROR_INVALIDDATA;
982  }
983 
984  f->version = AV_RL32(avctx->extradata) >> 16;
985  ff_dsputil_init(&f->dsp, avctx);
986  f->avctx = avctx;
987  init_vlcs(f);
988 
989  if (f->version > 2)
990  avctx->pix_fmt = AV_PIX_FMT_RGB565;
991  else
992  avctx->pix_fmt = AV_PIX_FMT_BGR555;
993 
994  f->current_picture = av_frame_alloc();
995  f->last_picture = av_frame_alloc();
996  if (!f->current_picture || !f->last_picture)
997  return AVERROR(ENOMEM);
998 
999  return 0;
1000 }
1001 
1002 
1003 static av_cold int decode_end(AVCodecContext *avctx)
1004 {
1005  FourXContext * const f = avctx->priv_data;
1006  int i;
1007 
1008  av_freep(&f->bitstream_buffer);
1009  f->bitstream_buffer_size = 0;
1010  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1011  av_freep(&f->cfrm[i].data);
1012  f->cfrm[i].allocated_size = 0;
1013  }
1014  ff_free_vlc(&f->pre_vlc);
1015  av_frame_free(&f->current_picture);
1016  av_frame_free(&f->last_picture);
1017 
1018  return 0;
1019 }
1020 
1021 AVCodec ff_fourxm_decoder = {
1022  .name = "4xm",
1023  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1024  .type = AVMEDIA_TYPE_VIDEO,
1025  .id = AV_CODEC_ID_4XM,
1026  .priv_data_size = sizeof(FourXContext),
1027  .init = decode_init,
1028  .close = decode_end,
1029  .decode = decode_frame,
1030  .capabilities = CODEC_CAP_DR1,
1031 };
Generated on Sat Jan 25 2014 19:51:43 for FFmpeg by   doxygen 1.8.2