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