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