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