Go to the documentation of this file.
45 #define BITSTREAM_READER_LE
56 #define VP8X_FLAG_ANIMATION 0x02
57 #define VP8X_FLAG_XMP_METADATA 0x04
58 #define VP8X_FLAG_EXIF_METADATA 0x08
59 #define VP8X_FLAG_ALPHA 0x10
60 #define VP8X_FLAG_ICC 0x20
62 #define MAX_PALETTE_SIZE 256
63 #define MAX_CACHE_BITS 11
64 #define NUM_CODE_LENGTH_CODES 19
65 #define HUFFMAN_CODES_PER_META_CODE 5
66 #define NUM_LITERAL_CODES 256
67 #define NUM_LENGTH_CODES 24
68 #define NUM_DISTANCE_CODES 40
69 #define NUM_SHORT_DISTANCES 120
70 #define MAX_HUFFMAN_CODE_LENGTH 15
79 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
83 { 0, 1 }, { 1, 0 }, { 1, 1 }, { -1, 1 }, { 0, 2 }, { 2, 0 }, { 1, 2 }, { -1, 2 },
84 { 2, 1 }, { -2, 1 }, { 2, 2 }, { -2, 2 }, { 0, 3 }, { 3, 0 }, { 1, 3 }, { -1, 3 },
85 { 3, 1 }, { -3, 1 }, { 2, 3 }, { -2, 3 }, { 3, 2 }, { -3, 2 }, { 0, 4 }, { 4, 0 },
86 { 1, 4 }, { -1, 4 }, { 4, 1 }, { -4, 1 }, { 3, 3 }, { -3, 3 }, { 2, 4 }, { -2, 4 },
87 { 4, 2 }, { -4, 2 }, { 0, 5 }, { 3, 4 }, { -3, 4 }, { 4, 3 }, { -4, 3 }, { 5, 0 },
88 { 1, 5 }, { -1, 5 }, { 5, 1 }, { -5, 1 }, { 2, 5 }, { -2, 5 }, { 5, 2 }, { -5, 2 },
89 { 4, 4 }, { -4, 4 }, { 3, 5 }, { -3, 5 }, { 5, 3 }, { -5, 3 }, { 0, 6 }, { 6, 0 },
90 { 1, 6 }, { -1, 6 }, { 6, 1 }, { -6, 1 }, { 2, 6 }, { -2, 6 }, { 6, 2 }, { -6, 2 },
91 { 4, 5 }, { -4, 5 }, { 5, 4 }, { -5, 4 }, { 3, 6 }, { -3, 6 }, { 6, 3 }, { -6, 3 },
92 { 0, 7 }, { 7, 0 }, { 1, 7 }, { -1, 7 }, { 5, 5 }, { -5, 5 }, { 7, 1 }, { -7, 1 },
93 { 4, 6 }, { -4, 6 }, { 6, 4 }, { -6, 4 }, { 2, 7 }, { -2, 7 }, { 7, 2 }, { -7, 2 },
94 { 3, 7 }, { -3, 7 }, { 7, 3 }, { -7, 3 }, { 5, 6 }, { -5, 6 }, { 6, 5 }, { -6, 5 },
95 { 8, 0 }, { 4, 7 }, { -4, 7 }, { 7, 4 }, { -7, 4 }, { 8, 1 }, { 8, 2 }, { 6, 6 },
96 { -6, 6 }, { 8, 3 }, { 5, 7 }, { -5, 7 }, { 7, 5 }, { -7, 5 }, { 8, 4 }, { 6, 7 },
97 { -6, 7 }, { 7, 6 }, { -7, 6 }, { 8, 5 }, { 7, 7 }, { -7, 7 }, { 8, 6 }, { 8, 7 }
220 #define GET_PIXEL(frame, x, y) \
221 ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x))
223 #define GET_PIXEL_COMP(frame, x, y, c) \
224 (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c))
233 if (
img->huffman_groups) {
234 for (
i = 0;
i <
img->nb_huffman_groups;
i++) {
240 memset(
img, 0,
sizeof(*
img));
246 if (
r->nb_symbols == 1)
247 return r->simple_symbols[0];
258 int max_code_length = 0;
262 for (sym = 0; sym < alphabet_size; sym++) {
263 if (code_lengths[sym] > 0) {
272 r->simple_symbols[0] =
code;
277 for (sym = 0; sym < alphabet_size; sym++)
278 max_code_length =
FFMAX(max_code_length, code_lengths[sym]);
289 for (
len = 1;
len <= max_code_length;
len++) {
290 for (sym = 0; sym < alphabet_size; sym++) {
291 if (code_lengths[sym] !=
len)
298 if (!
r->nb_symbols) {
304 code_lengths,
sizeof(*code_lengths),
sizeof(*code_lengths),
334 HuffReader code_len_hc = { { 0 }, 0, 0, { 0 } };
335 uint8_t *code_lengths;
337 int i, symbol, max_symbol, prev_code_len,
ret;
342 for (
i = 0;
i < num_codes;
i++)
359 if (max_symbol > alphabet_size) {
361 max_symbol, alphabet_size);
366 max_symbol = alphabet_size;
371 while (symbol < alphabet_size) {
379 code_lengths[symbol++] = code_len;
381 prev_code_len = code_len;
383 int repeat = 0, length = 0;
390 length = prev_code_len;
403 if (symbol + repeat > alphabet_size) {
405 "invalid symbol %d + repeat %d > alphabet size %d\n",
406 symbol, repeat, alphabet_size);
411 code_lengths[symbol++] = length;
426 #define PARSE_BLOCK_SIZE(w, h) do { \
427 block_bits = get_bits(&s->gb, 3) + 2; \
428 blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \
429 blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \
449 for (y = 0; y <
img->frame->height; y++) {
450 for (x = 0; x <
img->frame->width; x++) {
453 int p = p0 << 8 | p1;
457 s->nb_huffman_groups =
max + 1;
497 int width_bits, index_size,
ret, x;
504 else if (index_size <= 4)
506 else if (index_size <= 16)
517 img->size_reduction = width_bits;
519 s->reduced_width = (
s->width + ((1 << width_bits) - 1)) >> width_bits;
522 ct =
img->frame->data[0] + 4;
523 for (x = 4; x <
img->frame->width * 4; x++, ct++)
540 group = g0 << 8 | g1;
548 uint32_t cache_idx = (0x1E35A7BD *
c) >> (32 -
img->color_cache_bits);
549 img->color_cache[cache_idx] =
c;
559 img = &
s->image[role];
569 img->frame->width =
w;
570 img->frame->height =
h;
581 if (
img->color_cache_bits < 1 ||
img->color_cache_bits > 11) {
583 img->color_cache_bits);
587 sizeof(*
img->color_cache));
588 if (!
img->color_cache)
591 img->color_cache_bits = 0;
594 img->nb_huffman_groups = 1;
599 img->nb_huffman_groups =
s->nb_huffman_groups;
603 sizeof(*
img->huffman_groups));
604 if (!
img->huffman_groups)
607 for (
i = 0;
i <
img->nb_huffman_groups;
i++) {
611 if (!j &&
img->color_cache_bits > 0)
612 alphabet_size += 1 <<
img->color_cache_bits;
629 while (y < img->
frame->height) {
644 if (
img->color_cache_bits)
653 int prefix_code, length,
distance, ref_x, ref_y;
657 if (prefix_code < 4) {
658 length = prefix_code + 1;
665 if (prefix_code > 39
U) {
667 "distance prefix code too large: %d\n", prefix_code);
670 if (prefix_code < 4) {
703 ref_x =
FFMAX(0, ref_x);
704 ref_y =
FFMAX(0, ref_y);
709 for (
i = 0;
i < length;
i++) {
714 if (
img->color_cache_bits)
722 if (ref_x ==
width) {
726 if (y ==
img->frame->height || ref_y ==
img->frame->height)
734 if (!
img->color_cache_bits) {
738 if (cache_idx >= 1 <<
img->color_cache_bits) {
740 "color cache index out-of-bounds\n");
756 static void inv_predict_0(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
757 const uint8_t *p_t,
const uint8_t *p_tr)
763 static void inv_predict_1(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
764 const uint8_t *p_t,
const uint8_t *p_tr)
770 static void inv_predict_2(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
771 const uint8_t *p_t,
const uint8_t *p_tr)
777 static void inv_predict_3(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
778 const uint8_t *p_t,
const uint8_t *p_tr)
784 static void inv_predict_4(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
785 const uint8_t *p_t,
const uint8_t *p_tr)
791 static void inv_predict_5(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
792 const uint8_t *p_t,
const uint8_t *p_tr)
794 p[0] = p_t[0] + (p_l[0] + p_tr[0] >> 1) >> 1;
795 p[1] = p_t[1] + (p_l[1] + p_tr[1] >> 1) >> 1;
796 p[2] = p_t[2] + (p_l[2] + p_tr[2] >> 1) >> 1;
797 p[3] = p_t[3] + (p_l[3] + p_tr[3] >> 1) >> 1;
801 static void inv_predict_6(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
802 const uint8_t *p_t,
const uint8_t *p_tr)
804 p[0] = p_l[0] + p_tl[0] >> 1;
805 p[1] = p_l[1] + p_tl[1] >> 1;
806 p[2] = p_l[2] + p_tl[2] >> 1;
807 p[3] = p_l[3] + p_tl[3] >> 1;
811 static void inv_predict_7(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
812 const uint8_t *p_t,
const uint8_t *p_tr)
814 p[0] = p_l[0] + p_t[0] >> 1;
815 p[1] = p_l[1] + p_t[1] >> 1;
816 p[2] = p_l[2] + p_t[2] >> 1;
817 p[3] = p_l[3] + p_t[3] >> 1;
821 static void inv_predict_8(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
822 const uint8_t *p_t,
const uint8_t *p_tr)
824 p[0] = p_tl[0] + p_t[0] >> 1;
825 p[1] = p_tl[1] + p_t[1] >> 1;
826 p[2] = p_tl[2] + p_t[2] >> 1;
827 p[3] = p_tl[3] + p_t[3] >> 1;
831 static void inv_predict_9(uint8_t *p,
const uint8_t *p_l,
const uint8_t *p_tl,
832 const uint8_t *p_t,
const uint8_t *p_tr)
834 p[0] = p_t[0] + p_tr[0] >> 1;
835 p[1] = p_t[1] + p_tr[1] >> 1;
836 p[2] = p_t[2] + p_tr[2] >> 1;
837 p[3] = p_t[3] + p_tr[3] >> 1;
842 const uint8_t *p_t,
const uint8_t *p_tr)
844 p[0] = (p_l[0] + p_tl[0] >> 1) + (p_t[0] + p_tr[0] >> 1) >> 1;
845 p[1] = (p_l[1] + p_tl[1] >> 1) + (p_t[1] + p_tr[1] >> 1) >> 1;
846 p[2] = (p_l[2] + p_tl[2] >> 1) + (p_t[2] + p_tr[2] >> 1) >> 1;
847 p[3] = (p_l[3] + p_tl[3] >> 1) + (p_t[3] + p_tr[3] >> 1) >> 1;
852 const uint8_t *p_t,
const uint8_t *p_tr)
855 (
FFABS(p_l[1] - p_tl[1]) -
FFABS(p_t[1] - p_tl[1])) +
856 (
FFABS(p_l[2] - p_tl[2]) -
FFABS(p_t[2] - p_tl[2])) +
857 (
FFABS(p_l[3] - p_tl[3]) -
FFABS(p_t[3] - p_tl[3]));
866 const uint8_t *p_t,
const uint8_t *p_tr)
882 const uint8_t *p_t,
const uint8_t *p_tr)
891 const uint8_t *p_tl,
const uint8_t *p_t,
892 const uint8_t *p_tr);
903 uint8_t *dec, *p_l, *p_tl, *p_t, *p_tr;
910 if (x ==
frame->width - 1)
929 for (y = 0; y <
img->frame->height; y++) {
930 for (x = 0; x <
s->reduced_width; x++) {
945 "invalid predictor mode: %d\n", m);
969 for (y = 0; y <
img->frame->height; y++) {
970 for (x = 0; x <
s->reduced_width; x++) {
989 for (y = 0; y <
img->frame->height; y++) {
990 for (x = 0; x <
s->reduced_width; x++) {
1018 for (y = 0; y <
img->frame->height; y++) {
1020 memcpy(
line, p,
img->frame->linesize[0]);
1024 for (x = 0; x <
img->frame->width; x++) {
1026 p[2] =
get_bits(&gb_g, pixel_bits);
1035 s->reduced_width =
s->width;
1039 if (
img->frame->height *
img->frame->width > 300) {
1040 uint8_t palette[256 * 4];
1045 memset(palette +
size, 0, 256 * 4 -
size);
1046 for (y = 0; y <
img->frame->height; y++) {
1047 for (x = 0; x <
img->frame->width; x++) {
1054 for (y = 0; y <
img->frame->height; y++) {
1055 for (x = 0; x <
img->frame->width; x++) {
1074 if (
s->width &&
s->width !=
w) {
1079 if (
s->height &&
s->height !=
h) {
1087 int *got_frame,
const uint8_t *data_start,
1088 unsigned int data_size,
int is_alpha_chunk)
1093 if (!is_alpha_chunk) {
1102 if (!is_alpha_chunk) {
1124 if (!
s->width || !
s->height)
1131 s->nb_transforms = 0;
1132 s->reduced_width =
s->width;
1140 goto free_and_return;
1156 goto free_and_return;
1165 goto free_and_return;
1168 for (
i =
s->nb_transforms - 1;
i >= 0;
i--) {
1169 switch (
s->transforms[
i]) {
1184 goto free_and_return;
1204 ls =
frame->linesize[3];
1207 dec =
frame->data[3] + 1;
1208 for (x = 1; x <
frame->width; x++, dec++)
1212 dec =
frame->data[3] + ls;
1213 for (y = 1; y <
frame->height; y++, dec += ls)
1214 *dec += *(dec - ls);
1219 for (y = 1; y <
frame->height; y++) {
1220 dec =
frame->data[3] + y * ls + 1;
1221 for (x = 1; x <
frame->width; x++, dec++)
1226 for (y = 1; y <
frame->height; y++) {
1227 dec =
frame->data[3] + y * ls + 1;
1228 for (x = 1; x <
frame->width; x++, dec++)
1229 *dec += *(dec - ls);
1233 for (y = 1; y <
frame->height; y++) {
1234 dec =
frame->data[3] + y * ls + 1;
1235 for (x = 1; x <
frame->width; x++, dec++)
1236 dec[0] +=
av_clip_uint8(*(dec - 1) + *(dec - ls) - *(dec - ls - 1));
1243 const uint8_t *data_start,
1244 unsigned int data_size)
1253 for (y = 0; y <
s->height; y++)
1258 int alpha_got_frame = 0;
1261 if (!
s->alpha_frame)
1265 data_start, data_size, 1);
1270 if (!alpha_got_frame) {
1276 for (y = 0; y <
s->height; y++) {
1279 for (x = 0; x <
s->width; x++) {
1289 if (
s->alpha_filter)
1296 int *got_frame, uint8_t *data_start,
1297 unsigned int data_size)
1302 if (!
s->initialized) {
1305 s->v.actually_webp = 1;
1310 if (data_size > INT_MAX) {
1316 s->pkt->data = data_start;
1317 s->pkt->size = data_size;
1330 s->alpha_data_size);
1343 uint32_t chunk_type, chunk_size;
1358 if (bytestream2_get_le32(&gb) !=
MKTAG(
'R',
'I',
'F',
'F')) {
1363 chunk_size = bytestream2_get_le32(&gb);
1367 if (bytestream2_get_le32(&gb) !=
MKTAG(
'W',
'E',
'B',
'P')) {
1373 char chunk_str[5] = { 0 };
1375 chunk_type = bytestream2_get_le32(&gb);
1376 chunk_size = bytestream2_get_le32(&gb);
1377 if (chunk_size == UINT32_MAX)
1379 chunk_size += chunk_size & 1;
1387 switch (chunk_type) {
1388 case MKTAG(
'V',
'P',
'8',
' '):
1398 case MKTAG(
'V',
'P',
'8',
'L'):
1409 case MKTAG(
'V',
'P',
'8',
'X'):
1410 if (
s->width ||
s->height || *got_frame) {
1414 vp8x_flags = bytestream2_get_byte(&gb);
1416 s->width = bytestream2_get_le24(&gb) + 1;
1417 s->height = bytestream2_get_le24(&gb) + 1;
1422 case MKTAG(
'A',
'L',
'P',
'H'): {
1423 int alpha_header, filter_m, compression;
1427 "ALPHA chunk present, but alpha bit not set in the "
1430 if (chunk_size == 0) {
1434 alpha_header = bytestream2_get_byte(&gb);
1436 s->alpha_data_size = chunk_size - 1;
1439 filter_m = (alpha_header >> 2) & 0x03;
1440 compression = alpha_header & 0x03;
1444 "skipping unsupported ALPHA chunk\n");
1447 s->alpha_compression = compression;
1448 s->alpha_filter = filter_m;
1453 case MKTAG(
'E',
'X',
'I',
'F'): {
1464 "EXIF chunk present, but Exif bit not set in the "
1469 avpkt->
size - exif_offset);
1489 case MKTAG(
'I',
'C',
'C',
'P'): {
1499 "ICCP chunk present, but ICC Profile bit not set in the "
1510 case MKTAG(
'A',
'N',
'I',
'M'):
1511 case MKTAG(
'A',
'N',
'M',
'F'):
1512 case MKTAG(
'X',
'M',
'P',
' '):
1513 AV_WL32(chunk_str, chunk_type);
1519 AV_WL32(chunk_str, chunk_type);
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
#define AV_LOG_WARNING
Something somehow does not look correct.
static void inv_predict_12(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
static int get_bits_left(GetBitContext *gb)
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
#define NUM_SHORT_DISTANCES
static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, uint8_t *data_start, unsigned int data_size)
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
#define INIT_VLC_OUTPUT_LE
@ PRED_MODE_AVG_T_AVG_L_TR
@ ALPHA_FILTER_HORIZONTAL
uint16_t simple_symbols[2]
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
static int8_t ff_u8_to_s8(uint8_t a)
static const uint8_t block_bits[]
static void inv_predict_4(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static void inv_predict_2(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
This structure describes decoded (raw) audio or video data.
#define GET_PIXEL_COMP(frame, x, y, c)
@ PRED_MODE_ADD_SUBTRACT_FULL
@ COLOR_INDEXING_TRANSFORM
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
static int parse_transform_color(WebPContext *s)
#define AV_LOG_VERBOSE
Detailed information.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths, int alphabet_size)
enum TransformType transforms[4]
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, const uint8_t *data_start, unsigned int data_size, int is_alpha_chunk)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void skip_bits(GetBitContext *s, int n)
enum AlphaCompression alpha_compression
static void inv_predict_10(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static void inv_predict_8(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
AVCodec p
The public AVCodec.
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
static void update_canvas_size(AVCodecContext *avctx, int w, int h)
int key_frame
1 -> keyframe, 0-> not
void(* inv_predict_func)(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
#define VP8X_FLAG_EXIF_METADATA
static void inv_predict_3(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
const FFCodec ff_webp_decoder
static av_always_inline uint8_t color_transform_delta(uint8_t color_pred, uint8_t color)
static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, int w, int h)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, int alphabet_size)
int ff_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le, int depth, AVDictionary **metadata)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
#define FF_CODEC_PROPERTY_LOSSLESS
static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
#define FF_CODEC_DECODE_CB(func)
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
#define HUFFMAN_CODES_PER_META_CODE
static const uint8_t code_length_code_order[NUM_CODE_LENGTH_CODES]
static av_always_inline void color_cache_put(ImageContext *img, uint32_t c)
#define NUM_DISTANCE_CODES
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static void inv_predict_11(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
#define NUM_CODE_LENGTH_CODES
#define xi(width, name, var, range_min, range_max, subs,...)
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define GET_PIXEL(frame, x, y)
static av_cold int webp_decode_close(AVCodecContext *avctx)
HuffReader * huffman_groups
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static int apply_subtract_green_transform(WebPContext *s)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static const inv_predict_func inverse_predict[14]
static const int8_t transform[32][32]
@ AV_PICTURE_TYPE_I
Intra.
static unsigned int get_bits1(GetBitContext *s)
static int parse_transform_color_indexing(WebPContext *s)
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
static av_cold int webp_decode_init(AVCodecContext *avctx)
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
static const uint16_t alphabet_sizes[HUFFMAN_CODES_PER_META_CODE]
#define NUM_LITERAL_CODES
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
static void alpha_inverse_prediction(AVFrame *frame, enum AlphaFilter m)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline int bytestream2_tell(GetByteContext *g)
@ IMAGE_ROLE_COLOR_INDEXING
enum AVPictureType pict_type
Picture type of the frame.
static void inv_predict_0(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
static int decode_entropy_image(WebPContext *s)
static int apply_color_transform(WebPContext *s)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
static int parse_transform_predictor(WebPContext *s)
@ PRED_MODE_AVG_AVG_L_TL_AVG_T_TR
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
static void inv_predict_5(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
#define i(width, name, range_min, range_max)
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
unsigned properties
Properties of the stream that gets decoded.
#define av_malloc_array(a, b)
static const int8_t lz77_distance_offsets[NUM_SHORT_DISTANCES][2]
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static int apply_predictor_transform(WebPContext *s)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static void inv_predict_7(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
void * av_calloc(size_t nmemb, size_t size)
void ff_free_vlc(VLC *vlc)
static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb)
static void inv_predict_13(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
ImageContext image[IMAGE_ROLE_NB]
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static void inv_predict_6(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
#define AV_INPUT_BUFFER_PADDING_SIZE
static int vp8_lossy_decode_alpha(AVCodecContext *avctx, AVFrame *p, const uint8_t *data_start, unsigned int data_size)
main external API structure.
static int webp_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
AVDictionary * metadata
metadata.
int ff_tdecode_header(GetByteContext *gb, int *le, int *ifd_offset)
Decodes a TIFF header from the input bytestream and sets the endianness in *le and the offset to the ...
static void image_ctx_free(ImageContext *img)
static int apply_color_indexing_transform(WebPContext *s)
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
const uint8_t * alpha_data
Structure to hold side data for an AVFrame.
#define MAX_HUFFMAN_CODE_LENGTH
#define PARSE_BLOCK_SIZE(w, h)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
This structure stores compressed data.
int ff_vp8_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
int width
picture width / height.
static float distance(float x, float y, int band)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
static void read_huffman_code_simple(WebPContext *s, HuffReader *hc)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define MKTAG(a, b, c, d)
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 HuffReader * get_huffman_group(WebPContext *s, ImageContext *img, int x, int y)
static void inv_predict_9(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
static void inv_predict_1(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, const uint8_t *p_t, const uint8_t *p_tr)
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
enum AlphaFilter alpha_filter
@ PRED_MODE_ADD_SUBTRACT_HALF
@ IMAGE_ROLE_COLOR_TRANSFORM