Go to the documentation of this file.
46 #define BITSTREAM_READER_LE
57 #define VP8X_FLAG_ANIMATION 0x02
58 #define VP8X_FLAG_XMP_METADATA 0x04
59 #define VP8X_FLAG_EXIF_METADATA 0x08
60 #define VP8X_FLAG_ALPHA 0x10
61 #define VP8X_FLAG_ICC 0x20
63 #define MAX_PALETTE_SIZE 256
64 #define MAX_CACHE_BITS 11
65 #define NUM_CODE_LENGTH_CODES 19
66 #define HUFFMAN_CODES_PER_META_CODE 5
67 #define NUM_LITERAL_CODES 256
68 #define NUM_LENGTH_CODES 24
69 #define NUM_DISTANCE_CODES 40
70 #define NUM_SHORT_DISTANCES 120
71 #define MAX_HUFFMAN_CODE_LENGTH 15
80 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
84 { 0, 1 }, { 1, 0 }, { 1, 1 }, { -1, 1 }, { 0, 2 }, { 2, 0 }, { 1, 2 }, { -1, 2 },
85 { 2, 1 }, { -2, 1 }, { 2, 2 }, { -2, 2 }, { 0, 3 }, { 3, 0 }, { 1, 3 }, { -1, 3 },
86 { 3, 1 }, { -3, 1 }, { 2, 3 }, { -2, 3 }, { 3, 2 }, { -3, 2 }, { 0, 4 }, { 4, 0 },
87 { 1, 4 }, { -1, 4 }, { 4, 1 }, { -4, 1 }, { 3, 3 }, { -3, 3 }, { 2, 4 }, { -2, 4 },
88 { 4, 2 }, { -4, 2 }, { 0, 5 }, { 3, 4 }, { -3, 4 }, { 4, 3 }, { -4, 3 }, { 5, 0 },
89 { 1, 5 }, { -1, 5 }, { 5, 1 }, { -5, 1 }, { 2, 5 }, { -2, 5 }, { 5, 2 }, { -5, 2 },
90 { 4, 4 }, { -4, 4 }, { 3, 5 }, { -3, 5 }, { 5, 3 }, { -5, 3 }, { 0, 6 }, { 6, 0 },
91 { 1, 6 }, { -1, 6 }, { 6, 1 }, { -6, 1 }, { 2, 6 }, { -2, 6 }, { 6, 2 }, { -6, 2 },
92 { 4, 5 }, { -4, 5 }, { 5, 4 }, { -5, 4 }, { 3, 6 }, { -3, 6 }, { 6, 3 }, { -6, 3 },
93 { 0, 7 }, { 7, 0 }, { 1, 7 }, { -1, 7 }, { 5, 5 }, { -5, 5 }, { 7, 1 }, { -7, 1 },
94 { 4, 6 }, { -4, 6 }, { 6, 4 }, { -6, 4 }, { 2, 7 }, { -2, 7 }, { 7, 2 }, { -7, 2 },
95 { 3, 7 }, { -3, 7 }, { 7, 3 }, { -7, 3 }, { 5, 6 }, { -5, 6 }, { 6, 5 }, { -6, 5 },
96 { 8, 0 }, { 4, 7 }, { -4, 7 }, { 7, 4 }, { -7, 4 }, { 8, 1 }, { 8, 2 }, { 6, 6 },
97 { -6, 6 }, { 8, 3 }, { 5, 7 }, { -5, 7 }, { 7, 5 }, { -7, 5 }, { 8, 4 }, { 6, 7 },
98 { -6, 7 }, { 7, 6 }, { -7, 6 }, { 8, 5 }, { 7, 7 }, { -7, 7 }, { 8, 6 }, { 8, 7 }
221 #define GET_PIXEL(frame, x, y) \
222 ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x))
224 #define GET_PIXEL_COMP(frame, x, y, c) \
225 (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c))
234 if (
img->huffman_groups) {
235 for (
i = 0;
i <
img->nb_huffman_groups;
i++) {
241 memset(
img, 0,
sizeof(*
img));
247 if (
r->nb_symbols == 1)
248 return r->simple_symbols[0];
257 uint8_t lens[], uint16_t syms[],
258 int alphabet_size,
void *logctx)
260 unsigned nb_codes = 0;
266 unsigned cnt = len_counts[
len];
267 len_counts[
len] = nb_codes;
271 for (
int sym = 0; sym < alphabet_size; ++sym) {
272 if (code_lengths[sym]) {
273 unsigned idx = len_counts[code_lengths[sym]]++;
275 lens[idx] = code_lengths[sym];
283 r->simple_symbols[0] = syms[0];
315 HuffReader code_len_hc = { { 0 }, 0, 0, { 0 } };
316 uint8_t *code_lengths;
321 int symbol, max_symbol, prev_code_len,
ret;
326 for (
int i = 0;
i < num_codes;
i++) {
335 if (max_symbol > alphabet_size) {
337 max_symbol, alphabet_size);
341 max_symbol = alphabet_size;
345 reordered_code_length_code_lengths,
346 reordered_code_length_syms,
351 code_lengths =
av_malloc_array(alphabet_size, 2 *
sizeof(uint8_t) +
sizeof(uint16_t));
359 memset(len_counts, 0,
sizeof(len_counts));
360 while (symbol < alphabet_size) {
366 if (code_len < 16
U) {
368 code_lengths[symbol++] = code_len;
369 len_counts[code_len]++;
371 prev_code_len = code_len;
373 int repeat = 0, length = 0;
383 length = prev_code_len;
384 len_counts[length] += repeat;
397 if (symbol + repeat > alphabet_size) {
399 "invalid symbol %d + repeat %d > alphabet size %d\n",
400 symbol, repeat, alphabet_size);
405 code_lengths[symbol++] = length;
410 code_lengths + symbol,
411 (uint16_t*)(code_lengths + 2 * symbol),
423 #define PARSE_BLOCK_SIZE(w, h) do { \
424 block_bits = get_bits(&s->gb, 3) + 2; \
425 blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \
426 blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \
446 for (y = 0; y <
img->frame->height; y++) {
447 for (x = 0; x <
img->frame->width; x++) {
450 int p = p0 << 8 | p1;
454 s->nb_huffman_groups =
max + 1;
494 int width_bits, index_size,
ret, x;
501 else if (index_size <= 4)
503 else if (index_size <= 16)
514 img->size_reduction = width_bits;
516 s->reduced_width = (
s->width + ((1 << width_bits) - 1)) >> width_bits;
519 ct =
img->frame->data[0] + 4;
520 for (x = 4; x <
img->frame->width * 4; x++, ct++)
537 group = g0 << 8 | g1;
545 uint32_t cache_idx = (0x1E35A7BD *
c) >> (32 -
img->color_cache_bits);
546 img->color_cache[cache_idx] =
c;
556 img = &
s->image[role];
566 img->frame->width =
w;
567 img->frame->height =
h;
578 if (
img->color_cache_bits < 1 ||
img->color_cache_bits > 11) {
580 img->color_cache_bits);
584 sizeof(*
img->color_cache));
585 if (!
img->color_cache)
588 img->color_cache_bits = 0;
591 img->nb_huffman_groups = 1;
596 img->nb_huffman_groups =
s->nb_huffman_groups;
600 sizeof(*
img->huffman_groups));
601 if (!
img->huffman_groups)
604 for (
i = 0;
i <
img->nb_huffman_groups;
i++) {
608 if (!j &&
img->color_cache_bits > 0)
609 alphabet_size += 1 <<
img->color_cache_bits;
626 while (y < img->
frame->height) {
641 if (
img->color_cache_bits)
650 int prefix_code, length,
distance, ref_x, ref_y;
654 if (prefix_code < 4) {
655 length = prefix_code + 1;
662 if (prefix_code > 39
U) {
664 "distance prefix code too large: %d\n", prefix_code);
667 if (prefix_code < 4) {
700 ref_x =
FFMAX(0, ref_x);
701 ref_y =
FFMAX(0, ref_y);
703 if (ref_y == y && ref_x >= x)
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;
1205 ls =
frame->linesize[3];
1208 dec =
frame->data[3] + 1;
1209 for (x = 1; x <
frame->width; x++, dec++)
1213 dec =
frame->data[3] + ls;
1214 for (y = 1; y <
frame->height; y++, dec += ls)
1215 *dec += *(dec - ls);
1220 for (y = 1; y <
frame->height; y++) {
1221 dec =
frame->data[3] + y * ls + 1;
1222 for (x = 1; x <
frame->width; x++, dec++)
1227 for (y = 1; y <
frame->height; y++) {
1228 dec =
frame->data[3] + y * ls + 1;
1229 for (x = 1; x <
frame->width; x++, dec++)
1230 *dec += *(dec - ls);
1234 for (y = 1; y <
frame->height; y++) {
1235 dec =
frame->data[3] + y * ls + 1;
1236 for (x = 1; x <
frame->width; x++, dec++)
1237 dec[0] +=
av_clip_uint8(*(dec - 1) + *(dec - ls) - *(dec - ls - 1));
1244 const uint8_t *data_start,
1245 unsigned int data_size)
1254 for (y = 0; y <
s->height; y++)
1259 int alpha_got_frame = 0;
1262 if (!
s->alpha_frame)
1266 data_start, data_size, 1);
1271 if (!alpha_got_frame) {
1277 for (y = 0; y <
s->height; y++) {
1280 for (x = 0; x <
s->width; x++) {
1290 if (
s->alpha_filter)
1297 int *got_frame, uint8_t *data_start,
1298 unsigned int data_size)
1303 if (!
s->initialized) {
1306 s->v.actually_webp = 1;
1311 if (data_size > INT_MAX) {
1317 s->pkt->data = data_start;
1318 s->pkt->size = data_size;
1331 s->alpha_data_size);
1344 uint32_t chunk_type, chunk_size;
1359 if (bytestream2_get_le32(&gb) !=
MKTAG(
'R',
'I',
'F',
'F')) {
1364 chunk_size = bytestream2_get_le32(&gb);
1368 if (bytestream2_get_le32(&gb) !=
MKTAG(
'W',
'E',
'B',
'P')) {
1374 char chunk_str[5] = { 0 };
1376 chunk_type = bytestream2_get_le32(&gb);
1377 chunk_size = bytestream2_get_le32(&gb);
1378 if (chunk_size == UINT32_MAX)
1380 chunk_size += chunk_size & 1;
1388 switch (chunk_type) {
1389 case MKTAG(
'V',
'P',
'8',
' '):
1399 case MKTAG(
'V',
'P',
'8',
'L'):
1406 #if FF_API_CODEC_PROPS
1414 case MKTAG(
'V',
'P',
'8',
'X'):
1415 if (
s->width ||
s->height || *got_frame) {
1419 vp8x_flags = bytestream2_get_byte(&gb);
1421 s->width = bytestream2_get_le24(&gb) + 1;
1422 s->height = bytestream2_get_le24(&gb) + 1;
1427 case MKTAG(
'A',
'L',
'P',
'H'): {
1428 int alpha_header, filter_m, compression;
1432 "ALPHA chunk present, but alpha bit not set in the "
1435 if (chunk_size == 0) {
1439 alpha_header = bytestream2_get_byte(&gb);
1441 s->alpha_data_size = chunk_size - 1;
1444 filter_m = (alpha_header >> 2) & 0x03;
1445 compression = alpha_header & 0x03;
1449 "skipping unsupported ALPHA chunk\n");
1452 s->alpha_compression = compression;
1453 s->alpha_filter = filter_m;
1458 case MKTAG(
'E',
'X',
'I',
'F'): {
1469 "EXIF chunk present, but Exif bit not set in the "
1474 avpkt->
size - exif_offset);
1494 case MKTAG(
'I',
'C',
'C',
'P'): {
1504 "ICCP chunk present, but ICC Profile bit not set in the "
1520 case MKTAG(
'A',
'N',
'I',
'M'):
1521 case MKTAG(
'A',
'N',
'M',
'F'):
1522 case MKTAG(
'X',
'M',
'P',
' '):
1523 AV_WL32(chunk_str, chunk_type);
1529 AV_WL32(chunk_str, chunk_type);
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
#define FF_ENABLE_DEPRECATION_WARNINGS
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)
int ff_vlc_init_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
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.
@ PRED_MODE_AVG_T_AVG_L_TR
@ ALPHA_FILTER_HORIZONTAL
uint16_t simple_symbols[2]
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
static int parse_transform_color(WebPContext *s)
#define AV_LOG_VERBOSE
Detailed information.
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
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.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
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.
static void update_canvas_size(AVCodecContext *avctx, int w, int h)
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 FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
#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
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
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)
static const int8_t transform[32][32]
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
#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)
#define CODEC_LONG_NAME(str)
HuffReader * huffman_groups
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int ff_vp8_decode_init(AVCodecContext *avctx)
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]
@ 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
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.
int(* init)(AVBSFContext *ctx)
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.
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
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)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
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)
#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)
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)
static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb)
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
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)
void ff_vlc_free(VLC *vlc)
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
int ff_vp8_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
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)
#define FF_DISABLE_DEPRECATION_WARNINGS
static int apply_color_indexing_transform(WebPContext *s)
const uint8_t * alpha_data
Structure to hold side data for an AVFrame.
#define VLC_INIT_OUTPUT_LE
#define MAX_HUFFMAN_CODE_LENGTH
#define PARSE_BLOCK_SIZE(w, h)
This structure stores compressed data.
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.
attribute_deprecated unsigned properties
Properties of the stream that gets decoded.
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)
static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths, uint16_t len_counts[MAX_HUFFMAN_CODE_LENGTH+1], uint8_t lens[], uint16_t syms[], int alphabet_size, void *logctx)
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)
#define AV_FRAME_FLAG_LOSSLESS
A decoder can use this flag to mark frames which were originally encoded losslessly.
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