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;
132  uint8_t *data;
133 } CFrameBuffer;
134 
135 typedef struct FourXContext {
136  AVCodecContext *avctx;
137  BlockDSPContext bdsp;
138  BswapDSPContext bbdsp;
139  uint16_t *frame_buffer;
140  uint16_t *last_frame_buffer;
141  GetBitContext pre_gb; ///< ac/dc prefix
142  GetBitContext gb;
143  GetByteContext g;
144  GetByteContext g2;
145  int mv[256];
146  VLC pre_vlc;
147  int last_dc;
148  DECLARE_ALIGNED(32, int16_t, block)[6][64];
149  void *bitstream_buffer;
150  unsigned int bitstream_buffer_size;
151  int version;
152  CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
153 } FourXContext;
154 
155 
156 #define FIX_1_082392200 70936
157 #define FIX_1_414213562 92682
158 #define FIX_1_847759065 121095
159 #define FIX_2_613125930 171254
160 
161 #define MULTIPLY(var, const) ((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 
248 static av_cold void init_vlcs(FourXContext *f)
249 {
250  static VLC_TYPE table[2][4][32][2];
251  int i, j;
252 
253  for (i = 0; i < 2; i++) {
254  for (j = 0; j < 4; j++) {
255  block_type_vlc[i][j].table = table[i][j];
256  block_type_vlc[i][j].table_allocated = 32;
257  init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
258  &block_type_tab[i][j][0][1], 2, 1,
259  &block_type_tab[i][j][0][0], 2, 1,
260  INIT_VLC_USE_NEW_STATIC);
261  }
262  }
263 }
264 
265 static void init_mv(FourXContext *f, int linesize)
266 {
267  int i;
268 
269  for (i = 0; i < 256; i++) {
270  if (f->version > 1)
271  f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
272  else
273  f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
274  }
275 }
276 
277 #if HAVE_BIGENDIAN
278 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
279  { \
280  unsigned tmpval = AV_RN32(src); \
281  tmpval = (tmpval << 16) | (tmpval >> 16); \
282  tmpval = tmpval * (scale) + (dc); \
283  tmpval = (tmpval << 16) | (tmpval >> 16); \
284  AV_WN32A(dst, tmpval); \
285  }
286 #else
287 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
288  { \
289  unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
290  AV_WN32A(dst, tmpval); \
291  }
292 #endif
293 
294 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
295  int h, int stride, int scale, unsigned dc)
296 {
297  int i;
298  dc *= 0x10001;
299 
300  switch (log2w) {
301  case 0:
302  for (i = 0; i < h; i++) {
303  dst[0] = scale * src[0] + dc;
304  if (scale)
305  src += stride;
306  dst += stride;
307  }
308  break;
309  case 1:
310  for (i = 0; i < h; i++) {
311  LE_CENTRIC_MUL(dst, src, scale, dc);
312  if (scale)
313  src += stride;
314  dst += stride;
315  }
316  break;
317  case 2:
318  for (i = 0; i < h; i++) {
319  LE_CENTRIC_MUL(dst, src, scale, dc);
320  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
321  if (scale)
322  src += stride;
323  dst += stride;
324  }
325  break;
326  case 3:
327  for (i = 0; i < h; i++) {
328  LE_CENTRIC_MUL(dst, src, scale, dc);
329  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
330  LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
331  LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
332  if (scale)
333  src += stride;
334  dst += stride;
335  }
336  break;
337  default:
338  av_assert0(0);
339  }
340 }
341 
342 static int decode_p_block(FourXContext *f, uint16_t *dst, 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,
358  BLOCK_TYPE_VLC_BITS, 1);
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 
465  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
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 
602 static int decode_i_mb(FourXContext *f)
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 
616 static const uint8_t *read_huffman_tables(FourXContext *f,
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 ?
698  av_log(f->avctx, AV_LOG_ERROR,
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 
809  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
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 
970 static av_cold int decode_end(AVCodecContext *avctx)
971 {
972  FourXContext * const f = avctx->priv_data;
973  int i;
974 
975  av_freep(&f->frame_buffer);
976  av_freep(&f->last_frame_buffer);
977  av_freep(&f->bitstream_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 
988 static av_cold int decode_init(AVCodecContext *avctx)
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 
1027 AVCodec ff_fourxm_decoder = {
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 };
NULL
#define NULL
Definition: coverity.c:32
FourXContext::g
GetByteContext g
Definition: 4xm.c:143
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
h
h
Definition: vp9dsp_template.c:2038
idct
static void idct(int16_t block[64])
Definition: 4xm.c:163
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
ret
ret
Definition: filter_design.txt:187
imgutils.h
misc image utilities
FourXContext::bdsp
BlockDSPContext bdsp
Definition: 4xm.c:137
temp
else temp
Definition: vf_mcdeint.c:256
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVPacket::size
int size
Definition: packet.h:364
init_vlcs
static av_cold void init_vlcs(FourXContext *f)
Definition: 4xm.c:248
ff_fourxm_decoder
AVCodec ff_fourxm_decoder
Definition: 4xm.c:1027
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
CFrameBuffer::id
int id
Definition: 4xm.c:131
block_type_vlc
static VLC block_type_vlc[2][4]
Definition: 4xm.c:125
read_huffman_tables
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition: 4xm.c:616
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
mcdc
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition: 4xm.c:294
av_fast_padded_malloc
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:72
FIX_1_414213562
#define FIX_1_414213562
Definition: 4xm.c:157
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
FIX_1_082392200
#define FIX_1_082392200
Definition: 4xm.c:156
AVCodec
AVCodec.
Definition: codec.h:190
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
CFrameBuffer::size
unsigned int size
Definition: 4xm.c:130
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:88
BswapDSPContext::bswap_buf
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
f
#define f(width, name)
Definition: cbs_vp9.c:255
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
CFrameBuffer::allocated_size
unsigned int allocated_size
Definition: 4xm.c:129
FourXContext::last_frame_buffer
uint16_t * last_frame_buffer
Definition: 4xm.c:140
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
block_type_tab
static const uint8_t block_type_tab[2][4][8][2]
Definition: 4xm.c:46
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
height
#define height
AVPacket::data
uint8_t * data
Definition: packet.h:363
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:988
c1
static const uint64_t c1
Definition: murmur3.c:49
get_bits.h
bitstream reader API header.
FourXContext::avctx
AVCodecContext * avctx
Definition: 4xm.c:136
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
table
static const uint16_t table[]
Definition: prosumer.c:206
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: 4xm.c:834
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
decode_i_mb
static int decode_i_mb(FourXContext *f)
Definition: 4xm.c:602
src
#define src
Definition: vp8dsp.c:254
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
FourXContext::gb
GetBitContext gb
Definition: 4xm.c:142
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
LE_CENTRIC_MUL
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition: 4xm.c:287
BlockDSPContext::clear_blocks
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:37
decode_i_block
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition: 4xm.c:497
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
FIX_1_847759065
#define FIX_1_847759065
Definition: 4xm.c:158
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
FourXContext::bitstream_buffer
void * bitstream_buffer
Definition: 4xm.c:149
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
length
GLsizei GLsizei * length
Definition: opengl_enc.c:114
size2index
static const uint8_t size2index[4][4]
Definition: 4xm.c:70
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
bits
uint8_t bits
Definition: vp3data.h:202
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
VLC
Definition: vlc.h:26
frame.h
reference-counted frame API
AV_CODEC_ID_4XM
Definition: codec_id.h:83
CFRAME_BUFFER_COUNT
#define CFRAME_BUFFER_COUNT
Definition: 4xm.c:44
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
decode_i_frame
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:770
FourXContext::frame_buffer
uint16_t * frame_buffer
Definition: 4xm.c:139
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
width
#define width
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
get_vlc2
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
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
FourXContext::pre_vlc
VLC pre_vlc
Definition: 4xm.c:146
decode_p_block
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition: 4xm.c:342
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
mv
static const int8_t mv[256][2]
Definition: 4xm.c:77
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:392
idct_put
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:556
mix
static int mix(int c0, int c1)
Definition: 4xm.c:714
decode_i2_frame
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:722
frame_size
int frame_size
Definition: mxfenc.c:2166
avcodec.h
Libavcodec external API header.
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
AVCodecContext
main external API structure.
Definition: avcodec.h:526
init_mv
static void init_mv(FourXContext *f, int linesize)
Definition: 4xm.c:265
dc
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
get_xbits
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
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1872
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
index
int index
Definition: gxfenc.c:89
dequant_table
static const uint8_t dequant_table[64]
Definition: 4xm.c:114
FourXContext::cfrm
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: 4xm.c:152
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
ACDC_VLC_BITS
#define ACDC_VLC_BITS
Definition: 4xm.c:42
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
FourXContext::bitstream_buffer_size
unsigned int bitstream_buffer_size
Definition: 4xm.c:150
CFrameBuffer::data
uint8_t * data
Definition: 4xm.c:132
code
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
Definition: filter_design.txt:172
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: 4xm.c:970
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
level
uint8_t level
Definition: svq3.c:205
FIX_2_613125930
#define FIX_2_613125930
Definition: 4xm.c:159
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
FourXContext::bbdsp
BswapDSPContext bbdsp
Definition: 4xm.c:138
decode_p_frame
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:429
internal.h
common internal api header.
flag
#define flag(name)
Definition: cbs_av1.c:552
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
FourXContext::pre_gb
GetBitContext pre_gb
ac/dc prefix
Definition: 4xm.c:141
FourXContext::mv
int mv[256]
Definition: 4xm.c:145
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:663
len
int len
Definition: vorbis_enc_data.h:452
FourXContext::last_dc
int last_dc
Definition: 4xm.c:147
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
FourXContext::g2
GetByteContext g2
Definition: 4xm.c:144
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:386
FourXContext::version
int version
Definition: 4xm.c:151
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
FourXContext::block
int16_t block[6][64]
Definition: 4xm.c:148
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
BLOCK_TYPE_VLC_BITS
#define BLOCK_TYPE_VLC_BITS
Definition: 4xm.c:41
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:373
stride
#define stride
MULTIPLY
#define MULTIPLY(var, const)
Definition: 4xm.c:161
AVERROR
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
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVPacket
This structure stores compressed data.
Definition: packet.h:340
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:358
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
i
int i
Definition: input.c:407
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
Generated on Tue Sep 22 2020 19:20:59 for FFmpeg by   doxygen 1.8.11