FFmpeg
webp.c
Go to the documentation of this file.
1 /*
2  * WebP (.webp) image decoder
3  * Copyright (c) 2013 Aneesh Dogra <aneesh@sugarlabs.org>
4  * Copyright (c) 2013 Justin Ruggles <justin.ruggles@gmail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * WebP image decoder
26  *
27  * @author Aneesh Dogra <aneesh@sugarlabs.org>
28  * Container and Lossy decoding
29  *
30  * @author Justin Ruggles <justin.ruggles@gmail.com>
31  * Lossless decoder
32  * Compressed alpha for lossy
33  *
34  * @author James Almer <jamrial@gmail.com>
35  * Exif metadata
36  * ICC profile
37  *
38  * Unimplemented:
39  * - Animation
40  * - XMP metadata
41  */
42 
43 #include "libavutil/imgutils.h"
44 
45 #define BITSTREAM_READER_LE
46 #include "avcodec.h"
47 #include "bytestream.h"
48 #include "exif.h"
49 #include "get_bits.h"
50 #include "internal.h"
51 #include "thread.h"
52 #include "vp8.h"
53 
54 #define VP8X_FLAG_ANIMATION 0x02
55 #define VP8X_FLAG_XMP_METADATA 0x04
56 #define VP8X_FLAG_EXIF_METADATA 0x08
57 #define VP8X_FLAG_ALPHA 0x10
58 #define VP8X_FLAG_ICC 0x20
59 
60 #define MAX_PALETTE_SIZE 256
61 #define MAX_CACHE_BITS 11
62 #define NUM_CODE_LENGTH_CODES 19
63 #define HUFFMAN_CODES_PER_META_CODE 5
64 #define NUM_LITERAL_CODES 256
65 #define NUM_LENGTH_CODES 24
66 #define NUM_DISTANCE_CODES 40
67 #define NUM_SHORT_DISTANCES 120
68 #define MAX_HUFFMAN_CODE_LENGTH 15
69 
70 static const uint16_t alphabet_sizes[HUFFMAN_CODES_PER_META_CODE] = {
74 };
75 
77  17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
78 };
79 
80 static const int8_t lz77_distance_offsets[NUM_SHORT_DISTANCES][2] = {
81  { 0, 1 }, { 1, 0 }, { 1, 1 }, { -1, 1 }, { 0, 2 }, { 2, 0 }, { 1, 2 }, { -1, 2 },
82  { 2, 1 }, { -2, 1 }, { 2, 2 }, { -2, 2 }, { 0, 3 }, { 3, 0 }, { 1, 3 }, { -1, 3 },
83  { 3, 1 }, { -3, 1 }, { 2, 3 }, { -2, 3 }, { 3, 2 }, { -3, 2 }, { 0, 4 }, { 4, 0 },
84  { 1, 4 }, { -1, 4 }, { 4, 1 }, { -4, 1 }, { 3, 3 }, { -3, 3 }, { 2, 4 }, { -2, 4 },
85  { 4, 2 }, { -4, 2 }, { 0, 5 }, { 3, 4 }, { -3, 4 }, { 4, 3 }, { -4, 3 }, { 5, 0 },
86  { 1, 5 }, { -1, 5 }, { 5, 1 }, { -5, 1 }, { 2, 5 }, { -2, 5 }, { 5, 2 }, { -5, 2 },
87  { 4, 4 }, { -4, 4 }, { 3, 5 }, { -3, 5 }, { 5, 3 }, { -5, 3 }, { 0, 6 }, { 6, 0 },
88  { 1, 6 }, { -1, 6 }, { 6, 1 }, { -6, 1 }, { 2, 6 }, { -2, 6 }, { 6, 2 }, { -6, 2 },
89  { 4, 5 }, { -4, 5 }, { 5, 4 }, { -5, 4 }, { 3, 6 }, { -3, 6 }, { 6, 3 }, { -6, 3 },
90  { 0, 7 }, { 7, 0 }, { 1, 7 }, { -1, 7 }, { 5, 5 }, { -5, 5 }, { 7, 1 }, { -7, 1 },
91  { 4, 6 }, { -4, 6 }, { 6, 4 }, { -6, 4 }, { 2, 7 }, { -2, 7 }, { 7, 2 }, { -7, 2 },
92  { 3, 7 }, { -3, 7 }, { 7, 3 }, { -7, 3 }, { 5, 6 }, { -5, 6 }, { 6, 5 }, { -6, 5 },
93  { 8, 0 }, { 4, 7 }, { -4, 7 }, { 7, 4 }, { -7, 4 }, { 8, 1 }, { 8, 2 }, { 6, 6 },
94  { -6, 6 }, { 8, 3 }, { 5, 7 }, { -5, 7 }, { 7, 5 }, { -7, 5 }, { 8, 4 }, { 6, 7 },
95  { -6, 7 }, { 7, 6 }, { -7, 6 }, { 8, 5 }, { 7, 7 }, { -7, 7 }, { 8, 6 }, { 8, 7 }
96 };
97 
101 };
102 
108 };
109 
115 };
116 
132 };
133 
140 };
141 
142 /* The structure of WebP lossless is an optional series of transformation data,
143  * followed by the primary image. The primary image also optionally contains
144  * an entropy group mapping if there are multiple entropy groups. There is a
145  * basic image type called an "entropy coded image" that is used for all of
146  * these. The type of each entropy coded image is referred to by the
147  * specification as its role. */
148 enum ImageRole {
149  /* Primary Image: Stores the actual pixels of the image. */
151 
152  /* Entropy Image: Defines which Huffman group to use for different areas of
153  * the primary image. */
155 
156  /* Predictors: Defines which predictor type to use for different areas of
157  * the primary image. */
159 
160  /* Color Transform Data: Defines the color transformation for different
161  * areas of the primary image. */
163 
164  /* Color Index: Stored as an image of height == 1. */
166 
168 };
169 
170 typedef struct HuffReader {
171  VLC vlc; /* Huffman decoder context */
172  int simple; /* whether to use simple mode */
173  int nb_symbols; /* number of coded symbols */
174  uint16_t simple_symbols[2]; /* symbols for simple mode */
175 } HuffReader;
176 
177 typedef struct ImageContext {
178  enum ImageRole role; /* role of this image */
179  AVFrame *frame; /* AVFrame for data */
180  int color_cache_bits; /* color cache size, log2 */
181  uint32_t *color_cache; /* color cache data */
182  int nb_huffman_groups; /* number of huffman groups */
183  HuffReader *huffman_groups; /* reader for each huffman group */
184  int size_reduction; /* relative size compared to primary image, log2 */
186 } ImageContext;
187 
188 typedef struct WebPContext {
189  VP8Context v; /* VP8 Context used for lossy decoding */
190  GetBitContext gb; /* bitstream reader for main image chunk */
191  AVFrame *alpha_frame; /* AVFrame for alpha data decompressed from VP8L */
192  AVPacket *pkt; /* AVPacket to be passed to the underlying VP8 decoder */
193  AVCodecContext *avctx; /* parent AVCodecContext */
194  int initialized; /* set once the VP8 context is initialized */
195  int has_alpha; /* has a separate alpha chunk */
196  enum AlphaCompression alpha_compression; /* compression type for alpha chunk */
197  enum AlphaFilter alpha_filter; /* filtering method for alpha chunk */
198  uint8_t *alpha_data; /* alpha chunk data */
199  int alpha_data_size; /* alpha chunk data size */
200  int has_exif; /* set after an EXIF chunk has been processed */
201  int has_iccp; /* set after an ICCP chunk has been processed */
202  int width; /* image width */
203  int height; /* image height */
204  int lossless; /* indicates lossless or lossy */
205 
206  int nb_transforms; /* number of transforms */
207  enum TransformType transforms[4]; /* transformations used in the image, in order */
208  int reduced_width; /* reduced width for index image, if applicable */
209  int nb_huffman_groups; /* number of huffman groups in the primary image */
210  ImageContext image[IMAGE_ROLE_NB]; /* image context for each role */
211 } WebPContext;
212 
213 #define GET_PIXEL(frame, x, y) \
214  ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x))
215 
216 #define GET_PIXEL_COMP(frame, x, y, c) \
217  (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c))
218 
220 {
221  int i, j;
222 
223  av_free(img->color_cache);
224  if (img->role != IMAGE_ROLE_ARGB && !img->is_alpha_primary)
225  av_frame_free(&img->frame);
226  if (img->huffman_groups) {
227  for (i = 0; i < img->nb_huffman_groups; i++) {
228  for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++)
229  ff_free_vlc(&img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE + j].vlc);
230  }
231  av_free(img->huffman_groups);
232  }
233  memset(img, 0, sizeof(*img));
234 }
235 
237 {
238  if (r->simple) {
239  if (r->nb_symbols == 1)
240  return r->simple_symbols[0];
241  else
242  return r->simple_symbols[get_bits1(gb)];
243  } else
244  return get_vlc2(gb, r->vlc.table, 8, 2);
245 }
246 
247 static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths,
248  int alphabet_size)
249 {
250  int len = 0, sym, code = 0, ret;
251  int max_code_length = 0;
252  uint16_t *codes;
253 
254  /* special-case 1 symbol since the vlc reader cannot handle it */
255  for (sym = 0; sym < alphabet_size; sym++) {
256  if (code_lengths[sym] > 0) {
257  len++;
258  code = sym;
259  if (len > 1)
260  break;
261  }
262  }
263  if (len == 1) {
264  r->nb_symbols = 1;
265  r->simple_symbols[0] = code;
266  r->simple = 1;
267  return 0;
268  }
269 
270  for (sym = 0; sym < alphabet_size; sym++)
271  max_code_length = FFMAX(max_code_length, code_lengths[sym]);
272 
273  if (max_code_length == 0 || max_code_length > MAX_HUFFMAN_CODE_LENGTH)
274  return AVERROR(EINVAL);
275 
276  codes = av_malloc_array(alphabet_size, sizeof(*codes));
277  if (!codes)
278  return AVERROR(ENOMEM);
279 
280  code = 0;
281  r->nb_symbols = 0;
282  for (len = 1; len <= max_code_length; len++) {
283  for (sym = 0; sym < alphabet_size; sym++) {
284  if (code_lengths[sym] != len)
285  continue;
286  codes[sym] = code++;
287  r->nb_symbols++;
288  }
289  code <<= 1;
290  }
291  if (!r->nb_symbols) {
292  av_free(codes);
293  return AVERROR_INVALIDDATA;
294  }
295 
296  ret = init_vlc(&r->vlc, 8, alphabet_size,
297  code_lengths, sizeof(*code_lengths), sizeof(*code_lengths),
298  codes, sizeof(*codes), sizeof(*codes), INIT_VLC_OUTPUT_LE);
299  if (ret < 0) {
300  av_free(codes);
301  return ret;
302  }
303  r->simple = 0;
304 
305  av_free(codes);
306  return 0;
307 }
308 
310 {
311  hc->nb_symbols = get_bits1(&s->gb) + 1;
312 
313  if (get_bits1(&s->gb))
314  hc->simple_symbols[0] = get_bits(&s->gb, 8);
315  else
316  hc->simple_symbols[0] = get_bits1(&s->gb);
317 
318  if (hc->nb_symbols == 2)
319  hc->simple_symbols[1] = get_bits(&s->gb, 8);
320 
321  hc->simple = 1;
322 }
323 
325  int alphabet_size)
326 {
327  HuffReader code_len_hc = { { 0 }, 0, 0, { 0 } };
328  uint8_t *code_lengths;
329  uint8_t code_length_code_lengths[NUM_CODE_LENGTH_CODES] = { 0 };
330  int i, symbol, max_symbol, prev_code_len, ret;
331  int num_codes = 4 + get_bits(&s->gb, 4);
332 
333  av_assert1(num_codes <= NUM_CODE_LENGTH_CODES);
334 
335  for (i = 0; i < num_codes; i++)
336  code_length_code_lengths[code_length_code_order[i]] = get_bits(&s->gb, 3);
337 
338  ret = huff_reader_build_canonical(&code_len_hc, code_length_code_lengths,
340  if (ret < 0)
341  return ret;
342 
343  code_lengths = av_mallocz(alphabet_size);
344  if (!code_lengths) {
345  ret = AVERROR(ENOMEM);
346  goto finish;
347  }
348 
349  if (get_bits1(&s->gb)) {
350  int bits = 2 + 2 * get_bits(&s->gb, 3);
351  max_symbol = 2 + get_bits(&s->gb, bits);
352  if (max_symbol > alphabet_size) {
353  av_log(s->avctx, AV_LOG_ERROR, "max symbol %d > alphabet size %d\n",
354  max_symbol, alphabet_size);
355  ret = AVERROR_INVALIDDATA;
356  goto finish;
357  }
358  } else {
359  max_symbol = alphabet_size;
360  }
361 
362  prev_code_len = 8;
363  symbol = 0;
364  while (symbol < alphabet_size) {
365  int code_len;
366 
367  if (!max_symbol--)
368  break;
369  code_len = huff_reader_get_symbol(&code_len_hc, &s->gb);
370  if (code_len < 16) {
371  /* Code length code [0..15] indicates literal code lengths. */
372  code_lengths[symbol++] = code_len;
373  if (code_len)
374  prev_code_len = code_len;
375  } else {
376  int repeat = 0, length = 0;
377  switch (code_len) {
378  case 16:
379  /* Code 16 repeats the previous non-zero value [3..6] times,
380  * i.e., 3 + ReadBits(2) times. If code 16 is used before a
381  * non-zero value has been emitted, a value of 8 is repeated. */
382  repeat = 3 + get_bits(&s->gb, 2);
383  length = prev_code_len;
384  break;
385  case 17:
386  /* Code 17 emits a streak of zeros [3..10], i.e.,
387  * 3 + ReadBits(3) times. */
388  repeat = 3 + get_bits(&s->gb, 3);
389  break;
390  case 18:
391  /* Code 18 emits a streak of zeros of length [11..138], i.e.,
392  * 11 + ReadBits(7) times. */
393  repeat = 11 + get_bits(&s->gb, 7);
394  break;
395  }
396  if (symbol + repeat > alphabet_size) {
398  "invalid symbol %d + repeat %d > alphabet size %d\n",
399  symbol, repeat, alphabet_size);
400  ret = AVERROR_INVALIDDATA;
401  goto finish;
402  }
403  while (repeat-- > 0)
404  code_lengths[symbol++] = length;
405  }
406  }
407 
408  ret = huff_reader_build_canonical(hc, code_lengths, alphabet_size);
409 
410 finish:
411  ff_free_vlc(&code_len_hc.vlc);
412  av_free(code_lengths);
413  return ret;
414 }
415 
416 static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role,
417  int w, int h);
418 
419 #define PARSE_BLOCK_SIZE(w, h) do { \
420  block_bits = get_bits(&s->gb, 3) + 2; \
421  blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \
422  blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \
423 } while (0)
424 
426 {
427  ImageContext *img;
428  int ret, block_bits, width, blocks_w, blocks_h, x, y, max;
429 
430  width = s->width;
431  if (s->reduced_width > 0)
432  width = s->reduced_width;
433 
434  PARSE_BLOCK_SIZE(width, s->height);
435 
436  ret = decode_entropy_coded_image(s, IMAGE_ROLE_ENTROPY, blocks_w, blocks_h);
437  if (ret < 0)
438  return ret;
439 
440  img = &s->image[IMAGE_ROLE_ENTROPY];
441  img->size_reduction = block_bits;
442 
443  /* the number of huffman groups is determined by the maximum group number
444  * coded in the entropy image */
445  max = 0;
446  for (y = 0; y < img->frame->height; y++) {
447  for (x = 0; x < img->frame->width; x++) {
448  int p0 = GET_PIXEL_COMP(img->frame, x, y, 1);
449  int p1 = GET_PIXEL_COMP(img->frame, x, y, 2);
450  int p = p0 << 8 | p1;
451  max = FFMAX(max, p);
452  }
453  }
454  s->nb_huffman_groups = max + 1;
455 
456  return 0;
457 }
458 
460 {
461  int block_bits, blocks_w, blocks_h, ret;
462 
463  PARSE_BLOCK_SIZE(s->width, s->height);
464 
466  blocks_h);
467  if (ret < 0)
468  return ret;
469 
471 
472  return 0;
473 }
474 
476 {
477  int block_bits, blocks_w, blocks_h, ret;
478 
479  PARSE_BLOCK_SIZE(s->width, s->height);
480 
482  blocks_h);
483  if (ret < 0)
484  return ret;
485 
487 
488  return 0;
489 }
490 
492 {
493  ImageContext *img;
494  int width_bits, index_size, ret, x;
495  uint8_t *ct;
496 
497  index_size = get_bits(&s->gb, 8) + 1;
498 
499  if (index_size <= 2)
500  width_bits = 3;
501  else if (index_size <= 4)
502  width_bits = 2;
503  else if (index_size <= 16)
504  width_bits = 1;
505  else
506  width_bits = 0;
507 
509  index_size, 1);
510  if (ret < 0)
511  return ret;
512 
513  img = &s->image[IMAGE_ROLE_COLOR_INDEXING];
514  img->size_reduction = width_bits;
515  if (width_bits > 0)
516  s->reduced_width = (s->width + ((1 << width_bits) - 1)) >> width_bits;
517 
518  /* color index values are delta-coded */
519  ct = img->frame->data[0] + 4;
520  for (x = 4; x < img->frame->width * 4; x++, ct++)
521  ct[0] += ct[-4];
522 
523  return 0;
524 }
525 
527  int x, int y)
528 {
530  int group = 0;
531 
532  if (gimg->size_reduction > 0) {
533  int group_x = x >> gimg->size_reduction;
534  int group_y = y >> gimg->size_reduction;
535  int g0 = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 1);
536  int g1 = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 2);
537  group = g0 << 8 | g1;
538  }
539 
540  return &img->huffman_groups[group * HUFFMAN_CODES_PER_META_CODE];
541 }
542 
544 {
545  uint32_t cache_idx = (0x1E35A7BD * c) >> (32 - img->color_cache_bits);
546  img->color_cache[cache_idx] = c;
547 }
548 
550  int w, int h)
551 {
552  ImageContext *img;
553  HuffReader *hg;
554  int i, j, ret, x, y, width;
555 
556  img = &s->image[role];
557  img->role = role;
558 
559  if (!img->frame) {
560  img->frame = av_frame_alloc();
561  if (!img->frame)
562  return AVERROR(ENOMEM);
563  }
564 
565  img->frame->format = AV_PIX_FMT_ARGB;
566  img->frame->width = w;
567  img->frame->height = h;
568 
569  if (role == IMAGE_ROLE_ARGB && !img->is_alpha_primary) {
570  ThreadFrame pt = { .f = img->frame };
571  ret = ff_thread_get_buffer(s->avctx, &pt, 0);
572  } else
573  ret = av_frame_get_buffer(img->frame, 1);
574  if (ret < 0)
575  return ret;
576 
577  if (get_bits1(&s->gb)) {
578  img->color_cache_bits = get_bits(&s->gb, 4);
579  if (img->color_cache_bits < 1 || img->color_cache_bits > 11) {
580  av_log(s->avctx, AV_LOG_ERROR, "invalid color cache bits: %d\n",
581  img->color_cache_bits);
582  return AVERROR_INVALIDDATA;
583  }
585  sizeof(*img->color_cache));
586  if (!img->color_cache)
587  return AVERROR(ENOMEM);
588  } else {
589  img->color_cache_bits = 0;
590  }
591 
592  img->nb_huffman_groups = 1;
593  if (role == IMAGE_ROLE_ARGB && get_bits1(&s->gb)) {
594  ret = decode_entropy_image(s);
595  if (ret < 0)
596  return ret;
598  }
601  sizeof(*img->huffman_groups));
602  if (!img->huffman_groups)
603  return AVERROR(ENOMEM);
604 
605  for (i = 0; i < img->nb_huffman_groups; i++) {
607  for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++) {
608  int alphabet_size = alphabet_sizes[j];
609  if (!j && img->color_cache_bits > 0)
610  alphabet_size += 1 << img->color_cache_bits;
611 
612  if (get_bits1(&s->gb)) {
613  read_huffman_code_simple(s, &hg[j]);
614  } else {
615  ret = read_huffman_code_normal(s, &hg[j], alphabet_size);
616  if (ret < 0)
617  return ret;
618  }
619  }
620  }
621 
622  width = img->frame->width;
623  if (role == IMAGE_ROLE_ARGB && s->reduced_width > 0)
624  width = s->reduced_width;
625 
626  x = 0; y = 0;
627  while (y < img->frame->height) {
628  int v;
629 
630  hg = get_huffman_group(s, img, x, y);
632  if (v < NUM_LITERAL_CODES) {
633  /* literal pixel values */
634  uint8_t *p = GET_PIXEL(img->frame, x, y);
635  p[2] = v;
636  p[1] = huff_reader_get_symbol(&hg[HUFF_IDX_RED], &s->gb);
637  p[3] = huff_reader_get_symbol(&hg[HUFF_IDX_BLUE], &s->gb);
638  p[0] = huff_reader_get_symbol(&hg[HUFF_IDX_ALPHA], &s->gb);
639  if (img->color_cache_bits)
640  color_cache_put(img, AV_RB32(p));
641  x++;
642  if (x == width) {
643  x = 0;
644  y++;
645  }
646  } else if (v < NUM_LITERAL_CODES + NUM_LENGTH_CODES) {
647  /* LZ77 backwards mapping */
648  int prefix_code, length, distance, ref_x, ref_y;
649 
650  /* parse length and distance */
651  prefix_code = v - NUM_LITERAL_CODES;
652  if (prefix_code < 4) {
653  length = prefix_code + 1;
654  } else {
655  int extra_bits = (prefix_code - 2) >> 1;
656  int offset = 2 + (prefix_code & 1) << extra_bits;
657  length = offset + get_bits(&s->gb, extra_bits) + 1;
658  }
659  prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->gb);
660  if (prefix_code > 39U) {
662  "distance prefix code too large: %d\n", prefix_code);
663  return AVERROR_INVALIDDATA;
664  }
665  if (prefix_code < 4) {
666  distance = prefix_code + 1;
667  } else {
668  int extra_bits = prefix_code - 2 >> 1;
669  int offset = 2 + (prefix_code & 1) << extra_bits;
670  distance = offset + get_bits(&s->gb, extra_bits) + 1;
671  }
672 
673  /* find reference location */
674  if (distance <= NUM_SHORT_DISTANCES) {
675  int xi = lz77_distance_offsets[distance - 1][0];
676  int yi = lz77_distance_offsets[distance - 1][1];
677  distance = FFMAX(1, xi + yi * width);
678  } else {
679  distance -= NUM_SHORT_DISTANCES;
680  }
681  ref_x = x;
682  ref_y = y;
683  if (distance <= x) {
684  ref_x -= distance;
685  distance = 0;
686  } else {
687  ref_x = 0;
688  distance -= x;
689  }
690  while (distance >= width) {
691  ref_y--;
692  distance -= width;
693  }
694  if (distance > 0) {
695  ref_x = width - distance;
696  ref_y--;
697  }
698  ref_x = FFMAX(0, ref_x);
699  ref_y = FFMAX(0, ref_y);
700 
701  /* copy pixels
702  * source and dest regions can overlap and wrap lines, so just
703  * copy per-pixel */
704  for (i = 0; i < length; i++) {
705  uint8_t *p_ref = GET_PIXEL(img->frame, ref_x, ref_y);
706  uint8_t *p = GET_PIXEL(img->frame, x, y);
707 
708  AV_COPY32(p, p_ref);
709  if (img->color_cache_bits)
710  color_cache_put(img, AV_RB32(p));
711  x++;
712  ref_x++;
713  if (x == width) {
714  x = 0;
715  y++;
716  }
717  if (ref_x == width) {
718  ref_x = 0;
719  ref_y++;
720  }
721  if (y == img->frame->height || ref_y == img->frame->height)
722  break;
723  }
724  } else {
725  /* read from color cache */
726  uint8_t *p = GET_PIXEL(img->frame, x, y);
727  int cache_idx = v - (NUM_LITERAL_CODES + NUM_LENGTH_CODES);
728 
729  if (!img->color_cache_bits) {
730  av_log(s->avctx, AV_LOG_ERROR, "color cache not found\n");
731  return AVERROR_INVALIDDATA;
732  }
733  if (cache_idx >= 1 << img->color_cache_bits) {
735  "color cache index out-of-bounds\n");
736  return AVERROR_INVALIDDATA;
737  }
738  AV_WB32(p, img->color_cache[cache_idx]);
739  x++;
740  if (x == width) {
741  x = 0;
742  y++;
743  }
744  }
745  }
746 
747  return 0;
748 }
749 
750 /* PRED_MODE_BLACK */
751 static void inv_predict_0(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
752  const uint8_t *p_t, const uint8_t *p_tr)
753 {
754  AV_WB32(p, 0xFF000000);
755 }
756 
757 /* PRED_MODE_L */
758 static void inv_predict_1(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
759  const uint8_t *p_t, const uint8_t *p_tr)
760 {
761  AV_COPY32(p, p_l);
762 }
763 
764 /* PRED_MODE_T */
765 static void inv_predict_2(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
766  const uint8_t *p_t, const uint8_t *p_tr)
767 {
768  AV_COPY32(p, p_t);
769 }
770 
771 /* PRED_MODE_TR */
772 static void inv_predict_3(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
773  const uint8_t *p_t, const uint8_t *p_tr)
774 {
775  AV_COPY32(p, p_tr);
776 }
777 
778 /* PRED_MODE_TL */
779 static void inv_predict_4(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
780  const uint8_t *p_t, const uint8_t *p_tr)
781 {
782  AV_COPY32(p, p_tl);
783 }
784 
785 /* PRED_MODE_AVG_T_AVG_L_TR */
786 static void inv_predict_5(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
787  const uint8_t *p_t, const uint8_t *p_tr)
788 {
789  p[0] = p_t[0] + (p_l[0] + p_tr[0] >> 1) >> 1;
790  p[1] = p_t[1] + (p_l[1] + p_tr[1] >> 1) >> 1;
791  p[2] = p_t[2] + (p_l[2] + p_tr[2] >> 1) >> 1;
792  p[3] = p_t[3] + (p_l[3] + p_tr[3] >> 1) >> 1;
793 }
794 
795 /* PRED_MODE_AVG_L_TL */
796 static void inv_predict_6(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
797  const uint8_t *p_t, const uint8_t *p_tr)
798 {
799  p[0] = p_l[0] + p_tl[0] >> 1;
800  p[1] = p_l[1] + p_tl[1] >> 1;
801  p[2] = p_l[2] + p_tl[2] >> 1;
802  p[3] = p_l[3] + p_tl[3] >> 1;
803 }
804 
805 /* PRED_MODE_AVG_L_T */
806 static void inv_predict_7(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
807  const uint8_t *p_t, const uint8_t *p_tr)
808 {
809  p[0] = p_l[0] + p_t[0] >> 1;
810  p[1] = p_l[1] + p_t[1] >> 1;
811  p[2] = p_l[2] + p_t[2] >> 1;
812  p[3] = p_l[3] + p_t[3] >> 1;
813 }
814 
815 /* PRED_MODE_AVG_TL_T */
816 static void inv_predict_8(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
817  const uint8_t *p_t, const uint8_t *p_tr)
818 {
819  p[0] = p_tl[0] + p_t[0] >> 1;
820  p[1] = p_tl[1] + p_t[1] >> 1;
821  p[2] = p_tl[2] + p_t[2] >> 1;
822  p[3] = p_tl[3] + p_t[3] >> 1;
823 }
824 
825 /* PRED_MODE_AVG_T_TR */
826 static void inv_predict_9(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
827  const uint8_t *p_t, const uint8_t *p_tr)
828 {
829  p[0] = p_t[0] + p_tr[0] >> 1;
830  p[1] = p_t[1] + p_tr[1] >> 1;
831  p[2] = p_t[2] + p_tr[2] >> 1;
832  p[3] = p_t[3] + p_tr[3] >> 1;
833 }
834 
835 /* PRED_MODE_AVG_AVG_L_TL_AVG_T_TR */
836 static void inv_predict_10(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
837  const uint8_t *p_t, const uint8_t *p_tr)
838 {
839  p[0] = (p_l[0] + p_tl[0] >> 1) + (p_t[0] + p_tr[0] >> 1) >> 1;
840  p[1] = (p_l[1] + p_tl[1] >> 1) + (p_t[1] + p_tr[1] >> 1) >> 1;
841  p[2] = (p_l[2] + p_tl[2] >> 1) + (p_t[2] + p_tr[2] >> 1) >> 1;
842  p[3] = (p_l[3] + p_tl[3] >> 1) + (p_t[3] + p_tr[3] >> 1) >> 1;
843 }
844 
845 /* PRED_MODE_SELECT */
846 static void inv_predict_11(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
847  const uint8_t *p_t, const uint8_t *p_tr)
848 {
849  int diff = (FFABS(p_l[0] - p_tl[0]) - FFABS(p_t[0] - p_tl[0])) +
850  (FFABS(p_l[1] - p_tl[1]) - FFABS(p_t[1] - p_tl[1])) +
851  (FFABS(p_l[2] - p_tl[2]) - FFABS(p_t[2] - p_tl[2])) +
852  (FFABS(p_l[3] - p_tl[3]) - FFABS(p_t[3] - p_tl[3]));
853  if (diff <= 0)
854  AV_COPY32(p, p_t);
855  else
856  AV_COPY32(p, p_l);
857 }
858 
859 /* PRED_MODE_ADD_SUBTRACT_FULL */
860 static void inv_predict_12(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
861  const uint8_t *p_t, const uint8_t *p_tr)
862 {
863  p[0] = av_clip_uint8(p_l[0] + p_t[0] - p_tl[0]);
864  p[1] = av_clip_uint8(p_l[1] + p_t[1] - p_tl[1]);
865  p[2] = av_clip_uint8(p_l[2] + p_t[2] - p_tl[2]);
866  p[3] = av_clip_uint8(p_l[3] + p_t[3] - p_tl[3]);
867 }
868 
870 {
871  int d = a + b >> 1;
872  return av_clip_uint8(d + (d - c) / 2);
873 }
874 
875 /* PRED_MODE_ADD_SUBTRACT_HALF */
876 static void inv_predict_13(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
877  const uint8_t *p_t, const uint8_t *p_tr)
878 {
879  p[0] = clamp_add_subtract_half(p_l[0], p_t[0], p_tl[0]);
880  p[1] = clamp_add_subtract_half(p_l[1], p_t[1], p_tl[1]);
881  p[2] = clamp_add_subtract_half(p_l[2], p_t[2], p_tl[2]);
882  p[3] = clamp_add_subtract_half(p_l[3], p_t[3], p_tl[3]);
883 }
884 
885 typedef void (*inv_predict_func)(uint8_t *p, const uint8_t *p_l,
886  const uint8_t *p_tl, const uint8_t *p_t,
887  const uint8_t *p_tr);
888 
889 static const inv_predict_func inverse_predict[14] = {
894 };
895 
896 static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
897 {
898  uint8_t *dec, *p_l, *p_tl, *p_t, *p_tr;
899  uint8_t p[4];
900 
901  dec = GET_PIXEL(frame, x, y);
902  p_l = GET_PIXEL(frame, x - 1, y);
903  p_tl = GET_PIXEL(frame, x - 1, y - 1);
904  p_t = GET_PIXEL(frame, x, y - 1);
905  if (x == frame->width - 1)
906  p_tr = GET_PIXEL(frame, 0, y);
907  else
908  p_tr = GET_PIXEL(frame, x + 1, y - 1);
909 
910  inverse_predict[m](p, p_l, p_tl, p_t, p_tr);
911 
912  dec[0] += p[0];
913  dec[1] += p[1];
914  dec[2] += p[2];
915  dec[3] += p[3];
916 }
917 
919 {
922  int x, y;
923 
924  for (y = 0; y < img->frame->height; y++) {
925  for (x = 0; x < img->frame->width; x++) {
926  int tx = x >> pimg->size_reduction;
927  int ty = y >> pimg->size_reduction;
928  enum PredictionMode m = GET_PIXEL_COMP(pimg->frame, tx, ty, 2);
929 
930  if (x == 0) {
931  if (y == 0)
932  m = PRED_MODE_BLACK;
933  else
934  m = PRED_MODE_T;
935  } else if (y == 0)
936  m = PRED_MODE_L;
937 
938  if (m > 13) {
940  "invalid predictor mode: %d\n", m);
941  return AVERROR_INVALIDDATA;
942  }
943  inverse_prediction(img->frame, m, x, y);
944  }
945  }
946  return 0;
947 }
948 
950  uint8_t color)
951 {
952  return (int)ff_u8_to_s8(color_pred) * ff_u8_to_s8(color) >> 5;
953 }
954 
956 {
957  ImageContext *img, *cimg;
958  int x, y, cx, cy;
959  uint8_t *p, *cp;
960 
961  img = &s->image[IMAGE_ROLE_ARGB];
962  cimg = &s->image[IMAGE_ROLE_COLOR_TRANSFORM];
963 
964  for (y = 0; y < img->frame->height; y++) {
965  for (x = 0; x < img->frame->width; x++) {
966  cx = x >> cimg->size_reduction;
967  cy = y >> cimg->size_reduction;
968  cp = GET_PIXEL(cimg->frame, cx, cy);
969  p = GET_PIXEL(img->frame, x, y);
970 
971  p[1] += color_transform_delta(cp[3], p[2]);
972  p[3] += color_transform_delta(cp[2], p[2]) +
973  color_transform_delta(cp[1], p[1]);
974  }
975  }
976  return 0;
977 }
978 
980 {
981  int x, y;
983 
984  for (y = 0; y < img->frame->height; y++) {
985  for (x = 0; x < img->frame->width; x++) {
986  uint8_t *p = GET_PIXEL(img->frame, x, y);
987  p[1] += p[2];
988  p[3] += p[2];
989  }
990  }
991  return 0;
992 }
993 
995 {
996  ImageContext *img;
997  ImageContext *pal;
998  int i, x, y;
999  uint8_t *p;
1000 
1001  img = &s->image[IMAGE_ROLE_ARGB];
1002  pal = &s->image[IMAGE_ROLE_COLOR_INDEXING];
1003 
1004  if (pal->size_reduction > 0) {
1005  GetBitContext gb_g;
1006  uint8_t *line;
1007  int pixel_bits = 8 >> pal->size_reduction;
1008 
1010  if (!line)
1011  return AVERROR(ENOMEM);
1012 
1013  for (y = 0; y < img->frame->height; y++) {
1014  p = GET_PIXEL(img->frame, 0, y);
1015  memcpy(line, p, img->frame->linesize[0]);
1016  init_get_bits(&gb_g, line, img->frame->linesize[0] * 8);
1017  skip_bits(&gb_g, 16);
1018  i = 0;
1019  for (x = 0; x < img->frame->width; x++) {
1020  p = GET_PIXEL(img->frame, x, y);
1021  p[2] = get_bits(&gb_g, pixel_bits);
1022  i++;
1023  if (i == 1 << pal->size_reduction) {
1024  skip_bits(&gb_g, 24);
1025  i = 0;
1026  }
1027  }
1028  }
1029  av_free(line);
1030  }
1031 
1032  // switch to local palette if it's worth initializing it
1033  if (img->frame->height * img->frame->width > 300) {
1034  uint8_t palette[256 * 4];
1035  const int size = pal->frame->width * 4;
1036  av_assert0(size <= 1024U);
1037  memcpy(palette, GET_PIXEL(pal->frame, 0, 0), size); // copy palette
1038  // set extra entries to transparent black
1039  memset(palette + size, 0, 256 * 4 - size);
1040  for (y = 0; y < img->frame->height; y++) {
1041  for (x = 0; x < img->frame->width; x++) {
1042  p = GET_PIXEL(img->frame, x, y);
1043  i = p[2];
1044  AV_COPY32(p, &palette[i * 4]);
1045  }
1046  }
1047  } else {
1048  for (y = 0; y < img->frame->height; y++) {
1049  for (x = 0; x < img->frame->width; x++) {
1050  p = GET_PIXEL(img->frame, x, y);
1051  i = p[2];
1052  if (i >= pal->frame->width) {
1053  AV_WB32(p, 0x00000000);
1054  } else {
1055  const uint8_t *pi = GET_PIXEL(pal->frame, i, 0);
1056  AV_COPY32(p, pi);
1057  }
1058  }
1059  }
1060  }
1061 
1062  return 0;
1063 }
1064 
1065 static void update_canvas_size(AVCodecContext *avctx, int w, int h)
1066 {
1067  WebPContext *s = avctx->priv_data;
1068  if (s->width && s->width != w) {
1069  av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n",
1070  s->width, w);
1071  }
1072  s->width = w;
1073  if (s->height && s->height != h) {
1074  av_log(avctx, AV_LOG_WARNING, "Height mismatch. %d != %d\n",
1075  s->height, h);
1076  }
1077  s->height = h;
1078 }
1079 
1081  int *got_frame, uint8_t *data_start,
1082  unsigned int data_size, int is_alpha_chunk)
1083 {
1084  WebPContext *s = avctx->priv_data;
1085  int w, h, ret, i, used;
1086 
1087  if (!is_alpha_chunk) {
1088  s->lossless = 1;
1089  avctx->pix_fmt = AV_PIX_FMT_ARGB;
1090  }
1091 
1092  ret = init_get_bits8(&s->gb, data_start, data_size);
1093  if (ret < 0)
1094  return ret;
1095 
1096  if (!is_alpha_chunk) {
1097  if (get_bits(&s->gb, 8) != 0x2F) {
1098  av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless signature\n");
1099  return AVERROR_INVALIDDATA;
1100  }
1101 
1102  w = get_bits(&s->gb, 14) + 1;
1103  h = get_bits(&s->gb, 14) + 1;
1104 
1105  update_canvas_size(avctx, w, h);
1106 
1107  ret = ff_set_dimensions(avctx, s->width, s->height);
1108  if (ret < 0)
1109  return ret;
1110 
1111  s->has_alpha = get_bits1(&s->gb);
1112 
1113  if (get_bits(&s->gb, 3) != 0x0) {
1114  av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless version\n");
1115  return AVERROR_INVALIDDATA;
1116  }
1117  } else {
1118  if (!s->width || !s->height)
1119  return AVERROR_BUG;
1120  w = s->width;
1121  h = s->height;
1122  }
1123 
1124  /* parse transformations */
1125  s->nb_transforms = 0;
1126  s->reduced_width = 0;
1127  used = 0;
1128  while (get_bits1(&s->gb)) {
1129  enum TransformType transform = get_bits(&s->gb, 2);
1130  if (used & (1 << transform)) {
1131  av_log(avctx, AV_LOG_ERROR, "Transform %d used more than once\n",
1132  transform);
1133  ret = AVERROR_INVALIDDATA;
1134  goto free_and_return;
1135  }
1136  used |= (1 << transform);
1137  s->transforms[s->nb_transforms++] = transform;
1138  switch (transform) {
1139  case PREDICTOR_TRANSFORM:
1140  ret = parse_transform_predictor(s);
1141  break;
1142  case COLOR_TRANSFORM:
1143  ret = parse_transform_color(s);
1144  break;
1147  break;
1148  }
1149  if (ret < 0)
1150  goto free_and_return;
1151  }
1152 
1153  /* decode primary image */
1154  s->image[IMAGE_ROLE_ARGB].frame = p;
1155  if (is_alpha_chunk)
1158  if (ret < 0)
1159  goto free_and_return;
1160 
1161  /* apply transformations */
1162  for (i = s->nb_transforms - 1; i >= 0; i--) {
1163  switch (s->transforms[i]) {
1164  case PREDICTOR_TRANSFORM:
1165  ret = apply_predictor_transform(s);
1166  break;
1167  case COLOR_TRANSFORM:
1168  ret = apply_color_transform(s);
1169  break;
1170  case SUBTRACT_GREEN:
1172  break;
1175  break;
1176  }
1177  if (ret < 0)
1178  goto free_and_return;
1179  }
1180 
1181  *got_frame = 1;
1183  p->key_frame = 1;
1184  ret = data_size;
1185 
1186 free_and_return:
1187  for (i = 0; i < IMAGE_ROLE_NB; i++)
1188  image_ctx_free(&s->image[i]);
1189 
1190  return ret;
1191 }
1192 
1194 {
1195  int x, y, ls;
1196  uint8_t *dec;
1197 
1198  ls = frame->linesize[3];
1199 
1200  /* filter first row using horizontal filter */
1201  dec = frame->data[3] + 1;
1202  for (x = 1; x < frame->width; x++, dec++)
1203  *dec += *(dec - 1);
1204 
1205  /* filter first column using vertical filter */
1206  dec = frame->data[3] + ls;
1207  for (y = 1; y < frame->height; y++, dec += ls)
1208  *dec += *(dec - ls);
1209 
1210  /* filter the rest using the specified filter */
1211  switch (m) {
1213  for (y = 1; y < frame->height; y++) {
1214  dec = frame->data[3] + y * ls + 1;
1215  for (x = 1; x < frame->width; x++, dec++)
1216  *dec += *(dec - 1);
1217  }
1218  break;
1219  case ALPHA_FILTER_VERTICAL:
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++)
1223  *dec += *(dec - ls);
1224  }
1225  break;
1226  case ALPHA_FILTER_GRADIENT:
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[0] += av_clip_uint8(*(dec - 1) + *(dec - ls) - *(dec - ls - 1));
1231  }
1232  break;
1233  }
1234 }
1235 
1237  uint8_t *data_start,
1238  unsigned int data_size)
1239 {
1240  WebPContext *s = avctx->priv_data;
1241  int x, y, ret;
1242 
1244  GetByteContext gb;
1245 
1246  bytestream2_init(&gb, data_start, data_size);
1247  for (y = 0; y < s->height; y++)
1248  bytestream2_get_buffer(&gb, p->data[3] + p->linesize[3] * y,
1249  s->width);
1250  } else if (s->alpha_compression == ALPHA_COMPRESSION_VP8L) {
1251  uint8_t *ap, *pp;
1252  int alpha_got_frame = 0;
1253 
1254  s->alpha_frame = av_frame_alloc();
1255  if (!s->alpha_frame)
1256  return AVERROR(ENOMEM);
1257 
1258  ret = vp8_lossless_decode_frame(avctx, s->alpha_frame, &alpha_got_frame,
1259  data_start, data_size, 1);
1260  if (ret < 0) {
1262  return ret;
1263  }
1264  if (!alpha_got_frame) {
1266  return AVERROR_INVALIDDATA;
1267  }
1268 
1269  /* copy green component of alpha image to alpha plane of primary image */
1270  for (y = 0; y < s->height; y++) {
1271  ap = GET_PIXEL(s->alpha_frame, 0, y) + 2;
1272  pp = p->data[3] + p->linesize[3] * y;
1273  for (x = 0; x < s->width; x++) {
1274  *pp = *ap;
1275  pp++;
1276  ap += 4;
1277  }
1278  }
1280  }
1281 
1282  /* apply alpha filtering */
1283  if (s->alpha_filter)
1285 
1286  return 0;
1287 }
1288 
1290  int *got_frame, uint8_t *data_start,
1291  unsigned int data_size)
1292 {
1293  WebPContext *s = avctx->priv_data;
1294  int ret;
1295 
1296  if (!s->initialized) {
1297  ff_vp8_decode_init(avctx);
1298  s->initialized = 1;
1299  s->v.actually_webp = 1;
1300  }
1302  s->lossless = 0;
1303 
1304  if (data_size > INT_MAX) {
1305  av_log(avctx, AV_LOG_ERROR, "unsupported chunk size\n");
1306  return AVERROR_PATCHWELCOME;
1307  }
1308 
1309  av_packet_unref(s->pkt);
1310  s->pkt->data = data_start;
1311  s->pkt->size = data_size;
1312 
1313  ret = ff_vp8_decode_frame(avctx, p, got_frame, s->pkt);
1314  if (ret < 0)
1315  return ret;
1316 
1317  if (!*got_frame)
1318  return AVERROR_INVALIDDATA;
1319 
1320  update_canvas_size(avctx, avctx->width, avctx->height);
1321 
1322  if (s->has_alpha) {
1323  ret = vp8_lossy_decode_alpha(avctx, p, s->alpha_data,
1324  s->alpha_data_size);
1325  if (ret < 0)
1326  return ret;
1327  }
1328  return ret;
1329 }
1330 
1331 static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1332  AVPacket *avpkt)
1333 {
1334  AVFrame * const p = data;
1335  WebPContext *s = avctx->priv_data;
1336  GetByteContext gb;
1337  int ret;
1338  uint32_t chunk_type, chunk_size;
1339  int vp8x_flags = 0;
1340 
1341  s->avctx = avctx;
1342  s->width = 0;
1343  s->height = 0;
1344  *got_frame = 0;
1345  s->has_alpha = 0;
1346  s->has_exif = 0;
1347  s->has_iccp = 0;
1348  bytestream2_init(&gb, avpkt->data, avpkt->size);
1349 
1350  if (bytestream2_get_bytes_left(&gb) < 12)
1351  return AVERROR_INVALIDDATA;
1352 
1353  if (bytestream2_get_le32(&gb) != MKTAG('R', 'I', 'F', 'F')) {
1354  av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n");
1355  return AVERROR_INVALIDDATA;
1356  }
1357 
1358  chunk_size = bytestream2_get_le32(&gb);
1359  if (bytestream2_get_bytes_left(&gb) < chunk_size)
1360  return AVERROR_INVALIDDATA;
1361 
1362  if (bytestream2_get_le32(&gb) != MKTAG('W', 'E', 'B', 'P')) {
1363  av_log(avctx, AV_LOG_ERROR, "missing WEBP tag\n");
1364  return AVERROR_INVALIDDATA;
1365  }
1366 
1367  while (bytestream2_get_bytes_left(&gb) > 8) {
1368  char chunk_str[5] = { 0 };
1369 
1370  chunk_type = bytestream2_get_le32(&gb);
1371  chunk_size = bytestream2_get_le32(&gb);
1372  if (chunk_size == UINT32_MAX)
1373  return AVERROR_INVALIDDATA;
1374  chunk_size += chunk_size & 1;
1375 
1376  if (bytestream2_get_bytes_left(&gb) < chunk_size) {
1377  /* we seem to be running out of data, but it could also be that the
1378  bitstream has trailing junk leading to bogus chunk_size. */
1379  break;
1380  }
1381 
1382  switch (chunk_type) {
1383  case MKTAG('V', 'P', '8', ' '):
1384  if (!*got_frame) {
1385  ret = vp8_lossy_decode_frame(avctx, p, got_frame,
1386  avpkt->data + bytestream2_tell(&gb),
1387  chunk_size);
1388  if (ret < 0)
1389  return ret;
1390  }
1391  bytestream2_skip(&gb, chunk_size);
1392  break;
1393  case MKTAG('V', 'P', '8', 'L'):
1394  if (!*got_frame) {
1395  ret = vp8_lossless_decode_frame(avctx, p, got_frame,
1396  avpkt->data + bytestream2_tell(&gb),
1397  chunk_size, 0);
1398  if (ret < 0)
1399  return ret;
1401  }
1402  bytestream2_skip(&gb, chunk_size);
1403  break;
1404  case MKTAG('V', 'P', '8', 'X'):
1405  if (s->width || s->height || *got_frame) {
1406  av_log(avctx, AV_LOG_ERROR, "Canvas dimensions are already set\n");
1407  return AVERROR_INVALIDDATA;
1408  }
1409  vp8x_flags = bytestream2_get_byte(&gb);
1410  bytestream2_skip(&gb, 3);
1411  s->width = bytestream2_get_le24(&gb) + 1;
1412  s->height = bytestream2_get_le24(&gb) + 1;
1413  ret = av_image_check_size(s->width, s->height, 0, avctx);
1414  if (ret < 0)
1415  return ret;
1416  break;
1417  case MKTAG('A', 'L', 'P', 'H'): {
1418  int alpha_header, filter_m, compression;
1419 
1420  if (!(vp8x_flags & VP8X_FLAG_ALPHA)) {
1421  av_log(avctx, AV_LOG_WARNING,
1422  "ALPHA chunk present, but alpha bit not set in the "
1423  "VP8X header\n");
1424  }
1425  if (chunk_size == 0) {
1426  av_log(avctx, AV_LOG_ERROR, "invalid ALPHA chunk size\n");
1427  return AVERROR_INVALIDDATA;
1428  }
1429  alpha_header = bytestream2_get_byte(&gb);
1430  s->alpha_data = avpkt->data + bytestream2_tell(&gb);
1431  s->alpha_data_size = chunk_size - 1;
1433 
1434  filter_m = (alpha_header >> 2) & 0x03;
1435  compression = alpha_header & 0x03;
1436 
1437  if (compression > ALPHA_COMPRESSION_VP8L) {
1438  av_log(avctx, AV_LOG_VERBOSE,
1439  "skipping unsupported ALPHA chunk\n");
1440  } else {
1441  s->has_alpha = 1;
1442  s->alpha_compression = compression;
1443  s->alpha_filter = filter_m;
1444  }
1445 
1446  break;
1447  }
1448  case MKTAG('E', 'X', 'I', 'F'): {
1449  int le, ifd_offset, exif_offset = bytestream2_tell(&gb);
1450  AVDictionary *exif_metadata = NULL;
1451  GetByteContext exif_gb;
1452 
1453  if (s->has_exif) {
1454  av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra EXIF chunk\n");
1455  goto exif_end;
1456  }
1457  if (!(vp8x_flags & VP8X_FLAG_EXIF_METADATA))
1458  av_log(avctx, AV_LOG_WARNING,
1459  "EXIF chunk present, but Exif bit not set in the "
1460  "VP8X header\n");
1461 
1462  s->has_exif = 1;
1463  bytestream2_init(&exif_gb, avpkt->data + exif_offset,
1464  avpkt->size - exif_offset);
1465  if (ff_tdecode_header(&exif_gb, &le, &ifd_offset) < 0) {
1466  av_log(avctx, AV_LOG_ERROR, "invalid TIFF header "
1467  "in Exif data\n");
1468  goto exif_end;
1469  }
1470 
1471  bytestream2_seek(&exif_gb, ifd_offset, SEEK_SET);
1472  if (ff_exif_decode_ifd(avctx, &exif_gb, le, 0, &exif_metadata) < 0) {
1473  av_log(avctx, AV_LOG_ERROR, "error decoding Exif data\n");
1474  goto exif_end;
1475  }
1476 
1477  av_dict_copy(&((AVFrame *) data)->metadata, exif_metadata, 0);
1478 
1479 exif_end:
1480  av_dict_free(&exif_metadata);
1481  bytestream2_skip(&gb, chunk_size);
1482  break;
1483  }
1484  case MKTAG('I', 'C', 'C', 'P'): {
1485  AVFrameSideData *sd;
1486 
1487  if (s->has_iccp) {
1488  av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra ICCP chunk\n");
1489  bytestream2_skip(&gb, chunk_size);
1490  break;
1491  }
1492  if (!(vp8x_flags & VP8X_FLAG_ICC))
1493  av_log(avctx, AV_LOG_WARNING,
1494  "ICCP chunk present, but ICC Profile bit not set in the "
1495  "VP8X header\n");
1496 
1497  s->has_iccp = 1;
1499  if (!sd)
1500  return AVERROR(ENOMEM);
1501 
1502  bytestream2_get_buffer(&gb, sd->data, chunk_size);
1503  break;
1504  }
1505  case MKTAG('A', 'N', 'I', 'M'):
1506  case MKTAG('A', 'N', 'M', 'F'):
1507  case MKTAG('X', 'M', 'P', ' '):
1508  AV_WL32(chunk_str, chunk_type);
1509  av_log(avctx, AV_LOG_WARNING, "skipping unsupported chunk: %s\n",
1510  chunk_str);
1511  bytestream2_skip(&gb, chunk_size);
1512  break;
1513  default:
1514  AV_WL32(chunk_str, chunk_type);
1515  av_log(avctx, AV_LOG_VERBOSE, "skipping unknown chunk: %s\n",
1516  chunk_str);
1517  bytestream2_skip(&gb, chunk_size);
1518  break;
1519  }
1520  }
1521 
1522  if (!*got_frame) {
1523  av_log(avctx, AV_LOG_ERROR, "image data not found\n");
1524  return AVERROR_INVALIDDATA;
1525  }
1526 
1527  return avpkt->size;
1528 }
1529 
1531 {
1532  WebPContext *s = avctx->priv_data;
1533 
1534  s->pkt = av_packet_alloc();
1535  if (!s->pkt)
1536  return AVERROR(ENOMEM);
1537 
1538  return 0;
1539 }
1540 
1542 {
1543  WebPContext *s = avctx->priv_data;
1544 
1545  av_packet_free(&s->pkt);
1546 
1547  if (s->initialized)
1548  return ff_vp8_decode_free(avctx);
1549 
1550  return 0;
1551 }
1552 
1554  .name = "webp",
1555  .long_name = NULL_IF_CONFIG_SMALL("WebP image"),
1556  .type = AVMEDIA_TYPE_VIDEO,
1557  .id = AV_CODEC_ID_WEBP,
1558  .priv_data_size = sizeof(WebPContext),
1561  .close = webp_decode_close,
1562  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1563 };
int nb_huffman_groups
Definition: webp.c:182
#define extra_bits(eb)
Definition: intrax8.c:125
static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, int alphabet_size)
Definition: webp.c:324
enum ImageRole role
Definition: webp.c:178
#define NULL
Definition: coverity.c:32
HuffReader * huffman_groups
Definition: webp.c:183
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int ff_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le, int depth, AVDictionary **metadata)
Definition: exif.c:115
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
TransformType
Definition: webp.c:110
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)
Definition: webp.c:836
ImageRole
Definition: webp.c:148
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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.
Definition: utils.c:84
int initialized
Definition: webp.c:194
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static int parse_transform_color_indexing(WebPContext *s)
Definition: webp.c:491
static HuffReader * get_huffman_group(WebPContext *s, ImageContext *img, int x, int y)
Definition: webp.c:526
HuffmanIndex
Definition: webp.c:134
static const uint8_t code_length_code_order[NUM_CODE_LENGTH_CODES]
Definition: webp.c:76
int size
Definition: packet.h:370
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)
Definition: webp.c:885
#define VP8X_FLAG_EXIF_METADATA
Definition: webp.c:56
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)
Definition: webp.c:846
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
Definition: undefined.txt:36
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb)
Definition: webp.c:236
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
GetBitContext gb
Definition: webp.c:190
static int8_t ff_u8_to_s8(uint8_t a)
Definition: mathops.h:233
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static const inv_predict_func inverse_predict[14]
Definition: webp.c:889
static int apply_color_indexing_transform(WebPContext *s)
Definition: webp.c:994
AVCodec.
Definition: codec.h:197
EXIF metadata parser.
#define AV_COPY32(d, s)
Definition: intreadwrite.h:601
AVPacket * pkt
Definition: webp.c:192
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AlphaCompression
Definition: webp.c:98
static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
Definition: webp.c:869
enum TransformType transforms[4]
Definition: webp.c:207
uint16_t simple_symbols[2]
Definition: webp.c:174
int height
Definition: webp.c:203
static int vp8_lossy_decode_alpha(AVCodecContext *avctx, AVFrame *p, uint8_t *data_start, unsigned int data_size)
Definition: webp.c:1236
#define NUM_LITERAL_CODES
Definition: webp.c:64
#define img
static av_always_inline void color_cache_put(ImageContext *img, uint32_t c)
Definition: webp.c:543
enum AlphaFilter alpha_filter
Definition: webp.c:197
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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)
Definition: webp.c:826
uint8_t * alpha_data
Definition: webp.c:198
#define NUM_CODE_LENGTH_CODES
Definition: webp.c:62
int reduced_width
Definition: webp.c:208
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
int nb_huffman_groups
Definition: webp.c:209
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:191
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
int nb_symbols
Definition: webp.c:173
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
Definition: undefined.txt:32
Multithreading support functions.
int ff_vp8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vp8.c:2810
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:2184
int simple
Definition: webp.c:172
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)
Definition: webp.c:860
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
Definition: bytestream.h:91
Structure to hold side data for an AVFrame.
Definition: frame.h:220
#define NUM_SHORT_DISTANCES
Definition: webp.c:67
int pt
Definition: rtp.c:35
static void finish(void)
Definition: movenc.c:342
uint8_t * data
Definition: packet.h:369
#define VP8X_FLAG_ICC
Definition: webp.c:58
bitstream reader API header.
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
static int decode_entropy_image(WebPContext *s)
Definition: webp.c:425
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
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)
Definition: webp.c:758
#define U(x)
Definition: vp56_arith.h:37
static int apply_color_transform(WebPContext *s)
Definition: webp.c:955
#define VP8X_FLAG_ALPHA
Definition: webp.c:57
int width
Definition: frame.h:376
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: webp.c:1331
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)
Definition: webp.c:796
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
const char * r
Definition: vf_curves.c:116
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: codec.h:204
uint8_t bits
Definition: vp3data.h:141
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)
Definition: webp.c:772
int has_exif
Definition: webp.c:200
VP8Context v
Definition: webp.c:189
static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, uint8_t *data_start, unsigned int data_size)
Definition: webp.c:1289
#define FFMAX(a, b)
Definition: common.h:103
static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, uint8_t *data_start, unsigned int data_size, int is_alpha_chunk)
Definition: webp.c:1080
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
enum AlphaCompression alpha_compression
Definition: webp.c:196
static void image_ctx_free(ImageContext *img)
Definition: webp.c:219
Definition: vlc.h:26
static float distance(float x, float y, int band)
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 int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths, int alphabet_size)
Definition: webp.c:247
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...
Definition: imgutils.c:317
#define b
Definition: input.c:41
#define PARSE_BLOCK_SIZE(w, h)
Definition: webp.c:419
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
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)
Definition: webp.c:765
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int has_iccp
Definition: webp.c:201
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:404
#define width
int width
picture width / height.
Definition: avcodec.h:709
uint8_t w
Definition: llviddspenc.c:39
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
uint32_t * color_cache
Definition: webp.c:181
AlphaFilter
Definition: webp.c:103
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
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
AVFrame * frame
Definition: webp.c:179
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:143
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
int has_alpha
Definition: webp.c:195
PredictionMode
Definition: webp.c:117
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:391
static const int8_t transform[32][32]
Definition: hevcdsp.c:27
int alpha_data_size
Definition: webp.c:199
Libavcodec external API header.
static av_cold int webp_decode_init(AVCodecContext *avctx)
Definition: webp.c:1530
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:536
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
uint8_t * data
Definition: frame.h:222
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
static av_always_inline uint8_t color_transform_delta(uint8_t color_pred, uint8_t color)
Definition: webp.c:949
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, buffer_size_t size)
Add a new side data to a frame.
Definition: frame.c:727
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
AVCodec ff_webp_decoder
Definition: webp.c:1553
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)
Definition: webp.c:779
static const struct @72 transforms[18]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
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)
Definition: webp.c:751
#define MAX_HUFFMAN_CODE_LENGTH
Definition: webp.c:68
int size_reduction
Definition: webp.c:184
int actually_webp
Definition: vp8.h:152
static const uint16_t alphabet_sizes[HUFFMAN_CODES_PER_META_CODE]
Definition: webp.c:70
#define HUFFMAN_CODES_PER_META_CODE
Definition: webp.c:63
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:338
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 void read_huffman_code_simple(WebPContext *s, HuffReader *hc)
Definition: webp.c:309
av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
Definition: vp8.c:2894
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
Definition: vp8.c:2824
static int parse_transform_predictor(WebPContext *s)
Definition: webp.c:459
#define GET_PIXEL(frame, x, y)
Definition: webp.c:213
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
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
Definition: swscale.txt:33
static av_cold int webp_decode_close(AVCodecContext *avctx)
Definition: webp.c:1541
int nb_transforms
Definition: webp.c:206
common internal api header.
static int apply_subtract_green_transform(WebPContext *s)
Definition: webp.c:979
int is_alpha_primary
Definition: webp.c:185
#define GET_PIXEL_COMP(frame, x, y, c)
Definition: webp.c:216
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)
Definition: webp.c:816
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2183
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
void * priv_data
Definition: avcodec.h:563
static const int8_t lz77_distance_offsets[NUM_SHORT_DISTANCES][2]
Definition: webp.c:80
ImageContext image[IMAGE_ROLE_NB]
Definition: webp.c:210
int width
Definition: webp.c:202
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static int apply_predictor_transform(WebPContext *s)
Definition: webp.c:918
#define av_free(p)
#define av_clip_uint8
Definition: common.h:128
VLC vlc
Definition: webp.c:171
int len
int color_cache_bits
Definition: webp.c:180
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
static int parse_transform_color(WebPContext *s)
Definition: webp.c:475
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
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)
Definition: webp.c:806
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, int w, int h)
Definition: webp.c:549
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)
Definition: webp.c:876
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 ...
Definition: tiff_common.c:261
AVCodecContext * avctx
Definition: webp.c:193
int height
Definition: frame.h:376
static void alpha_inverse_prediction(AVFrame *frame, enum AlphaFilter m)
Definition: webp.c:1193
#define av_always_inline
Definition: attributes.h:45
static const uint8_t block_bits[]
Definition: imm4.c:103
#define av_malloc_array(a, b)
int lossless
Definition: webp.c:204
static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
Definition: webp.c:896
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 MKTAG(a, b, c, d)
Definition: common.h:478
This structure stores compressed data.
Definition: packet.h:346
AVFrame * alpha_frame
Definition: webp.c:191
static void update_canvas_size(AVCodecContext *avctx, int w, int h)
Definition: webp.c:1065
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
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)
Definition: webp.c:786
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
#define NUM_LENGTH_CODES
Definition: webp.c:65
int i
Definition: input.c:407
#define NUM_DISTANCE_CODES
Definition: webp.c:66
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
#define INIT_VLC_OUTPUT_LE
Definition: vlc.h:93