FFmpeg: libavcodec/4xm.c Source File

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 VLC block_type_vlc[2][4];
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  static VLCElem table[2][4][32];
254  int i, j;
255 
256  for (i = 0; i < 2; i++) {
257  for (j = 0; j < 4; j++) {
258  block_type_vlc[i][j].table = table[i][j];
259  block_type_vlc[i][j].table_allocated = 32;
260  init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
261  &block_type_tab[i][j][0][1], 2, 1,
262  &block_type_tab[i][j][0][0], 2, 1,
263  INIT_VLC_USE_NEW_STATIC);
264  }
265  }
266 }
267 
268  static void init_mv(FourXContext *f, int linesize)
269 {
270  int i;
271 
272  for (i = 0; i < 256; i++) {
273  if (f->version > 1)
274  f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
275  else
276  f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
277  }
278 }
279 
280 #if HAVE_BIGENDIAN
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
282  { \
283  unsigned tmpval = AV_RN32(src); \
284  tmpval = (tmpval << 16) | (tmpval >> 16); \
285  tmpval = tmpval * (scale) + (dc); \
286  tmpval = (tmpval << 16) | (tmpval >> 16); \
287  AV_WN32A(dst, tmpval); \
288  }
289 #else
290  #define LE_CENTRIC_MUL(dst, src, scale, dc) \
291  { \
292  unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
293  AV_WN32A(dst, tmpval); \
294  }
295 #endif
296 
297  static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
298  int h, int stride, int scale, unsigned dc)
299 {
300  int i;
301  dc *= 0x10001;
302 
303  switch (log2w) {
304  case 0:
305  for (i = 0; i < h; i++) {
306  dst[0] = scale * src[0] + dc;
307  if (scale)
308  src += stride;
309  dst += stride;
310  }
311  break;
312  case 1:
313  for (i = 0; i < h; i++) {
314  LE_CENTRIC_MUL(dst, src, scale, dc);
315  if (scale)
316  src += stride;
317  dst += stride;
318  }
319  break;
320  case 2:
321  for (i = 0; i < h; i++) {
322  LE_CENTRIC_MUL(dst, src, scale, dc);
323  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
324  if (scale)
325  src += stride;
326  dst += stride;
327  }
328  break;
329  case 3:
330  for (i = 0; i < h; i++) {
331  LE_CENTRIC_MUL(dst, src, scale, dc);
332  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
333  LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
334  LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
335  if (scale)
336  src += stride;
337  dst += stride;
338  }
339  break;
340  default:
341  av_assert0(0);
342  }
343 }
344 
345  static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
346  int log2w, int log2h, int stride)
347 {
348  int index, h, code, ret, scale = 1;
349  uint16_t *start, *end;
350  unsigned dc = 0;
351 
352  av_assert0(log2w >= 0 && log2h >= 0);
353 
354  index = size2index[log2h][log2w];
355  av_assert0(index >= 0);
356 
357  if (get_bits_left(&f->gb) < 1)
358  return AVERROR_INVALIDDATA;
359  h = 1 << log2h;
360  code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
361  BLOCK_TYPE_VLC_BITS, 1);
362  av_assert0(code >= 0 && code <= 6);
363 
364  start = f->last_frame_buffer;
365  end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
366 
367  if (code == 1) {
368  log2h--;
369  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
370  return ret;
371  return decode_p_block(f, dst + (stride << log2h),
372  src + (stride << log2h),
373  log2w, log2h, stride);
374  } else if (code == 2) {
375  log2w--;
376  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
377  return ret;
378  return decode_p_block(f, dst + (1 << log2w),
379  src + (1 << log2w),
380  log2w, log2h, stride);
381  } else if (code == 6) {
382  if (bytestream2_get_bytes_left(&f->g2) < 4) {
383  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
384  return AVERROR_INVALIDDATA;
385  }
386  if (log2w) {
387  dst[0] = bytestream2_get_le16u(&f->g2);
388  dst[1] = bytestream2_get_le16u(&f->g2);
389  } else {
390  dst[0] = bytestream2_get_le16u(&f->g2);
391  dst[stride] = bytestream2_get_le16u(&f->g2);
392  }
393  return 0;
394  }
395 
396  if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
397  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
398  return AVERROR_INVALIDDATA;
399  }
400 
401  if (code == 0) {
402  src += f->mv[bytestream2_get_byte(&f->g)];
403  } else if (code == 3 && f->version >= 2) {
404  return 0;
405  } else if (code == 4) {
406  src += f->mv[bytestream2_get_byte(&f->g)];
407  if (bytestream2_get_bytes_left(&f->g2) < 2){
408  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
409  return AVERROR_INVALIDDATA;
410  }
411  dc = bytestream2_get_le16(&f->g2);
412  } else if (code == 5) {
413  if (bytestream2_get_bytes_left(&f->g2) < 2){
414  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
415  return AVERROR_INVALIDDATA;
416  }
417  av_assert0(start <= src && src <= end);
418  scale = 0;
419  dc = bytestream2_get_le16(&f->g2);
420  }
421 
422  if (start > src || src > end) {
423  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
424  return AVERROR_INVALIDDATA;
425  }
426 
427  mcdc(dst, src, log2w, h, stride, scale, dc);
428 
429  return 0;
430 }
431 
432  static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
433 {
434  int x, y;
435  const int width = f->avctx->width;
436  const int height = f->avctx->height;
437  uint16_t *dst = f->frame_buffer;
438  uint16_t *src;
439  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
440  bytestream_offset, wordstream_offset;
441  int ret;
442 
443  src = f->last_frame_buffer;
444 
445  if (f->version > 1) {
446  extra = 20;
447  if (length < extra)
448  return AVERROR_INVALIDDATA;
449  bitstream_size = AV_RL32(buf + 8);
450  wordstream_size = AV_RL32(buf + 12);
451  bytestream_size = AV_RL32(buf + 16);
452  } else {
453  extra = 0;
454  bitstream_size = AV_RL16(buf - 4);
455  wordstream_size = AV_RL16(buf - 2);
456  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
457  }
458 
459  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
460  bytestream_size > length - bitstream_size ||
461  wordstream_size > length - bytestream_size - bitstream_size ||
462  extra > length - bytestream_size - bitstream_size - wordstream_size) {
463  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
464  bitstream_size+ bytestream_size+ wordstream_size - length);
465  return AVERROR_INVALIDDATA;
466  }
467 
468  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
469  bitstream_size);
470  if (!f->bitstream_buffer)
471  return AVERROR(ENOMEM);
472  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
473  bitstream_size / 4);
474  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
475 
476  wordstream_offset = extra + bitstream_size;
477  bytestream_offset = extra + bitstream_size + wordstream_size;
478  bytestream2_init(&f->g2, buf + wordstream_offset,
479  length - wordstream_offset);
480  bytestream2_init(&f->g, buf + bytestream_offset,
481  length - bytestream_offset);
482 
483  init_mv(f, width * 2);
484 
485  for (y = 0; y < height; y += 8) {
486  for (x = 0; x < width; x += 8)
487  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
488  return ret;
489  src += 8 * width;
490  dst += 8 * width;
491  }
492 
493  return 0;
494 }
495 
496 /**
497  * decode block and dequantize.
498  * Note this is almost identical to MJPEG.
499  */
500  static int decode_i_block(FourXContext *f, int16_t *block)
501 {
502  int code, i, j, level, val;
503 
504  if (get_bits_left(&f->pre_gb) < 2) {
505  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->pre_gb));
506  return AVERROR_INVALIDDATA;
507  }
508 
509  /* DC coef */
510  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
511  if (val >> 4) {
512  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
513  return AVERROR_INVALIDDATA;
514  }
515 
516  if (val)
517  val = get_xbits(&f->gb, val);
518 
519  val = val * dequant_table[0] + f->last_dc;
520  f->last_dc = block[0] = val;
521  /* AC coefs */
522  i = 1;
523  for (;;) {
524  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
525 
526  /* EOB */
527  if (code == 0)
528  break;
529  if (code == 0xf0) {
530  i += 16;
531  if (i >= 64) {
532  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
533  return 0;
534  }
535  } else {
536  if (code & 0xf) {
537  level = get_xbits(&f->gb, code & 0xf);
538  } else {
539  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
540  return AVERROR_INVALIDDATA;
541  }
542  i += code >> 4;
543  if (i >= 64) {
544  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
545  return 0;
546  }
547 
548  j = ff_zigzag_direct[i];
549  block[j] = level * dequant_table[j];
550  i++;
551  if (i >= 64)
552  break;
553  }
554  }
555 
556  return 0;
557 }
558 
559  static inline void idct_put(FourXContext *f, int x, int y)
560 {
561  int16_t (*block)[64] = f->block;
562  int stride = f->avctx->width;
563  int i;
564  uint16_t *dst = f->frame_buffer + y * stride + x;
565 
566  for (i = 0; i < 4; i++) {
567  block[i][0] += 0x80 * 8 * 8;
568  idct(block[i]);
569  }
570 
571  if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
572  for (i = 4; i < 6; i++)
573  idct(block[i]);
574  }
575 
576  /* Note transform is:
577  * y = ( 1b + 4g + 2r) / 14
578  * cb = ( 3b - 2g - 1r) / 14
579  * cr = (-1b - 4g + 5r) / 14 */
580  for (y = 0; y < 8; y++) {
581  for (x = 0; x < 8; x++) {
582  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
583  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
584  int cb = block[4][x + 8 * y];
585  int cr = block[5][x + 8 * y];
586  int cg = (cb + cr) >> 1;
587  int y;
588 
589  cb += cb;
590 
591  y = temp[0];
592  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593  y = temp[1];
594  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595  y = temp[8];
596  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
597  y = temp[9];
598  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
599  dst += 2;
600  }
601  dst += 2 * stride - 2 * 8;
602  }
603 }
604 
605  static int decode_i_mb(FourXContext *f)
606 {
607  int ret;
608  int i;
609 
610  f->bdsp.clear_blocks(f->block[0]);
611 
612  for (i = 0; i < 6; i++)
613  if ((ret = decode_i_block(f, f->block[i])) < 0)
614  return ret;
615 
616  return 0;
617 }
618 
619  static const uint8_t *read_huffman_tables(FourXContext *f,
620  const uint8_t * const buf,
621  int buf_size)
622 {
623  int frequency[512] = { 0 };
624  uint8_t flag[512];
625  int up[512];
626  uint8_t len_tab[257];
627  int bits_tab[257];
628  int start, end;
629  const uint8_t *ptr = buf;
630  const uint8_t *ptr_end = buf + buf_size;
631  int j;
632 
633  memset(up, -1, sizeof(up));
634 
635  start = *ptr++;
636  end = *ptr++;
637  for (;;) {
638  int i;
639 
640  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
641  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
642  return NULL;
643  }
644 
645  for (i = start; i <= end; i++)
646  frequency[i] = *ptr++;
647  start = *ptr++;
648  if (start == 0)
649  break;
650 
651  end = *ptr++;
652  }
653  frequency[256] = 1;
654 
655  while ((ptr - buf) & 3)
656  ptr++; // 4byte align
657 
658  if (ptr > ptr_end) {
659  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
660  return NULL;
661  }
662 
663  for (j = 257; j < 512; j++) {
664  int min_freq[2] = { 256 * 256, 256 * 256 };
665  int smallest[2] = { 0, 0 };
666  int i;
667  for (i = 0; i < j; i++) {
668  if (frequency[i] == 0)
669  continue;
670  if (frequency[i] < min_freq[1]) {
671  if (frequency[i] < min_freq[0]) {
672  min_freq[1] = min_freq[0];
673  smallest[1] = smallest[0];
674  min_freq[0] = frequency[i];
675  smallest[0] = i;
676  } else {
677  min_freq[1] = frequency[i];
678  smallest[1] = i;
679  }
680  }
681  }
682  if (min_freq[1] == 256 * 256)
683  break;
684 
685  frequency[j] = min_freq[0] + min_freq[1];
686  flag[smallest[0]] = 0;
687  flag[smallest[1]] = 1;
688  up[smallest[0]] =
689  up[smallest[1]] = j;
690  frequency[smallest[0]] = frequency[smallest[1]] = 0;
691  }
692 
693  for (j = 0; j < 257; j++) {
694  int node, len = 0, bits = 0;
695 
696  for (node = j; up[node] != -1; node = up[node]) {
697  bits += flag[node] << len;
698  len++;
699  if (len > 31)
700  // can this happen at all ?
701  av_log(f->avctx, AV_LOG_ERROR,
702  "vlc length overflow\n");
703  }
704 
705  bits_tab[j] = bits;
706  len_tab[j] = len;
707  }
708 
709  ff_free_vlc(&f->pre_vlc);
710  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
711  bits_tab, 4, 4, 0))
712  return NULL;
713 
714  return ptr;
715 }
716 
717  static int mix(int c0, int c1)
718 {
719  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
720  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
721  int red = 2 * (c0 >> 10) + (c1 >> 10);
722  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
723 }
724 
725  static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
726 {
727  int x, y, x2, y2;
728  const int width = f->avctx->width;
729  const int height = f->avctx->height;
730  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
731  uint16_t *dst = f->frame_buffer;
732  const uint8_t *buf_end = buf + length;
733  GetByteContext g3;
734 
735  if (length < mbs * 8) {
736  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
737  return AVERROR_INVALIDDATA;
738  }
739  bytestream2_init(&g3, buf, length);
740 
741  for (y = 0; y < height; y += 16) {
742  for (x = 0; x < width; x += 16) {
743  unsigned int color[4] = { 0 }, bits;
744  if (buf_end - buf < 8)
745  return AVERROR_INVALIDDATA;
746  // warning following is purely guessed ...
747  color[0] = bytestream2_get_le16u(&g3);
748  color[1] = bytestream2_get_le16u(&g3);
749 
750  if (color[0] & 0x8000)
751  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
752  if (color[1] & 0x8000)
753  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
754 
755  color[2] = mix(color[0], color[1]);
756  color[3] = mix(color[1], color[0]);
757 
758  bits = bytestream2_get_le32u(&g3);
759  for (y2 = 0; y2 < 16; y2++) {
760  for (x2 = 0; x2 < 16; x2++) {
761  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
762  dst[y2 * width + x2] = color[(bits >> index) & 3];
763  }
764  }
765  dst += 16;
766  }
767  dst += 16 * width - x;
768  }
769 
770  return 0;
771 }
772 
773  static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
774 {
775  int x, y, ret;
776  const int width = f->avctx->width;
777  const int height = f->avctx->height;
778  const unsigned int bitstream_size = AV_RL32(buf);
779  unsigned int prestream_size;
780  const uint8_t *prestream;
781 
782  if (bitstream_size > (1 << 26))
783  return AVERROR_INVALIDDATA;
784 
785  if (length < bitstream_size + 12) {
786  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
787  return AVERROR_INVALIDDATA;
788  }
789 
790  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
791  prestream = buf + bitstream_size + 12;
792 
793  if (prestream_size + bitstream_size + 12 != length
794  || prestream_size > (1 << 26)) {
795  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
796  prestream_size, bitstream_size, length);
797  return AVERROR_INVALIDDATA;
798  }
799 
800  prestream = read_huffman_tables(f, prestream, prestream_size);
801  if (!prestream) {
802  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
803  return AVERROR_INVALIDDATA;
804  }
805 
806  av_assert0(prestream <= buf + length);
807 
808  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
809 
810  prestream_size = length + buf - prestream;
811 
812  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
813  prestream_size);
814  if (!f->bitstream_buffer)
815  return AVERROR(ENOMEM);
816  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
817  prestream_size / 4);
818  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
819 
820  f->last_dc = 0 * 128 * 8 * 8;
821 
822  for (y = 0; y < height; y += 16) {
823  for (x = 0; x < width; x += 16) {
824  if ((ret = decode_i_mb(f)) < 0)
825  return ret;
826 
827  idct_put(f, x, y);
828  }
829  }
830 
831  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
832  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
833 
834  return 0;
835 }
836 
837  static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
838  int *got_frame, AVPacket *avpkt)
839 {
840  const uint8_t *buf = avpkt->data;
841  int buf_size = avpkt->size;
842  FourXContext *const f = avctx->priv_data;
843  int i, frame_4cc, frame_size, ret;
844 
845  if (buf_size < 20)
846  return AVERROR_INVALIDDATA;
847 
848  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
849 
850  if (buf_size < AV_RL32(buf + 4) + 8) {
851  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
852  buf_size, AV_RL32(buf + 4));
853  return AVERROR_INVALIDDATA;
854  }
855 
856  frame_4cc = AV_RL32(buf);
857 
858  if (frame_4cc == AV_RL32("cfrm")) {
859  int free_index = -1;
860  int id, whole_size;
861  const int data_size = buf_size - 20;
862  CFrameBuffer *cfrm;
863 
864  if (f->version <= 1) {
865  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
866  return AVERROR_INVALIDDATA;
867  }
868 
869  id = AV_RL32(buf + 12);
870  whole_size = AV_RL32(buf + 16);
871 
872  if (data_size < 0 || whole_size < 0) {
873  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
874  return AVERROR_INVALIDDATA;
875  }
876 
877  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
878  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_num)
879  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
880  f->cfrm[i].id);
881 
882  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
883  if (f->cfrm[i].id == id)
884  break;
885  if (f->cfrm[i].size == 0)
886  free_index = i;
887  }
888 
889  if (i >= CFRAME_BUFFER_COUNT) {
890  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  picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
961 
962  av_image_copy_plane(picture->data[0], picture->linesize[0],
963  (const uint8_t*)f->frame_buffer, avctx->width * 2,
964  avctx->width * 2, avctx->height);
965  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
966 
967  *got_frame = 1;
968 
969  return buf_size;
970 }
971 
972  static av_cold int decode_end(AVCodecContext *avctx)
973 {
974  FourXContext * const f = avctx->priv_data;
975  int i;
976 
977  av_freep(&f->frame_buffer);
978  av_freep(&f->last_frame_buffer);
979  av_freep(&f->bitstream_buffer);
980  f->bitstream_buffer_size = 0;
981  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
982  av_freep(&f->cfrm[i].data);
983  f->cfrm[i].allocated_size = 0;
984  }
985  ff_free_vlc(&f->pre_vlc);
986 
987  return 0;
988 }
989 
990  static av_cold int decode_init(AVCodecContext *avctx)
991 {
992  static AVOnce init_static_once = AV_ONCE_INIT;
993  FourXContext * const f = avctx->priv_data;
994  int ret;
995 
996  if (avctx->extradata_size != 4 || !avctx->extradata) {
997  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
998  return AVERROR_INVALIDDATA;
999  }
1000  if((avctx->width % 16) || (avctx->height % 16)) {
1001  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
1002  return AVERROR_INVALIDDATA;
1003  }
1004 
1005  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1006  if (ret < 0)
1007  return ret;
1008 
1009  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1010  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1011  if (!f->frame_buffer || !f->last_frame_buffer)
1012  return AVERROR(ENOMEM);
1013 
1014  f->version = AV_RL32(avctx->extradata) >> 16;
1015  ff_blockdsp_init(&f->bdsp);
1016  ff_bswapdsp_init(&f->bbdsp);
1017  f->avctx = avctx;
1018 
1019  if (f->version > 2)
1020  avctx->pix_fmt = AV_PIX_FMT_RGB565;
1021  else
1022  avctx->pix_fmt = AV_PIX_FMT_BGR555;
1023 
1024  ff_thread_once(&init_static_once, init_vlcs);
1025 
1026  return 0;
1027 }
1028 
1029  const FFCodec ff_fourxm_decoder = {
1030  .p.name = "4xm",
1031  CODEC_LONG_NAME("4X Movie"),
1032  .p.type = AVMEDIA_TYPE_VIDEO,
1033  .p.id = AV_CODEC_ID_4XM,
1034  .priv_data_size = sizeof(FourXContext),
1035  .init = decode_init,
1036  .close = decode_end,
1037  FF_CODEC_DECODE_CB(decode_frame),
1038  .p.capabilities = AV_CODEC_CAP_DR1,
1039  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1040 };
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:717
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:664
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:509
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:239
GetByteContext
Definition: bytestream.h:33
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: 4xm.c:837
thread.h
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
AVPacket::data
uint8_t * data
Definition: packet.h:374
FourXContext::cfrm
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: 4xm.c:155
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:43
table
static const uint16_t table[]
Definition: prosumer.c:205
FFCodec
Definition: codec_internal.h:127
decode_i_block
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition: 4xm.c:500
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
c1
static const uint64_t c1
Definition: murmur3.c:51
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:493
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
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:268
GetBitContext
Definition: get_bits.h:107
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:422
LE_CENTRIC_MUL
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition: 4xm.c:290
val
static double val(void *priv, double ch)
Definition: aeval.c:77
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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:605
avassert.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:184
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:528
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:345
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
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:2205
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
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:37
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:182
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
NULL
#define NULL
Definition: coverity.c:32
read_huffman_tables
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition: 4xm.c:619
idct_put
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:559
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
FourXContext::last_dc
int last_dc
Definition: 4xm.c:150
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:100
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:631
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:181
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
VLC::table_allocated
int table_allocated
Definition: vlc.h:34
f
f
Definition: af_crystalizer.c:122
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:427
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1473
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:301
AVPacket::size
int size
Definition: packet.h:375
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
decode_i2_frame
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:725
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:87
FourXContext::gb
GetBitContext gb
Definition: 4xm.c:145
VLCElem
Definition: vlc.h:27
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:452
ff_fourxm_decoder
const FFCodec ff_fourxm_decoder
Definition: 4xm.c:1029
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:282
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:553
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:269
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:527
BLOCK_TYPE_VLC_BITS
#define BLOCK_TYPE_VLC_BITS
Definition: 4xm.c:44
block_type_vlc
static VLC block_type_vlc[2][4]
Definition: 4xm.c:128
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:49
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:990
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:191
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:598
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:635
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:446
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:2065
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
decode_p_frame
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:432
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
id
enum AVCodecID id
Definition: dts2pts_bsf.c:364
AVCodecContext
main external API structure.
Definition: avcodec.h:426
mcdc
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition: 4xm.c:297
VLC
Definition: vlc.h:31
temp
else temp
Definition: vf_mcdeint.c:248
VLC::table
VLCElem * table
Definition: vlc.h:33
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:275
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:972
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:453
AVPacket
This structure stores compressed data.
Definition: packet.h:351
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:240
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:773
FourXContext::avctx
AVCodecContext * avctx
Definition: 4xm.c:139
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:598
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:375
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
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 Tue Feb 28 2023 21:33:05 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /