FFmpeg
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 "libavutil/mem_internal.h"
34 #include "avcodec.h"
35 #include "blockdsp.h"
36 #include "bswapdsp.h"
37 #include "bytestream.h"
38 #include "get_bits.h"
39 #include "internal.h"
40 
41 
42 #define BLOCK_TYPE_VLC_BITS 5
43 #define ACDC_VLC_BITS 9
44 
45 #define CFRAME_BUFFER_COUNT 100
46 
47 static const uint8_t block_type_tab[2][4][8][2] = {
48  {
49  { // { 8, 4, 2 } x { 8, 4, 2}
50  { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
51  }, { // { 8, 4 } x 1
52  { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
53  }, { // 1 x { 8, 4 }
54  { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
55  }, { // 1 x 2, 2 x 1
56  { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
57  }
58  }, {
59  { // { 8, 4, 2 } x { 8, 4, 2}
60  { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61  }, {// { 8, 4 } x 1
62  { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
63  }, {// 1 x { 8, 4 }
64  { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
65  }, {// 1 x 2, 2 x 1
66  { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
67  }
68  }
69 };
70 
71 static const uint8_t size2index[4][4] = {
72  { -1, 3, 1, 1 },
73  { 3, 0, 0, 0 },
74  { 2, 0, 0, 0 },
75  { 2, 0, 0, 0 },
76 };
77 
78 static const int8_t mv[256][2] = {
79  { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
80  { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
81  { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
82  { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
83  { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
84  { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
85  { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
86  { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
87  { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
88  { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
89  { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
90  { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
91  { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
92  { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
93  { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
94  { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
95  { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
96  { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
97  { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
98  { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
99  { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
100  { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
101  { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
102  { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
103  { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
104  { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
105  { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
106  { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
107  { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
108  { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
109  { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
110  { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
111 };
112 
113 /* This is simply the scaled down elementwise product of the standard JPEG
114  * quantizer table and the AAN premul table. */
115 static const uint8_t dequant_table[64] = {
116  16, 15, 13, 19, 24, 31, 28, 17,
117  17, 23, 25, 31, 36, 63, 45, 21,
118  18, 24, 27, 37, 52, 59, 49, 20,
119  16, 28, 34, 40, 60, 80, 51, 20,
120  18, 31, 48, 66, 68, 86, 56, 21,
121  19, 38, 56, 59, 64, 64, 48, 20,
122  27, 48, 55, 55, 56, 51, 35, 15,
123  20, 35, 34, 32, 31, 22, 15, 8,
124 };
125 
126 static VLC block_type_vlc[2][4];
127 
128 
129 typedef struct CFrameBuffer {
130  unsigned int allocated_size;
131  unsigned int size;
132  int id;
134 } CFrameBuffer;
135 
136 typedef struct FourXContext {
140  uint16_t *frame_buffer;
141  uint16_t *last_frame_buffer;
142  GetBitContext pre_gb; ///< ac/dc prefix
146  int mv[256];
148  int last_dc;
149  DECLARE_ALIGNED(32, int16_t, block)[6][64];
151  unsigned int bitstream_buffer_size;
152  int version;
154 } FourXContext;
155 
156 
157 #define FIX_1_082392200 70936
158 #define FIX_1_414213562 92682
159 #define FIX_1_847759065 121095
160 #define FIX_2_613125930 171254
161 
162 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
163 
164 static void idct(int16_t block[64])
165 {
166  int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
167  int tmp10, tmp11, tmp12, tmp13;
168  int z5, z10, z11, z12, z13;
169  int i;
170  int temp[64];
171 
172  for (i = 0; i < 8; i++) {
173  tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
174  tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
175 
176  tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
177  tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
178 
179  tmp0 = tmp10 + tmp13;
180  tmp3 = tmp10 - tmp13;
181  tmp1 = tmp11 + tmp12;
182  tmp2 = tmp11 - tmp12;
183 
184  z13 = block[8 * 5 + i] + block[8 * 3 + i];
185  z10 = block[8 * 5 + i] - block[8 * 3 + i];
186  z11 = block[8 * 1 + i] + block[8 * 7 + i];
187  z12 = block[8 * 1 + i] - block[8 * 7 + i];
188 
189  tmp7 = z11 + z13;
190  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
191 
192  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
193  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
194  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
195 
196  tmp6 = tmp12 - tmp7;
197  tmp5 = tmp11 - tmp6;
198  tmp4 = tmp10 + tmp5;
199 
200  temp[8 * 0 + i] = tmp0 + tmp7;
201  temp[8 * 7 + i] = tmp0 - tmp7;
202  temp[8 * 1 + i] = tmp1 + tmp6;
203  temp[8 * 6 + i] = tmp1 - tmp6;
204  temp[8 * 2 + i] = tmp2 + tmp5;
205  temp[8 * 5 + i] = tmp2 - tmp5;
206  temp[8 * 4 + i] = tmp3 + tmp4;
207  temp[8 * 3 + i] = tmp3 - tmp4;
208  }
209 
210  for (i = 0; i < 8 * 8; i += 8) {
211  tmp10 = temp[0 + i] + temp[4 + i];
212  tmp11 = temp[0 + i] - temp[4 + i];
213 
214  tmp13 = temp[2 + i] + temp[6 + i];
215  tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
216 
217  tmp0 = tmp10 + tmp13;
218  tmp3 = tmp10 - tmp13;
219  tmp1 = tmp11 + tmp12;
220  tmp2 = tmp11 - tmp12;
221 
222  z13 = temp[5 + i] + temp[3 + i];
223  z10 = temp[5 + i] - temp[3 + i];
224  z11 = temp[1 + i] + temp[7 + i];
225  z12 = temp[1 + i] - temp[7 + i];
226 
227  tmp7 = z11 + z13;
228  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
229 
230  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
231  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
232  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
233 
234  tmp6 = tmp12 - tmp7;
235  tmp5 = tmp11 - tmp6;
236  tmp4 = tmp10 + tmp5;
237 
238  block[0 + i] = (tmp0 + tmp7) >> 6;
239  block[7 + i] = (tmp0 - tmp7) >> 6;
240  block[1 + i] = (tmp1 + tmp6) >> 6;
241  block[6 + i] = (tmp1 - tmp6) >> 6;
242  block[2 + i] = (tmp2 + tmp5) >> 6;
243  block[5 + i] = (tmp2 - tmp5) >> 6;
244  block[4 + i] = (tmp3 + tmp4) >> 6;
245  block[3 + i] = (tmp3 - tmp4) >> 6;
246  }
247 }
248 
250 {
251  static VLC_TYPE table[2][4][32][2];
252  int i, j;
253 
254  for (i = 0; i < 2; i++) {
255  for (j = 0; j < 4; j++) {
256  block_type_vlc[i][j].table = table[i][j];
257  block_type_vlc[i][j].table_allocated = 32;
258  init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
259  &block_type_tab[i][j][0][1], 2, 1,
260  &block_type_tab[i][j][0][0], 2, 1,
262  }
263  }
264 }
265 
266 static void init_mv(FourXContext *f, int linesize)
267 {
268  int i;
269 
270  for (i = 0; i < 256; i++) {
271  if (f->version > 1)
272  f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
273  else
274  f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
275  }
276 }
277 
278 #if HAVE_BIGENDIAN
279 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
280  { \
281  unsigned tmpval = AV_RN32(src); \
282  tmpval = (tmpval << 16) | (tmpval >> 16); \
283  tmpval = tmpval * (scale) + (dc); \
284  tmpval = (tmpval << 16) | (tmpval >> 16); \
285  AV_WN32A(dst, tmpval); \
286  }
287 #else
288 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
289  { \
290  unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
291  AV_WN32A(dst, tmpval); \
292  }
293 #endif
294 
295 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
296  int h, int stride, int scale, unsigned dc)
297 {
298  int i;
299  dc *= 0x10001;
300 
301  switch (log2w) {
302  case 0:
303  for (i = 0; i < h; i++) {
304  dst[0] = scale * src[0] + dc;
305  if (scale)
306  src += stride;
307  dst += stride;
308  }
309  break;
310  case 1:
311  for (i = 0; i < h; i++) {
312  LE_CENTRIC_MUL(dst, src, scale, dc);
313  if (scale)
314  src += stride;
315  dst += stride;
316  }
317  break;
318  case 2:
319  for (i = 0; i < h; i++) {
320  LE_CENTRIC_MUL(dst, src, scale, dc);
321  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
322  if (scale)
323  src += stride;
324  dst += stride;
325  }
326  break;
327  case 3:
328  for (i = 0; i < h; i++) {
329  LE_CENTRIC_MUL(dst, src, scale, dc);
330  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
331  LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
332  LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
333  if (scale)
334  src += stride;
335  dst += stride;
336  }
337  break;
338  default:
339  av_assert0(0);
340  }
341 }
342 
343 static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
344  int log2w, int log2h, int stride)
345 {
346  int index, h, code, ret, scale = 1;
347  uint16_t *start, *end;
348  unsigned dc = 0;
349 
350  av_assert0(log2w >= 0 && log2h >= 0);
351 
352  index = size2index[log2h][log2w];
353  av_assert0(index >= 0);
354 
355  if (get_bits_left(&f->gb) < 1)
356  return AVERROR_INVALIDDATA;
357  h = 1 << log2h;
358  code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
360  av_assert0(code >= 0 && code <= 6);
361 
362  start = f->last_frame_buffer;
363  end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
364 
365  if (code == 1) {
366  log2h--;
367  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
368  return ret;
369  return decode_p_block(f, dst + (stride << log2h),
370  src + (stride << log2h),
371  log2w, log2h, stride);
372  } else if (code == 2) {
373  log2w--;
374  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
375  return ret;
376  return decode_p_block(f, dst + (1 << log2w),
377  src + (1 << log2w),
378  log2w, log2h, stride);
379  } else if (code == 6) {
380  if (bytestream2_get_bytes_left(&f->g2) < 4) {
381  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
382  return AVERROR_INVALIDDATA;
383  }
384  if (log2w) {
385  dst[0] = bytestream2_get_le16u(&f->g2);
386  dst[1] = bytestream2_get_le16u(&f->g2);
387  } else {
388  dst[0] = bytestream2_get_le16u(&f->g2);
389  dst[stride] = bytestream2_get_le16u(&f->g2);
390  }
391  return 0;
392  }
393 
394  if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
395  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
396  return AVERROR_INVALIDDATA;
397  }
398 
399  if (code == 0) {
400  src += f->mv[bytestream2_get_byte(&f->g)];
401  } else if (code == 3 && f->version >= 2) {
402  return 0;
403  } else if (code == 4) {
404  src += f->mv[bytestream2_get_byte(&f->g)];
405  if (bytestream2_get_bytes_left(&f->g2) < 2){
406  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
407  return AVERROR_INVALIDDATA;
408  }
409  dc = bytestream2_get_le16(&f->g2);
410  } else if (code == 5) {
411  if (bytestream2_get_bytes_left(&f->g2) < 2){
412  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
413  return AVERROR_INVALIDDATA;
414  }
415  av_assert0(start <= src && src <= end);
416  scale = 0;
417  dc = bytestream2_get_le16(&f->g2);
418  }
419 
420  if (start > src || src > end) {
421  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
422  return AVERROR_INVALIDDATA;
423  }
424 
425  mcdc(dst, src, log2w, h, stride, scale, dc);
426 
427  return 0;
428 }
429 
430 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
431 {
432  int x, y;
433  const int width = f->avctx->width;
434  const int height = f->avctx->height;
435  uint16_t *dst = f->frame_buffer;
436  uint16_t *src;
437  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
438  bytestream_offset, wordstream_offset;
439  int ret;
440 
441  src = f->last_frame_buffer;
442 
443  if (f->version > 1) {
444  extra = 20;
445  if (length < extra)
446  return AVERROR_INVALIDDATA;
447  bitstream_size = AV_RL32(buf + 8);
448  wordstream_size = AV_RL32(buf + 12);
449  bytestream_size = AV_RL32(buf + 16);
450  } else {
451  extra = 0;
452  bitstream_size = AV_RL16(buf - 4);
453  wordstream_size = AV_RL16(buf - 2);
454  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
455  }
456 
457  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
458  bytestream_size > length - bitstream_size ||
459  wordstream_size > length - bytestream_size - bitstream_size ||
460  extra > length - bytestream_size - bitstream_size - wordstream_size) {
461  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
462  bitstream_size+ bytestream_size+ wordstream_size - length);
463  return AVERROR_INVALIDDATA;
464  }
465 
467  bitstream_size);
468  if (!f->bitstream_buffer)
469  return AVERROR(ENOMEM);
470  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
471  bitstream_size / 4);
472  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
473 
474  wordstream_offset = extra + bitstream_size;
475  bytestream_offset = extra + bitstream_size + wordstream_size;
476  bytestream2_init(&f->g2, buf + wordstream_offset,
477  length - wordstream_offset);
478  bytestream2_init(&f->g, buf + bytestream_offset,
479  length - bytestream_offset);
480 
481  init_mv(f, width * 2);
482 
483  for (y = 0; y < height; y += 8) {
484  for (x = 0; x < width; x += 8)
485  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
486  return ret;
487  src += 8 * width;
488  dst += 8 * width;
489  }
490 
491  return 0;
492 }
493 
494 /**
495  * decode block and dequantize.
496  * Note this is almost identical to MJPEG.
497  */
498 static int decode_i_block(FourXContext *f, int16_t *block)
499 {
500  int code, i, j, level, val;
501 
502  if (get_bits_left(&f->pre_gb) < 2) {
503  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->pre_gb));
504  return AVERROR_INVALIDDATA;
505  }
506 
507  /* DC coef */
508  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
509  if (val >> 4) {
510  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
511  return AVERROR_INVALIDDATA;
512  }
513 
514  if (val)
515  val = get_xbits(&f->gb, val);
516 
517  val = val * dequant_table[0] + f->last_dc;
518  f->last_dc = block[0] = val;
519  /* AC coefs */
520  i = 1;
521  for (;;) {
522  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
523 
524  /* EOB */
525  if (code == 0)
526  break;
527  if (code == 0xf0) {
528  i += 16;
529  if (i >= 64) {
530  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
531  return 0;
532  }
533  } else {
534  if (code & 0xf) {
535  level = get_xbits(&f->gb, code & 0xf);
536  } else {
537  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
538  return AVERROR_INVALIDDATA;
539  }
540  i += code >> 4;
541  if (i >= 64) {
542  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
543  return 0;
544  }
545 
546  j = ff_zigzag_direct[i];
547  block[j] = level * dequant_table[j];
548  i++;
549  if (i >= 64)
550  break;
551  }
552  }
553 
554  return 0;
555 }
556 
557 static inline void idct_put(FourXContext *f, int x, int y)
558 {
559  int16_t (*block)[64] = f->block;
560  int stride = f->avctx->width;
561  int i;
562  uint16_t *dst = f->frame_buffer + y * stride + x;
563 
564  for (i = 0; i < 4; i++) {
565  block[i][0] += 0x80 * 8 * 8;
566  idct(block[i]);
567  }
568 
569  if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
570  for (i = 4; i < 6; i++)
571  idct(block[i]);
572  }
573 
574  /* Note transform is:
575  * y = ( 1b + 4g + 2r) / 14
576  * cb = ( 3b - 2g - 1r) / 14
577  * cr = (-1b - 4g + 5r) / 14 */
578  for (y = 0; y < 8; y++) {
579  for (x = 0; x < 8; x++) {
580  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
581  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
582  int cb = block[4][x + 8 * y];
583  int cr = block[5][x + 8 * y];
584  int cg = (cb + cr) >> 1;
585  int y;
586 
587  cb += cb;
588 
589  y = temp[0];
590  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
591  y = temp[1];
592  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593  y = temp[8];
594  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595  y = temp[9];
596  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
597  dst += 2;
598  }
599  dst += 2 * stride - 2 * 8;
600  }
601 }
602 
604 {
605  int ret;
606  int i;
607 
608  f->bdsp.clear_blocks(f->block[0]);
609 
610  for (i = 0; i < 6; i++)
611  if ((ret = decode_i_block(f, f->block[i])) < 0)
612  return ret;
613 
614  return 0;
615 }
616 
618  const uint8_t * const buf,
619  int buf_size)
620 {
621  int frequency[512] = { 0 };
622  uint8_t flag[512];
623  int up[512];
624  uint8_t len_tab[257];
625  int bits_tab[257];
626  int start, end;
627  const uint8_t *ptr = buf;
628  const uint8_t *ptr_end = buf + buf_size;
629  int j;
630 
631  memset(up, -1, sizeof(up));
632 
633  start = *ptr++;
634  end = *ptr++;
635  for (;;) {
636  int i;
637 
638  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
639  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
640  return NULL;
641  }
642 
643  for (i = start; i <= end; i++)
644  frequency[i] = *ptr++;
645  start = *ptr++;
646  if (start == 0)
647  break;
648 
649  end = *ptr++;
650  }
651  frequency[256] = 1;
652 
653  while ((ptr - buf) & 3)
654  ptr++; // 4byte align
655 
656  if (ptr > ptr_end) {
657  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
658  return NULL;
659  }
660 
661  for (j = 257; j < 512; j++) {
662  int min_freq[2] = { 256 * 256, 256 * 256 };
663  int smallest[2] = { 0, 0 };
664  int i;
665  for (i = 0; i < j; i++) {
666  if (frequency[i] == 0)
667  continue;
668  if (frequency[i] < min_freq[1]) {
669  if (frequency[i] < min_freq[0]) {
670  min_freq[1] = min_freq[0];
671  smallest[1] = smallest[0];
672  min_freq[0] = frequency[i];
673  smallest[0] = i;
674  } else {
675  min_freq[1] = frequency[i];
676  smallest[1] = i;
677  }
678  }
679  }
680  if (min_freq[1] == 256 * 256)
681  break;
682 
683  frequency[j] = min_freq[0] + min_freq[1];
684  flag[smallest[0]] = 0;
685  flag[smallest[1]] = 1;
686  up[smallest[0]] =
687  up[smallest[1]] = j;
688  frequency[smallest[0]] = frequency[smallest[1]] = 0;
689  }
690 
691  for (j = 0; j < 257; j++) {
692  int node, len = 0, bits = 0;
693 
694  for (node = j; up[node] != -1; node = up[node]) {
695  bits += flag[node] << len;
696  len++;
697  if (len > 31)
698  // can this happen at all ?
700  "vlc length overflow\n");
701  }
702 
703  bits_tab[j] = bits;
704  len_tab[j] = len;
705  }
706 
707  ff_free_vlc(&f->pre_vlc);
708  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
709  bits_tab, 4, 4, 0))
710  return NULL;
711 
712  return ptr;
713 }
714 
715 static int mix(int c0, int c1)
716 {
717  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
718  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
719  int red = 2 * (c0 >> 10) + (c1 >> 10);
720  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
721 }
722 
723 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
724 {
725  int x, y, x2, y2;
726  const int width = f->avctx->width;
727  const int height = f->avctx->height;
728  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
729  uint16_t *dst = f->frame_buffer;
730  const uint8_t *buf_end = buf + length;
731  GetByteContext g3;
732 
733  if (length < mbs * 8) {
734  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
735  return AVERROR_INVALIDDATA;
736  }
737  bytestream2_init(&g3, buf, length);
738 
739  for (y = 0; y < height; y += 16) {
740  for (x = 0; x < width; x += 16) {
741  unsigned int color[4] = { 0 }, bits;
742  if (buf_end - buf < 8)
743  return AVERROR_INVALIDDATA;
744  // warning following is purely guessed ...
745  color[0] = bytestream2_get_le16u(&g3);
746  color[1] = bytestream2_get_le16u(&g3);
747 
748  if (color[0] & 0x8000)
749  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
750  if (color[1] & 0x8000)
751  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
752 
753  color[2] = mix(color[0], color[1]);
754  color[3] = mix(color[1], color[0]);
755 
756  bits = bytestream2_get_le32u(&g3);
757  for (y2 = 0; y2 < 16; y2++) {
758  for (x2 = 0; x2 < 16; x2++) {
759  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
760  dst[y2 * width + x2] = color[(bits >> index) & 3];
761  }
762  }
763  dst += 16;
764  }
765  dst += 16 * width - x;
766  }
767 
768  return 0;
769 }
770 
771 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
772 {
773  int x, y, ret;
774  const int width = f->avctx->width;
775  const int height = f->avctx->height;
776  const unsigned int bitstream_size = AV_RL32(buf);
777  unsigned int prestream_size;
778  const uint8_t *prestream;
779 
780  if (bitstream_size > (1 << 26))
781  return AVERROR_INVALIDDATA;
782 
783  if (length < bitstream_size + 12) {
784  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
785  return AVERROR_INVALIDDATA;
786  }
787 
788  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
789  prestream = buf + bitstream_size + 12;
790 
791  if (prestream_size + bitstream_size + 12 != length
792  || prestream_size > (1 << 26)) {
793  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
794  prestream_size, bitstream_size, length);
795  return AVERROR_INVALIDDATA;
796  }
797 
798  prestream = read_huffman_tables(f, prestream, prestream_size);
799  if (!prestream) {
800  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
801  return AVERROR_INVALIDDATA;
802  }
803 
804  av_assert0(prestream <= buf + length);
805 
806  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
807 
808  prestream_size = length + buf - prestream;
809 
811  prestream_size);
812  if (!f->bitstream_buffer)
813  return AVERROR(ENOMEM);
814  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
815  prestream_size / 4);
816  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
817 
818  f->last_dc = 0 * 128 * 8 * 8;
819 
820  for (y = 0; y < height; y += 16) {
821  for (x = 0; x < width; x += 16) {
822  if ((ret = decode_i_mb(f)) < 0)
823  return ret;
824 
825  idct_put(f, x, y);
826  }
827  }
828 
829  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
830  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
831 
832  return 0;
833 }
834 
835 static int decode_frame(AVCodecContext *avctx, void *data,
836  int *got_frame, AVPacket *avpkt)
837 {
838  const uint8_t *buf = avpkt->data;
839  int buf_size = avpkt->size;
840  FourXContext *const f = avctx->priv_data;
841  AVFrame *picture = data;
842  int i, frame_4cc, frame_size, ret;
843 
844  if (buf_size < 20)
845  return AVERROR_INVALIDDATA;
846 
847  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
848 
849  if (buf_size < AV_RL32(buf + 4) + 8) {
850  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
851  buf_size, AV_RL32(buf + 4));
852  return AVERROR_INVALIDDATA;
853  }
854 
855  frame_4cc = AV_RL32(buf);
856 
857  if (frame_4cc == AV_RL32("cfrm")) {
858  int free_index = -1;
859  int id, whole_size;
860  const int data_size = buf_size - 20;
861  CFrameBuffer *cfrm;
862 
863  if (f->version <= 1) {
864  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
865  return AVERROR_INVALIDDATA;
866  }
867 
868  id = AV_RL32(buf + 12);
869  whole_size = AV_RL32(buf + 16);
870 
871  if (data_size < 0 || whole_size < 0) {
872  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
873  return AVERROR_INVALIDDATA;
874  }
875 
876  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
877  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
878  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
879  f->cfrm[i].id);
880 
881  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
882  if (f->cfrm[i].id == id)
883  break;
884  if (f->cfrm[i].size == 0)
885  free_index = i;
886  }
887 
888  if (i >= CFRAME_BUFFER_COUNT) {
889  i = free_index;
890  f->cfrm[i].id = id;
891  }
892  cfrm = &f->cfrm[i];
893 
894  if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
895  return AVERROR_INVALIDDATA;
896 
897  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
898  cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
899  // explicit check needed as memcpy below might not catch a NULL
900  if (!cfrm->data) {
901  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
902  return AVERROR(ENOMEM);
903  }
904 
905  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
906  cfrm->size += data_size;
907 
908  if (cfrm->size >= whole_size) {
909  buf = cfrm->data;
910  frame_size = cfrm->size;
911 
912  if (id != avctx->frame_number)
913  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
914  id, avctx->frame_number);
915 
916  if (f->version <= 1)
917  return AVERROR_INVALIDDATA;
918 
919  cfrm->size = cfrm->id = 0;
920  frame_4cc = AV_RL32("pfrm");
921  } else
922  return buf_size;
923  } else {
924  buf = buf + 12;
925  frame_size = buf_size - 12;
926  }
927 
928  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
929  return ret;
930 
931  if (frame_4cc == AV_RL32("ifr2")) {
932  picture->pict_type = AV_PICTURE_TYPE_I;
933  if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
934  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
935  return ret;
936  }
937  } else if (frame_4cc == AV_RL32("ifrm")) {
938  picture->pict_type = AV_PICTURE_TYPE_I;
939  if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
940  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
941  return ret;
942  }
943  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
944  picture->pict_type = AV_PICTURE_TYPE_P;
945  if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
946  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
947  return ret;
948  }
949  } else if (frame_4cc == AV_RL32("snd_")) {
950  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
951  buf_size);
952  } else {
953  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
954  buf_size);
955  }
956 
957  picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
958 
959  av_image_copy_plane(picture->data[0], picture->linesize[0],
960  (const uint8_t*)f->frame_buffer, avctx->width * 2,
961  avctx->width * 2, avctx->height);
962  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
963 
964  *got_frame = 1;
965 
966  emms_c();
967 
968  return buf_size;
969 }
970 
972 {
973  FourXContext * const f = avctx->priv_data;
974  int i;
975 
976  av_freep(&f->frame_buffer);
979  f->bitstream_buffer_size = 0;
980  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
981  av_freep(&f->cfrm[i].data);
982  f->cfrm[i].allocated_size = 0;
983  }
984  ff_free_vlc(&f->pre_vlc);
985 
986  return 0;
987 }
988 
990 {
991  FourXContext * const f = avctx->priv_data;
992  int ret;
993 
994  if (avctx->extradata_size != 4 || !avctx->extradata) {
995  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
996  return AVERROR_INVALIDDATA;
997  }
998  if((avctx->width % 16) || (avctx->height % 16)) {
999  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
1000  return AVERROR_INVALIDDATA;
1001  }
1002 
1003  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1004  if (ret < 0)
1005  return ret;
1006 
1007  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1008  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1009  if (!f->frame_buffer || !f->last_frame_buffer) {
1010  decode_end(avctx);
1011  return AVERROR(ENOMEM);
1012  }
1013 
1014  f->version = AV_RL32(avctx->extradata) >> 16;
1015  ff_blockdsp_init(&f->bdsp, avctx);
1016  ff_bswapdsp_init(&f->bbdsp);
1017  f->avctx = avctx;
1018  init_vlcs(f);
1019 
1020  if (f->version > 2)
1021  avctx->pix_fmt = AV_PIX_FMT_RGB565;
1022  else
1023  avctx->pix_fmt = AV_PIX_FMT_BGR555;
1024 
1025  return 0;
1026 }
1027 
1029  .name = "4xm",
1030  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1031  .type = AVMEDIA_TYPE_VIDEO,
1032  .id = AV_CODEC_ID_4XM,
1033  .priv_data_size = sizeof(FourXContext),
1034  .init = decode_init,
1035  .close = decode_end,
1036  .decode = decode_frame,
1037  .capabilities = AV_CODEC_CAP_DR1,
1038 };
#define NULL
Definition: coverity.c:32
GetByteContext g
Definition: 4xm.c:144
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
static void idct(int16_t block[64])
Definition: 4xm.c:164
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
misc image utilities
BlockDSPContext bdsp
Definition: 4xm.c:138
else temp
Definition: vf_mcdeint.c:259
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
int size
Definition: packet.h:370
static av_cold void init_vlcs(FourXContext *f)
Definition: 4xm.c:249
AVCodec ff_fourxm_decoder
Definition: 4xm.c:1028
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
int id
Definition: 4xm.c:132
static VLC block_type_vlc[2][4]
Definition: 4xm.c:126
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition: 4xm.c:617
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition: 4xm.c:295
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:50
#define FIX_1_414213562
Definition: 4xm.c:158
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define FIX_1_082392200
Definition: 4xm.c:157
fg index
AVCodec.
Definition: codec.h:197
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:91
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
unsigned int size
Definition: 4xm.c:131
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
#define f(width, name)
Definition: cbs_vp9.c:255
unsigned int allocated_size
Definition: 4xm.c:130
uint16_t * last_frame_buffer
Definition: 4xm.c:141
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
static const uint8_t block_type_tab[2][4][8][2]
Definition: 4xm.c:47
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
#define height
uint8_t * data
Definition: packet.h:369
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:989
static const uint64_t c1
Definition: murmur3.c:51
bitstream reader API header.
AVCodecContext * avctx
Definition: 4xm.c:137
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: 4xm.c:835
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
static int decode_i_mb(FourXContext *f)
Definition: 4xm.c:603
#define src
Definition: vp8dsp.c:255
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
GetBitContext gb
Definition: 4xm.c:143
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition: 4xm.c:288
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:37
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition: 4xm.c:498
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
#define FIX_1_847759065
Definition: 4xm.c:159
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
void * bitstream_buffer
Definition: 4xm.c:150
simple assert() macros that are a bit more flexible than ISO C assert().
GLsizei GLsizei * length
Definition: opengl_enc.c:114
static const uint8_t size2index[4][4]
Definition: 4xm.c:71
const char * name
Name of the codec implementation.
Definition: codec.h:204
uint8_t bits
Definition: vp3data.h:141
#define FFMAX(a, b)
Definition: common.h:103
Definition: vlc.h:26
reference-counted frame API
#define CFRAME_BUFFER_COUNT
Definition: 4xm.c:45
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:771
uint16_t * frame_buffer
Definition: 4xm.c:140
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
#define width
int width
picture width / height.
Definition: avcodec.h:709
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
VLC pre_vlc
Definition: 4xm.c:147
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition: 4xm.c:343
int table_allocated
Definition: vlc.h:29
static const int8_t mv[256][2]
Definition: 4xm.c:78
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:392
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:557
static int mix(int c0, int c1)
Definition: 4xm.c:715
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:723
int frame_size
Definition: mxfenc.c:2206
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
main external API structure.
Definition: avcodec.h:536
static void init_mv(FourXContext *f, int linesize)
Definition: 4xm.c:266
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition: get_bits.h:321
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
int extradata_size
Definition: avcodec.h:638
static const uint8_t dequant_table[64]
Definition: 4xm.c:115
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: 4xm.c:153
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#define ACDC_VLC_BITS
Definition: 4xm.c:43
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
unsigned int bitstream_buffer_size
Definition: 4xm.c:151
uint8_t * data
Definition: 4xm.c:133
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static av_cold int decode_end(AVCodecContext *avctx)
Definition: 4xm.c:971
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
uint8_t level
Definition: svq3.c:204
#define FIX_2_613125930
Definition: 4xm.c:160
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
BswapDSPContext bbdsp
Definition: 4xm.c:139
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:430
common internal api header.
#define flag(name)
Definition: cbs_av1.c:553
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
GetBitContext pre_gb
ac/dc prefix
Definition: 4xm.c:142
int mv[256]
Definition: 4xm.c:146
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:563
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
int len
int last_dc
Definition: 4xm.c:148
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
GetByteContext g2
Definition: 4xm.c:145
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:386
int version
Definition: 4xm.c:152
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1227
int16_t block[6][64]
Definition: 4xm.c:149
#define av_freep(p)
#define BLOCK_TYPE_VLC_BITS
Definition: 4xm.c:42
#define VLC_TYPE
Definition: vlc.h:24
#define FFSWAP(type, a, b)
Definition: common.h:108
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:373
#define stride
#define MULTIPLY(var, const)
Definition: 4xm.c:162
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:346
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275