libavcodec/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 "libavutil/frame.h"
28 #include "libavutil/intreadwrite.h"
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "dsputil.h"
32 #include "get_bits.h"
33 #include "internal.h"
34 
35 #include "libavutil/avassert.h"
36 
37 #define BLOCK_TYPE_VLC_BITS 5
38 #define ACDC_VLC_BITS 9
39 
40 #define CFRAME_BUFFER_COUNT 100
41 
42 static const uint8_t block_type_tab[2][4][8][2] = {
43  {
44  { // { 8, 4, 2 } x { 8, 4, 2}
45  { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
46  }, { // { 8, 4 } x 1
47  { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
48  }, { // 1 x { 8, 4 }
49  { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
50  }, { // 1 x 2, 2 x 1
51  { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
52  }
53  }, {
54  { // { 8, 4, 2 } x { 8, 4, 2}
55  { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
56  }, {// { 8, 4 } x 1
57  { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
58  }, {// 1 x { 8, 4 }
59  { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60  }, {// 1 x 2, 2 x 1
61  { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
62  }
63  }
64 };
65 
66 static const uint8_t size2index[4][4] = {
67  { -1, 3, 1, 1 },
68  { 3, 0, 0, 0 },
69  { 2, 0, 0, 0 },
70  { 2, 0, 0, 0 },
71 };
72 
73 static const int8_t mv[256][2] = {
74  { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
75  { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
76  { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
77  { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
78  { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
79  { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
80  { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
81  { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
82  { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
83  { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
84  { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
85  { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
86  { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
87  { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
88  { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
89  { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
90  { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
91  { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
92  { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
93  { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
94  { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
95  { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
96  { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
97  { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
98  { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
99  { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
100  { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
101  { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
102  { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
103  { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
104  { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
105  { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
106 };
107 
108 /* This is simply the scaled down elementwise product of the standard JPEG
109  * quantizer table and the AAN premul table. */
110 static const uint8_t dequant_table[64] = {
111  16, 15, 13, 19, 24, 31, 28, 17,
112  17, 23, 25, 31, 36, 63, 45, 21,
113  18, 24, 27, 37, 52, 59, 49, 20,
114  16, 28, 34, 40, 60, 80, 51, 20,
115  18, 31, 48, 66, 68, 86, 56, 21,
116  19, 38, 56, 59, 64, 64, 48, 20,
117  27, 48, 55, 55, 56, 51, 35, 15,
118  20, 35, 34, 32, 31, 22, 15, 8,
119 };
120 
121 static VLC block_type_vlc[2][4];
122 
123 
124 typedef struct CFrameBuffer {
125  unsigned int allocated_size;
126  unsigned int size;
127  int id;
128  uint8_t *data;
129 } CFrameBuffer;
130 
131 typedef struct FourXContext {
132  AVCodecContext *avctx;
133  DSPContext dsp;
134  AVFrame *current_picture, *last_picture;
135  GetBitContext pre_gb; ///< ac/dc prefix
136  GetBitContext gb;
137  GetByteContext g;
138  GetByteContext g2;
139  int mv[256];
140  VLC pre_vlc;
141  int last_dc;
142  DECLARE_ALIGNED(16, int16_t, block)[6][64];
143  void *bitstream_buffer;
144  unsigned int bitstream_buffer_size;
145  int version;
146  CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
147 } FourXContext;
148 
149 
150 #define FIX_1_082392200 70936
151 #define FIX_1_414213562 92682
152 #define FIX_1_847759065 121095
153 #define FIX_2_613125930 171254
154 
155 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
156 
157 static void idct(int16_t block[64])
158 {
159  int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
160  int tmp10, tmp11, tmp12, tmp13;
161  int z5, z10, z11, z12, z13;
162  int i;
163  int temp[64];
164 
165  for (i = 0; i < 8; i++) {
166  tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
167  tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
168 
169  tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
170  tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
171 
172  tmp0 = tmp10 + tmp13;
173  tmp3 = tmp10 - tmp13;
174  tmp1 = tmp11 + tmp12;
175  tmp2 = tmp11 - tmp12;
176 
177  z13 = block[8 * 5 + i] + block[8 * 3 + i];
178  z10 = block[8 * 5 + i] - block[8 * 3 + i];
179  z11 = block[8 * 1 + i] + block[8 * 7 + i];
180  z12 = block[8 * 1 + i] - block[8 * 7 + i];
181 
182  tmp7 = z11 + z13;
183  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
184 
185  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
186  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
187  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
188 
189  tmp6 = tmp12 - tmp7;
190  tmp5 = tmp11 - tmp6;
191  tmp4 = tmp10 + tmp5;
192 
193  temp[8 * 0 + i] = tmp0 + tmp7;
194  temp[8 * 7 + i] = tmp0 - tmp7;
195  temp[8 * 1 + i] = tmp1 + tmp6;
196  temp[8 * 6 + i] = tmp1 - tmp6;
197  temp[8 * 2 + i] = tmp2 + tmp5;
198  temp[8 * 5 + i] = tmp2 - tmp5;
199  temp[8 * 4 + i] = tmp3 + tmp4;
200  temp[8 * 3 + i] = tmp3 - tmp4;
201  }
202 
203  for (i = 0; i < 8 * 8; i += 8) {
204  tmp10 = temp[0 + i] + temp[4 + i];
205  tmp11 = temp[0 + i] - temp[4 + i];
206 
207  tmp13 = temp[2 + i] + temp[6 + i];
208  tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
209 
210  tmp0 = tmp10 + tmp13;
211  tmp3 = tmp10 - tmp13;
212  tmp1 = tmp11 + tmp12;
213  tmp2 = tmp11 - tmp12;
214 
215  z13 = temp[5 + i] + temp[3 + i];
216  z10 = temp[5 + i] - temp[3 + i];
217  z11 = temp[1 + i] + temp[7 + i];
218  z12 = temp[1 + i] - temp[7 + i];
219 
220  tmp7 = z11 + z13;
221  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
222 
223  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
224  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
225  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
226 
227  tmp6 = tmp12 - tmp7;
228  tmp5 = tmp11 - tmp6;
229  tmp4 = tmp10 + tmp5;
230 
231  block[0 + i] = (tmp0 + tmp7) >> 6;
232  block[7 + i] = (tmp0 - tmp7) >> 6;
233  block[1 + i] = (tmp1 + tmp6) >> 6;
234  block[6 + i] = (tmp1 - tmp6) >> 6;
235  block[2 + i] = (tmp2 + tmp5) >> 6;
236  block[5 + i] = (tmp2 - tmp5) >> 6;
237  block[4 + i] = (tmp3 + tmp4) >> 6;
238  block[3 + i] = (tmp3 - tmp4) >> 6;
239  }
240 }
241 
242 static av_cold void init_vlcs(FourXContext *f)
243 {
244  static VLC_TYPE table[2][4][32][2];
245  int i, j;
246 
247  for (i = 0; i < 2; i++) {
248  for (j = 0; j < 4; j++) {
249  block_type_vlc[i][j].table = table[i][j];
250  block_type_vlc[i][j].table_allocated = 32;
251  init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
252  &block_type_tab[i][j][0][1], 2, 1,
253  &block_type_tab[i][j][0][0], 2, 1,
254  INIT_VLC_USE_NEW_STATIC);
255  }
256  }
257 }
258 
259 static void init_mv(FourXContext *f, int linesize)
260 {
261  int i;
262 
263  for (i = 0; i < 256; i++) {
264  if (f->version > 1)
265  f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
266  else
267  f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
268  }
269 }
270 
271 #if HAVE_BIGENDIAN
272 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
273  { \
274  unsigned tmpval = AV_RN32(src); \
275  tmpval = (tmpval << 16) | (tmpval >> 16); \
276  tmpval = tmpval * (scale) + (dc); \
277  tmpval = (tmpval << 16) | (tmpval >> 16); \
278  AV_WN32A(dst, tmpval); \
279  }
280 #else
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
282  { \
283  unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
284  AV_WN32A(dst, tmpval); \
285  }
286 #endif
287 
288 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
289  int h, int stride, int scale, unsigned dc)
290 {
291  int i;
292  dc *= 0x10001;
293 
294  switch (log2w) {
295  case 0:
296  for (i = 0; i < h; i++) {
297  dst[0] = scale * src[0] + dc;
298  if (scale)
299  src += stride;
300  dst += stride;
301  }
302  break;
303  case 1:
304  for (i = 0; i < h; i++) {
305  LE_CENTRIC_MUL(dst, src, scale, dc);
306  if (scale)
307  src += stride;
308  dst += stride;
309  }
310  break;
311  case 2:
312  for (i = 0; i < h; i++) {
313  LE_CENTRIC_MUL(dst, src, scale, dc);
314  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
315  if (scale)
316  src += stride;
317  dst += stride;
318  }
319  break;
320  case 3:
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  LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
325  LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
326  if (scale)
327  src += stride;
328  dst += stride;
329  }
330  break;
331  default:
332  av_assert2(0);
333  }
334 }
335 
336 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
337  int log2w, int log2h, int stride)
338 {
339  const int index = size2index[log2h][log2w];
340  const int h = 1 << log2h;
341  int code = get_vlc2(&f->gb,
342  block_type_vlc[1 - (f->version > 1)][index].table,
343  BLOCK_TYPE_VLC_BITS, 1);
344  uint16_t *start = (uint16_t *)f->last_picture->data[0];
345  uint16_t *end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
346 
347  av_assert2(code >= 0 && code <= 6);
348 
349  if (code == 0) {
350  if (bytestream2_get_bytes_left(&f->g) < 1) {
351  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
352  return;
353  }
354  src += f->mv[bytestream2_get_byteu(&f->g)];
355  if (start > src || src > end) {
356  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
357  return;
358  }
359  mcdc(dst, src, log2w, h, stride, 1, 0);
360  } else if (code == 1) {
361  log2h--;
362  decode_p_block(f, dst, src, log2w, log2h, stride);
363  decode_p_block(f, dst + (stride << log2h),
364  src + (stride << log2h), log2w, log2h, stride);
365  } else if (code == 2) {
366  log2w--;
367  decode_p_block(f, dst , src, log2w, log2h, stride);
368  decode_p_block(f, dst + (1 << log2w),
369  src + (1 << log2w), log2w, log2h, stride);
370  } else if (code == 3 && f->version < 2) {
371  mcdc(dst, src, log2w, h, stride, 1, 0);
372  } else if (code == 4) {
373  if (bytestream2_get_bytes_left(&f->g) < 1) {
374  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
375  return;
376  }
377  src += f->mv[bytestream2_get_byteu(&f->g)];
378  if (start > src || src > end) {
379  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
380  return;
381  }
382  if (bytestream2_get_bytes_left(&f->g2) < 2){
383  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
384  return;
385  }
386  mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16u(&f->g2));
387  } else if (code == 5) {
388  if (bytestream2_get_bytes_left(&f->g2) < 2) {
389  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
390  return;
391  }
392  mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16u(&f->g2));
393  } else if (code == 6) {
394  if (bytestream2_get_bytes_left(&f->g2) < 4) {
395  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
396  return;
397  }
398  if (log2w) {
399  dst[0] = bytestream2_get_le16u(&f->g2);
400  dst[1] = bytestream2_get_le16u(&f->g2);
401  } else {
402  dst[0] = bytestream2_get_le16u(&f->g2);
403  dst[stride] = bytestream2_get_le16u(&f->g2);
404  }
405  }
406 }
407 
408 static int decode_p_frame(FourXContext *f, AVFrame *frame,
409  const uint8_t *buf, int length)
410 {
411  int x, y;
412  const int width = f->avctx->width;
413  const int height = f->avctx->height;
414  uint16_t *src = (uint16_t *)f->last_picture->data[0];
415  uint16_t *dst = (uint16_t *)frame->data[0];
416  const int stride = frame->linesize[0] >> 1;
417  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
418  bytestream_offset, wordstream_offset;
419 
420  if (f->version > 1) {
421  extra = 20;
422  if (length < extra)
423  return -1;
424  bitstream_size = AV_RL32(buf + 8);
425  wordstream_size = AV_RL32(buf + 12);
426  bytestream_size = AV_RL32(buf + 16);
427  } else {
428  extra = 0;
429  bitstream_size = AV_RL16(buf - 4);
430  wordstream_size = AV_RL16(buf - 2);
431  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
432  }
433 
434  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
435  bytestream_size > length - bitstream_size ||
436  wordstream_size > length - bytestream_size - bitstream_size ||
437  extra > length - bytestream_size - bitstream_size - wordstream_size) {
438  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
439  bitstream_size+ bytestream_size+ wordstream_size - length);
440  return AVERROR_INVALIDDATA;
441  }
442 
443  av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
444  bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
445  if (!f->bitstream_buffer)
446  return AVERROR(ENOMEM);
447  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
448  bitstream_size / 4);
449  memset((uint8_t*)f->bitstream_buffer + bitstream_size,
450  0, FF_INPUT_BUFFER_PADDING_SIZE);
451  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
452 
453  wordstream_offset = extra + bitstream_size;
454  bytestream_offset = extra + bitstream_size + wordstream_size;
455  bytestream2_init(&f->g2, buf + wordstream_offset,
456  length - wordstream_offset);
457  bytestream2_init(&f->g, buf + bytestream_offset,
458  length - bytestream_offset);
459 
460  init_mv(f, frame->linesize[0]);
461 
462  for (y = 0; y < height; y += 8) {
463  for (x = 0; x < width; x += 8)
464  decode_p_block(f, dst + x, src + x, 3, 3, stride);
465  src += 8 * stride;
466  dst += 8 * stride;
467  }
468 
469  return 0;
470 }
471 
472 /**
473  * decode block and dequantize.
474  * Note this is almost identical to MJPEG.
475  */
476 static int decode_i_block(FourXContext *f, int16_t *block)
477 {
478  int code, i, j, level, val;
479 
480  if (get_bits_left(&f->gb) < 2){
481  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
482  return -1;
483  }
484 
485  /* DC coef */
486  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
487  if (val >> 4)
488  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
489 
490  if (val)
491  val = get_xbits(&f->gb, val);
492 
493  val = val * dequant_table[0] + f->last_dc;
494  f->last_dc = block[0] = val;
495  /* AC coefs */
496  i = 1;
497  for (;;) {
498  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
499 
500  /* EOB */
501  if (code == 0)
502  break;
503  if (code == 0xf0) {
504  i += 16;
505  } else {
506  level = get_xbits(&f->gb, code & 0xf);
507  i += code >> 4;
508  if (i >= 64) {
509  av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
510  return 0;
511  }
512 
513  j = ff_zigzag_direct[i];
514  block[j] = level * dequant_table[j];
515  i++;
516  if (i >= 64)
517  break;
518  }
519  }
520 
521  return 0;
522 }
523 
524 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
525 {
526  int16_t (*block)[64] = f->block;
527  int stride = frame->linesize[0] >> 1;
528  int i;
529  uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
530 
531  for (i = 0; i < 4; i++) {
532  block[i][0] += 0x80 * 8 * 8;
533  idct(block[i]);
534  }
535 
536  if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
537  for (i = 4; i < 6; i++)
538  idct(block[i]);
539  }
540 
541  /* Note transform is:
542  * y = ( 1b + 4g + 2r) / 14
543  * cb = ( 3b - 2g - 1r) / 14
544  * cr = (-1b - 4g + 5r) / 14 */
545  for (y = 0; y < 8; y++) {
546  for (x = 0; x < 8; x++) {
547  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
548  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
549  int cb = block[4][x + 8 * y];
550  int cr = block[5][x + 8 * y];
551  int cg = (cb + cr) >> 1;
552  int y;
553 
554  cb += cb;
555 
556  y = temp[0];
557  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
558  y = temp[1];
559  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
560  y = temp[8];
561  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
562  y = temp[9];
563  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
564  dst += 2;
565  }
566  dst += 2 * stride - 2 * 8;
567  }
568 }
569 
570 static int decode_i_mb(FourXContext *f)
571 {
572  int ret;
573  int i;
574 
575  f->dsp.clear_blocks(f->block[0]);
576 
577  for (i = 0; i < 6; i++)
578  if ((ret = decode_i_block(f, f->block[i])) < 0)
579  return ret;
580 
581  return 0;
582 }
583 
584 static const uint8_t *read_huffman_tables(FourXContext *f,
585  const uint8_t * const buf, int buf_size)
586 {
587  int frequency[512] = { 0 };
588  uint8_t flag[512];
589  int up[512];
590  uint8_t len_tab[257];
591  int bits_tab[257];
592  int start, end;
593  const uint8_t *ptr = buf;
594  const uint8_t *ptr_end = buf + buf_size;
595  int j;
596 
597  memset(up, -1, sizeof(up));
598 
599  start = *ptr++;
600  end = *ptr++;
601  for (;;) {
602  int i;
603 
604  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
605  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
606  return NULL;
607  }
608  for (i = start; i <= end; i++)
609  frequency[i] = *ptr++;
610  start = *ptr++;
611  if (start == 0)
612  break;
613 
614  end = *ptr++;
615  }
616  frequency[256] = 1;
617 
618  while ((ptr - buf) & 3)
619  ptr++; // 4byte align
620 
621  if (ptr > ptr_end) {
622  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
623  return NULL;
624  }
625 
626  for (j = 257; j < 512; j++) {
627  int min_freq[2] = { 256 * 256, 256 * 256 };
628  int smallest[2] = { 0, 0 };
629  int i;
630  for (i = 0; i < j; i++) {
631  if (frequency[i] == 0)
632  continue;
633  if (frequency[i] < min_freq[1]) {
634  if (frequency[i] < min_freq[0]) {
635  min_freq[1] = min_freq[0];
636  smallest[1] = smallest[0];
637  min_freq[0] = frequency[i];
638  smallest[0] = i;
639  } else {
640  min_freq[1] = frequency[i];
641  smallest[1] = i;
642  }
643  }
644  }
645  if (min_freq[1] == 256 * 256)
646  break;
647 
648  frequency[j] = min_freq[0] + min_freq[1];
649  flag[smallest[0]] = 0;
650  flag[smallest[1]] = 1;
651  up[smallest[0]] =
652  up[smallest[1]] = j;
653  frequency[smallest[0]] = frequency[smallest[1]] = 0;
654  }
655 
656  for (j = 0; j < 257; j++) {
657  int node, len = 0, bits = 0;
658 
659  for (node = j; up[node] != -1; node = up[node]) {
660  bits += flag[node] << len;
661  len++;
662  if (len > 31)
663  // can this happen at all ?
664  av_log(f->avctx, AV_LOG_ERROR,
665  "vlc length overflow\n");
666  }
667 
668  bits_tab[j] = bits;
669  len_tab[j] = len;
670  }
671 
672  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
673  bits_tab, 4, 4, 0))
674  return NULL;
675 
676  return ptr;
677 }
678 
679 static int mix(int c0, int c1)
680 {
681  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
682  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
683  int red = 2 * (c0 >> 10) + (c1 >> 10);
684  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
685 }
686 
687 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
688 {
689  int x, y, x2, y2;
690  const int width = f->avctx->width;
691  const int height = f->avctx->height;
692  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
693  uint16_t *dst = (uint16_t*)frame->data[0];
694  const int stride = frame->linesize[0]>>1;
695  const uint8_t *buf_end = buf + length;
696  GetByteContext g3;
697 
698  if (length < mbs * 8) {
699  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
700  return AVERROR_INVALIDDATA;
701  }
702  bytestream2_init(&g3, buf, length);
703 
704  for (y = 0; y < height; y += 16) {
705  for (x = 0; x < width; x += 16) {
706  unsigned int color[4] = { 0 }, bits;
707  if (buf_end - buf < 8)
708  return -1;
709  // warning following is purely guessed ...
710  color[0] = bytestream2_get_le16u(&g3);
711  color[1] = bytestream2_get_le16u(&g3);
712 
713  if (color[0] & 0x8000)
714  av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
715  if (color[1] & 0x8000)
716  av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
717 
718  color[2] = mix(color[0], color[1]);
719  color[3] = mix(color[1], color[0]);
720 
721  bits = bytestream2_get_le32u(&g3);
722  for (y2 = 0; y2 < 16; y2++) {
723  for (x2 = 0; x2 < 16; x2++) {
724  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
725  dst[y2 * stride + x2] = color[(bits >> index) & 3];
726  }
727  }
728  dst += 16;
729  }
730  dst += 16 * stride - x;
731  }
732 
733  return 0;
734 }
735 
736 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
737 {
738  int x, y, ret;
739  const int width = f->avctx->width;
740  const int height = f->avctx->height;
741  const unsigned int bitstream_size = AV_RL32(buf);
742  unsigned int prestream_size;
743  const uint8_t *prestream;
744 
745  if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
746  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
747  return AVERROR_INVALIDDATA;
748  }
749 
750  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
751  prestream = buf + bitstream_size + 12;
752 
753  if (prestream_size + bitstream_size + 12 != length
754  || bitstream_size > (1 << 26)
755  || prestream_size > (1 << 26)) {
756  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
757  prestream_size, bitstream_size, length);
758  return AVERROR_INVALIDDATA;
759  }
760 
761  prestream = read_huffman_tables(f, prestream, buf + length - prestream);
762  if (!prestream) {
763  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
764  return AVERROR_INVALIDDATA;
765  }
766 
767  av_assert0(prestream <= buf + length);
768 
769  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
770 
771  prestream_size = length + buf - prestream;
772 
773  av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
774  prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
775  if (!f->bitstream_buffer)
776  return AVERROR(ENOMEM);
777  f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
778  prestream_size / 4);
779  memset((uint8_t*)f->bitstream_buffer + prestream_size,
780  0, FF_INPUT_BUFFER_PADDING_SIZE);
781  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
782 
783  f->last_dc = 0 * 128 * 8 * 8;
784 
785  for (y = 0; y < height; y += 16) {
786  for (x = 0; x < width; x += 16) {
787  if ((ret = decode_i_mb(f)) < 0)
788  return ret;
789 
790  idct_put(f, frame, x, y);
791  }
792  }
793 
794  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
795  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
796 
797  return 0;
798 }
799 
800 static int decode_frame(AVCodecContext *avctx, void *data,
801  int *got_frame, AVPacket *avpkt)
802 {
803  const uint8_t *buf = avpkt->data;
804  int buf_size = avpkt->size;
805  FourXContext *const f = avctx->priv_data;
806  AVFrame *picture = data;
807  int i, frame_4cc, frame_size, ret;
808 
809  if (buf_size < 12)
810  return AVERROR_INVALIDDATA;
811  frame_4cc = AV_RL32(buf);
812  if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
813  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
814  buf_size, AV_RL32(buf + 4));
815 
816  if (frame_4cc == AV_RL32("cfrm")) {
817  int free_index = -1;
818  const int data_size = buf_size - 20;
819  const int id = AV_RL32(buf + 12);
820  const int whole_size = AV_RL32(buf + 16);
821  CFrameBuffer *cfrm;
822 
823  if (data_size < 0 || whole_size < 0) {
824  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
825  return AVERROR_INVALIDDATA;
826  }
827 
828  if (f->version <= 1) {
829  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
830  return AVERROR_INVALIDDATA;
831  }
832 
833  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
834  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
835  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
836  f->cfrm[i].id);
837 
838  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
839  if (f->cfrm[i].id == id)
840  break;
841  if (f->cfrm[i].size == 0)
842  free_index = i;
843  }
844 
845  if (i >= CFRAME_BUFFER_COUNT) {
846  i = free_index;
847  f->cfrm[i].id = id;
848  }
849  cfrm = &f->cfrm[i];
850 
851  if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
852  return AVERROR_INVALIDDATA;
853 
854  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
855  cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
856  // explicit check needed as memcpy below might not catch a NULL
857  if (!cfrm->data) {
858  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
859  return AVERROR(ENOMEM);
860  }
861 
862  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
863  cfrm->size += data_size;
864 
865  if (cfrm->size >= whole_size) {
866  buf = cfrm->data;
867  frame_size = cfrm->size;
868 
869  if (id != avctx->frame_number)
870  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
871  id, avctx->frame_number);
872 
873  cfrm->size = cfrm->id = 0;
874  frame_4cc = AV_RL32("pfrm");
875  } else
876  return buf_size;
877  } else {
878  buf = buf + 12;
879  frame_size = buf_size - 12;
880  }
881 
882  FFSWAP(AVFrame*, f->current_picture, f->last_picture);
883 
884  // alternatively we would have to use our own buffer management
885  avctx->flags |= CODEC_FLAG_EMU_EDGE;
886 
887  if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
888  return ret;
889 
890  if (frame_4cc == AV_RL32("ifr2")) {
891  f->current_picture->pict_type = AV_PICTURE_TYPE_I;
892  if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
893  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
894  return ret;
895  }
896  } else if (frame_4cc == AV_RL32("ifrm")) {
897  f->current_picture->pict_type = AV_PICTURE_TYPE_I;
898  if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
899  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
900  return ret;
901  }
902  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
903  if (!f->last_picture->data[0]) {
904  if ((ret = ff_get_buffer(avctx, f->last_picture,
905  AV_GET_BUFFER_FLAG_REF)) < 0)
906  return ret;
907  for (i=0; i<avctx->height; i++)
908  memset(f->last_picture->data[0] + i*f->last_picture->linesize[0], 0, 2*avctx->width);
909  }
910 
911  f->current_picture->pict_type = AV_PICTURE_TYPE_P;
912  if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
913  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
914  return ret;
915  }
916  } else if (frame_4cc == AV_RL32("snd_")) {
917  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
918  buf_size);
919  } else {
920  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
921  buf_size);
922  }
923 
924  f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
925 
926  if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
927  return ret;
928  *got_frame = 1;
929 
930  emms_c();
931 
932  return buf_size;
933 }
934 
935 static av_cold int decode_init(AVCodecContext *avctx)
936 {
937  FourXContext * const f = avctx->priv_data;
938 
939  if (avctx->extradata_size != 4 || !avctx->extradata) {
940  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
941  return AVERROR_INVALIDDATA;
942  }
943  if((avctx->width % 16) || (avctx->height % 16)) {
944  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
945  return AVERROR_INVALIDDATA;
946  }
947 
948  f->version = AV_RL32(avctx->extradata) >> 16;
949  ff_dsputil_init(&f->dsp, avctx);
950  f->avctx = avctx;
951  init_vlcs(f);
952 
953  if (f->version > 2)
954  avctx->pix_fmt = AV_PIX_FMT_RGB565;
955  else
956  avctx->pix_fmt = AV_PIX_FMT_BGR555;
957 
958  f->current_picture = av_frame_alloc();
959  f->last_picture = av_frame_alloc();
960  if (!f->current_picture || !f->last_picture)
961  return AVERROR(ENOMEM);
962 
963  return 0;
964 }
965 
966 
967 static av_cold int decode_end(AVCodecContext *avctx)
968 {
969  FourXContext * const f = avctx->priv_data;
970  int i;
971 
972  av_freep(&f->bitstream_buffer);
973  f->bitstream_buffer_size = 0;
974  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
975  av_freep(&f->cfrm[i].data);
976  f->cfrm[i].allocated_size = 0;
977  }
978  ff_free_vlc(&f->pre_vlc);
979  av_frame_free(&f->current_picture);
980  av_frame_free(&f->last_picture);
981 
982  return 0;
983 }
984 
985 AVCodec ff_fourxm_decoder = {
986  .name = "4xm",
987  .type = AVMEDIA_TYPE_VIDEO,
988  .id = AV_CODEC_ID_4XM,
989  .priv_data_size = sizeof(FourXContext),
990  .init = decode_init,
991  .close = decode_end,
992  .decode = decode_frame,
993  .capabilities = CODEC_CAP_DR1,
994  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
995 };
start
Definition: start.py:1
ff_dsputil_init
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2675
FourXContext::g
GetByteContext g
Definition: libavcodec/4xm.c:137
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
idct
static void idct(int16_t block[64])
Definition: libavcodec/4xm.c:157
temp
else temp
Definition: vf_mcdeint.c:148
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
init_vlcs
static av_cold void init_vlcs(FourXContext *f)
Definition: libavcodec/4xm.c:242
ff_fourxm_decoder
AVCodec ff_fourxm_decoder
Definition: libavcodec/4xm.c:985
block_type_vlc
static VLC block_type_vlc[2][4]
Definition: libavcodec/4xm.c:121
f
Sinusoidal phase f
Definition: FFT of a Simple Sinusoid.m:8
read_huffman_tables
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition: libavcodec/4xm.c:584
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:59
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: libavcodec/avcodec.h:1330
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
AV_RL16
#define AV_RL16
Definition: avr32/intreadwrite.h:42
mcdc
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition: libavcodec/4xm.c:288
VLC_TYPE
#define VLC_TYPE
Definition: get_bits.h:61
FIX_1_414213562
#define FIX_1_414213562
Definition: libavcodec/4xm.c:151
FIX_1_082392200
#define FIX_1_082392200
Definition: libavcodec/4xm.c:150
stride
int stride
Definition: mace.c:144
FFALIGN
#define FFALIGN(x, a)
Definition: common.h:63
FourXContext::last_picture
AVFrame * last_picture
Definition: libavcodec/4xm.c:134
av_freep
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
if
initialize output if(nPeaks >3)%at least 3 peaks in spectrum for trying to find f0 nf0peaks
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: libavcodec/utils.c:96
bits
uint8_t bits
Definition: crc.c:216
CFrameBuffer::size
unsigned int size
Definition: libavcodec/4xm.c:126
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:78
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:77
end
end end
Definition: extra/f0detection.m:15
decode_i_frame
static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
Definition: libavcodec/4xm.c:736
CFrameBuffer::allocated_size
unsigned int allocated_size
Definition: libavcodec/4xm.c:125
emms_c
#define emms_c()
Definition: libavutil/internal.h:48
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: libavcodec/avcodec.h:1242
CFrameBuffer
struct CFrameBuffer CFrameBuffer
CODEC_CAP_DR1
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: libavcodec/avcodec.h:743
block_type_tab
static const uint8_t block_type_tab[2][4][8][2]
Definition: libavcodec/4xm.c:42
AVPacket::data
uint8_t * data
Definition: libavcodec/avcodec.h:1051
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: libavcodec/4xm.c:935
get_bits.h
bitstream reader API header.
idct_put
static void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
Definition: libavcodec/4xm.c:524
FourXContext::avctx
AVCodecContext * avctx
Definition: libavcodec/4xm.c:132
FourXContext::current_picture
AVFrame * current_picture
Definition: libavcodec/4xm.c:134
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: libavcodec/4xm.c:800
frame
frame
Definition: stft.m:14
decode_i_mb
static int decode_i_mb(FourXContext *f)
Definition: libavcodec/4xm.c:570
frame_size
static const uint8_t frame_size[4]
Definition: g723_1_data.h:58
x
Discrete Time axis x
Definition: FFT of a Simple Sinusoid.m:10
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:557
FourXContext::gb
GetBitContext gb
Definition: libavcodec/4xm.c:136
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given block if it is not large enough, otherwise do nothing.
Definition: libavcodec/utils.c:63
decode_p_block
static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride)
Definition: libavcodec/4xm.c:336
LE_CENTRIC_MUL
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition: libavcodec/4xm.c:281
decode_i_block
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition: libavcodec/4xm.c:476
table
static const struct endianess table[]
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: libavutil/internal.h:123
FIX_1_847759065
#define FIX_1_847759065
Definition: libavcodec/4xm.c:152
bytestream2_get_bytes_left
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:149
AVCodecContext::flags
int flags
CODEC_FLAG_*.
Definition: libavcodec/avcodec.h:1222
DSPContext::clear_blocks
void(* clear_blocks)(int16_t *blocks)
Definition: dsputil.h:146
FourXContext::bitstream_buffer
void * bitstream_buffer
Definition: libavcodec/4xm.c:143
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
av_log
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
size2index
static const uint8_t size2index[4][4]
Definition: libavcodec/4xm.c:66
AVCodec::name
const char * name
Name of the codec implementation.
Definition: libavcodec/avcodec.h:2861
FFMAX
#define FFMAX(a, b)
Definition: common.h:56
avcodec.h
external API header
VLC
Definition: get_bits.h:63
AV_CODEC_ID_4XM
Definition: libavcodec/avcodec.h:137
CFRAME_BUFFER_COUNT
#define CFRAME_BUFFER_COUNT
Definition: libavcodec/4xm.c:40
FF_INPUT_BUFFER_PADDING_SIZE
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: libavcodec/avcodec.h:561
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: libavcodec/utils.c:868
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:216
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:144
ret
ret
Definition: avfilter.c:821
AVCodecContext::width
int width
picture width / height.
Definition: libavcodec/avcodec.h:1302
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:524
AV_RL32
#define AV_RL32
Definition: avr32/intreadwrite.h:146
level
FIXME Range Coding of cr are level
Definition: snow.txt:367
y2
y2
Definition: lab5.m:34
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:443
VLC::table_allocated
int table_allocated
Definition: get_bits.h:66
mv
static const int8_t mv[256][2]
Definition: libavcodec/4xm.c:73
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:273
FourXContext
struct FourXContext FourXContext
mix
static int mix(int c0, int c1)
Definition: libavcodec/4xm.c:679
NULL
NULL
Definition: eval.c:55
code
or the Software in violation of any applicable export control laws in any jurisdiction Except as provided by mandatorily applicable UPF has no obligation to provide you with source code to the Software In the event Software contains any source code
Definition: MELODIA - License.txt:24
width
static int width
Definition: tests/utils.c:158
src
AVS_Value src
Definition: avisynth_c.h:523
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
cb
FIXME Range Coding of cb
Definition: snow.txt:367
AVCodecContext
main external API structure.
Definition: libavcodec/avcodec.h:1134
init_mv
static void init_mv(FourXContext *f, int linesize)
Definition: libavcodec/4xm.c:259
close
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:375
dc
FIXME Range Coding of cr are mx and my are Motion Vector 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 Predicton block[y][x] dc[1]
Definition: snow.txt:392
get_xbits
static int get_xbits(GetBitContext *s, int n)
read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
Definition: get_bits.h:212
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: libavcodec/utils.c:823
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:426
buf
void * buf
Definition: avisynth_c.h:594
height
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
x2
x2
Definition: genspecsines3.m:8
index
int index
Definition: gxfenc.c:89
dequant_table
static const uint8_t dequant_table[64]
Definition: libavcodec/4xm.c:110
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
DSPContext::bswap_buf
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: dsputil.h:208
FourXContext::dsp
DSPContext dsp
Definition: libavcodec/4xm.c:133
FourXContext::cfrm
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: libavcodec/4xm.c:146
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:379
ACDC_VLC_BITS
#define ACDC_VLC_BITS
Definition: libavcodec/4xm.c:38
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer 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.Buffer references ownership and permissions
FourXContext::bitstream_buffer_size
unsigned int bitstream_buffer_size
Definition: libavcodec/4xm.c:144
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:95
CFrameBuffer::data
uint8_t * data
Definition: libavcodec/4xm.c:128
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: libavcodec/4xm.c:967
av_frame_ref
int av_frame_ref(AVFrame *dst, AVFrame *src)
Setup a new reference to the data described by an given frame.
Definition: frame.c:228
decode_p_frame
static int decode_p_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
Definition: libavcodec/4xm.c:408
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
FIX_2_613125930
#define FIX_2_613125930
Definition: libavcodec/4xm.c:153
CODEC_FLAG_EMU_EDGE
#define CODEC_FLAG_EMU_EDGE
Don&#39;t draw edges.
Definition: libavcodec/avcodec.h:707
internal.h
common internal api header.
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:115
CODEC_FLAG_GRAY
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: libavcodec/avcodec.h:706
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:108
FourXContext::pre_gb
GetBitContext pre_gb
ac/dc prefix
Definition: libavcodec/4xm.c:135
scale
Same thing on a dB scale
Definition: FFT of a Simple Sinusoid.m:36
y
function y
Definition: D.m:1
dsputil.h
DSP utils.
len
int len
Definition: vorbis_enc_data.h:452
dst
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
FourXContext::g2
GetByteContext g2
Definition: libavcodec/4xm.c:138
decode_i2_frame
static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
Definition: libavcodec/4xm.c:687
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:268
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: libavcodec/avcodec.h:1892
start
void INT64 start
Definition: avisynth_c.h:594
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:143
decode
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
BLOCK_TYPE_VLC_BITS
#define BLOCK_TYPE_VLC_BITS
Definition: libavcodec/4xm.c:37
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:61
length
const char int length
Definition: avisynth_c.h:668
MULTIPLY
#define MULTIPLY(var, const)
Definition: libavcodec/4xm.c:155
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:85
AVPacket
This structure stores compressed data.
Definition: libavcodec/avcodec.h:1028
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:344
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: libavcodec/avcodec.h:909
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:217
c1
#define c1
Definition: idct_sh4.c:26
DSPContext
DSPContext.
Definition: dsputil.h:127
Generated on Fri Dec 20 2024 06:55:56 for FFmpeg by   doxygen 1.8.11