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