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.h"
34 #include "libavutil/mem_internal.h"
35 #include "libavutil/thread.h"
36 #include "avcodec.h"
37 #include "blockdsp.h"
38 #include "bswapdsp.h"
39 #include "bytestream.h"
40 #include "codec_internal.h"
41 #include "decode.h"
42 #include "get_bits.h"
43 
44 
45 #define BLOCK_TYPE_VLC_BITS 5
46 #define ACDC_VLC_BITS 9
47 
48 #define CFRAME_BUFFER_COUNT 100
49 
50 static const uint8_t block_type_tab[2][4][8][2] = {
51  {
52  { // { 8, 4, 2 } x { 8, 4, 2}
53  { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
54  }, { // { 8, 4 } x 1
55  { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
56  }, { // 1 x { 8, 4 }
57  { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
58  }, { // 1 x 2, 2 x 1
59  { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
60  }
61  }, {
62  { // { 8, 4, 2 } x { 8, 4, 2}
63  { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64  }, {// { 8, 4 } x 1
65  { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
66  }, {// 1 x { 8, 4 }
67  { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
68  }, {// 1 x 2, 2 x 1
69  { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
70  }
71  }
72 };
73 
74 static const uint8_t size2index[4][4] = {
75  { -1, 3, 1, 1 },
76  { 3, 0, 0, 0 },
77  { 2, 0, 0, 0 },
78  { 2, 0, 0, 0 },
79 };
80 
81 static const int8_t mv[256][2] = {
82  { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
83  { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
84  { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
85  { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
86  { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
87  { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
88  { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
89  { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
90  { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
91  { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
92  { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
93  { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
94  { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
95  { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
96  { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
97  { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
98  { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
99  { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
100  { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
101  { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
102  { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
103  { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
104  { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
105  { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
106  { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
107  { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
108  { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
109  { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
110  { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
111  { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
112  { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
113  { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
114 };
115 
116 /* This is simply the scaled down elementwise product of the standard JPEG
117  * quantizer table and the AAN premul table. */
118 static const uint8_t dequant_table[64] = {
119  16, 15, 13, 19, 24, 31, 28, 17,
120  17, 23, 25, 31, 36, 63, 45, 21,
121  18, 24, 27, 37, 52, 59, 49, 20,
122  16, 28, 34, 40, 60, 80, 51, 20,
123  18, 31, 48, 66, 68, 86, 56, 21,
124  19, 38, 56, 59, 64, 64, 48, 20,
125  27, 48, 55, 55, 56, 51, 35, 15,
126  20, 35, 34, 32, 31, 22, 15, 8,
127 };
128 
129 static VLCElem block_type_vlc[2][4][32];
130 
131 
132 typedef struct CFrameBuffer {
133  unsigned int allocated_size;
134  unsigned int size;
135  int id;
136  uint8_t *data;
137 } CFrameBuffer;
138 
139 typedef struct FourXContext {
140  AVCodecContext *avctx;
141  BlockDSPContext bdsp;
142  BswapDSPContext bbdsp;
143  uint16_t *frame_buffer;
144  uint16_t *last_frame_buffer;
145  GetBitContext pre_gb; ///< ac/dc prefix
146  GetBitContext gb;
147  GetByteContext g;
148  GetByteContext g2;
149  int mv[256];
150  VLC pre_vlc;
151  int last_dc;
152  DECLARE_ALIGNED(32, int16_t, block)[6][64];
153  void *bitstream_buffer;
154  unsigned int bitstream_buffer_size;
155  int version;
156  CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
157 } FourXContext;
158 
159 
160 #define FIX_1_082392200 70936
161 #define FIX_1_414213562 92682
162 #define FIX_1_847759065 121095
163 #define FIX_2_613125930 171254
164 
165 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
166 
167 static void idct(int16_t block[64])
168 {
169  int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
170  int tmp10, tmp11, tmp12, tmp13;
171  int z5, z10, z11, z12, z13;
172  int i;
173  int temp[64];
174 
175  for (i = 0; i < 8; i++) {
176  tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
177  tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
178 
179  tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
180  tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
181 
182  tmp0 = tmp10 + tmp13;
183  tmp3 = tmp10 - tmp13;
184  tmp1 = tmp11 + tmp12;
185  tmp2 = tmp11 - tmp12;
186 
187  z13 = block[8 * 5 + i] + block[8 * 3 + i];
188  z10 = block[8 * 5 + i] - block[8 * 3 + i];
189  z11 = block[8 * 1 + i] + block[8 * 7 + i];
190  z12 = block[8 * 1 + i] - block[8 * 7 + i];
191 
192  tmp7 = z11 + z13;
193  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
194 
195  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
196  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
197  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
198 
199  tmp6 = tmp12 - tmp7;
200  tmp5 = tmp11 - tmp6;
201  tmp4 = tmp10 + tmp5;
202 
203  temp[8 * 0 + i] = tmp0 + tmp7;
204  temp[8 * 7 + i] = tmp0 - tmp7;
205  temp[8 * 1 + i] = tmp1 + tmp6;
206  temp[8 * 6 + i] = tmp1 - tmp6;
207  temp[8 * 2 + i] = tmp2 + tmp5;
208  temp[8 * 5 + i] = tmp2 - tmp5;
209  temp[8 * 4 + i] = tmp3 + tmp4;
210  temp[8 * 3 + i] = tmp3 - tmp4;
211  }
212 
213  for (i = 0; i < 8 * 8; i += 8) {
214  tmp10 = temp[0 + i] + temp[4 + i];
215  tmp11 = temp[0 + i] - temp[4 + i];
216 
217  tmp13 = temp[2 + i] + temp[6 + i];
218  tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
219 
220  tmp0 = tmp10 + tmp13;
221  tmp3 = tmp10 - tmp13;
222  tmp1 = tmp11 + tmp12;
223  tmp2 = tmp11 - tmp12;
224 
225  z13 = temp[5 + i] + temp[3 + i];
226  z10 = temp[5 + i] - temp[3 + i];
227  z11 = temp[1 + i] + temp[7 + i];
228  z12 = temp[1 + i] - temp[7 + i];
229 
230  tmp7 = z11 + z13;
231  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
232 
233  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
234  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
235  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
236 
237  tmp6 = tmp12 - tmp7;
238  tmp5 = tmp11 - tmp6;
239  tmp4 = tmp10 + tmp5;
240 
241  block[0 + i] = (tmp0 + tmp7) >> 6;
242  block[7 + i] = (tmp0 - tmp7) >> 6;
243  block[1 + i] = (tmp1 + tmp6) >> 6;
244  block[6 + i] = (tmp1 - tmp6) >> 6;
245  block[2 + i] = (tmp2 + tmp5) >> 6;
246  block[5 + i] = (tmp2 - tmp5) >> 6;
247  block[4 + i] = (tmp3 + tmp4) >> 6;
248  block[3 + i] = (tmp3 - tmp4) >> 6;
249  }
250 }
251 
252 static av_cold void init_vlcs(void)
253 {
254  int i, j;
255 
256  for (i = 0; i < 2; i++) {
257  for (j = 0; j < 4; j++) {
258  ff_vlc_init_table_sparse(block_type_vlc[i][j], FF_ARRAY_ELEMS(block_type_vlc[i][j]),
259  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  NULL, 0, 0, 0);
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_unreachable("log2w starts at 3 and gets only decremented during "
341  "recursive calls to decode_p_block");
342  }
343 }
344 
345 static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
346  int log2w, int log2h, int stride)
347 {
348  int index, h, code, ret, scale = 1;
349  uint16_t *start, *end;
350  unsigned dc = 0;
351 
352  av_assert0(log2w >= 0 && log2h >= 0);
353 
354  index = size2index[log2h][log2w];
355  av_assert0(index >= 0);
356 
357  if (get_bits_left(&f->gb) < 1)
358  return AVERROR_INVALIDDATA;
359  h = 1 << log2h;
360  code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index],
361  BLOCK_TYPE_VLC_BITS, 1);
362  av_assert0(code >= 0 && code <= 6);
363 
364  start = f->last_frame_buffer;
365  end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
366 
367  if (code == 1) {
368  log2h--;
369  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
370  return ret;
371  return decode_p_block(f, dst + (stride << log2h),
372  src + (stride << log2h),
373  log2w, log2h, stride);
374  } else if (code == 2) {
375  log2w--;
376  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
377  return ret;
378  return decode_p_block(f, dst + (1 << log2w),
379  src + (1 << log2w),
380  log2w, log2h, stride);
381  } else if (code == 6) {
382  if (bytestream2_get_bytes_left(&f->g2) < 4) {
383  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
384  return AVERROR_INVALIDDATA;
385  }
386  if (log2w) {
387  dst[0] = bytestream2_get_le16u(&f->g2);
388  dst[1] = bytestream2_get_le16u(&f->g2);
389  } else {
390  dst[0] = bytestream2_get_le16u(&f->g2);
391  dst[stride] = bytestream2_get_le16u(&f->g2);
392  }
393  return 0;
394  }
395 
396  if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
397  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
398  return AVERROR_INVALIDDATA;
399  }
400 
401  if (code == 0) {
402  src += f->mv[bytestream2_get_byte(&f->g)];
403  } else if (code == 3 && f->version >= 2) {
404  return 0;
405  } else if (code == 4) {
406  src += f->mv[bytestream2_get_byte(&f->g)];
407  if (bytestream2_get_bytes_left(&f->g2) < 2){
408  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
409  return AVERROR_INVALIDDATA;
410  }
411  dc = bytestream2_get_le16(&f->g2);
412  } else if (code == 5) {
413  if (bytestream2_get_bytes_left(&f->g2) < 2){
414  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
415  return AVERROR_INVALIDDATA;
416  }
417  av_assert0(start <= src && src <= end);
418  scale = 0;
419  dc = bytestream2_get_le16(&f->g2);
420  }
421 
422  if (start > src || src > end) {
423  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
424  return AVERROR_INVALIDDATA;
425  }
426 
427  mcdc(dst, src, log2w, h, stride, scale, dc);
428 
429  return 0;
430 }
431 
432 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
433 {
434  int x, y;
435  const int width = f->avctx->width;
436  const int height = f->avctx->height;
437  uint16_t *dst = f->frame_buffer;
438  uint16_t *src;
439  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
440  bytestream_offset, wordstream_offset;
441  int ret;
442 
443  src = f->last_frame_buffer;
444 
445  if (f->version > 1) {
446  extra = 20;
447  if (length < extra)
448  return AVERROR_INVALIDDATA;
449  bitstream_size = AV_RL32(buf + 8);
450  wordstream_size = AV_RL32(buf + 12);
451  bytestream_size = AV_RL32(buf + 16);
452  } else {
453  extra = 0;
454  bitstream_size = AV_RL16(buf - 4);
455  wordstream_size = AV_RL16(buf - 2);
456  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
457  }
458 
459  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
460  bytestream_size > length - bitstream_size ||
461  wordstream_size > length - bytestream_size - bitstream_size ||
462  extra > length - bytestream_size - bitstream_size - wordstream_size) {
463  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
464  bitstream_size+ bytestream_size+ wordstream_size - length);
465  return AVERROR_INVALIDDATA;
466  }
467 
468  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
469  bitstream_size);
470  if (!f->bitstream_buffer)
471  return AVERROR(ENOMEM);
472  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
473  bitstream_size / 4);
474  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
475 
476  wordstream_offset = extra + bitstream_size;
477  bytestream_offset = extra + bitstream_size + wordstream_size;
478  bytestream2_init(&f->g2, buf + wordstream_offset,
479  length - wordstream_offset);
480  bytestream2_init(&f->g, buf + bytestream_offset,
481  length - bytestream_offset);
482 
483  init_mv(f, width * 2);
484 
485  for (y = 0; y < height; y += 8) {
486  for (x = 0; x < width; x += 8)
487  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
488  return ret;
489  src += 8 * width;
490  dst += 8 * width;
491  }
492 
493  return 0;
494 }
495 
496 /**
497  * decode block and dequantize.
498  * Note this is almost identical to MJPEG.
499  */
500 static int decode_i_block(FourXContext *f, int16_t *block)
501 {
502  int code, i, j, level, val;
503 
504  if (get_bits_left(&f->pre_gb) < 2) {
505  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->pre_gb));
506  return AVERROR_INVALIDDATA;
507  }
508 
509  /* DC coef */
510  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
511  if (val >> 4) {
512  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
513  return AVERROR_INVALIDDATA;
514  }
515 
516  if (val)
517  val = get_xbits(&f->gb, val);
518 
519  val = val * dequant_table[0] + f->last_dc;
520  f->last_dc = block[0] = val;
521  /* AC coefs */
522  i = 1;
523  for (;;) {
524  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
525 
526  /* EOB */
527  if (code == 0)
528  break;
529  if (code == 0xf0) {
530  i += 16;
531  if (i >= 64) {
532  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
533  return 0;
534  }
535  } else {
536  if (code & 0xf) {
537  level = get_xbits(&f->gb, code & 0xf);
538  } else {
539  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
540  return AVERROR_INVALIDDATA;
541  }
542  i += code >> 4;
543  if (i >= 64) {
544  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
545  return 0;
546  }
547 
548  j = ff_zigzag_direct[i];
549  block[j] = level * dequant_table[j];
550  i++;
551  if (i >= 64)
552  break;
553  }
554  }
555 
556  return 0;
557 }
558 
559 static inline void idct_put(FourXContext *f, int x, int y)
560 {
561  int16_t (*block)[64] = f->block;
562  int stride = f->avctx->width;
563  int i;
564  uint16_t *dst = f->frame_buffer + y * stride + x;
565 
566  for (i = 0; i < 4; i++) {
567  block[i][0] += 0x80 * 8 * 8;
568  idct(block[i]);
569  }
570 
571  if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
572  for (i = 4; i < 6; i++)
573  idct(block[i]);
574  }
575 
576  /* Note transform is:
577  * y = ( 1b + 4g + 2r) / 14
578  * cb = ( 3b - 2g - 1r) / 14
579  * cr = (-1b - 4g + 5r) / 14 */
580  for (y = 0; y < 8; y++) {
581  for (x = 0; x < 8; x++) {
582  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
583  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
584  int cb = block[4][x + 8 * y];
585  int cr = block[5][x + 8 * y];
586  int cg = (cb + cr) >> 1;
587  int y;
588 
589  cb += cb;
590 
591  y = temp[0];
592  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593  y = temp[1];
594  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595  y = temp[8];
596  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
597  y = temp[9];
598  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
599  dst += 2;
600  }
601  dst += 2 * stride - 2 * 8;
602  }
603 }
604 
605 static int decode_i_mb(FourXContext *f)
606 {
607  int ret;
608  int i;
609 
610  f->bdsp.clear_blocks(f->block[0]);
611 
612  for (i = 0; i < 6; i++)
613  if ((ret = decode_i_block(f, f->block[i])) < 0)
614  return ret;
615 
616  return 0;
617 }
618 
619 static const uint8_t *read_huffman_tables(FourXContext *f,
620  const uint8_t * const buf,
621  int buf_size)
622 {
623  int frequency[512] = { 0 };
624  uint8_t flag[512];
625  int up[512];
626  uint8_t len_tab[257];
627  int bits_tab[257];
628  int start, end;
629  const uint8_t *ptr = buf;
630  const uint8_t *ptr_end = buf + buf_size;
631  int j;
632 
633  memset(up, -1, sizeof(up));
634 
635  start = *ptr++;
636  end = *ptr++;
637  for (;;) {
638  int i;
639 
640  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
641  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
642  return NULL;
643  }
644 
645  for (i = start; i <= end; i++)
646  frequency[i] = *ptr++;
647  start = *ptr++;
648  if (start == 0)
649  break;
650 
651  end = *ptr++;
652  }
653  frequency[256] = 1;
654 
655  while ((ptr - buf) & 3)
656  ptr++; // 4byte align
657 
658  if (ptr > ptr_end) {
659  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
660  return NULL;
661  }
662 
663  for (j = 257; j < 512; j++) {
664  int min_freq[2] = { 256 * 256, 256 * 256 };
665  int smallest[2] = { 0, 0 };
666  int i;
667  for (i = 0; i < j; i++) {
668  if (frequency[i] == 0)
669  continue;
670  if (frequency[i] < min_freq[1]) {
671  if (frequency[i] < min_freq[0]) {
672  min_freq[1] = min_freq[0];
673  smallest[1] = smallest[0];
674  min_freq[0] = frequency[i];
675  smallest[0] = i;
676  } else {
677  min_freq[1] = frequency[i];
678  smallest[1] = i;
679  }
680  }
681  }
682  if (min_freq[1] == 256 * 256)
683  break;
684 
685  frequency[j] = min_freq[0] + min_freq[1];
686  flag[smallest[0]] = 0;
687  flag[smallest[1]] = 1;
688  up[smallest[0]] =
689  up[smallest[1]] = j;
690  frequency[smallest[0]] = frequency[smallest[1]] = 0;
691  }
692 
693  for (j = 0; j < 257; j++) {
694  int node, len = 0, bits = 0;
695 
696  for (node = j; up[node] != -1; node = up[node]) {
697  bits += flag[node] << len;
698  len++;
699  if (len > 31)
700  // can this happen at all ?
701  av_log(f->avctx, AV_LOG_ERROR,
702  "vlc length overflow\n");
703  }
704 
705  bits_tab[j] = bits;
706  len_tab[j] = len;
707  }
708 
709  ff_vlc_free(&f->pre_vlc);
710  if (vlc_init(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
711  bits_tab, 4, 4, 0))
712  return NULL;
713 
714  return ptr;
715 }
716 
717 static int mix(int c0, int c1)
718 {
719  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
720  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
721  int red = 2 * (c0 >> 10) + (c1 >> 10);
722  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
723 }
724 
725 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
726 {
727  int x, y, x2, y2;
728  const int width = f->avctx->width;
729  const int height = f->avctx->height;
730  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
731  uint16_t *dst = f->frame_buffer;
732  const uint8_t *buf_end = buf + length;
733  GetByteContext g3;
734 
735  if (length < mbs * 8) {
736  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
737  return AVERROR_INVALIDDATA;
738  }
739  bytestream2_init(&g3, buf, length);
740 
741  for (y = 0; y < height; y += 16) {
742  for (x = 0; x < width; x += 16) {
743  unsigned int color[4] = { 0 }, bits;
744  if (buf_end - buf < 8)
745  return AVERROR_INVALIDDATA;
746  // warning following is purely guessed ...
747  color[0] = bytestream2_get_le16u(&g3);
748  color[1] = bytestream2_get_le16u(&g3);
749 
750  if (color[0] & 0x8000)
751  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
752  if (color[1] & 0x8000)
753  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
754 
755  color[2] = mix(color[0], color[1]);
756  color[3] = mix(color[1], color[0]);
757 
758  bits = bytestream2_get_le32u(&g3);
759  for (y2 = 0; y2 < 16; y2++) {
760  for (x2 = 0; x2 < 16; x2++) {
761  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
762  dst[y2 * width + x2] = color[(bits >> index) & 3];
763  }
764  }
765  dst += 16;
766  }
767  dst += 16 * width - x;
768  }
769 
770  return 0;
771 }
772 
773 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
774 {
775  int x, y, ret;
776  const int width = f->avctx->width;
777  const int height = f->avctx->height;
778  const unsigned int bitstream_size = AV_RL32(buf);
779  unsigned int prestream_size;
780  const uint8_t *prestream;
781 
782  if (bitstream_size > (1 << 26))
783  return AVERROR_INVALIDDATA;
784 
785  if (length < bitstream_size + 12) {
786  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
787  return AVERROR_INVALIDDATA;
788  }
789 
790  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
791  prestream = buf + bitstream_size + 12;
792 
793  if (prestream_size + bitstream_size + 12 != length
794  || prestream_size > (1 << 26)) {
795  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
796  prestream_size, bitstream_size, length);
797  return AVERROR_INVALIDDATA;
798  }
799 
800  prestream = read_huffman_tables(f, prestream, prestream_size);
801  if (!prestream) {
802  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
803  return AVERROR_INVALIDDATA;
804  }
805 
806  av_assert0(prestream <= buf + length);
807 
808  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
809 
810  prestream_size = length + buf - prestream;
811 
812  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
813  prestream_size);
814  if (!f->bitstream_buffer)
815  return AVERROR(ENOMEM);
816  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
817  prestream_size / 4);
818  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
819 
820  f->last_dc = 0 * 128 * 8 * 8;
821 
822  for (y = 0; y < height; y += 16) {
823  for (x = 0; x < width; x += 16) {
824  if ((ret = decode_i_mb(f)) < 0)
825  return ret;
826 
827  idct_put(f, x, y);
828  }
829  }
830 
831  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
832  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
833 
834  return 0;
835 }
836 
837 static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
838  int *got_frame, AVPacket *avpkt)
839 {
840  const uint8_t *buf = avpkt->data;
841  int buf_size = avpkt->size;
842  FourXContext *const f = avctx->priv_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_num)
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  if (free_index < 0)
891  return AVERROR_INVALIDDATA;
892  i = free_index;
893  f->cfrm[i].id = id;
894  }
895  cfrm = &f->cfrm[i];
896 
897  if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
898  return AVERROR_INVALIDDATA;
899 
900  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
901  cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
902  // explicit check needed as memcpy below might not catch a NULL
903  if (!cfrm->data) {
904  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
905  return AVERROR(ENOMEM);
906  }
907 
908  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
909  cfrm->size += data_size;
910 
911  if (cfrm->size >= whole_size) {
912  buf = cfrm->data;
913  frame_size = cfrm->size;
914 
915  if (id != avctx->frame_num)
916  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %"PRId64"\n",
917  id, avctx->frame_num);
918 
919  if (f->version <= 1)
920  return AVERROR_INVALIDDATA;
921 
922  cfrm->size = cfrm->id = 0;
923  frame_4cc = AV_RL32("pfrm");
924  } else
925  return buf_size;
926  } else {
927  buf = buf + 12;
928  frame_size = buf_size - 12;
929  }
930 
931  if ( frame_4cc == AV_RL32("ifr2") || frame_4cc == AV_RL32("ifrm")
932  || frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
933  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
934  return ret;
935  }
936 
937  if (frame_4cc == AV_RL32("ifr2")) {
938  picture->pict_type = AV_PICTURE_TYPE_I;
939  if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
940  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
941  return ret;
942  }
943  } else if (frame_4cc == AV_RL32("ifrm")) {
944  picture->pict_type = AV_PICTURE_TYPE_I;
945  if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
946  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
947  return ret;
948  }
949  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
950  picture->pict_type = AV_PICTURE_TYPE_P;
951  if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
952  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
953  return ret;
954  }
955  } else if (frame_4cc == AV_RL32("snd_")) {
956  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
957  buf_size);
958  return AVERROR_INVALIDDATA;
959  } else {
960  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
961  buf_size);
962  return AVERROR_INVALIDDATA;
963  }
964 
965  if (picture->pict_type == AV_PICTURE_TYPE_I)
966  picture->flags |= AV_FRAME_FLAG_KEY;
967  else
968  picture->flags &= ~AV_FRAME_FLAG_KEY;
969 
970  av_image_copy_plane(picture->data[0], picture->linesize[0],
971  (const uint8_t*)f->frame_buffer, avctx->width * 2,
972  avctx->width * 2, avctx->height);
973  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
974 
975  *got_frame = 1;
976 
977  return buf_size;
978 }
979 
980 static av_cold int decode_end(AVCodecContext *avctx)
981 {
982  FourXContext * const f = avctx->priv_data;
983  int i;
984 
985  av_freep(&f->frame_buffer);
986  av_freep(&f->last_frame_buffer);
987  av_freep(&f->bitstream_buffer);
988  f->bitstream_buffer_size = 0;
989  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
990  av_freep(&f->cfrm[i].data);
991  f->cfrm[i].allocated_size = 0;
992  }
993  ff_vlc_free(&f->pre_vlc);
994 
995  return 0;
996 }
997 
998 static av_cold int decode_init(AVCodecContext *avctx)
999 {
1000  static AVOnce init_static_once = AV_ONCE_INIT;
1001  FourXContext * const f = avctx->priv_data;
1002  int ret;
1003 
1004  if (avctx->extradata_size != 4 || !avctx->extradata) {
1005  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
1006  return AVERROR_INVALIDDATA;
1007  }
1008  if((avctx->width % 16) || (avctx->height % 16)) {
1009  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
1010  return AVERROR_INVALIDDATA;
1011  }
1012 
1013  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1014  if (ret < 0)
1015  return ret;
1016 
1017  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1018  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1019  if (!f->frame_buffer || !f->last_frame_buffer)
1020  return AVERROR(ENOMEM);
1021 
1022  f->version = AV_RL32(avctx->extradata) >> 16;
1023  ff_blockdsp_init(&f->bdsp);
1024  ff_bswapdsp_init(&f->bbdsp);
1025  f->avctx = avctx;
1026 
1027  if (f->version > 2)
1028  avctx->pix_fmt = AV_PIX_FMT_RGB565;
1029  else
1030  avctx->pix_fmt = AV_PIX_FMT_BGR555;
1031 
1032  ff_thread_once(&init_static_once, init_vlcs);
1033 
1034  return 0;
1035 }
1036 
1037 const FFCodec ff_fourxm_decoder = {
1038  .p.name = "4xm",
1039  CODEC_LONG_NAME("4X Movie"),
1040  .p.type = AVMEDIA_TYPE_VIDEO,
1041  .p.id = AV_CODEC_ID_4XM,
1042  .priv_data_size = sizeof(FourXContext),
1043  .init = decode_init,
1044  .close = decode_end,
1045  FF_CODEC_DECODE_CB(decode_frame),
1046  .p.capabilities = AV_CODEC_CAP_DR1,
1047  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1048 };
bswapdsp.h
level
uint8_t level
Definition: svq3.c:208
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
mix
static int mix(int c0, int c1)
Definition: 4xm.c:717
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:689
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
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition: bytestream.h:158
mem_internal.h
color
Definition: vf_paletteuse.c:513
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:247
GetByteContext
Definition: bytestream.h:33
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: 4xm.c:837
thread.h
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AVPacket::data
uint8_t * data
Definition: packet.h:588
FourXContext::cfrm
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: 4xm.c:156
FFCodec
Definition: codec_internal.h:127
decode_i_block
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition: 4xm.c:500
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:671
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
c1
static const uint64_t c1
Definition: murmur3.c:52
BlockDSPContext
Definition: blockdsp.h:32
FIX_1_082392200
#define FIX_1_082392200
Definition: 4xm.c:160
FourXContext::g
GetByteContext g
Definition: 4xm.c:147
MULTIPLY
#define MULTIPLY(var, const)
Definition: 4xm.c:165
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:512
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:448
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:163
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:135
FourXContext::mv
int mv[256]
Definition: 4xm.c:149
FourXContext::pre_vlc
VLC pre_vlc
Definition: 4xm.c:150
ACDC_VLC_BITS
#define ACDC_VLC_BITS
Definition: 4xm.c:46
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
init_mv
static void init_mv(FourXContext *f, int linesize)
Definition: 4xm.c:267
GetBitContext
Definition: get_bits.h:109
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:77
idct
static void idct(int16_t block[64])
Definition: 4xm.c:167
decode_i_mb
static int decode_i_mb(FourXContext *f)
Definition: 4xm.c:605
avassert.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:106
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:642
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
AV_CODEC_ID_4XM
@ AV_CODEC_ID_4XM
Definition: codec_id.h:86
CFrameBuffer::id
int id
Definition: 4xm.c:135
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:497
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:345
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:346
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
intreadwrite.h
frame_size
int frame_size
Definition: mxfenc.c:2487
bits
uint8_t bits
Definition: vp3data.h:128
size2index
static const uint8_t size2index[4][4]
Definition: 4xm.c:74
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
vlc_init
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:70
decode.h
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
FourXContext::bitstream_buffer
void * bitstream_buffer
Definition: 4xm.c:153
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:331
CFRAME_BUFFER_COUNT
#define CFRAME_BUFFER_COUNT
Definition: 4xm.c:48
init_vlcs
static av_cold void init_vlcs(void)
Definition: 4xm.c:252
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
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:619
idct_put
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:559
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition: avassert.h:108
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
FourXContext::last_dc
int last_dc
Definition: 4xm.c:151
FourXContext::block
int16_t block[6][64]
Definition: 4xm.c:152
FourXContext::bitstream_buffer_size
unsigned int bitstream_buffer_size
Definition: 4xm.c:154
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:646
FourXContext::frame_buffer
uint16_t * frame_buffer
Definition: 4xm.c:143
FourXContext::last_frame_buffer
uint16_t * last_frame_buffer
Definition: 4xm.c:144
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
f
f
Definition: af_crystalizer.c:122
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:519
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1720
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:302
AVPacket::size
int size
Definition: packet.h:589
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
decode_i2_frame
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:725
height
#define height
Definition: dsp.h:89
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
FourXContext::gb
GetBitContext gb
Definition: 4xm.c:146
VLCElem
Definition: vlc.h:32
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:545
ff_fourxm_decoder
const FFCodec ff_fourxm_decoder
Definition: 4xm.c:1037
frame.h
block_type_tab
static const uint8_t block_type_tab[2][4][8][2]
Definition: 4xm.c:50
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:290
CFrameBuffer::size
unsigned int size
Definition: 4xm.c:134
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:622
FourXContext::bdsp
BlockDSPContext bdsp
Definition: 4xm.c:141
FIX_1_847759065
#define FIX_1_847759065
Definition: 4xm.c:162
FourXContext
Definition: 4xm.c:139
FourXContext::version
int version
Definition: 4xm.c:155
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
BLOCK_TYPE_VLC_BITS
#define BLOCK_TYPE_VLC_BITS
Definition: 4xm.c:45
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:53
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:998
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
FIX_1_414213562
#define FIX_1_414213562
Definition: 4xm.c:161
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:539
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:137
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:1878
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:580
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:432
flag
#define flag(name)
Definition: cbs_av1.c:496
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
id
enum AVCodecID id
Definition: dts2pts.c:367
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AVCodecContext
main external API structure.
Definition: avcodec.h:431
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
block_type_vlc
static VLCElem block_type_vlc[2][4][32]
Definition: 4xm.c:129
VLC
Definition: vlc.h:50
temp
else temp
Definition: vf_mcdeint.c:271
FourXContext::bbdsp
BswapDSPContext bbdsp
Definition: 4xm.c:142
FourXContext::g2
GetByteContext g2
Definition: 4xm.c:148
FourXContext::pre_gb
GetBitContext pre_gb
ac/dc prefix
Definition: 4xm.c:145
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
mem.h
CFrameBuffer::allocated_size
unsigned int allocated_size
Definition: 4xm.c:133
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: 4xm.c:980
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AVPacket
This structure stores compressed data.
Definition: packet.h:565
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:248
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:773
FourXContext::avctx
AVCodecContext * avctx
Definition: 4xm.c:140
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
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:472
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:27
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:2070
dequant_table
static const uint8_t dequant_table[64]
Definition: 4xm.c:118
ff_vlc_init_table_sparse
av_cold void ff_vlc_init_table_sparse(VLCElem table[], int table_size, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: vlc.c:384
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
width
#define width
Definition: dsp.h:89
CFrameBuffer::data
uint8_t * data
Definition: 4xm.c:136
src
#define src
Definition: vp8dsp.c:248
CFrameBuffer
Definition: 4xm.c:132
Generated on Fri Oct 31 2025 19:21:38 for FFmpeg by   doxygen 1.8.17