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  if (i >= 64) {
529  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
530  return 0;
531  }
532  } else {
533  if (code & 0xf) {
534  level = get_xbits(&f->gb, code & 0xf);
535  } else {
536  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
537  return AVERROR_INVALIDDATA;
538  }
539  i += code >> 4;
540  if (i >= 64) {
541  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
542  return 0;
543  }
544 
545  j = ff_zigzag_direct[i];
546  block[j] = level * dequant_table[j];
547  i++;
548  if (i >= 64)
549  break;
550  }
551  }
552 
553  return 0;
554 }
555 
556 static inline void idct_put(FourXContext *f, int x, int y)
557 {
558  int16_t (*block)[64] = f->block;
559  int stride = f->avctx->width;
560  int i;
561  uint16_t *dst = f->frame_buffer + y * stride + x;
562 
563  for (i = 0; i < 4; i++) {
564  block[i][0] += 0x80 * 8 * 8;
565  idct(block[i]);
566  }
567 
568  if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
569  for (i = 4; i < 6; i++)
570  idct(block[i]);
571  }
572 
573  /* Note transform is:
574  * y = ( 1b + 4g + 2r) / 14
575  * cb = ( 3b - 2g - 1r) / 14
576  * cr = (-1b - 4g + 5r) / 14 */
577  for (y = 0; y < 8; y++) {
578  for (x = 0; x < 8; x++) {
579  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
580  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
581  int cb = block[4][x + 8 * y];
582  int cr = block[5][x + 8 * y];
583  int cg = (cb + cr) >> 1;
584  int y;
585 
586  cb += cb;
587 
588  y = temp[0];
589  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590  y = temp[1];
591  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592  y = temp[8];
593  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594  y = temp[9];
595  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
596  dst += 2;
597  }
598  dst += 2 * stride - 2 * 8;
599  }
600 }
601 
603 {
604  int ret;
605  int i;
606 
607  f->bdsp.clear_blocks(f->block[0]);
608 
609  for (i = 0; i < 6; i++)
610  if ((ret = decode_i_block(f, f->block[i])) < 0)
611  return ret;
612 
613  return 0;
614 }
615 
617  const uint8_t * const buf,
618  int buf_size)
619 {
620  int frequency[512] = { 0 };
621  uint8_t flag[512];
622  int up[512];
623  uint8_t len_tab[257];
624  int bits_tab[257];
625  int start, end;
626  const uint8_t *ptr = buf;
627  const uint8_t *ptr_end = buf + buf_size;
628  int j;
629 
630  memset(up, -1, sizeof(up));
631 
632  start = *ptr++;
633  end = *ptr++;
634  for (;;) {
635  int i;
636 
637  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
638  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
639  return NULL;
640  }
641 
642  for (i = start; i <= end; i++)
643  frequency[i] = *ptr++;
644  start = *ptr++;
645  if (start == 0)
646  break;
647 
648  end = *ptr++;
649  }
650  frequency[256] = 1;
651 
652  while ((ptr - buf) & 3)
653  ptr++; // 4byte align
654 
655  if (ptr > ptr_end) {
656  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
657  return NULL;
658  }
659 
660  for (j = 257; j < 512; j++) {
661  int min_freq[2] = { 256 * 256, 256 * 256 };
662  int smallest[2] = { 0, 0 };
663  int i;
664  for (i = 0; i < j; i++) {
665  if (frequency[i] == 0)
666  continue;
667  if (frequency[i] < min_freq[1]) {
668  if (frequency[i] < min_freq[0]) {
669  min_freq[1] = min_freq[0];
670  smallest[1] = smallest[0];
671  min_freq[0] = frequency[i];
672  smallest[0] = i;
673  } else {
674  min_freq[1] = frequency[i];
675  smallest[1] = i;
676  }
677  }
678  }
679  if (min_freq[1] == 256 * 256)
680  break;
681 
682  frequency[j] = min_freq[0] + min_freq[1];
683  flag[smallest[0]] = 0;
684  flag[smallest[1]] = 1;
685  up[smallest[0]] =
686  up[smallest[1]] = j;
687  frequency[smallest[0]] = frequency[smallest[1]] = 0;
688  }
689 
690  for (j = 0; j < 257; j++) {
691  int node, len = 0, bits = 0;
692 
693  for (node = j; up[node] != -1; node = up[node]) {
694  bits += flag[node] << len;
695  len++;
696  if (len > 31)
697  // can this happen at all ?
699  "vlc length overflow\n");
700  }
701 
702  bits_tab[j] = bits;
703  len_tab[j] = len;
704  }
705 
706  ff_free_vlc(&f->pre_vlc);
707  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
708  bits_tab, 4, 4, 0))
709  return NULL;
710 
711  return ptr;
712 }
713 
714 static int mix(int c0, int c1)
715 {
716  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
717  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
718  int red = 2 * (c0 >> 10) + (c1 >> 10);
719  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
720 }
721 
722 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
723 {
724  int x, y, x2, y2;
725  const int width = f->avctx->width;
726  const int height = f->avctx->height;
727  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
728  uint16_t *dst = f->frame_buffer;
729  const uint8_t *buf_end = buf + length;
730  GetByteContext g3;
731 
732  if (length < mbs * 8) {
733  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
734  return AVERROR_INVALIDDATA;
735  }
736  bytestream2_init(&g3, buf, length);
737 
738  for (y = 0; y < height; y += 16) {
739  for (x = 0; x < width; x += 16) {
740  unsigned int color[4] = { 0 }, bits;
741  if (buf_end - buf < 8)
742  return AVERROR_INVALIDDATA;
743  // warning following is purely guessed ...
744  color[0] = bytestream2_get_le16u(&g3);
745  color[1] = bytestream2_get_le16u(&g3);
746 
747  if (color[0] & 0x8000)
748  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
749  if (color[1] & 0x8000)
750  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
751 
752  color[2] = mix(color[0], color[1]);
753  color[3] = mix(color[1], color[0]);
754 
755  bits = bytestream2_get_le32u(&g3);
756  for (y2 = 0; y2 < 16; y2++) {
757  for (x2 = 0; x2 < 16; x2++) {
758  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
759  dst[y2 * width + x2] = color[(bits >> index) & 3];
760  }
761  }
762  dst += 16;
763  }
764  dst += 16 * width - x;
765  }
766 
767  return 0;
768 }
769 
770 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
771 {
772  int x, y, ret;
773  const int width = f->avctx->width;
774  const int height = f->avctx->height;
775  const unsigned int bitstream_size = AV_RL32(buf);
776  unsigned int prestream_size;
777  const uint8_t *prestream;
778 
779  if (bitstream_size > (1 << 26))
780  return AVERROR_INVALIDDATA;
781 
782  if (length < bitstream_size + 12) {
783  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
784  return AVERROR_INVALIDDATA;
785  }
786 
787  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
788  prestream = buf + bitstream_size + 12;
789 
790  if (prestream_size + bitstream_size + 12 != length
791  || prestream_size > (1 << 26)) {
792  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
793  prestream_size, bitstream_size, length);
794  return AVERROR_INVALIDDATA;
795  }
796 
797  prestream = read_huffman_tables(f, prestream, prestream_size);
798  if (!prestream) {
799  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
800  return AVERROR_INVALIDDATA;
801  }
802 
803  av_assert0(prestream <= buf + length);
804 
805  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
806 
807  prestream_size = length + buf - prestream;
808 
810  prestream_size);
811  if (!f->bitstream_buffer)
812  return AVERROR(ENOMEM);
813  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
814  prestream_size / 4);
815  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
816 
817  f->last_dc = 0 * 128 * 8 * 8;
818 
819  for (y = 0; y < height; y += 16) {
820  for (x = 0; x < width; x += 16) {
821  if ((ret = decode_i_mb(f)) < 0)
822  return ret;
823 
824  idct_put(f, x, y);
825  }
826  }
827 
828  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
829  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
830 
831  return 0;
832 }
833 
834 static int decode_frame(AVCodecContext *avctx, void *data,
835  int *got_frame, AVPacket *avpkt)
836 {
837  const uint8_t *buf = avpkt->data;
838  int buf_size = avpkt->size;
839  FourXContext *const f = avctx->priv_data;
840  AVFrame *picture = data;
841  int i, frame_4cc, frame_size, ret;
842 
843  if (buf_size < 20)
844  return AVERROR_INVALIDDATA;
845 
846  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
847 
848  if (buf_size < AV_RL32(buf + 4) + 8) {
849  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
850  buf_size, AV_RL32(buf + 4));
851  return AVERROR_INVALIDDATA;
852  }
853 
854  frame_4cc = AV_RL32(buf);
855 
856  if (frame_4cc == AV_RL32("cfrm")) {
857  int free_index = -1;
858  int id, whole_size;
859  const int data_size = buf_size - 20;
860  CFrameBuffer *cfrm;
861 
862  if (f->version <= 1) {
863  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
864  return AVERROR_INVALIDDATA;
865  }
866 
867  id = AV_RL32(buf + 12);
868  whole_size = AV_RL32(buf + 16);
869 
870  if (data_size < 0 || whole_size < 0) {
871  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
872  return AVERROR_INVALIDDATA;
873  }
874 
875  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
876  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
877  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
878  f->cfrm[i].id);
879 
880  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
881  if (f->cfrm[i].id == id)
882  break;
883  if (f->cfrm[i].size == 0)
884  free_index = i;
885  }
886 
887  if (i >= CFRAME_BUFFER_COUNT) {
888  i = free_index;
889  f->cfrm[i].id = id;
890  }
891  cfrm = &f->cfrm[i];
892 
893  if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
894  return AVERROR_INVALIDDATA;
895 
896  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
897  cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
898  // explicit check needed as memcpy below might not catch a NULL
899  if (!cfrm->data) {
900  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
901  return AVERROR(ENOMEM);
902  }
903 
904  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
905  cfrm->size += data_size;
906 
907  if (cfrm->size >= whole_size) {
908  buf = cfrm->data;
909  frame_size = cfrm->size;
910 
911  if (id != avctx->frame_number)
912  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
913  id, avctx->frame_number);
914 
915  if (f->version <= 1)
916  return AVERROR_INVALIDDATA;
917 
918  cfrm->size = cfrm->id = 0;
919  frame_4cc = AV_RL32("pfrm");
920  } else
921  return buf_size;
922  } else {
923  buf = buf + 12;
924  frame_size = buf_size - 12;
925  }
926 
927  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
928  return ret;
929 
930  if (frame_4cc == AV_RL32("ifr2")) {
931  picture->pict_type = AV_PICTURE_TYPE_I;
932  if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
933  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
934  return ret;
935  }
936  } else if (frame_4cc == AV_RL32("ifrm")) {
937  picture->pict_type = AV_PICTURE_TYPE_I;
938  if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
939  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
940  return ret;
941  }
942  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
943  picture->pict_type = AV_PICTURE_TYPE_P;
944  if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
945  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
946  return ret;
947  }
948  } else if (frame_4cc == AV_RL32("snd_")) {
949  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
950  buf_size);
951  } else {
952  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
953  buf_size);
954  }
955 
956  picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
957 
958  av_image_copy_plane(picture->data[0], picture->linesize[0],
959  (const uint8_t*)f->frame_buffer, avctx->width * 2,
960  avctx->width * 2, avctx->height);
961  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
962 
963  *got_frame = 1;
964 
965  emms_c();
966 
967  return buf_size;
968 }
969 
971 {
972  FourXContext * const f = avctx->priv_data;
973  int i;
974 
975  av_freep(&f->frame_buffer);
978  f->bitstream_buffer_size = 0;
979  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
980  av_freep(&f->cfrm[i].data);
981  f->cfrm[i].allocated_size = 0;
982  }
983  ff_free_vlc(&f->pre_vlc);
984 
985  return 0;
986 }
987 
989 {
990  FourXContext * const f = avctx->priv_data;
991  int ret;
992 
993  if (avctx->extradata_size != 4 || !avctx->extradata) {
994  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
995  return AVERROR_INVALIDDATA;
996  }
997  if((avctx->width % 16) || (avctx->height % 16)) {
998  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
999  return AVERROR_INVALIDDATA;
1000  }
1001 
1002  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1003  if (ret < 0)
1004  return ret;
1005 
1006  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1007  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1008  if (!f->frame_buffer || !f->last_frame_buffer) {
1009  decode_end(avctx);
1010  return AVERROR(ENOMEM);
1011  }
1012 
1013  f->version = AV_RL32(avctx->extradata) >> 16;
1014  ff_blockdsp_init(&f->bdsp, avctx);
1015  ff_bswapdsp_init(&f->bbdsp);
1016  f->avctx = avctx;
1017  init_vlcs(f);
1018 
1019  if (f->version > 2)
1020  avctx->pix_fmt = AV_PIX_FMT_RGB565;
1021  else
1022  avctx->pix_fmt = AV_PIX_FMT_BGR555;
1023 
1024  return 0;
1025 }
1026 
1028  .name = "4xm",
1029  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1030  .type = AVMEDIA_TYPE_VIDEO,
1031  .id = AV_CODEC_ID_4XM,
1032  .priv_data_size = sizeof(FourXContext),
1033  .init = decode_init,
1034  .close = decode_end,
1035  .decode = decode_frame,
1036  .capabilities = AV_CODEC_CAP_DR1,
1037 };
#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:1484
static av_cold void init_vlcs(FourXContext *f)
Definition: 4xm.c:248
AVCodec ff_fourxm_decoder
Definition: 4xm.c:1027
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:616
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1781
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:3495
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: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:139
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:1672
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:1483
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:988
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:889
#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:834
static int decode_i_mb(FourXContext *f)
Definition: 4xm.c:602
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:1651
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:3502
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:770
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:1744
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:556
static int mix(int c0, int c1)
Definition: 4xm.c:714
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:722
int frame_size
Definition: mxfenc.c:2150
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:1571
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:1968
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1673
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:970
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:796
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1598
#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:2262
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:140
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1460
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:987
Predicted.
Definition: avutil.h:275