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