41 #define BLOCK_TYPE_VLC_BITS 5 42 #define ACDC_VLC_BITS 9 44 #define CFRAME_BUFFER_COUNT 100 49 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
51 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
53 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
55 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
59 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
63 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
65 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
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 }
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,
156 #define FIX_1_082392200 70936 157 #define FIX_1_414213562 92682 158 #define FIX_1_847759065 121095 159 #define FIX_2_613125930 171254 161 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16) 165 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
166 int tmp10, tmp11, tmp12, tmp13;
167 int z5, z10, z11, z12, z13;
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];
175 tmp13 = block[8 * 2 +
i] + block[8 * 6 +
i];
178 tmp0 = tmp10 + tmp13;
179 tmp3 = tmp10 - tmp13;
180 tmp1 = tmp11 + tmp12;
181 tmp2 = tmp11 - tmp12;
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];
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;
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];
213 tmp13 = temp[2 +
i] + temp[6 +
i];
216 tmp0 = tmp10 + tmp13;
217 tmp3 = tmp10 - tmp13;
218 tmp1 = tmp11 + tmp12;
219 tmp2 = tmp11 - tmp12;
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];
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;
253 for (i = 0; i < 2; i++) {
254 for (j = 0; j < 4; j++) {
255 block_type_vlc[
i][j].
table = table[
i][j];
269 for (i = 0; i < 256; i++) {
271 f->
mv[
i] =
mv[
i][0] +
mv[
i][1] * linesize / 2;
273 f->
mv[
i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
278 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 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); \ 287 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 289 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \ 290 AV_WN32A(dst, tmpval); \ 294 static inline void mcdc(uint16_t *dst,
const uint16_t *
src,
int log2w,
295 int h,
int stride,
int scale,
unsigned dc)
302 for (i = 0; i <
h; i++) {
303 dst[0] = scale * src[0] +
dc;
310 for (i = 0; i <
h; i++) {
318 for (i = 0; i <
h; i++) {
327 for (i = 0; i <
h; i++) {
343 int log2w,
int log2h,
int stride)
346 uint16_t *start, *
end;
362 end = start + stride * (f->
avctx->
height - h + 1) - (1 << log2w);
366 if ((ret =
decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
369 src + (stride << log2h),
370 log2w, log2h, stride);
371 }
else if (code == 2) {
373 if ((ret =
decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
377 log2w, log2h, stride);
378 }
else if (code == 6) {
384 dst[0] = bytestream2_get_le16u(&f->
g2);
385 dst[1] = bytestream2_get_le16u(&f->
g2);
387 dst[0] = bytestream2_get_le16u(&f->
g2);
388 dst[
stride] = bytestream2_get_le16u(&f->
g2);
399 src += f->
mv[bytestream2_get_byte(&f->
g)];
400 }
else if (code == 3 && f->
version >= 2) {
402 }
else if (code == 4) {
403 src += f->
mv[bytestream2_get_byte(&f->
g)];
408 dc = bytestream2_get_le16(&f->
g2);
409 }
else if (code == 5) {
416 dc = bytestream2_get_le16(&f->
g2);
419 if (start > src || src > end) {
424 mcdc(dst, src, log2w, h, stride, scale, dc);
436 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
437 bytestream_offset, wordstream_offset;
446 bitstream_size =
AV_RL32(buf + 8);
447 wordstream_size =
AV_RL32(buf + 12);
448 bytestream_size =
AV_RL32(buf + 16);
451 bitstream_size =
AV_RL16(buf - 4);
452 wordstream_size =
AV_RL16(buf - 2);
453 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
456 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
457 bytestream_size > length - bitstream_size ||
458 wordstream_size > length - bytestream_size - bitstream_size ||
459 extra > length - bytestream_size - bitstream_size - wordstream_size) {
461 bitstream_size+ bytestream_size+ wordstream_size - length);
473 wordstream_offset = extra + bitstream_size;
474 bytestream_offset = extra + bitstream_size + wordstream_size;
476 length - wordstream_offset);
478 length - bytestream_offset);
482 for (y = 0; y <
height; y += 8) {
483 for (x = 0; x <
width; x += 8)
563 for (i = 0; i < 4; i++) {
564 block[
i][0] += 0x80 * 8 * 8;
569 for (i = 4; i < 6; i++)
577 for (y = 0; y < 8; y++) {
578 for (x = 0; x < 8; x++) {
579 int16_t *
temp =
block[(x >> 2) + 2 * (y >> 2)] +
580 2 * (x & 3) + 2 * 8 * (y & 3);
583 int cg = (cb +
cr) >> 1;
589 dst[0] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
591 dst[1] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
593 dst[
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
595 dst[1 +
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
598 dst += 2 * stride - 2 * 8;
609 for (i = 0; i < 6; i++)
620 int frequency[512] = { 0 };
627 const uint8_t *ptr_end = buf + buf_size;
630 memset(up, -1,
sizeof(up));
637 if (ptr_end - ptr <
FFMAX(end - start + 1, 0) + 1) {
642 for (i = start; i <=
end; i++)
643 frequency[i] = *ptr++;
652 while ((ptr - buf) & 3)
660 for (j = 257; j < 512; j++) {
661 int min_freq[2] = { 256 * 256, 256 * 256 };
662 int smallest[2] = { 0, 0 };
664 for (i = 0; i < j; i++) {
665 if (frequency[i] == 0)
667 if (frequency[i] < min_freq[1]) {
668 if (frequency[i] < min_freq[0]) {
669 min_freq[1] = min_freq[0];
670 smallest[1] = smallest[0];
671 min_freq[0] = frequency[
i];
674 min_freq[1] = frequency[
i];
679 if (min_freq[1] == 256 * 256)
682 frequency[j] = min_freq[0] + min_freq[1];
683 flag[smallest[0]] = 0;
684 flag[smallest[1]] = 1;
687 frequency[smallest[0]] = frequency[smallest[1]] = 0;
690 for (j = 0; j < 257; j++) {
693 for (node = j; up[node] != -1; node = up[node]) {
699 "vlc length overflow\n");
716 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
717 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
718 int red = 2 * (c0 >> 10) + (c1 >> 10);
719 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
727 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
729 const uint8_t *buf_end = buf + length;
732 if (length < mbs * 8) {
738 for (y = 0; y <
height; y += 16) {
739 for (x = 0; x <
width; x += 16) {
741 if (buf_end - buf < 8)
744 color[0] = bytestream2_get_le16u(&g3);
745 color[1] = bytestream2_get_le16u(&g3);
747 if (color[0] & 0x8000)
749 if (color[1] & 0x8000)
752 color[2] =
mix(color[0], color[1]);
753 color[3] =
mix(color[1], color[0]);
755 bits = bytestream2_get_le32u(&g3);
756 for (y2 = 0; y2 < 16; y2++) {
757 for (x2 = 0; x2 < 16; x2++) {
758 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
759 dst[y2 * width + x2] = color[(
bits >>
index) & 3];
764 dst += 16 * width - x;
775 const unsigned int bitstream_size =
AV_RL32(buf);
776 unsigned int prestream_size;
779 if (bitstream_size > (1 << 26))
782 if (length < bitstream_size + 12) {
787 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
788 prestream = buf + bitstream_size + 12;
790 if (prestream_size + bitstream_size + 12 != length
791 || prestream_size > (1 << 26)) {
793 prestream_size, bitstream_size, length);
807 prestream_size = length + buf - prestream;
819 for (y = 0; y <
height; y += 16) {
820 for (x = 0; x <
width; x += 16) {
838 int buf_size = avpkt->
size;
848 if (buf_size <
AV_RL32(buf + 4) + 8) {
856 if (frame_4cc ==
AV_RL32(
"cfrm")) {
859 const int data_size = buf_size - 20;
868 whole_size =
AV_RL32(buf + 16);
870 if (data_size < 0 || whole_size < 0) {
887 if (i >= CFRAME_BUFFER_COUNT) {
906 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
907 cfrm->
size += data_size;
909 if (cfrm->
size >= whole_size) {
911 frame_size = cfrm->
size;
920 cfrm->
size = cfrm->
id = 0;
926 frame_size = buf_size - 12;
932 if (frame_4cc ==
AV_RL32(
"ifr2")) {
938 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
944 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
950 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
static void idct(int16_t block[64])
static av_cold int init(AVCodecContext *avctx)
static av_cold void init_vlcs(FourXContext *f)
AVCodec ff_fourxm_decoder
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
static VLC block_type_vlc[2][4]
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
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...
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static double cb(void *priv, double x, double y)
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
static av_cold int end(AVCodecContext *avctx)
unsigned int allocated_size
uint16_t * last_frame_buffer
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static const uint8_t block_type_tab[2][4][8][2]
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
static av_cold int decode_init(AVCodecContext *avctx)
bitstream reader API header.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
static const uint16_t table[]
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static int decode_i_mb(FourXContext *f)
static int get_bits_left(GetBitContext *gb)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define LE_CENTRIC_MUL(dst, src, scale, dc)
void(* clear_blocks)(int16_t *blocks)
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int flags
AV_CODEC_FLAG_*.
simple assert() macros that are a bit more flexible than ISO C assert().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static const uint8_t size2index[4][4]
const char * name
Name of the codec implementation.
reference-counted frame API
#define CFRAME_BUFFER_COUNT
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...
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
enum AVPictureType pict_type
Picture type of the frame.
int width
picture width / height.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
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.
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
static const int8_t mv[256][2]
#define AV_PIX_FMT_BGR555
static void idct_put(FourXContext *f, int x, int y)
static int mix(int c0, int c1)
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
static void init_mv(FourXContext *f, int linesize)
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static const uint8_t dequant_table[64]
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
const uint8_t ff_zigzag_direct[64]
unsigned int bitstream_buffer_size
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
static av_cold int decode_end(AVCodecContext *avctx)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
common internal api header.
#define INIT_VLC_USE_NEW_STATIC
GetBitContext pre_gb
ac/dc prefix
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
#define xf(width, name, var, range_min, range_max, subs,...)
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
#define AV_PIX_FMT_RGB565
int frame_number
Frame counter, set by libavcodec.
#define BLOCK_TYPE_VLC_BITS
#define FFSWAP(type, a, b)
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.
#define MULTIPLY(var, const)
static double cr(void *priv, double x, double y)
static double val(void *priv, double ch)
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.