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 "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;
133 } CFrameBuffer;
134 
135 typedef struct FourXContext {
139  uint16_t *frame_buffer;
140  uint16_t *last_frame_buffer;
141  GetBitContext pre_gb; ///< ac/dc prefix
145  int mv[256];
147  int last_dc;
148  DECLARE_ALIGNED(32, int16_t, block)[6][64];
150  unsigned int bitstream_buffer_size;
151  int version;
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) ((int)((var) * (unsigned)(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 
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,
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, const uint16_t *src,
343  int log2w, int log2h, int stride)
344 {
345  int index, h, code, ret, scale = 1;
346  uint16_t *start, *end;
347  unsigned dc = 0;
348 
349  av_assert0(log2w >= 0 && log2h >= 0);
350 
351  index = size2index[log2h][log2w];
352  av_assert0(index >= 0);
353 
354  if (get_bits_left(&f->gb) < 1)
355  return AVERROR_INVALIDDATA;
356  h = 1 << log2h;
357  code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
359  av_assert0(code >= 0 && code <= 6);
360 
361  start = f->last_frame_buffer;
362  end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
363 
364  if (code == 1) {
365  log2h--;
366  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
367  return ret;
368  return decode_p_block(f, dst + (stride << log2h),
369  src + (stride << log2h),
370  log2w, log2h, stride);
371  } else if (code == 2) {
372  log2w--;
373  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
374  return ret;
375  return decode_p_block(f, dst + (1 << log2w),
376  src + (1 << log2w),
377  log2w, log2h, stride);
378  } else if (code == 6) {
379  if (bytestream2_get_bytes_left(&f->g2) < 4) {
380  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
381  return AVERROR_INVALIDDATA;
382  }
383  if (log2w) {
384  dst[0] = bytestream2_get_le16u(&f->g2);
385  dst[1] = bytestream2_get_le16u(&f->g2);
386  } else {
387  dst[0] = bytestream2_get_le16u(&f->g2);
388  dst[stride] = bytestream2_get_le16u(&f->g2);
389  }
390  return 0;
391  }
392 
393  if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
394  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
395  return AVERROR_INVALIDDATA;
396  }
397 
398  if (code == 0) {
399  src += f->mv[bytestream2_get_byte(&f->g)];
400  } else if (code == 3 && f->version >= 2) {
401  return 0;
402  } else if (code == 4) {
403  src += f->mv[bytestream2_get_byte(&f->g)];
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  dc = bytestream2_get_le16(&f->g2);
409  } else if (code == 5) {
410  if (bytestream2_get_bytes_left(&f->g2) < 2){
411  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
412  return AVERROR_INVALIDDATA;
413  }
414  av_assert0(start <= src && src <= end);
415  scale = 0;
416  dc = bytestream2_get_le16(&f->g2);
417  }
418 
419  if (start > src || src > end) {
420  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
421  return AVERROR_INVALIDDATA;
422  }
423 
424  mcdc(dst, src, log2w, h, stride, scale, dc);
425 
426  return 0;
427 }
428 
429 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
430 {
431  int x, y;
432  const int width = f->avctx->width;
433  const int height = f->avctx->height;
434  uint16_t *dst = f->frame_buffer;
435  uint16_t *src;
436  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
437  bytestream_offset, wordstream_offset;
438  int ret;
439 
440  src = f->last_frame_buffer;
441 
442  if (f->version > 1) {
443  extra = 20;
444  if (length < extra)
445  return AVERROR_INVALIDDATA;
446  bitstream_size = AV_RL32(buf + 8);
447  wordstream_size = AV_RL32(buf + 12);
448  bytestream_size = AV_RL32(buf + 16);
449  } else {
450  extra = 0;
451  bitstream_size = AV_RL16(buf - 4);
452  wordstream_size = AV_RL16(buf - 2);
453  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
454  }
455 
456  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
457  bytestream_size > length - bitstream_size ||
458  wordstream_size > length - bytestream_size - bitstream_size ||
459  extra > length - bytestream_size - bitstream_size - wordstream_size) {
460  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
461  bitstream_size+ bytestream_size+ wordstream_size - length);
462  return AVERROR_INVALIDDATA;
463  }
464 
466  bitstream_size);
467  if (!f->bitstream_buffer)
468  return AVERROR(ENOMEM);
469  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
470  bitstream_size / 4);
471  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
472 
473  wordstream_offset = extra + bitstream_size;
474  bytestream_offset = extra + bitstream_size + wordstream_size;
475  bytestream2_init(&f->g2, buf + wordstream_offset,
476  length - wordstream_offset);
477  bytestream2_init(&f->g, buf + bytestream_offset,
478  length - bytestream_offset);
479 
480  init_mv(f, width * 2);
481 
482  for (y = 0; y < height; y += 8) {
483  for (x = 0; x < width; x += 8)
484  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
485  return ret;
486  src += 8 * width;
487  dst += 8 * width;
488  }
489 
490  return 0;
491 }
492 
493 /**
494  * decode block and dequantize.
495  * Note this is almost identical to MJPEG.
496  */
497 static int decode_i_block(FourXContext *f, int16_t *block)
498 {
499  int code, i, j, level, val;
500 
501  if (get_bits_left(&f->gb) < 2){
502  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
503  return AVERROR_INVALIDDATA;
504  }
505 
506  /* DC coef */
507  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
508  if (val >> 4) {
509  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
510  return AVERROR_INVALIDDATA;
511  }
512 
513  if (val)
514  val = get_xbits(&f->gb, val);
515 
516  val = val * dequant_table[0] + f->last_dc;
517  f->last_dc = block[0] = val;
518  /* AC coefs */
519  i = 1;
520  for (;;) {
521  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
522 
523  /* EOB */
524  if (code == 0)
525  break;
526  if (code == 0xf0) {
527  i += 16;
528  } else {
529  if (code & 0xf) {
530  level = get_xbits(&f->gb, code & 0xf);
531  } else {
532  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
533  return AVERROR_INVALIDDATA;
534  }
535  i += code >> 4;
536  if (i >= 64) {
537  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
538  return 0;
539  }
540 
541  j = ff_zigzag_direct[i];
542  block[j] = level * dequant_table[j];
543  i++;
544  if (i >= 64)
545  break;
546  }
547  }
548 
549  return 0;
550 }
551 
552 static inline void idct_put(FourXContext *f, int x, int y)
553 {
554  int16_t (*block)[64] = f->block;
555  int stride = f->avctx->width;
556  int i;
557  uint16_t *dst = f->frame_buffer + y * stride + x;
558 
559  for (i = 0; i < 4; i++) {
560  block[i][0] += 0x80 * 8 * 8;
561  idct(block[i]);
562  }
563 
564  if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
565  for (i = 4; i < 6; i++)
566  idct(block[i]);
567  }
568 
569  /* Note transform is:
570  * y = ( 1b + 4g + 2r) / 14
571  * cb = ( 3b - 2g - 1r) / 14
572  * cr = (-1b - 4g + 5r) / 14 */
573  for (y = 0; y < 8; y++) {
574  for (x = 0; x < 8; x++) {
575  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
576  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
577  int cb = block[4][x + 8 * y];
578  int cr = block[5][x + 8 * y];
579  int cg = (cb + cr) >> 1;
580  int y;
581 
582  cb += cb;
583 
584  y = temp[0];
585  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
586  y = temp[1];
587  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
588  y = temp[8];
589  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590  y = temp[9];
591  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592  dst += 2;
593  }
594  dst += 2 * stride - 2 * 8;
595  }
596 }
597 
599 {
600  int ret;
601  int i;
602 
603  f->bdsp.clear_blocks(f->block[0]);
604 
605  for (i = 0; i < 6; i++)
606  if ((ret = decode_i_block(f, f->block[i])) < 0)
607  return ret;
608 
609  return 0;
610 }
611 
613  const uint8_t * const buf,
614  int buf_size)
615 {
616  int frequency[512] = { 0 };
617  uint8_t flag[512];
618  int up[512];
619  uint8_t len_tab[257];
620  int bits_tab[257];
621  int start, end;
622  const uint8_t *ptr = buf;
623  const uint8_t *ptr_end = buf + buf_size;
624  int j;
625 
626  memset(up, -1, sizeof(up));
627 
628  start = *ptr++;
629  end = *ptr++;
630  for (;;) {
631  int i;
632 
633  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
634  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
635  return NULL;
636  }
637 
638  for (i = start; i <= end; i++)
639  frequency[i] = *ptr++;
640  start = *ptr++;
641  if (start == 0)
642  break;
643 
644  end = *ptr++;
645  }
646  frequency[256] = 1;
647 
648  while ((ptr - buf) & 3)
649  ptr++; // 4byte align
650 
651  if (ptr > ptr_end) {
652  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
653  return NULL;
654  }
655 
656  for (j = 257; j < 512; j++) {
657  int min_freq[2] = { 256 * 256, 256 * 256 };
658  int smallest[2] = { 0, 0 };
659  int i;
660  for (i = 0; i < j; i++) {
661  if (frequency[i] == 0)
662  continue;
663  if (frequency[i] < min_freq[1]) {
664  if (frequency[i] < min_freq[0]) {
665  min_freq[1] = min_freq[0];
666  smallest[1] = smallest[0];
667  min_freq[0] = frequency[i];
668  smallest[0] = i;
669  } else {
670  min_freq[1] = frequency[i];
671  smallest[1] = i;
672  }
673  }
674  }
675  if (min_freq[1] == 256 * 256)
676  break;
677 
678  frequency[j] = min_freq[0] + min_freq[1];
679  flag[smallest[0]] = 0;
680  flag[smallest[1]] = 1;
681  up[smallest[0]] =
682  up[smallest[1]] = j;
683  frequency[smallest[0]] = frequency[smallest[1]] = 0;
684  }
685 
686  for (j = 0; j < 257; j++) {
687  int node, len = 0, bits = 0;
688 
689  for (node = j; up[node] != -1; node = up[node]) {
690  bits += flag[node] << len;
691  len++;
692  if (len > 31)
693  // can this happen at all ?
695  "vlc length overflow\n");
696  }
697 
698  bits_tab[j] = bits;
699  len_tab[j] = len;
700  }
701 
702  ff_free_vlc(&f->pre_vlc);
703  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
704  bits_tab, 4, 4, 0))
705  return NULL;
706 
707  return ptr;
708 }
709 
710 static int mix(int c0, int c1)
711 {
712  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
713  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
714  int red = 2 * (c0 >> 10) + (c1 >> 10);
715  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
716 }
717 
718 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
719 {
720  int x, y, x2, y2;
721  const int width = f->avctx->width;
722  const int height = f->avctx->height;
723  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
724  uint16_t *dst = f->frame_buffer;
725  const uint8_t *buf_end = buf + length;
726  GetByteContext g3;
727 
728  if (length < mbs * 8) {
729  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
730  return AVERROR_INVALIDDATA;
731  }
732  bytestream2_init(&g3, buf, length);
733 
734  for (y = 0; y < height; y += 16) {
735  for (x = 0; x < width; x += 16) {
736  unsigned int color[4] = { 0 }, bits;
737  if (buf_end - buf < 8)
738  return AVERROR_INVALIDDATA;
739  // warning following is purely guessed ...
740  color[0] = bytestream2_get_le16u(&g3);
741  color[1] = bytestream2_get_le16u(&g3);
742 
743  if (color[0] & 0x8000)
744  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
745  if (color[1] & 0x8000)
746  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
747 
748  color[2] = mix(color[0], color[1]);
749  color[3] = mix(color[1], color[0]);
750 
751  bits = bytestream2_get_le32u(&g3);
752  for (y2 = 0; y2 < 16; y2++) {
753  for (x2 = 0; x2 < 16; x2++) {
754  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
755  dst[y2 * width + x2] = color[(bits >> index) & 3];
756  }
757  }
758  dst += 16;
759  }
760  dst += 16 * width - x;
761  }
762 
763  return 0;
764 }
765 
766 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
767 {
768  int x, y, ret;
769  const int width = f->avctx->width;
770  const int height = f->avctx->height;
771  const unsigned int bitstream_size = AV_RL32(buf);
772  unsigned int prestream_size;
773  const uint8_t *prestream;
774 
775  if (bitstream_size > (1 << 26))
776  return AVERROR_INVALIDDATA;
777 
778  if (length < bitstream_size + 12) {
779  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
780  return AVERROR_INVALIDDATA;
781  }
782 
783  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
784  prestream = buf + bitstream_size + 12;
785 
786  if (prestream_size + bitstream_size + 12 != length
787  || prestream_size > (1 << 26)) {
788  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
789  prestream_size, bitstream_size, length);
790  return AVERROR_INVALIDDATA;
791  }
792 
793  prestream = read_huffman_tables(f, prestream, prestream_size);
794  if (!prestream) {
795  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
796  return AVERROR_INVALIDDATA;
797  }
798 
799  av_assert0(prestream <= buf + length);
800 
801  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
802 
803  prestream_size = length + buf - prestream;
804 
806  prestream_size);
807  if (!f->bitstream_buffer)
808  return AVERROR(ENOMEM);
809  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
810  prestream_size / 4);
811  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
812 
813  f->last_dc = 0 * 128 * 8 * 8;
814 
815  for (y = 0; y < height; y += 16) {
816  for (x = 0; x < width; x += 16) {
817  if ((ret = decode_i_mb(f)) < 0)
818  return ret;
819 
820  idct_put(f, x, y);
821  }
822  }
823 
824  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
825  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
826 
827  return 0;
828 }
829 
830 static int decode_frame(AVCodecContext *avctx, void *data,
831  int *got_frame, AVPacket *avpkt)
832 {
833  const uint8_t *buf = avpkt->data;
834  int buf_size = avpkt->size;
835  FourXContext *const f = avctx->priv_data;
836  AVFrame *picture = data;
837  int i, frame_4cc, frame_size, ret;
838 
839  if (buf_size < 20)
840  return AVERROR_INVALIDDATA;
841 
842  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
843 
844  if (buf_size < AV_RL32(buf + 4) + 8) {
845  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
846  buf_size, AV_RL32(buf + 4));
847  return AVERROR_INVALIDDATA;
848  }
849 
850  frame_4cc = AV_RL32(buf);
851 
852  if (frame_4cc == AV_RL32("cfrm")) {
853  int free_index = -1;
854  int id, whole_size;
855  const int data_size = buf_size - 20;
856  CFrameBuffer *cfrm;
857 
858  if (f->version <= 1) {
859  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
860  return AVERROR_INVALIDDATA;
861  }
862 
863  id = AV_RL32(buf + 12);
864  whole_size = AV_RL32(buf + 16);
865 
866  if (data_size < 0 || whole_size < 0) {
867  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
868  return AVERROR_INVALIDDATA;
869  }
870 
871  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
872  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
873  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
874  f->cfrm[i].id);
875 
876  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
877  if (f->cfrm[i].id == id)
878  break;
879  if (f->cfrm[i].size == 0)
880  free_index = i;
881  }
882 
883  if (i >= CFRAME_BUFFER_COUNT) {
884  i = free_index;
885  f->cfrm[i].id = id;
886  }
887  cfrm = &f->cfrm[i];
888 
889  if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
890  return AVERROR_INVALIDDATA;
891 
892  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
893  cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
894  // explicit check needed as memcpy below might not catch a NULL
895  if (!cfrm->data) {
896  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
897  return AVERROR(ENOMEM);
898  }
899 
900  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
901  cfrm->size += data_size;
902 
903  if (cfrm->size >= whole_size) {
904  buf = cfrm->data;
905  frame_size = cfrm->size;
906 
907  if (id != avctx->frame_number)
908  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
909  id, avctx->frame_number);
910 
911  if (f->version <= 1)
912  return AVERROR_INVALIDDATA;
913 
914  cfrm->size = cfrm->id = 0;
915  frame_4cc = AV_RL32("pfrm");
916  } else
917  return buf_size;
918  } else {
919  buf = buf + 12;
920  frame_size = buf_size - 12;
921  }
922 
923  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
924  return ret;
925 
926  if (frame_4cc == AV_RL32("ifr2")) {
927  picture->pict_type = AV_PICTURE_TYPE_I;
928  if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
929  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
930  return ret;
931  }
932  } else if (frame_4cc == AV_RL32("ifrm")) {
933  picture->pict_type = AV_PICTURE_TYPE_I;
934  if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
935  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
936  return ret;
937  }
938  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
939  picture->pict_type = AV_PICTURE_TYPE_P;
940  if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
941  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
942  return ret;
943  }
944  } else if (frame_4cc == AV_RL32("snd_")) {
945  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
946  buf_size);
947  } else {
948  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
949  buf_size);
950  }
951 
952  picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
953 
954  av_image_copy_plane(picture->data[0], picture->linesize[0],
955  (const uint8_t*)f->frame_buffer, avctx->width * 2,
956  avctx->width * 2, avctx->height);
957  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
958 
959  *got_frame = 1;
960 
961  emms_c();
962 
963  return buf_size;
964 }
965 
967 {
968  FourXContext * const f = avctx->priv_data;
969  int i;
970 
971  av_freep(&f->frame_buffer);
974  f->bitstream_buffer_size = 0;
975  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
976  av_freep(&f->cfrm[i].data);
977  f->cfrm[i].allocated_size = 0;
978  }
979  ff_free_vlc(&f->pre_vlc);
980 
981  return 0;
982 }
983 
985 {
986  FourXContext * const f = avctx->priv_data;
987  int ret;
988 
989  if (avctx->extradata_size != 4 || !avctx->extradata) {
990  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
991  return AVERROR_INVALIDDATA;
992  }
993  if((avctx->width % 16) || (avctx->height % 16)) {
994  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
995  return AVERROR_INVALIDDATA;
996  }
997 
998  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
999  if (ret < 0)
1000  return ret;
1001 
1002  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1003  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1004  if (!f->frame_buffer || !f->last_frame_buffer) {
1005  decode_end(avctx);
1006  return AVERROR(ENOMEM);
1007  }
1008 
1009  f->version = AV_RL32(avctx->extradata) >> 16;
1010  ff_blockdsp_init(&f->bdsp, avctx);
1011  ff_bswapdsp_init(&f->bbdsp);
1012  f->avctx = avctx;
1013  init_vlcs(f);
1014 
1015  if (f->version > 2)
1016  avctx->pix_fmt = AV_PIX_FMT_RGB565;
1017  else
1018  avctx->pix_fmt = AV_PIX_FMT_BGR555;
1019 
1020  return 0;
1021 }
1022 
1024  .name = "4xm",
1025  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1026  .type = AVMEDIA_TYPE_VIDEO,
1027  .id = AV_CODEC_ID_4XM,
1028  .priv_data_size = sizeof(FourXContext),
1029  .init = decode_init,
1030  .close = decode_end,
1031  .decode = decode_frame,
1032  .capabilities = AV_CODEC_CAP_DR1,
1033 };
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
GetByteContext g
Definition: 4xm.c:143
#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:295
static void idct(int16_t block[64])
Definition: 4xm.c:163
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
misc image utilities
BlockDSPContext bdsp
Definition: 4xm.c:137
else temp
Definition: vf_mcdeint.c:256
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1478
static av_cold void init_vlcs(FourXContext *f)
Definition: 4xm.c:248
AVCodec ff_fourxm_decoder
Definition: 4xm.c:1023
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
int id
Definition: 4xm.c:131
static VLC block_type_vlc[2][4]
Definition: 4xm.c:125
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition: 4xm.c:612
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition: 4xm.c:294
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:70
#define FIX_1_414213562
Definition: 4xm.c:157
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
#define FIX_1_082392200
Definition: 4xm.c:156
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3481
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
#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:112
unsigned int size
Definition: 4xm.c:130
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:82
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
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
unsigned int allocated_size
Definition: 4xm.c:129
uint16_t * last_frame_buffer
Definition: 4xm.c:140
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
static const uint8_t block_type_tab[2][4][8][2]
Definition: 4xm.c:46
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
#define height
uint8_t * data
Definition: avcodec.h:1477
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:984
static const uint64_t c1
Definition: murmur3.c:49
bitstream reader API header.
AVCodecContext * avctx
Definition: 4xm.c:136
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:883
#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:830
static int decode_i_mb(FourXContext *f)
Definition: 4xm.c:598
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
GetBitContext gb
Definition: 4xm.c:142
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#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:287
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:497
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define FIX_1_847759065
Definition: 4xm.c:158
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
void * bitstream_buffer
Definition: 4xm.c:149
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:70
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
uint8_t bits
Definition: vp3data.h:202
#define FFMAX(a, b)
Definition: common.h:94
Definition: vlc.h:26
reference-counted frame API
#define CFRAME_BUFFER_COUNT
Definition: 4xm.c:44
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:282
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:766
uint16_t * frame_buffer
Definition: 4xm.c:139
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define width
int width
picture width / height.
Definition: avcodec.h:1738
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:476
VLC pre_vlc
Definition: 4xm.c:146
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition: 4xm.c:342
int table_allocated
Definition: vlc.h:29
static const int8_t mv[256][2]
Definition: 4xm.c:77
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:380
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:552
static int mix(int c0, int c1)
Definition: 4xm.c:710
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:718
int frame_size
Definition: mxfenc.c:2215
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1565
static void init_mv(FourXContext *f, int linesize)
Definition: 4xm.c:265
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:1964
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1667
int index
Definition: gxfenc.c:89
static const uint8_t dequant_table[64]
Definition: 4xm.c:114
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: 4xm.c:152
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:42
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
unsigned int bitstream_buffer_size
Definition: 4xm.c:150
uint8_t * data
Definition: 4xm.c:132
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:966
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:207
#define FIX_2_613125930
Definition: 4xm.c:159
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
BswapDSPContext bbdsp
Definition: 4xm.c:138
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:429
common internal api header.
#define flag(name)
Definition: cbs_av1.c:553
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
GetBitContext pre_gb
ac/dc prefix
Definition: 4xm.c:141
int mv[256]
Definition: 4xm.c:145
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1592
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
int len
int last_dc
Definition: 4xm.c:147
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
GetByteContext g2
Definition: 4xm.c:144
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:374
int version
Definition: 4xm.c:151
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2256
int16_t block[6][64]
Definition: 4xm.c:148
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
#define BLOCK_TYPE_VLC_BITS
Definition: 4xm.c:41
#define VLC_TYPE
Definition: vlc.h:24
#define FFSWAP(type, a, b)
Definition: common.h:99
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:338
#define stride
#define MULTIPLY(var, const)
Definition: 4xm.c:161
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:113
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1454
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
Predicted.
Definition: avutil.h:275