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_assert0(0);
341  }
342 }
343 
344 static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
345  int log2w, int log2h, int stride)
346 {
347  int index, h, code, ret, scale = 1;
348  uint16_t *start, *end;
349  unsigned dc = 0;
350 
351  av_assert0(log2w >= 0 && log2h >= 0);
352 
353  index = size2index[log2h][log2w];
354  av_assert0(index >= 0);
355 
356  if (get_bits_left(&f->gb) < 1)
357  return AVERROR_INVALIDDATA;
358  h = 1 << log2h;
359  code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index],
360  BLOCK_TYPE_VLC_BITS, 1);
361  av_assert0(code >= 0 && code <= 6);
362 
363  start = f->last_frame_buffer;
364  end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
365 
366  if (code == 1) {
367  log2h--;
368  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
369  return ret;
370  return decode_p_block(f, dst + (stride << log2h),
371  src + (stride << log2h),
372  log2w, log2h, stride);
373  } else if (code == 2) {
374  log2w--;
375  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
376  return ret;
377  return decode_p_block(f, dst + (1 << log2w),
378  src + (1 << log2w),
379  log2w, log2h, stride);
380  } else if (code == 6) {
381  if (bytestream2_get_bytes_left(&f->g2) < 4) {
382  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
383  return AVERROR_INVALIDDATA;
384  }
385  if (log2w) {
386  dst[0] = bytestream2_get_le16u(&f->g2);
387  dst[1] = bytestream2_get_le16u(&f->g2);
388  } else {
389  dst[0] = bytestream2_get_le16u(&f->g2);
390  dst[stride] = bytestream2_get_le16u(&f->g2);
391  }
392  return 0;
393  }
394 
395  if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
396  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
397  return AVERROR_INVALIDDATA;
398  }
399 
400  if (code == 0) {
401  src += f->mv[bytestream2_get_byte(&f->g)];
402  } else if (code == 3 && f->version >= 2) {
403  return 0;
404  } else if (code == 4) {
405  src += f->mv[bytestream2_get_byte(&f->g)];
406  if (bytestream2_get_bytes_left(&f->g2) < 2){
407  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
408  return AVERROR_INVALIDDATA;
409  }
410  dc = bytestream2_get_le16(&f->g2);
411  } else if (code == 5) {
412  if (bytestream2_get_bytes_left(&f->g2) < 2){
413  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
414  return AVERROR_INVALIDDATA;
415  }
416  av_assert0(start <= src && src <= end);
417  scale = 0;
418  dc = bytestream2_get_le16(&f->g2);
419  }
420 
421  if (start > src || src > end) {
422  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
423  return AVERROR_INVALIDDATA;
424  }
425 
426  mcdc(dst, src, log2w, h, stride, scale, dc);
427 
428  return 0;
429 }
430 
431 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
432 {
433  int x, y;
434  const int width = f->avctx->width;
435  const int height = f->avctx->height;
436  uint16_t *dst = f->frame_buffer;
437  uint16_t *src;
438  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
439  bytestream_offset, wordstream_offset;
440  int ret;
441 
442  src = f->last_frame_buffer;
443 
444  if (f->version > 1) {
445  extra = 20;
446  if (length < extra)
447  return AVERROR_INVALIDDATA;
448  bitstream_size = AV_RL32(buf + 8);
449  wordstream_size = AV_RL32(buf + 12);
450  bytestream_size = AV_RL32(buf + 16);
451  } else {
452  extra = 0;
453  bitstream_size = AV_RL16(buf - 4);
454  wordstream_size = AV_RL16(buf - 2);
455  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
456  }
457 
458  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
459  bytestream_size > length - bitstream_size ||
460  wordstream_size > length - bytestream_size - bitstream_size ||
461  extra > length - bytestream_size - bitstream_size - wordstream_size) {
462  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
463  bitstream_size+ bytestream_size+ wordstream_size - length);
464  return AVERROR_INVALIDDATA;
465  }
466 
467  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
468  bitstream_size);
469  if (!f->bitstream_buffer)
470  return AVERROR(ENOMEM);
471  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
472  bitstream_size / 4);
473  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
474 
475  wordstream_offset = extra + bitstream_size;
476  bytestream_offset = extra + bitstream_size + wordstream_size;
477  bytestream2_init(&f->g2, buf + wordstream_offset,
478  length - wordstream_offset);
479  bytestream2_init(&f->g, buf + bytestream_offset,
480  length - bytestream_offset);
481 
482  init_mv(f, width * 2);
483 
484  for (y = 0; y < height; y += 8) {
485  for (x = 0; x < width; x += 8)
486  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
487  return ret;
488  src += 8 * width;
489  dst += 8 * width;
490  }
491 
492  return 0;
493 }
494 
495 /**
496  * decode block and dequantize.
497  * Note this is almost identical to MJPEG.
498  */
499 static int decode_i_block(FourXContext *f, int16_t *block)
500 {
501  int code, i, j, level, val;
502 
503  if (get_bits_left(&f->pre_gb) < 2) {
504  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->pre_gb));
505  return AVERROR_INVALIDDATA;
506  }
507 
508  /* DC coef */
509  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
510  if (val >> 4) {
511  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
512  return AVERROR_INVALIDDATA;
513  }
514 
515  if (val)
516  val = get_xbits(&f->gb, val);
517 
518  val = val * dequant_table[0] + f->last_dc;
519  f->last_dc = block[0] = val;
520  /* AC coefs */
521  i = 1;
522  for (;;) {
523  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
524 
525  /* EOB */
526  if (code == 0)
527  break;
528  if (code == 0xf0) {
529  i += 16;
530  if (i >= 64) {
531  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
532  return 0;
533  }
534  } else {
535  if (code & 0xf) {
536  level = get_xbits(&f->gb, code & 0xf);
537  } else {
538  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
539  return AVERROR_INVALIDDATA;
540  }
541  i += code >> 4;
542  if (i >= 64) {
543  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
544  return 0;
545  }
546 
547  j = ff_zigzag_direct[i];
548  block[j] = level * dequant_table[j];
549  i++;
550  if (i >= 64)
551  break;
552  }
553  }
554 
555  return 0;
556 }
557 
558 static inline void idct_put(FourXContext *f, int x, int y)
559 {
560  int16_t (*block)[64] = f->block;
561  int stride = f->avctx->width;
562  int i;
563  uint16_t *dst = f->frame_buffer + y * stride + x;
564 
565  for (i = 0; i < 4; i++) {
566  block[i][0] += 0x80 * 8 * 8;
567  idct(block[i]);
568  }
569 
570  if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
571  for (i = 4; i < 6; i++)
572  idct(block[i]);
573  }
574 
575  /* Note transform is:
576  * y = ( 1b + 4g + 2r) / 14
577  * cb = ( 3b - 2g - 1r) / 14
578  * cr = (-1b - 4g + 5r) / 14 */
579  for (y = 0; y < 8; y++) {
580  for (x = 0; x < 8; x++) {
581  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
582  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
583  int cb = block[4][x + 8 * y];
584  int cr = block[5][x + 8 * y];
585  int cg = (cb + cr) >> 1;
586  int y;
587 
588  cb += cb;
589 
590  y = temp[0];
591  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592  y = temp[1];
593  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594  y = temp[8];
595  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
596  y = temp[9];
597  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
598  dst += 2;
599  }
600  dst += 2 * stride - 2 * 8;
601  }
602 }
603 
604 static int decode_i_mb(FourXContext *f)
605 {
606  int ret;
607  int i;
608 
609  f->bdsp.clear_blocks(f->block[0]);
610 
611  for (i = 0; i < 6; i++)
612  if ((ret = decode_i_block(f, f->block[i])) < 0)
613  return ret;
614 
615  return 0;
616 }
617 
618 static const uint8_t *read_huffman_tables(FourXContext *f,
619  const uint8_t * const buf,
620  int buf_size)
621 {
622  int frequency[512] = { 0 };
623  uint8_t flag[512];
624  int up[512];
625  uint8_t len_tab[257];
626  int bits_tab[257];
627  int start, end;
628  const uint8_t *ptr = buf;
629  const uint8_t *ptr_end = buf + buf_size;
630  int j;
631 
632  memset(up, -1, sizeof(up));
633 
634  start = *ptr++;
635  end = *ptr++;
636  for (;;) {
637  int i;
638 
639  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
640  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
641  return NULL;
642  }
643 
644  for (i = start; i <= end; i++)
645  frequency[i] = *ptr++;
646  start = *ptr++;
647  if (start == 0)
648  break;
649 
650  end = *ptr++;
651  }
652  frequency[256] = 1;
653 
654  while ((ptr - buf) & 3)
655  ptr++; // 4byte align
656 
657  if (ptr > ptr_end) {
658  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
659  return NULL;
660  }
661 
662  for (j = 257; j < 512; j++) {
663  int min_freq[2] = { 256 * 256, 256 * 256 };
664  int smallest[2] = { 0, 0 };
665  int i;
666  for (i = 0; i < j; i++) {
667  if (frequency[i] == 0)
668  continue;
669  if (frequency[i] < min_freq[1]) {
670  if (frequency[i] < min_freq[0]) {
671  min_freq[1] = min_freq[0];
672  smallest[1] = smallest[0];
673  min_freq[0] = frequency[i];
674  smallest[0] = i;
675  } else {
676  min_freq[1] = frequency[i];
677  smallest[1] = i;
678  }
679  }
680  }
681  if (min_freq[1] == 256 * 256)
682  break;
683 
684  frequency[j] = min_freq[0] + min_freq[1];
685  flag[smallest[0]] = 0;
686  flag[smallest[1]] = 1;
687  up[smallest[0]] =
688  up[smallest[1]] = j;
689  frequency[smallest[0]] = frequency[smallest[1]] = 0;
690  }
691 
692  for (j = 0; j < 257; j++) {
693  int node, len = 0, bits = 0;
694 
695  for (node = j; up[node] != -1; node = up[node]) {
696  bits += flag[node] << len;
697  len++;
698  if (len > 31)
699  // can this happen at all ?
700  av_log(f->avctx, AV_LOG_ERROR,
701  "vlc length overflow\n");
702  }
703 
704  bits_tab[j] = bits;
705  len_tab[j] = len;
706  }
707 
708  ff_vlc_free(&f->pre_vlc);
709  if (vlc_init(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
710  bits_tab, 4, 4, 0))
711  return NULL;
712 
713  return ptr;
714 }
715 
716 static int mix(int c0, int c1)
717 {
718  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
719  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
720  int red = 2 * (c0 >> 10) + (c1 >> 10);
721  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
722 }
723 
724 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
725 {
726  int x, y, x2, y2;
727  const int width = f->avctx->width;
728  const int height = f->avctx->height;
729  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
730  uint16_t *dst = f->frame_buffer;
731  const uint8_t *buf_end = buf + length;
732  GetByteContext g3;
733 
734  if (length < mbs * 8) {
735  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
736  return AVERROR_INVALIDDATA;
737  }
738  bytestream2_init(&g3, buf, length);
739 
740  for (y = 0; y < height; y += 16) {
741  for (x = 0; x < width; x += 16) {
742  unsigned int color[4] = { 0 }, bits;
743  if (buf_end - buf < 8)
744  return AVERROR_INVALIDDATA;
745  // warning following is purely guessed ...
746  color[0] = bytestream2_get_le16u(&g3);
747  color[1] = bytestream2_get_le16u(&g3);
748 
749  if (color[0] & 0x8000)
750  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
751  if (color[1] & 0x8000)
752  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
753 
754  color[2] = mix(color[0], color[1]);
755  color[3] = mix(color[1], color[0]);
756 
757  bits = bytestream2_get_le32u(&g3);
758  for (y2 = 0; y2 < 16; y2++) {
759  for (x2 = 0; x2 < 16; x2++) {
760  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
761  dst[y2 * width + x2] = color[(bits >> index) & 3];
762  }
763  }
764  dst += 16;
765  }
766  dst += 16 * width - x;
767  }
768 
769  return 0;
770 }
771 
772 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
773 {
774  int x, y, ret;
775  const int width = f->avctx->width;
776  const int height = f->avctx->height;
777  const unsigned int bitstream_size = AV_RL32(buf);
778  unsigned int prestream_size;
779  const uint8_t *prestream;
780 
781  if (bitstream_size > (1 << 26))
782  return AVERROR_INVALIDDATA;
783 
784  if (length < bitstream_size + 12) {
785  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
786  return AVERROR_INVALIDDATA;
787  }
788 
789  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
790  prestream = buf + bitstream_size + 12;
791 
792  if (prestream_size + bitstream_size + 12 != length
793  || prestream_size > (1 << 26)) {
794  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
795  prestream_size, bitstream_size, length);
796  return AVERROR_INVALIDDATA;
797  }
798 
799  prestream = read_huffman_tables(f, prestream, prestream_size);
800  if (!prestream) {
801  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
802  return AVERROR_INVALIDDATA;
803  }
804 
805  av_assert0(prestream <= buf + length);
806 
807  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
808 
809  prestream_size = length + buf - prestream;
810 
811  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
812  prestream_size);
813  if (!f->bitstream_buffer)
814  return AVERROR(ENOMEM);
815  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
816  prestream_size / 4);
817  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
818 
819  f->last_dc = 0 * 128 * 8 * 8;
820 
821  for (y = 0; y < height; y += 16) {
822  for (x = 0; x < width; x += 16) {
823  if ((ret = decode_i_mb(f)) < 0)
824  return ret;
825 
826  idct_put(f, x, y);
827  }
828  }
829 
830  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
831  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
832 
833  return 0;
834 }
835 
836 static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
837  int *got_frame, AVPacket *avpkt)
838 {
839  const uint8_t *buf = avpkt->data;
840  int buf_size = avpkt->size;
841  FourXContext *const f = avctx->priv_data;
842  int i, frame_4cc, frame_size, ret;
843 
844  if (buf_size < 20)
845  return AVERROR_INVALIDDATA;
846 
847  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
848 
849  if (buf_size < AV_RL32(buf + 4) + 8) {
850  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
851  buf_size, AV_RL32(buf + 4));
852  return AVERROR_INVALIDDATA;
853  }
854 
855  frame_4cc = AV_RL32(buf);
856 
857  if (frame_4cc == AV_RL32("cfrm")) {
858  int free_index = -1;
859  int id, whole_size;
860  const int data_size = buf_size - 20;
861  CFrameBuffer *cfrm;
862 
863  if (f->version <= 1) {
864  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
865  return AVERROR_INVALIDDATA;
866  }
867 
868  id = AV_RL32(buf + 12);
869  whole_size = AV_RL32(buf + 16);
870 
871  if (data_size < 0 || whole_size < 0) {
872  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
873  return AVERROR_INVALIDDATA;
874  }
875 
876  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
877  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_num)
878  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
879  f->cfrm[i].id);
880 
881  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
882  if (f->cfrm[i].id == id)
883  break;
884  if (f->cfrm[i].size == 0)
885  free_index = i;
886  }
887 
888  if (i >= CFRAME_BUFFER_COUNT) {
889  if (free_index < 0)
890  return AVERROR_INVALIDDATA;
891  i = free_index;
892  f->cfrm[i].id = id;
893  }
894  cfrm = &f->cfrm[i];
895 
896  if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
897  return AVERROR_INVALIDDATA;
898 
899  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
900  cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
901  // explicit check needed as memcpy below might not catch a NULL
902  if (!cfrm->data) {
903  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
904  return AVERROR(ENOMEM);
905  }
906 
907  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
908  cfrm->size += data_size;
909 
910  if (cfrm->size >= whole_size) {
911  buf = cfrm->data;
912  frame_size = cfrm->size;
913 
914  if (id != avctx->frame_num)
915  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %"PRId64"\n",
916  id, avctx->frame_num);
917 
918  if (f->version <= 1)
919  return AVERROR_INVALIDDATA;
920 
921  cfrm->size = cfrm->id = 0;
922  frame_4cc = AV_RL32("pfrm");
923  } else
924  return buf_size;
925  } else {
926  buf = buf + 12;
927  frame_size = buf_size - 12;
928  }
929 
930  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
931  return ret;
932 
933  if (frame_4cc == AV_RL32("ifr2")) {
934  picture->pict_type = AV_PICTURE_TYPE_I;
935  if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
936  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
937  return ret;
938  }
939  } else if (frame_4cc == AV_RL32("ifrm")) {
940  picture->pict_type = AV_PICTURE_TYPE_I;
941  if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
942  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
943  return ret;
944  }
945  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
946  picture->pict_type = AV_PICTURE_TYPE_P;
947  if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
948  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
949  return ret;
950  }
951  } else if (frame_4cc == AV_RL32("snd_")) {
952  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
953  buf_size);
954  return AVERROR_INVALIDDATA;
955  } else {
956  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
957  buf_size);
958  return AVERROR_INVALIDDATA;
959  }
960 
961  if (picture->pict_type == AV_PICTURE_TYPE_I)
962  picture->flags |= AV_FRAME_FLAG_KEY;
963  else
964  picture->flags &= ~AV_FRAME_FLAG_KEY;
965 
966  av_image_copy_plane(picture->data[0], picture->linesize[0],
967  (const uint8_t*)f->frame_buffer, avctx->width * 2,
968  avctx->width * 2, avctx->height);
969  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
970 
971  *got_frame = 1;
972 
973  return buf_size;
974 }
975 
976 static av_cold int decode_end(AVCodecContext *avctx)
977 {
978  FourXContext * const f = avctx->priv_data;
979  int i;
980 
981  av_freep(&f->frame_buffer);
982  av_freep(&f->last_frame_buffer);
983  av_freep(&f->bitstream_buffer);
984  f->bitstream_buffer_size = 0;
985  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
986  av_freep(&f->cfrm[i].data);
987  f->cfrm[i].allocated_size = 0;
988  }
989  ff_vlc_free(&f->pre_vlc);
990 
991  return 0;
992 }
993 
994 static av_cold int decode_init(AVCodecContext *avctx)
995 {
996  static AVOnce init_static_once = AV_ONCE_INIT;
997  FourXContext * const f = avctx->priv_data;
998  int ret;
999 
1000  if (avctx->extradata_size != 4 || !avctx->extradata) {
1001  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
1002  return AVERROR_INVALIDDATA;
1003  }
1004  if((avctx->width % 16) || (avctx->height % 16)) {
1005  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
1006  return AVERROR_INVALIDDATA;
1007  }
1008 
1009  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1010  if (ret < 0)
1011  return ret;
1012 
1013  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1014  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1015  if (!f->frame_buffer || !f->last_frame_buffer)
1016  return AVERROR(ENOMEM);
1017 
1018  f->version = AV_RL32(avctx->extradata) >> 16;
1019  ff_blockdsp_init(&f->bdsp);
1020  ff_bswapdsp_init(&f->bbdsp);
1021  f->avctx = avctx;
1022 
1023  if (f->version > 2)
1024  avctx->pix_fmt = AV_PIX_FMT_RGB565;
1025  else
1026  avctx->pix_fmt = AV_PIX_FMT_BGR555;
1027 
1028  ff_thread_once(&init_static_once, init_vlcs);
1029 
1030  return 0;
1031 }
1032 
1033 const FFCodec ff_fourxm_decoder = {
1034  .p.name = "4xm",
1035  CODEC_LONG_NAME("4X Movie"),
1036  .p.type = AVMEDIA_TYPE_VIDEO,
1037  .p.id = AV_CODEC_ID_4XM,
1038  .priv_data_size = sizeof(FourXContext),
1039  .init = decode_init,
1040  .close = decode_end,
1041  FF_CODEC_DECODE_CB(decode_frame),
1042  .p.capabilities = AV_CODEC_CAP_DR1,
1043  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1044 };
bswapdsp.h
level
uint8_t level
Definition: svq3.c:205
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:716
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:512
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:242
GetByteContext
Definition: bytestream.h:33
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: 4xm.c:836
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:375
AVPacket::data
uint8_t * data
Definition: packet.h:524
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:499
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:647
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:514
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:396
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
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:108
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:78
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:604
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:626
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: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
width
#define width
decode_p_block
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition: 4xm.c:344
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:2423
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: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:62
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:272
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:618
idct_put
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:558
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
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:652
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
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:477
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1554
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:525
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:724
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
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:471
ff_fourxm_decoder
const FFCodec ff_fourxm_decoder
Definition: 4xm.c:1033
frame.h
height
#define height
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:292
CFrameBuffer::size
unsigned int size
Definition: 4xm.c:134
FourXContext::bdsp
BlockDSPContext bdsp
Definition: 4xm.c:141
FIX_1_847759065
#define FIX_1_847759065
Definition: 4xm.c:162
flag
#define flag(name)
Definition: cbs_av1.c:466
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
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: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:52
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:590
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:994
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:194
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: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:431
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
id
enum AVCodecID id
Definition: dts2pts.c:365
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:296
block_type_vlc
static VLCElem block_type_vlc[2][4][32]
Definition: 4xm.c:129
VLC
Definition: vlc.h:36
temp
else temp
Definition: vf_mcdeint.c:263
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:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:976
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
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:501
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:243
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:772
FourXContext::avctx
AVCodecContext * avctx
Definition: 4xm.c:140
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:420
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: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
CFrameBuffer::data
uint8_t * data
Definition: 4xm.c:136
CFrameBuffer
Definition: 4xm.c:132
Generated on Wed Apr 17 2024 19:21:20 for FFmpeg by   doxygen 1.8.17