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