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;
132  uint8_t *data;
133 } CFrameBuffer;
134 
135 typedef struct FourXContext {
136  AVCodecContext *avctx;
137  BlockDSPContext bdsp;
138  BswapDSPContext bbdsp;
139  uint16_t *frame_buffer;
140  uint16_t *last_frame_buffer;
141  GetBitContext pre_gb; ///< ac/dc prefix
142  GetBitContext gb;
143  GetByteContext g;
144  GetByteContext g2;
145  int mv[256];
146  VLC pre_vlc;
147  int last_dc;
148  DECLARE_ALIGNED(16, int16_t, block)[6][64];
149  void *bitstream_buffer;
150  unsigned int bitstream_buffer_size;
151  int version;
152  CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
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 
248 static av_cold void init_vlcs(FourXContext *f)
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,
260  INIT_VLC_USE_NEW_STATIC);
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,
356  BLOCK_TYPE_VLC_BITS, 1);
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 
463  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
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 overflow\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 
610 static const uint8_t *read_huffman_tables(FourXContext *f,
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 ?
692  av_log(f->avctx, AV_LOG_ERROR,
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 
802  av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
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 
963 static av_cold int decode_end(AVCodecContext *avctx)
964 {
965  FourXContext * const f = avctx->priv_data;
966  int i;
967 
968  av_freep(&f->frame_buffer);
969  av_freep(&f->last_frame_buffer);
970  av_freep(&f->bitstream_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 
981 static av_cold int decode_init(AVCodecContext *avctx)
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 
1020 AVCodec ff_fourxm_decoder = {
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 };
BswapDSPContext::bswap_buf
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
NULL
#define NULL
Definition: coverity.c:32
val
const char const char void * val
Definition: avisynth_c.h:771
FourXContext::g
GetByteContext g
Definition: 4xm.c:143
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
flag
#define flag(name)
Definition: cbs_h2645.c:255
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
h
h
Definition: vp9dsp_template.c:2038
idct
static void idct(int16_t block[64])
Definition: 4xm.c:163
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
imgutils.h
misc image utilities
FourXContext::bdsp
BlockDSPContext bdsp
Definition: 4xm.c:137
temp
else temp
Definition: vf_mcdeint.c:256
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVPacket::size
int size
Definition: avcodec.h:1445
init_vlcs
static av_cold void init_vlcs(FourXContext *f)
Definition: 4xm.c:248
ff_fourxm_decoder
AVCodec ff_fourxm_decoder
Definition: 4xm.c:1020
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
CFrameBuffer::id
int id
Definition: 4xm.c:131
BlockDSPContext::clear_blocks
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:37
block_type_vlc
static VLC block_type_vlc[2][4]
Definition: 4xm.c:125
read_huffman_tables
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
Definition: 4xm.c:610
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1742
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
mcdc
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
Definition: 4xm.c:294
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:70
FIX_1_414213562
#define FIX_1_414213562
Definition: 4xm.c:157
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
FIX_1_082392200
#define FIX_1_082392200
Definition: 4xm.c:156
xf
#define xf(width, name, var, subs,...)
Definition: cbs_vp9.c:342
src
#define src
Definition: vp8dsp.c:254
AVCodec
AVCodec.
Definition: avcodec.h:3423
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
block
static int16_t block[64]
Definition: dct.c:115
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
CFrameBuffer::size
unsigned int size
Definition: 4xm.c:130
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
f
#define f(width, name)
Definition: cbs_vp9.c:255
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
CFrameBuffer::allocated_size
unsigned int allocated_size
Definition: 4xm.c:129
FourXContext::last_frame_buffer
uint16_t * last_frame_buffer
Definition: 4xm.c:140
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1633
block_type_tab
static const uint8_t block_type_tab[2][4][8][2]
Definition: 4xm.c:46
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
height
#define height
AVPacket::data
uint8_t * data
Definition: avcodec.h:1444
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:981
c1
static const uint64_t c1
Definition: murmur3.c:49
get_bits.h
bitstream reader API header.
FourXContext::avctx
AVCodecContext * avctx
Definition: 4xm.c:136
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:869
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: 4xm.c:827
decode_i_mb
static int decode_i_mb(FourXContext *f)
Definition: 4xm.c:596
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:814
FourXContext::gb
GetBitContext gb
Definition: 4xm.c:142
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
LE_CENTRIC_MUL
#define LE_CENTRIC_MUL(dst, src, scale, dc)
Definition: 4xm.c:287
AVERROR
#define AVERROR(e)
Definition: error.h:43
decode_i_block
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
Definition: 4xm.c:495
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
FIX_1_847759065
#define FIX_1_847759065
Definition: 4xm.c:158
bytestream2_get_bytes_left
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1612
width
uint16_t width
Definition: gdv.c:47
FourXContext::bitstream_buffer
void * bitstream_buffer
Definition: 4xm.c:149
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
length
GLsizei GLsizei * length
Definition: opengl_enc.c:115
size2index
static const uint8_t size2index[4][4]
Definition: 4xm.c:70
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3430
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
VLC
Definition: vlc.h:26
frame.h
reference-counted frame API
AV_CODEC_ID_4XM
Definition: avcodec.h:252
CFRAME_BUFFER_COUNT
#define CFRAME_BUFFER_COUNT
Definition: 4xm.c:44
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:282
decode_i_frame
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:763
FourXContext::frame_buffer
uint16_t * frame_buffer
Definition: 4xm.c:139
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1705
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:762
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:464
FourXContext::pre_vlc
VLC pre_vlc
Definition: 4xm.c:146
decode_p_block
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
Definition: 4xm.c:342
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
mv
static const int8_t mv[256][2]
Definition: 4xm.c:77
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:372
idct_put
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:550
mix
static int mix(int c0, int c1)
Definition: 4xm.c:707
decode_i2_frame
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:715
frame_size
int frame_size
Definition: mxfenc.c:2166
avcodec.h
Libavcodec external API header.
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
AVCodecContext
main external API structure.
Definition: avcodec.h:1532
init_mv
static void init_mv(FourXContext *f, int linesize)
Definition: 4xm.c:265
get_xbits
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition: get_bits.h:323
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1922
buf
void * buf
Definition: avisynth_c.h:690
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1634
table
static const uint32_t table[]
Definition: prosumer.c:204
index
int index
Definition: gxfenc.c:89
dequant_table
static const uint8_t dequant_table[64]
Definition: 4xm.c:114
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:615
FourXContext::cfrm
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
Definition: 4xm.c:152
ACDC_VLC_BITS
#define ACDC_VLC_BITS
Definition: 4xm.c:42
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
FourXContext::bitstream_buffer_size
unsigned int bitstream_buffer_size
Definition: 4xm.c:150
CFrameBuffer::data
uint8_t * data
Definition: 4xm.c:132
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: 4xm.c:963
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
level
uint8_t level
Definition: svq3.c:207
FIX_2_613125930
#define FIX_2_613125930
Definition: 4xm.c:159
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
FourXContext::bbdsp
BswapDSPContext bbdsp
Definition: 4xm.c:138
decode_p_frame
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
Definition: 4xm.c:427
internal.h
common internal api header.
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
FourXContext::pre_gb
GetBitContext pre_gb
ac/dc prefix
Definition: 4xm.c:141
FourXContext::mv
int mv[256]
Definition: 4xm.c:145
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:781
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1559
len
int len
Definition: vorbis_enc_data.h:452
FourXContext::last_dc
int last_dc
Definition: 4xm.c:147
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
FourXContext::g2
GetByteContext g2
Definition: 4xm.c:144
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:366
dc
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
Definition: audio_convert.c:194
FourXContext::version
int version
Definition: 4xm.c:151
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2219
FourXContext::block
int16_t block[6][64]
Definition: 4xm.c:148
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
start
void INT64 start
Definition: avisynth_c.h:690
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
BLOCK_TYPE_VLC_BITS
#define BLOCK_TYPE_VLC_BITS
Definition: 4xm.c:41
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:338
stride
#define stride
MULTIPLY
#define MULTIPLY(var, const)
Definition: 4xm.c:161
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:113
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:329
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1421
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:354
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:967
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
Generated on Sat Sep 22 2018 19:20:49 for FFmpeg by   doxygen 1.8.6