42 #define BLOCK_TYPE_VLC_BITS 5 43 #define ACDC_VLC_BITS 9 45 #define CFRAME_BUFFER_COUNT 100 50 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
52 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
54 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
56 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
60 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
66 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
78 static const int8_t
mv[256][2] = {
79 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
80 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
81 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
82 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
83 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
84 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
85 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
86 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
87 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
88 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
89 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
90 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
91 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
92 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
93 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
94 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
95 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
96 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
97 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
98 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
99 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
100 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
101 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
102 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
103 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
104 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
105 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
106 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
107 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
108 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
109 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
110 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
116 16, 15, 13, 19, 24, 31, 28, 17,
117 17, 23, 25, 31, 36, 63, 45, 21,
118 18, 24, 27, 37, 52, 59, 49, 20,
119 16, 28, 34, 40, 60, 80, 51, 20,
120 18, 31, 48, 66, 68, 86, 56, 21,
121 19, 38, 56, 59, 64, 64, 48, 20,
122 27, 48, 55, 55, 56, 51, 35, 15,
123 20, 35, 34, 32, 31, 22, 15, 8,
157 #define FIX_1_082392200 70936 158 #define FIX_1_414213562 92682 159 #define FIX_1_847759065 121095 160 #define FIX_2_613125930 171254 162 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16) 166 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
167 int tmp10, tmp11, tmp12, tmp13;
168 int z5, z10, z11, z12, z13;
172 for (i = 0; i < 8; i++) {
173 tmp10 = block[8 * 0 +
i] + block[8 * 4 +
i];
174 tmp11 = block[8 * 0 +
i] - block[8 * 4 +
i];
176 tmp13 = block[8 * 2 +
i] + block[8 * 6 +
i];
179 tmp0 = tmp10 + tmp13;
180 tmp3 = tmp10 - tmp13;
181 tmp1 = tmp11 + tmp12;
182 tmp2 = tmp11 - tmp12;
184 z13 = block[8 * 5 +
i] + block[8 * 3 +
i];
185 z10 = block[8 * 5 +
i] - block[8 * 3 +
i];
186 z11 = block[8 * 1 +
i] + block[8 * 7 +
i];
187 z12 = block[8 * 1 +
i] - block[8 * 7 +
i];
200 temp[8 * 0 +
i] = tmp0 + tmp7;
201 temp[8 * 7 +
i] = tmp0 - tmp7;
202 temp[8 * 1 +
i] = tmp1 + tmp6;
203 temp[8 * 6 +
i] = tmp1 - tmp6;
204 temp[8 * 2 +
i] = tmp2 + tmp5;
205 temp[8 * 5 +
i] = tmp2 - tmp5;
206 temp[8 * 4 +
i] = tmp3 + tmp4;
207 temp[8 * 3 +
i] = tmp3 - tmp4;
210 for (i = 0; i < 8 * 8; i += 8) {
211 tmp10 = temp[0 +
i] + temp[4 +
i];
212 tmp11 = temp[0 +
i] - temp[4 +
i];
214 tmp13 = temp[2 +
i] + temp[6 +
i];
217 tmp0 = tmp10 + tmp13;
218 tmp3 = tmp10 - tmp13;
219 tmp1 = tmp11 + tmp12;
220 tmp2 = tmp11 - tmp12;
222 z13 = temp[5 +
i] + temp[3 +
i];
223 z10 = temp[5 +
i] - temp[3 +
i];
224 z11 = temp[1 +
i] + temp[7 +
i];
225 z12 = temp[1 +
i] - temp[7 +
i];
238 block[0 +
i] = (tmp0 + tmp7) >> 6;
239 block[7 +
i] = (tmp0 - tmp7) >> 6;
240 block[1 +
i] = (tmp1 + tmp6) >> 6;
241 block[6 +
i] = (tmp1 - tmp6) >> 6;
242 block[2 +
i] = (tmp2 + tmp5) >> 6;
243 block[5 +
i] = (tmp2 - tmp5) >> 6;
244 block[4 +
i] = (tmp3 + tmp4) >> 6;
245 block[3 +
i] = (tmp3 - tmp4) >> 6;
254 for (i = 0; i < 2; i++) {
255 for (j = 0; j < 4; j++) {
256 block_type_vlc[
i][j].
table = table[
i][j];
270 for (i = 0; i < 256; i++) {
272 f->
mv[
i] =
mv[
i][0] +
mv[
i][1] * linesize / 2;
274 f->
mv[
i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
279 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 281 unsigned tmpval = AV_RN32(src); \ 282 tmpval = (tmpval << 16) | (tmpval >> 16); \ 283 tmpval = tmpval * (scale) + (dc); \ 284 tmpval = (tmpval << 16) | (tmpval >> 16); \ 285 AV_WN32A(dst, tmpval); \ 288 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 290 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \ 291 AV_WN32A(dst, tmpval); \ 295 static inline void mcdc(uint16_t *dst,
const uint16_t *
src,
int log2w,
296 int h,
int stride,
int scale,
unsigned dc)
303 for (i = 0; i <
h; i++) {
304 dst[0] = scale * src[0] +
dc;
311 for (i = 0; i <
h; i++) {
319 for (i = 0; i <
h; i++) {
328 for (i = 0; i <
h; i++) {
344 int log2w,
int log2h,
int stride)
347 uint16_t *start, *end;
363 end = start + stride * (f->
avctx->
height - h + 1) - (1 << log2w);
367 if ((ret =
decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
370 src + (stride << log2h),
371 log2w, log2h, stride);
372 }
else if (code == 2) {
374 if ((ret =
decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
378 log2w, log2h, stride);
379 }
else if (code == 6) {
385 dst[0] = bytestream2_get_le16u(&f->
g2);
386 dst[1] = bytestream2_get_le16u(&f->
g2);
388 dst[0] = bytestream2_get_le16u(&f->
g2);
389 dst[
stride] = bytestream2_get_le16u(&f->
g2);
400 src += f->
mv[bytestream2_get_byte(&f->
g)];
401 }
else if (code == 3 && f->
version >= 2) {
403 }
else if (code == 4) {
404 src += f->
mv[bytestream2_get_byte(&f->
g)];
409 dc = bytestream2_get_le16(&f->
g2);
410 }
else if (code == 5) {
417 dc = bytestream2_get_le16(&f->
g2);
420 if (start > src || src > end) {
425 mcdc(dst, src, log2w, h, stride, scale, dc);
437 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
438 bytestream_offset, wordstream_offset;
447 bitstream_size =
AV_RL32(buf + 8);
448 wordstream_size =
AV_RL32(buf + 12);
449 bytestream_size =
AV_RL32(buf + 16);
452 bitstream_size =
AV_RL16(buf - 4);
453 wordstream_size =
AV_RL16(buf - 2);
454 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
457 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
458 bytestream_size > length - bitstream_size ||
459 wordstream_size > length - bytestream_size - bitstream_size ||
460 extra > length - bytestream_size - bitstream_size - wordstream_size) {
462 bitstream_size+ bytestream_size+ wordstream_size - length);
474 wordstream_offset = extra + bitstream_size;
475 bytestream_offset = extra + bitstream_size + wordstream_size;
477 length - wordstream_offset);
479 length - bytestream_offset);
483 for (y = 0; y <
height; y += 8) {
484 for (x = 0; x <
width; x += 8)
564 for (i = 0; i < 4; i++) {
565 block[
i][0] += 0x80 * 8 * 8;
570 for (i = 4; i < 6; i++)
578 for (y = 0; y < 8; y++) {
579 for (x = 0; x < 8; x++) {
580 int16_t *
temp =
block[(x >> 2) + 2 * (y >> 2)] +
581 2 * (x & 3) + 2 * 8 * (y & 3);
584 int cg = (cb +
cr) >> 1;
590 dst[0] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
592 dst[1] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
594 dst[
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
596 dst[1 +
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
599 dst += 2 * stride - 2 * 8;
610 for (i = 0; i < 6; i++)
621 int frequency[512] = { 0 };
628 const uint8_t *ptr_end = buf + buf_size;
631 memset(up, -1,
sizeof(up));
638 if (ptr_end - ptr <
FFMAX(end - start + 1, 0) + 1) {
643 for (i = start; i <= end; i++)
644 frequency[i] = *ptr++;
653 while ((ptr - buf) & 3)
661 for (j = 257; j < 512; j++) {
662 int min_freq[2] = { 256 * 256, 256 * 256 };
663 int smallest[2] = { 0, 0 };
665 for (i = 0; i < j; i++) {
666 if (frequency[i] == 0)
668 if (frequency[i] < min_freq[1]) {
669 if (frequency[i] < min_freq[0]) {
670 min_freq[1] = min_freq[0];
671 smallest[1] = smallest[0];
672 min_freq[0] = frequency[
i];
675 min_freq[1] = frequency[
i];
680 if (min_freq[1] == 256 * 256)
683 frequency[j] = min_freq[0] + min_freq[1];
684 flag[smallest[0]] = 0;
685 flag[smallest[1]] = 1;
688 frequency[smallest[0]] = frequency[smallest[1]] = 0;
691 for (j = 0; j < 257; j++) {
694 for (node = j; up[node] != -1; node = up[node]) {
700 "vlc length overflow\n");
717 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
718 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
719 int red = 2 * (c0 >> 10) + (c1 >> 10);
720 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
728 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
733 if (length < mbs * 8) {
739 for (y = 0; y <
height; y += 16) {
740 for (x = 0; x <
width; x += 16) {
742 if (buf_end - buf < 8)
745 color[0] = bytestream2_get_le16u(&g3);
746 color[1] = bytestream2_get_le16u(&g3);
748 if (color[0] & 0x8000)
750 if (color[1] & 0x8000)
753 color[2] =
mix(color[0], color[1]);
754 color[3] =
mix(color[1], color[0]);
756 bits = bytestream2_get_le32u(&g3);
757 for (y2 = 0; y2 < 16; y2++) {
758 for (x2 = 0; x2 < 16; x2++) {
759 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
760 dst[y2 * width + x2] = color[(
bits >>
index) & 3];
765 dst += 16 * width - x;
776 const unsigned int bitstream_size =
AV_RL32(buf);
777 unsigned int prestream_size;
780 if (bitstream_size > (1 << 26))
783 if (length < bitstream_size + 12) {
788 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
789 prestream = buf + bitstream_size + 12;
791 if (prestream_size + bitstream_size + 12 != length
792 || prestream_size > (1 << 26)) {
794 prestream_size, bitstream_size, length);
808 prestream_size = length + buf - prestream;
820 for (y = 0; y <
height; y += 16) {
821 for (x = 0; x <
width; x += 16) {
839 int buf_size = avpkt->
size;
849 if (buf_size <
AV_RL32(buf + 4) + 8) {
857 if (frame_4cc ==
AV_RL32(
"cfrm")) {
860 const int data_size = buf_size - 20;
869 whole_size =
AV_RL32(buf + 16);
871 if (data_size < 0 || whole_size < 0) {
888 if (i >= CFRAME_BUFFER_COUNT) {
905 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
906 cfrm->
size += data_size;
908 if (cfrm->
size >= whole_size) {
910 frame_size = cfrm->
size;
919 cfrm->
size = cfrm->
id = 0;
925 frame_size = buf_size - 12;
931 if (frame_4cc ==
AV_RL32(
"ifr2")) {
937 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
943 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
949 }
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])
ptrdiff_t const GLvoid * data
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...
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
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)
The exact code depends on how similar the blocks are and how related they are to the block
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
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 AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
#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().
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)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
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
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static av_cold int decode_end(AVCodecContext *avctx)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
GLint GLenum GLboolean GLsizei stride
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)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static double cr(void *priv, double x, double y)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
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.