FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 "avcodec.h"
34 #include "blockdsp.h"
35 #include "bswapdsp.h"
36 #include "bytestream.h"
37 #include "get_bits.h"
38 #include "internal.h"
39 
40 
41 #define BLOCK_TYPE_VLC_BITS 5
42 #define ACDC_VLC_BITS 9
43 
44 #define CFRAME_BUFFER_COUNT 100
45 
46 static const uint8_t block_type_tab[2][4][8][2] = {
47  {
48  { // { 8, 4, 2 } x { 8, 4, 2}
49  { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
50  }, { // { 8, 4 } x 1
51  { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
52  }, { // 1 x { 8, 4 }
53  { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
54  }, { // 1 x 2, 2 x 1
55  { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
56  }
57  }, {
58  { // { 8, 4, 2 } x { 8, 4, 2}
59  { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60  }, {// { 8, 4 } x 1
61  { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62  }, {// 1 x { 8, 4 }
63  { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64  }, {// 1 x 2, 2 x 1
65  { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
66  }
67  }
68 };
69 
70 static const uint8_t size2index[4][4] = {
71  { -1, 3, 1, 1 },
72  { 3, 0, 0, 0 },
73  { 2, 0, 0, 0 },
74  { 2, 0, 0, 0 },
75 };
76 
77 static const int8_t mv[256][2] = {
78  { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
79  { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
80  { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
81  { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
82  { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
83  { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
84  { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
85  { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
86  { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
87  { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
88  { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
89  { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
90  { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
91  { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
92  { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
93  { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
94  { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
95  { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
96  { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
97  { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
98  { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
99  { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
100  { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
101  { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
102  { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
103  { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
104  { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
105  { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
106  { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
107  { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
108  { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
109  { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
110 };
111 
112 /* This is simply the scaled down elementwise product of the standard JPEG
113  * quantizer table and the AAN premul table. */
114 static const uint8_t dequant_table[64] = {
115  16, 15, 13, 19, 24, 31, 28, 17,
116  17, 23, 25, 31, 36, 63, 45, 21,
117  18, 24, 27, 37, 52, 59, 49, 20,
118  16, 28, 34, 40, 60, 80, 51, 20,
119  18, 31, 48, 66, 68, 86, 56, 21,
120  19, 38, 56, 59, 64, 64, 48, 20,
121  27, 48, 55, 55, 56, 51, 35, 15,
122  20, 35, 34, 32, 31, 22, 15, 8,
123 };
124 
125 static VLC block_type_vlc[2][4];
126 
127 
128 typedef struct CFrameBuffer {
129  unsigned int allocated_size;
130  unsigned int size;
131  int id;
133 } CFrameBuffer;
134 
135 typedef struct FourXContext {
139  uint16_t *frame_buffer;
140  uint16_t *last_frame_buffer;
141  GetBitContext pre_gb; ///< ac/dc prefix
145  int mv[256];
147  int last_dc;
148  DECLARE_ALIGNED(16, int16_t, block)[6][64];
150  unsigned int bitstream_buffer_size;
151  int version;
153 } FourXContext;
154 
155 
156 #define FIX_1_082392200 70936
157 #define FIX_1_414213562 92682
158 #define FIX_1_847759065 121095
159 #define FIX_2_613125930 171254
160 
161 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
162 
163 static void idct(int16_t block[64])
164 {
165  int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
166  int tmp10, tmp11, tmp12, tmp13;
167  int z5, z10, z11, z12, z13;
168  int i;
169  int temp[64];
170 
171  for (i = 0; i < 8; i++) {
172  tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
173  tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
174 
175  tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
176  tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
177 
178  tmp0 = tmp10 + tmp13;
179  tmp3 = tmp10 - tmp13;
180  tmp1 = tmp11 + tmp12;
181  tmp2 = tmp11 - tmp12;
182 
183  z13 = block[8 * 5 + i] + block[8 * 3 + i];
184  z10 = block[8 * 5 + i] - block[8 * 3 + i];
185  z11 = block[8 * 1 + i] + block[8 * 7 + i];
186  z12 = block[8 * 1 + i] - block[8 * 7 + i];
187 
188  tmp7 = z11 + z13;
189  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
190 
191  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
192  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
193  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
194 
195  tmp6 = tmp12 - tmp7;
196  tmp5 = tmp11 - tmp6;
197  tmp4 = tmp10 + tmp5;
198 
199  temp[8 * 0 + i] = tmp0 + tmp7;
200  temp[8 * 7 + i] = tmp0 - tmp7;
201  temp[8 * 1 + i] = tmp1 + tmp6;
202  temp[8 * 6 + i] = tmp1 - tmp6;
203  temp[8 * 2 + i] = tmp2 + tmp5;
204  temp[8 * 5 + i] = tmp2 - tmp5;
205  temp[8 * 4 + i] = tmp3 + tmp4;
206  temp[8 * 3 + i] = tmp3 - tmp4;
207  }
208 
209  for (i = 0; i < 8 * 8; i += 8) {
210  tmp10 = temp[0 + i] + temp[4 + i];
211  tmp11 = temp[0 + i] - temp[4 + i];
212 
213  tmp13 = temp[2 + i] + temp[6 + i];
214  tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
215 
216  tmp0 = tmp10 + tmp13;
217  tmp3 = tmp10 - tmp13;
218  tmp1 = tmp11 + tmp12;
219  tmp2 = tmp11 - tmp12;
220 
221  z13 = temp[5 + i] + temp[3 + i];
222  z10 = temp[5 + i] - temp[3 + i];
223  z11 = temp[1 + i] + temp[7 + i];
224  z12 = temp[1 + i] - temp[7 + i];
225 
226  tmp7 = z11 + z13;
227  tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
228 
229  z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
230  tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
231  tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
232 
233  tmp6 = tmp12 - tmp7;
234  tmp5 = tmp11 - tmp6;
235  tmp4 = tmp10 + tmp5;
236 
237  block[0 + i] = (tmp0 + tmp7) >> 6;
238  block[7 + i] = (tmp0 - tmp7) >> 6;
239  block[1 + i] = (tmp1 + tmp6) >> 6;
240  block[6 + i] = (tmp1 - tmp6) >> 6;
241  block[2 + i] = (tmp2 + tmp5) >> 6;
242  block[5 + i] = (tmp2 - tmp5) >> 6;
243  block[4 + i] = (tmp3 + tmp4) >> 6;
244  block[3 + i] = (tmp3 - tmp4) >> 6;
245  }
246 }
247 
249 {
250  static VLC_TYPE table[2][4][32][2];
251  int i, j;
252 
253  for (i = 0; i < 2; i++) {
254  for (j = 0; j < 4; j++) {
255  block_type_vlc[i][j].table = table[i][j];
256  block_type_vlc[i][j].table_allocated = 32;
257  init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
258  &block_type_tab[i][j][0][1], 2, 1,
259  &block_type_tab[i][j][0][0], 2, 1,
261  }
262  }
263 }
264 
265 static void init_mv(FourXContext *f, int linesize)
266 {
267  int i;
268 
269  for (i = 0; i < 256; i++) {
270  if (f->version > 1)
271  f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
272  else
273  f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
274  }
275 }
276 
277 #if HAVE_BIGENDIAN
278 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
279  { \
280  unsigned tmpval = AV_RN32(src); \
281  tmpval = (tmpval << 16) | (tmpval >> 16); \
282  tmpval = tmpval * (scale) + (dc); \
283  tmpval = (tmpval << 16) | (tmpval >> 16); \
284  AV_WN32A(dst, tmpval); \
285  }
286 #else
287 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
288  { \
289  unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
290  AV_WN32A(dst, tmpval); \
291  }
292 #endif
293 
294 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
295  int h, int stride, int scale, unsigned dc)
296 {
297  int i;
298  dc *= 0x10001;
299 
300  switch (log2w) {
301  case 0:
302  for (i = 0; i < h; i++) {
303  dst[0] = scale * src[0] + dc;
304  if (scale)
305  src += stride;
306  dst += stride;
307  }
308  break;
309  case 1:
310  for (i = 0; i < h; i++) {
311  LE_CENTRIC_MUL(dst, src, scale, dc);
312  if (scale)
313  src += stride;
314  dst += stride;
315  }
316  break;
317  case 2:
318  for (i = 0; i < h; i++) {
319  LE_CENTRIC_MUL(dst, src, scale, dc);
320  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
321  if (scale)
322  src += stride;
323  dst += stride;
324  }
325  break;
326  case 3:
327  for (i = 0; i < h; i++) {
328  LE_CENTRIC_MUL(dst, src, scale, dc);
329  LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
330  LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
331  LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
332  if (scale)
333  src += stride;
334  dst += stride;
335  }
336  break;
337  default:
338  av_assert0(0);
339  }
340 }
341 
342 static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
343  int log2w, int log2h, int stride)
344 {
345  int index, h, code, ret, scale = 1;
346  uint16_t *start, *end;
347  unsigned dc = 0;
348 
349  av_assert0(log2w >= 0 && log2h >= 0);
350 
351  index = size2index[log2h][log2w];
352  av_assert0(index >= 0);
353 
354  if (get_bits_left(&f->gb) < 1)
355  return AVERROR_INVALIDDATA;
356  h = 1 << log2h;
357  code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
359  av_assert0(code >= 0 && code <= 6);
360 
361  start = f->last_frame_buffer;
362  end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
363 
364  if (code == 1) {
365  log2h--;
366  if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
367  return ret;
368  return decode_p_block(f, dst + (stride << log2h),
369  src + (stride << log2h),
370  log2w, log2h, stride);
371  } else if (code == 2) {
372  log2w--;
373  if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
374  return ret;
375  return decode_p_block(f, dst + (1 << log2w),
376  src + (1 << log2w),
377  log2w, log2h, stride);
378  } else if (code == 6) {
379  if (bytestream2_get_bytes_left(&f->g2) < 4) {
380  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
381  return AVERROR_INVALIDDATA;
382  }
383  if (log2w) {
384  dst[0] = bytestream2_get_le16u(&f->g2);
385  dst[1] = bytestream2_get_le16u(&f->g2);
386  } else {
387  dst[0] = bytestream2_get_le16u(&f->g2);
388  dst[stride] = bytestream2_get_le16u(&f->g2);
389  }
390  return 0;
391  }
392 
393  if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
394  av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
395  return AVERROR_INVALIDDATA;
396  }
397 
398  if (code == 0) {
399  src += f->mv[bytestream2_get_byte(&f->g)];
400  } else if (code == 3 && f->version >= 2) {
401  return 0;
402  } else if (code == 4) {
403  src += f->mv[bytestream2_get_byte(&f->g)];
404  if (bytestream2_get_bytes_left(&f->g2) < 2){
405  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
406  return AVERROR_INVALIDDATA;
407  }
408  dc = bytestream2_get_le16(&f->g2);
409  } else if (code == 5) {
410  if (bytestream2_get_bytes_left(&f->g2) < 2){
411  av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
412  return AVERROR_INVALIDDATA;
413  }
414  av_assert0(start <= src && src <= end);
415  scale = 0;
416  dc = bytestream2_get_le16(&f->g2);
417  }
418 
419  if (start > src || src > end) {
420  av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
421  return AVERROR_INVALIDDATA;
422  }
423 
424  mcdc(dst, src, log2w, h, stride, scale, dc);
425 
426  return 0;
427 }
428 
429 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
430 {
431  int x, y;
432  const int width = f->avctx->width;
433  const int height = f->avctx->height;
434  uint16_t *dst = f->frame_buffer;
435  uint16_t *src;
436  unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
437  bytestream_offset, wordstream_offset;
438  int ret;
439 
440  src = f->last_frame_buffer;
441 
442  if (f->version > 1) {
443  extra = 20;
444  if (length < extra)
445  return AVERROR_INVALIDDATA;
446  bitstream_size = AV_RL32(buf + 8);
447  wordstream_size = AV_RL32(buf + 12);
448  bytestream_size = AV_RL32(buf + 16);
449  } else {
450  extra = 0;
451  bitstream_size = AV_RL16(buf - 4);
452  wordstream_size = AV_RL16(buf - 2);
453  bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
454  }
455 
456  if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
457  bytestream_size > length - bitstream_size ||
458  wordstream_size > length - bytestream_size - bitstream_size ||
459  extra > length - bytestream_size - bitstream_size - wordstream_size) {
460  av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
461  bitstream_size+ bytestream_size+ wordstream_size - length);
462  return AVERROR_INVALIDDATA;
463  }
464 
466  bitstream_size);
467  if (!f->bitstream_buffer)
468  return AVERROR(ENOMEM);
469  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
470  bitstream_size / 4);
471  init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
472 
473  wordstream_offset = extra + bitstream_size;
474  bytestream_offset = extra + bitstream_size + wordstream_size;
475  bytestream2_init(&f->g2, buf + wordstream_offset,
476  length - wordstream_offset);
477  bytestream2_init(&f->g, buf + bytestream_offset,
478  length - bytestream_offset);
479 
480  init_mv(f, width * 2);
481 
482  for (y = 0; y < height; y += 8) {
483  for (x = 0; x < width; x += 8)
484  if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
485  return ret;
486  src += 8 * width;
487  dst += 8 * width;
488  }
489 
490  return 0;
491 }
492 
493 /**
494  * decode block and dequantize.
495  * Note this is almost identical to MJPEG.
496  */
497 static int decode_i_block(FourXContext *f, int16_t *block)
498 {
499  int code, i, j, level, val;
500 
501  if (get_bits_left(&f->gb) < 2){
502  av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
503  return AVERROR_INVALIDDATA;
504  }
505 
506  /* DC coef */
507  val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
508  if (val >> 4) {
509  av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
510  return AVERROR_INVALIDDATA;
511  }
512 
513  if (val)
514  val = get_xbits(&f->gb, val);
515 
516  val = val * dequant_table[0] + f->last_dc;
517  f->last_dc = block[0] = val;
518  /* AC coefs */
519  i = 1;
520  for (;;) {
521  code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
522 
523  /* EOB */
524  if (code == 0)
525  break;
526  if (code == 0xf0) {
527  i += 16;
528  if (i >= 64) {
529  av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
530  return 0;
531  }
532  } else {
533  if (code & 0xf) {
534  level = get_xbits(&f->gb, code & 0xf);
535  } else {
536  av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
537  return AVERROR_INVALIDDATA;
538  }
539  i += code >> 4;
540  if (i >= 64) {
541  av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
542  return 0;
543  }
544 
545  j = ff_zigzag_direct[i];
546  block[j] = level * dequant_table[j];
547  i++;
548  if (i >= 64)
549  break;
550  }
551  }
552 
553  return 0;
554 }
555 
556 static inline void idct_put(FourXContext *f, int x, int y)
557 {
558  int16_t (*block)[64] = f->block;
559  int stride = f->avctx->width;
560  int i;
561  uint16_t *dst = f->frame_buffer + y * stride + x;
562 
563  for (i = 0; i < 4; i++) {
564  block[i][0] += 0x80 * 8 * 8;
565  idct(block[i]);
566  }
567 
568  if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
569  for (i = 4; i < 6; i++)
570  idct(block[i]);
571  }
572 
573  /* Note transform is:
574  * y = ( 1b + 4g + 2r) / 14
575  * cb = ( 3b - 2g - 1r) / 14
576  * cr = (-1b - 4g + 5r) / 14 */
577  for (y = 0; y < 8; y++) {
578  for (x = 0; x < 8; x++) {
579  int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
580  2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
581  int cb = block[4][x + 8 * y];
582  int cr = block[5][x + 8 * y];
583  int cg = (cb + cr) >> 1;
584  int y;
585 
586  cb += cb;
587 
588  y = temp[0];
589  dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
590  y = temp[1];
591  dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592  y = temp[8];
593  dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594  y = temp[9];
595  dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
596  dst += 2;
597  }
598  dst += 2 * stride - 2 * 8;
599  }
600 }
601 
602 static int decode_i_mb(FourXContext *f)
603 {
604  int ret;
605  int i;
606 
607  f->bdsp.clear_blocks(f->block[0]);
608 
609  for (i = 0; i < 6; i++)
610  if ((ret = decode_i_block(f, f->block[i])) < 0)
611  return ret;
612 
613  return 0;
614 }
615 
617  const uint8_t * const buf,
618  int buf_size)
619 {
620  int frequency[512] = { 0 };
621  uint8_t flag[512];
622  int up[512];
623  uint8_t len_tab[257];
624  int bits_tab[257];
625  int start, end;
626  const uint8_t *ptr = buf;
627  const uint8_t *ptr_end = buf + buf_size;
628  int j;
629 
630  memset(up, -1, sizeof(up));
631 
632  start = *ptr++;
633  end = *ptr++;
634  for (;;) {
635  int i;
636 
637  if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
638  av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
639  return NULL;
640  }
641 
642  for (i = start; i <= end; i++)
643  frequency[i] = *ptr++;
644  start = *ptr++;
645  if (start == 0)
646  break;
647 
648  end = *ptr++;
649  }
650  frequency[256] = 1;
651 
652  while ((ptr - buf) & 3)
653  ptr++; // 4byte align
654 
655  if (ptr > ptr_end) {
656  av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
657  return NULL;
658  }
659 
660  for (j = 257; j < 512; j++) {
661  int min_freq[2] = { 256 * 256, 256 * 256 };
662  int smallest[2] = { 0, 0 };
663  int i;
664  for (i = 0; i < j; i++) {
665  if (frequency[i] == 0)
666  continue;
667  if (frequency[i] < min_freq[1]) {
668  if (frequency[i] < min_freq[0]) {
669  min_freq[1] = min_freq[0];
670  smallest[1] = smallest[0];
671  min_freq[0] = frequency[i];
672  smallest[0] = i;
673  } else {
674  min_freq[1] = frequency[i];
675  smallest[1] = i;
676  }
677  }
678  }
679  if (min_freq[1] == 256 * 256)
680  break;
681 
682  frequency[j] = min_freq[0] + min_freq[1];
683  flag[smallest[0]] = 0;
684  flag[smallest[1]] = 1;
685  up[smallest[0]] =
686  up[smallest[1]] = j;
687  frequency[smallest[0]] = frequency[smallest[1]] = 0;
688  }
689 
690  for (j = 0; j < 257; j++) {
691  int node, len = 0, bits = 0;
692 
693  for (node = j; up[node] != -1; node = up[node]) {
694  bits += flag[node] << len;
695  len++;
696  if (len > 31)
697  // can this happen at all ?
699  "vlc length overflow\n");
700  }
701 
702  bits_tab[j] = bits;
703  len_tab[j] = len;
704  }
705 
706  if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
707  bits_tab, 4, 4, 0))
708  return NULL;
709 
710  return ptr;
711 }
712 
713 static int mix(int c0, int c1)
714 {
715  int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
716  int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
717  int red = 2 * (c0 >> 10) + (c1 >> 10);
718  return red / 3 * 1024 + green / 3 * 32 + blue / 3;
719 }
720 
721 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
722 {
723  int x, y, x2, y2;
724  const int width = f->avctx->width;
725  const int height = f->avctx->height;
726  const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
727  uint16_t *dst = f->frame_buffer;
728  const uint8_t *buf_end = buf + length;
729  GetByteContext g3;
730 
731  if (length < mbs * 8) {
732  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
733  return AVERROR_INVALIDDATA;
734  }
735  bytestream2_init(&g3, buf, length);
736 
737  for (y = 0; y < height; y += 16) {
738  for (x = 0; x < width; x += 16) {
739  unsigned int color[4] = { 0 }, bits;
740  if (buf_end - buf < 8)
741  return AVERROR_INVALIDDATA;
742  // warning following is purely guessed ...
743  color[0] = bytestream2_get_le16u(&g3);
744  color[1] = bytestream2_get_le16u(&g3);
745 
746  if (color[0] & 0x8000)
747  av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
748  if (color[1] & 0x8000)
749  av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
750 
751  color[2] = mix(color[0], color[1]);
752  color[3] = mix(color[1], color[0]);
753 
754  bits = bytestream2_get_le32u(&g3);
755  for (y2 = 0; y2 < 16; y2++) {
756  for (x2 = 0; x2 < 16; x2++) {
757  int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
758  dst[y2 * width + x2] = color[(bits >> index) & 3];
759  }
760  }
761  dst += 16;
762  }
763  dst += 16 * width - x;
764  }
765 
766  return 0;
767 }
768 
769 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
770 {
771  int x, y, ret;
772  const int width = f->avctx->width;
773  const int height = f->avctx->height;
774  const unsigned int bitstream_size = AV_RL32(buf);
775  unsigned int prestream_size;
776  const uint8_t *prestream;
777 
778  if (bitstream_size > (1 << 26))
779  return AVERROR_INVALIDDATA;
780 
781  if (length < bitstream_size + 12) {
782  av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
783  return AVERROR_INVALIDDATA;
784  }
785 
786  prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
787  prestream = buf + bitstream_size + 12;
788 
789  if (prestream_size + bitstream_size + 12 != length
790  || prestream_size > (1 << 26)) {
791  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
792  prestream_size, bitstream_size, length);
793  return AVERROR_INVALIDDATA;
794  }
795 
796  prestream = read_huffman_tables(f, prestream, prestream_size);
797  if (!prestream) {
798  av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
799  return AVERROR_INVALIDDATA;
800  }
801 
802  av_assert0(prestream <= buf + length);
803 
804  init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
805 
806  prestream_size = length + buf - prestream;
807 
809  prestream_size);
810  if (!f->bitstream_buffer)
811  return AVERROR(ENOMEM);
812  f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
813  prestream_size / 4);
814  init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
815 
816  f->last_dc = 0 * 128 * 8 * 8;
817 
818  for (y = 0; y < height; y += 16) {
819  for (x = 0; x < width; x += 16) {
820  if ((ret = decode_i_mb(f)) < 0)
821  return ret;
822 
823  idct_put(f, x, y);
824  }
825  }
826 
827  if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
828  av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
829 
830  return 0;
831 }
832 
833 static int decode_frame(AVCodecContext *avctx, void *data,
834  int *got_frame, AVPacket *avpkt)
835 {
836  const uint8_t *buf = avpkt->data;
837  int buf_size = avpkt->size;
838  FourXContext *const f = avctx->priv_data;
839  AVFrame *picture = data;
840  int i, frame_4cc, frame_size, ret;
841 
842  if (buf_size < 20)
843  return AVERROR_INVALIDDATA;
844 
845  av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
846 
847  if (buf_size < AV_RL32(buf + 4) + 8) {
848  av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
849  buf_size, AV_RL32(buf + 4));
850  return AVERROR_INVALIDDATA;
851  }
852 
853  frame_4cc = AV_RL32(buf);
854 
855  if (frame_4cc == AV_RL32("cfrm")) {
856  int free_index = -1;
857  int id, whole_size;
858  const int data_size = buf_size - 20;
859  CFrameBuffer *cfrm;
860 
861  if (f->version <= 1) {
862  av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
863  return AVERROR_INVALIDDATA;
864  }
865 
866  id = AV_RL32(buf + 12);
867  whole_size = AV_RL32(buf + 16);
868 
869  if (data_size < 0 || whole_size < 0) {
870  av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
871  return AVERROR_INVALIDDATA;
872  }
873 
874  for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
875  if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
876  av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
877  f->cfrm[i].id);
878 
879  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
880  if (f->cfrm[i].id == id)
881  break;
882  if (f->cfrm[i].size == 0)
883  free_index = i;
884  }
885 
886  if (i >= CFRAME_BUFFER_COUNT) {
887  i = free_index;
888  f->cfrm[i].id = id;
889  }
890  cfrm = &f->cfrm[i];
891 
892  if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
893  return AVERROR_INVALIDDATA;
894 
895  cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
896  cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
897  // explicit check needed as memcpy below might not catch a NULL
898  if (!cfrm->data) {
899  av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
900  return AVERROR(ENOMEM);
901  }
902 
903  memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
904  cfrm->size += data_size;
905 
906  if (cfrm->size >= whole_size) {
907  buf = cfrm->data;
908  frame_size = cfrm->size;
909 
910  if (id != avctx->frame_number)
911  av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
912  id, avctx->frame_number);
913 
914  if (f->version <= 1)
915  return AVERROR_INVALIDDATA;
916 
917  cfrm->size = cfrm->id = 0;
918  frame_4cc = AV_RL32("pfrm");
919  } else
920  return buf_size;
921  } else {
922  buf = buf + 12;
923  frame_size = buf_size - 12;
924  }
925 
926  if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
927  return ret;
928 
929  if (frame_4cc == AV_RL32("ifr2")) {
930  picture->pict_type = AV_PICTURE_TYPE_I;
931  if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
932  av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
933  return ret;
934  }
935  } else if (frame_4cc == AV_RL32("ifrm")) {
936  picture->pict_type = AV_PICTURE_TYPE_I;
937  if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
938  av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
939  return ret;
940  }
941  } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
942  picture->pict_type = AV_PICTURE_TYPE_P;
943  if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
944  av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
945  return ret;
946  }
947  } else if (frame_4cc == AV_RL32("snd_")) {
948  av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
949  buf_size);
950  } else {
951  av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
952  buf_size);
953  }
954 
955  picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
956 
957  av_image_copy_plane(picture->data[0], picture->linesize[0],
958  (const uint8_t*)f->frame_buffer, avctx->width * 2,
959  avctx->width * 2, avctx->height);
960  FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
961 
962  *got_frame = 1;
963 
964  emms_c();
965 
966  return buf_size;
967 }
968 
970 {
971  FourXContext * const f = avctx->priv_data;
972  int i;
973 
974  av_freep(&f->frame_buffer);
977  f->bitstream_buffer_size = 0;
978  for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
979  av_freep(&f->cfrm[i].data);
980  f->cfrm[i].allocated_size = 0;
981  }
982  ff_free_vlc(&f->pre_vlc);
983 
984  return 0;
985 }
986 
988 {
989  FourXContext * const f = avctx->priv_data;
990  int ret;
991 
992  if (avctx->extradata_size != 4 || !avctx->extradata) {
993  av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
994  return AVERROR_INVALIDDATA;
995  }
996  if((avctx->width % 16) || (avctx->height % 16)) {
997  av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
998  return AVERROR_INVALIDDATA;
999  }
1000 
1001  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
1002  if (ret < 0)
1003  return ret;
1004 
1005  f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1006  f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
1007  if (!f->frame_buffer || !f->last_frame_buffer) {
1008  decode_end(avctx);
1009  return AVERROR(ENOMEM);
1010  }
1011 
1012  f->version = AV_RL32(avctx->extradata) >> 16;
1013  ff_blockdsp_init(&f->bdsp, avctx);
1014  ff_bswapdsp_init(&f->bbdsp);
1015  f->avctx = avctx;
1016  init_vlcs(f);
1017 
1018  if (f->version > 2)
1019  avctx->pix_fmt = AV_PIX_FMT_RGB565;
1020  else
1021  avctx->pix_fmt = AV_PIX_FMT_BGR555;
1022 
1023  return 0;
1024 }
1025 
1027  .name = "4xm",
1028  .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
1029  .type = AVMEDIA_TYPE_VIDEO,
1030  .id = AV_CODEC_ID_4XM,
1031  .priv_data_size = sizeof(FourXContext),
1032  .init = decode_init,
1033  .close = decode_end,
1034  .decode = decode_frame,
1035  .capabilities = AV_CODEC_CAP_DR1,
1036 };
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:634
GetByteContext g
Definition: 4xm.c:143
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
static void idct(int16_t block[64])
Definition: 4xm.c:163
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
enum AVCodecID id
Definition: mxfenc.c:102
misc image utilities
BlockDSPContext bdsp
Definition: 4xm.c:137
else temp
Definition: vf_mcdeint.c:257
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1434
static av_cold void init_vlcs(FourXContext *f)
Definition: 4xm.c:248
AVCodec ff_fourxm_decoder
Definition: 4xm.c:1026
int id
Definition: 4xm.c:131
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:36
static VLC block_type_vlc[2][4]
Definition: 4xm.c:125
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition: 4xm.c:616
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1732
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
#define AV_RL16
Definition: intreadwrite.h:42
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition: 4xm.c:294
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:126
#define VLC_TYPE
Definition: get_bits.h:62
#define FIX_1_414213562
Definition: 4xm.c:157
#define FIX_1_082392200
Definition: 4xm.c:156
AVCodec.
Definition: avcodec.h:3482
#define FFALIGN(x, a)
Definition: common.h:97
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:97
uint8_t bits
Definition: crc.c:295
unsigned int size
Definition: 4xm.c:130
uint8_t
#define av_cold
Definition: attributes.h:74
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
unsigned int allocated_size
Definition: 4xm.c:129
uint16_t * last_frame_buffer
Definition: 4xm.c:140
#define emms_c()
Definition: internal.h:53
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1627
static const uint8_t block_type_tab[2][4][8][2]
Definition: 4xm.c:46
uint8_t * data
Definition: avcodec.h:1433
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:987
static const uint64_t c1
Definition: murmur3.c:49
bitstream reader API header.
AVCodecContext * avctx
Definition: 4xm.c:136
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:763
#define av_log(a,...)
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: 4xm.c:833
int flag
Definition: checkasm.c:76
static int decode_i_mb(FourXContext *f)
Definition: 4xm.c:602
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:594
GetBitContext gb
Definition: 4xm.c:142
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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: mem.c:492
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition: 4xm.c:287
#define AVERROR(e)
Definition: error.h:43
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition: 4xm.c:497
static const struct endianess table[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
#define FIX_1_847759065
Definition: 4xm.c:158
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1607
void * bitstream_buffer
Definition: 4xm.c:149
simple assert() macros that are a bit more flexible than ISO C assert().
GLsizei GLsizei * length
Definition: opengl_enc.c:115
static const uint8_t size2index[4][4]
Definition: 4xm.c:70
const char * name
Name of the codec implementation.
Definition: avcodec.h:3489
#define FFMAX(a, b)
Definition: common.h:90
Libavcodec external API header.
Definition: get_bits.h:64
reference-counted frame API
#define CFRAME_BUFFER_COUNT
Definition: 4xm.c:44
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:266
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:769
uint16_t * frame_buffer
Definition: 4xm.c:139
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
float y
int width
picture width / height.
Definition: avcodec.h:1691
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:561
#define AV_RL32
Definition: intreadwrite.h:146
VLC pre_vlc
Definition: 4xm.c:146
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition: 4xm.c:342
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:479
int table_allocated
Definition: get_bits.h:67
static const int8_t mv[256][2]
Definition: 4xm.c:77
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:377
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:556
static int mix(int c0, int c1)
Definition: 4xm.c:713
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:721
int frame_size
Definition: mxfenc.c:1819
AVS_Value src
Definition: avisynth_c.h:482
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
main external API structure.
Definition: avcodec.h:1512
static void init_mv(FourXContext *f, int linesize)
Definition: 4xm.c:265
static int get_xbits(GetBitContext *s, int n)
read mpeg1 dc style vlc (sign bit + mantissa with no MSB).
Definition: get_bits.h:232
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1048
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:462
void * buf
Definition: avisynth_c.h:553
int extradata_size
Definition: avcodec.h:1628
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
int index
Definition: gxfenc.c:89
static const uint8_t dequant_table[64]
Definition: 4xm.c:114
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:415
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: 4xm.c:152
#define ACDC_VLC_BITS
Definition: 4xm.c:42
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
unsigned int bitstream_buffer_size
Definition: 4xm.c:150
uint8_t * data
Definition: 4xm.c:132
static av_cold int decode_end(AVCodecContext *avctx)
Definition: 4xm.c:969
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
uint8_t level
Definition: svq3.c:150
#define FIX_2_613125930
Definition: 4xm.c:159
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:521
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
BswapDSPContext bbdsp
Definition: 4xm.c:138
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:429
common internal api header.
GetBitContext pre_gb
ac/dc prefix
Definition: 4xm.c:141
int mv[256]
Definition: 4xm.c:145
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:636
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1554
int len
int last_dc
Definition: 4xm.c:147
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
GetByteContext g2
Definition: 4xm.c:144
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:371
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
int version
Definition: 4xm.c:151
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2303
int16_t block[6][64]
Definition: 4xm.c:148
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:553
#define BLOCK_TYPE_VLC_BITS
Definition: 4xm.c:41
#define FFSWAP(type, a, b)
Definition: common.h:95
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:292
#define stride
#define MULTIPLY(var, const)
Definition: 4xm.c:161
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:98
This structure stores compressed data.
Definition: avcodec.h:1410
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:364
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:857
Predicted.
Definition: avutil.h:267
static int width
static int16_t block[64]
Definition: dct-test.c:110