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