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