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)
345 int index,
h, code, ret, scale = 1;
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++) {
691 int node,
len = 0, bits = 0;
693 for (node = j; up[node] != -1; node = up[node]) {
694 bits += flag[node] <<
len;
699 "vlc length overflow\n");
715 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
716 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
717 int red = 2 * (c0 >> 10) + (c1 >> 10);
718 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
726 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
731 if (length < mbs * 8) {
737 for (y = 0; y <
height; y += 16) {
738 for (x = 0; x <
width; x += 16) {
739 unsigned int color[4] = { 0 }, bits;
740 if (buf_end - buf < 8)
743 color[0] = bytestream2_get_le16u(&g3);
744 color[1] = bytestream2_get_le16u(&g3);
746 if (color[0] & 0x8000)
748 if (color[1] & 0x8000)
751 color[2] =
mix(color[0], color[1]);
752 color[3] =
mix(color[1], color[0]);
754 bits = bytestream2_get_le32u(&g3);
755 for (y2 = 0; y2 < 16; y2++) {
756 for (x2 = 0; x2 < 16; x2++) {
757 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
758 dst[y2 * width + x2] = color[(bits >>
index) & 3];
763 dst += 16 * width - x;
774 const unsigned int bitstream_size =
AV_RL32(buf);
775 unsigned int prestream_size;
778 if (bitstream_size > (1 << 26))
781 if (length < bitstream_size + 12) {
786 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
787 prestream = buf + bitstream_size + 12;
789 if (prestream_size + bitstream_size + 12 != length
790 || prestream_size > (1 << 26)) {
792 prestream_size, bitstream_size, length);
806 prestream_size = length + buf - prestream;
818 for (y = 0; y <
height; y += 16) {
819 for (x = 0; x <
width; x += 16) {
837 int buf_size = avpkt->
size;
847 if (buf_size <
AV_RL32(buf + 4) + 8) {
855 if (frame_4cc ==
AV_RL32(
"cfrm")) {
858 const int data_size = buf_size - 20;
867 whole_size =
AV_RL32(buf + 16);
869 if (data_size < 0 || whole_size < 0) {
886 if (i >= CFRAME_BUFFER_COUNT) {
903 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
904 cfrm->
size += data_size;
906 if (cfrm->
size >= whole_size) {
908 frame_size = cfrm->
size;
917 cfrm->
size = cfrm->
id = 0;
923 frame_size = buf_size - 12;
929 if (frame_4cc ==
AV_RL32(
"ifr2")) {
935 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
941 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
947 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {
const char const char void * val
#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 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. ...
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
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)
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.