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);
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) {
397  av_log(s->avctx, AV_LOG_ERROR,
398  "invalid symbol %d + repeat %d > alphabet size %d\n",
399  symbol, repeat, alphabet_size);
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 
470  s->image[IMAGE_ROLE_PREDICTOR].size_reduction = block_bits;
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 
486  s->image[IMAGE_ROLE_COLOR_TRANSFORM].size_reduction = block_bits;
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 {
529  ImageContext *gimg = &s->image[IMAGE_ROLE_ENTROPY];
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  }
584  img->color_cache = av_mallocz_array(1 << img->color_cache_bits,
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)) {
595  if (ret < 0)
596  return ret;
597  img->nb_huffman_groups = s->nb_huffman_groups;
598  }
599  img->huffman_groups = av_mallocz_array(img->nb_huffman_groups *
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++) {
606  hg = &img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE];
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);
631  v = huff_reader_get_symbol(&hg[HUFF_IDX_GREEN], &s->gb);
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)
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) {
661  av_log(s->avctx, AV_LOG_ERROR,
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 {
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)
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) {
734  av_log(s->avctx, AV_LOG_ERROR,
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 
869 static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
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 {
920  ImageContext *img = &s->image[IMAGE_ROLE_ARGB];
921  ImageContext *pimg = &s->image[IMAGE_ROLE_PREDICTOR];
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) {
939  av_log(s->avctx, AV_LOG_ERROR,
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 
949 static av_always_inline uint8_t color_transform_delta(uint8_t color_pred,
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;
982  ImageContext *img = &s->image[IMAGE_ROLE_ARGB];
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 
1009  line = av_malloc(img->frame->linesize[0] + AV_INPUT_BUFFER_PADDING_SIZE);
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);
1134  goto free_and_return;
1135  }
1136  used |= (1 << transform);
1137  s->transforms[s->nb_transforms++] = transform;
1138  switch (transform) {
1139  case PREDICTOR_TRANSFORM:
1141  break;
1142  case COLOR_TRANSFORM:
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)
1156  s->image[IMAGE_ROLE_ARGB].is_alpha_primary = 1;
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:
1166  break;
1167  case COLOR_TRANSFORM:
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 
1243  if (s->alpha_compression == ALPHA_COMPRESSION_NONE) {
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) {
1261  av_frame_free(&s->alpha_frame);
1262  return ret;
1263  }
1264  if (!alpha_got_frame) {
1265  av_frame_free(&s->alpha_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  }
1279  av_frame_free(&s->alpha_frame);
1280  }
1281 
1282  /* apply alpha filtering */
1283  if (s->alpha_filter)
1284  alpha_inverse_prediction(p, 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  }
1301  avctx->pix_fmt = s->has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
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;
1432  bytestream2_skip(&gb, s->alpha_data_size);
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  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1564 };
WebPContext::width
int width
Definition: webp.c:202
WebPContext::alpha_frame
AVFrame * alpha_frame
Definition: webp.c:191
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:403
AVCodec
AVCodec.
Definition: codec.h:197
ff_vp8_decode_free
av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
Definition: vp8.c:2824
HuffReader::vlc
VLC vlc
Definition: webp.c:171
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:187
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
inv_predict_12
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
extra_bits
#define extra_bits(eb)
Definition: intrax8.c:125
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
r
const char * r
Definition: vf_curves.c:116
AVERROR
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
NUM_SHORT_DISTANCES
#define NUM_SHORT_DISTANCES
Definition: webp.c:67
vp8_lossy_decode_alpha
static int vp8_lossy_decode_alpha(AVCodecContext *avctx, AVFrame *p, uint8_t *data_start, unsigned int data_size)
Definition: webp.c:1236
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
vp8_lossy_decode_frame
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
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:245
vp8_lossless_decode_frame
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
INIT_VLC_OUTPUT_LE
#define INIT_VLC_OUTPUT_LE
Definition: vlc.h:93
color
Definition: vf_paletteuse.c:583
PRED_MODE_AVG_T_AVG_L_TR
@ PRED_MODE_AVG_T_AVG_L_TR
Definition: webp.c:123
ALPHA_FILTER_HORIZONTAL
@ ALPHA_FILTER_HORIZONTAL
Definition: webp.c:105
HuffReader::simple_symbols
uint16_t simple_symbols[2]
Definition: webp.c:174
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:604
GetByteContext
Definition: bytestream.h:33
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
ff_u8_to_s8
static int8_t ff_u8_to_s8(uint8_t a)
Definition: mathops.h:233
block_bits
static const uint8_t block_bits[]
Definition: imm4.c:103
PRED_MODE_BLACK
@ PRED_MODE_BLACK
Definition: webp.c:118
inv_predict_4
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
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
inv_predict_2
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
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AVFrame::width
int width
Definition: frame.h:361
w
uint8_t w
Definition: llviddspenc.c:39
GET_PIXEL_COMP
#define GET_PIXEL_COMP(frame, x, y, c)
Definition: webp.c:216
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
PRED_MODE_ADD_SUBTRACT_FULL
@ PRED_MODE_ADD_SUBTRACT_FULL
Definition: webp.c:130
COLOR_INDEXING_TRANSFORM
@ COLOR_INDEXING_TRANSFORM
Definition: webp.c:114
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:142
SUBTRACT_GREEN
@ SUBTRACT_GREEN
Definition: webp.c:113
ImageContext::nb_huffman_groups
int nb_huffman_groups
Definition: webp.c:182
parse_transform_color
static int parse_transform_color(WebPContext *s)
Definition: webp.c:475
PRED_MODE_AVG_TL_T
@ PRED_MODE_AVG_TL_T
Definition: webp.c:126
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:197
get_vlc2
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:798
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:197
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVDictionary
Definition: dict.c:30
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
thread.h
huff_reader_build_canonical
static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths, int alphabet_size)
Definition: webp.c:247
WebPContext::transforms
enum TransformType transforms[4]
Definition: webp.c:207
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:70
PRED_MODE_TR
@ PRED_MODE_TR
Definition: webp.c:121
PRED_MODE_AVG_L_T
@ PRED_MODE_AVG_L_T
Definition: webp.c:125
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
HuffReader::simple
int simple
Definition: webp.c:172
PRED_MODE_TL
@ PRED_MODE_TL
Definition: webp.c:122
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
WebPContext::alpha_compression
enum AlphaCompression alpha_compression
Definition: webp.c:196
inv_predict_10
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
webp_decode_frame
static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: webp.c:1331
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
inv_predict_8
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
WebPContext::avctx
AVCodecContext * avctx
Definition: webp.c:193
finish
static void finish(void)
Definition: movenc.c:342
U
#define U(x)
Definition: vp56_arith.h:37
ALPHA_COMPRESSION_NONE
@ ALPHA_COMPRESSION_NONE
Definition: webp.c:99
WebPContext::nb_transforms
int nb_transforms
Definition: webp.c:206
GetBitContext
Definition: get_bits.h:62
ff_thread_get_buffer
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
update_canvas_size
static void update_canvas_size(AVCodecContext *avctx, int w, int h)
Definition: webp.c:1065
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:381
WebPContext::alpha_data_size
int alpha_data_size
Definition: webp.c:199
inv_predict_func
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
COLOR_TRANSFORM
@ COLOR_TRANSFORM
Definition: webp.c:112
VP8X_FLAG_EXIF_METADATA
#define VP8X_FLAG_EXIF_METADATA
Definition: webp.c:56
inv_predict_3
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
color_transform_delta
static av_always_inline uint8_t color_transform_delta(uint8_t color_pred, uint8_t color)
Definition: webp.c:949
decode_entropy_coded_image
static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, int w, int h)
Definition: webp.c:549
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:98
HUFF_IDX_GREEN
@ HUFF_IDX_GREEN
Definition: webp.c:135
WebPContext::has_exif
int has_exif
Definition: webp.c:200
read_huffman_code_normal
static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, int alphabet_size)
Definition: webp.c:324
WebPContext::has_alpha
int has_alpha
Definition: webp.c:195
ff_exif_decode_ifd
int ff_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le, int depth, AVDictionary **metadata)
Definition: exif.c:115
PredictionMode
PredictionMode
Definition: webp.c:117
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
av_cold
#define av_cold
Definition: attributes.h:90
ImageContext::frame
AVFrame * frame
Definition: webp.c:179
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:1812
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
inverse_prediction
static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
Definition: webp.c:896
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
TransformType
TransformType
Definition: webp.c:110
PRED_MODE_AVG_T_TR
@ PRED_MODE_AVG_T_TR
Definition: webp.c:127
HUFFMAN_CODES_PER_META_CODE
#define HUFFMAN_CODES_PER_META_CODE
Definition: webp.c:63
code_length_code_order
static const uint8_t code_length_code_order[NUM_CODE_LENGTH_CODES]
Definition: webp.c:76
color_cache_put
static av_always_inline void color_cache_put(ImageContext *img, uint32_t c)
Definition: webp.c:543
bits
uint8_t bits
Definition: vp3data.h:141
NUM_DISTANCE_CODES
#define NUM_DISTANCE_CODES
Definition: webp.c:66
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
inv_predict_11
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
NUM_CODE_LENGTH_CODES
#define NUM_CODE_LENGTH_CODES
Definition: webp.c:62
ImageContext
Definition: webp.c:177
get_bits.h
xi
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:404
ImageContext::color_cache
uint32_t * color_cache
Definition: webp.c:181
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:420
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
GET_PIXEL
#define GET_PIXEL(frame, x, y)
Definition: webp.c:213
ImageContext::is_alpha_primary
int is_alpha_primary
Definition: webp.c:185
PRED_MODE_AVG_L_TL
@ PRED_MODE_AVG_L_TL
Definition: webp.c:124
webp_decode_close
static av_cold int webp_decode_close(AVCodecContext *avctx)
Definition: webp.c:1541
ImageContext::huffman_groups
HuffReader * huffman_groups
Definition: webp.c:183
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
apply_subtract_green_transform
static int apply_subtract_green_transform(WebPContext *s)
Definition: webp.c:979
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
HuffReader::nb_symbols
int nb_symbols
Definition: webp.c:173
WebPContext::height
int height
Definition: webp.c:203
ALPHA_FILTER_NONE
@ ALPHA_FILTER_NONE
Definition: webp.c:104
clamp_add_subtract_half
static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
Definition: webp.c:869
WebPContext::alpha_data
uint8_t * alpha_data
Definition: webp.c:198
HUFF_IDX_DIST
@ HUFF_IDX_DIST
Definition: webp.c:139
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
inverse_predict
static const inv_predict_func inverse_predict[14]
Definition: webp.c:889
transform
static const int8_t transform[32][32]
Definition: hevcdsp.c:27
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
ImageContext::color_cache_bits
int color_cache_bits
Definition: webp.c:180
parse_transform_color_indexing
static int parse_transform_color_indexing(WebPContext *s)
Definition: webp.c:491
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:143
webp_decode_init
static av_cold int webp_decode_init(AVCodecContext *avctx)
Definition: webp.c:1530
WebPContext::v
VP8Context v
Definition: webp.c:189
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
alphabet_sizes
static const uint16_t alphabet_sizes[HUFFMAN_CODES_PER_META_CODE]
Definition: webp.c:70
NUM_LITERAL_CODES
#define NUM_LITERAL_CODES
Definition: webp.c:64
IMAGE_ROLE_PREDICTOR
@ IMAGE_ROLE_PREDICTOR
Definition: webp.c:158
ff_vp8_decode_frame
int ff_vp8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vp8.c:2810
c
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
vp8.h
ff_vp8_decode_init
av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
Definition: vp8.c:2894
alpha_inverse_prediction
static void alpha_inverse_prediction(AVFrame *frame, enum AlphaFilter m)
Definition: webp.c:1193
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
IMAGE_ROLE_COLOR_INDEXING
@ IMAGE_ROLE_COLOR_INDEXING
Definition: webp.c:165
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:386
inv_predict_0
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
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
IMAGE_ROLE_NB
@ IMAGE_ROLE_NB
Definition: webp.c:167
VP8X_FLAG_ICC
#define VP8X_FLAG_ICC
Definition: webp.c:58
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AlphaCompression
AlphaCompression
Definition: webp.c:98
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
PREDICTOR_TRANSFORM
@ PREDICTOR_TRANSFORM
Definition: webp.c:111
ImageContext::size_reduction
int size_reduction
Definition: webp.c:184
size
int size
Definition: twinvq_data.h:10344
AV_RB32
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:96
AVFrameSideData::data
uint8_t * data
Definition: frame.h:211
ImageContext::role
enum ImageRole role
Definition: webp.c:178
decode_entropy_image
static int decode_entropy_image(WebPContext *s)
Definition: webp.c:425
apply_color_transform
static int apply_color_transform(WebPContext *s)
Definition: webp.c:955
VP8X_FLAG_ALPHA
#define VP8X_FLAG_ALPHA
Definition: webp.c:57
a
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:41
img
#define img
Definition: vf_colormatrix.c:116
pt
int pt
Definition: rtp.c:35
offset
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
Definition: writing_filters.txt:86
line
Definition: graph2dot.c:48
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:59
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
HuffReader
Definition: webp.c:170
parse_transform_predictor
static int parse_transform_predictor(WebPContext *s)
Definition: webp.c:459
PRED_MODE_AVG_AVG_L_TL_AVG_T_TR
@ PRED_MODE_AVG_AVG_L_TL_AVG_T_TR
Definition: webp.c:128
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
ALPHA_FILTER_GRADIENT
@ ALPHA_FILTER_GRADIENT
Definition: webp.c:107
WebPContext::nb_huffman_groups
int nb_huffman_groups
Definition: webp.c:209
inv_predict_5
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
WebPContext::lossless
int lossless
Definition: webp.c:204
i
int i
Definition: input.c:407
WebPContext::reduced_width
int reduced_width
Definition: webp.c:208
NUM_LENGTH_CODES
#define NUM_LENGTH_CODES
Definition: webp.c:65
code
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
Definition: filter_design.txt:178
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1811
WebPContext::pkt
AVPacket * pkt
Definition: webp.c:192
AlphaFilter
AlphaFilter
Definition: webp.c:103
PRED_MODE_SELECT
@ PRED_MODE_SELECT
Definition: webp.c:129
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
lz77_distance_offsets
static const int8_t lz77_distance_offsets[NUM_SHORT_DISTANCES][2]
Definition: webp.c:80
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
WebPContext::gb
GetBitContext gb
Definition: webp.c:190
apply_predictor_transform
static int apply_predictor_transform(WebPContext *s)
Definition: webp.c:918
av_always_inline
#define av_always_inline
Definition: attributes.h:49
HuffmanIndex
HuffmanIndex
Definition: webp.c:134
AV_COPY32
#define AV_COPY32(d, s)
Definition: intreadwrite.h:601
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:244
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AV_CODEC_ID_WEBP
@ AV_CODEC_ID_WEBP
Definition: codec_id.h:222
len
int len
Definition: vorbis_enc_data.h:426
exif.h
AVCodecContext::height
int height
Definition: avcodec.h:557
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:594
inv_predict_7
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
huff_reader_get_symbol
static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb)
Definition: webp.c:236
avcodec.h
inv_predict_13
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
ret
ret
Definition: filter_design.txt:187
WebPContext::image
ImageContext image[IMAGE_ROLE_NB]
Definition: webp.c:210
frame
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
Definition: filter_design.txt:264
inv_predict_6
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
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:384
ThreadFrame
Definition: thread.h:34
HUFF_IDX_BLUE
@ HUFF_IDX_BLUE
Definition: webp.c:137
IMAGE_ROLE_ENTROPY
@ IMAGE_ROLE_ENTROPY
Definition: webp.c:154
VLC
Definition: vlc.h:26
ff_tdecode_header
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
image_ctx_free
static void image_ctx_free(ImageContext *img)
Definition: webp.c:219
av_clip_uint8
#define av_clip_uint8
Definition: common.h:128
WebPContext::initialized
int initialized
Definition: webp.c:194
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
apply_color_indexing_transform
static int apply_color_indexing_transform(WebPContext *s)
Definition: webp.c:994
ff_set_dimensions
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:86
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:209
MAX_HUFFMAN_CODE_LENGTH
#define MAX_HUFFMAN_CODE_LENGTH
Definition: webp.c:68
ALPHA_FILTER_VERTICAL
@ ALPHA_FILTER_VERTICAL
Definition: webp.c:106
PARSE_BLOCK_SIZE
#define PARSE_BLOCK_SIZE(w, h)
Definition: webp.c:419
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
PRED_MODE_L
@ PRED_MODE_L
Definition: webp.c:119
WebPContext
Definition: webp.c:188
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
AVPacket
This structure stores compressed data.
Definition: packet.h:342
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
VP8Context
Definition: vp8.h:148
d
d
Definition: ffmpeg_filter.c:156
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:557
ImageRole
ImageRole
Definition: webp.c:148
bytestream.h
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:233
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
read_huffman_code_simple
static void read_huffman_code_simple(WebPContext *s, HuffReader *hc)
Definition: webp.c:309
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_webp_decoder
const AVCodec ff_webp_decoder
Definition: webp.c:1553
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
HUFF_IDX_ALPHA
@ HUFF_IDX_ALPHA
Definition: webp.c:138
h
h
Definition: vp9dsp_template.c:2038
av_image_check_size
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:318
WebPContext::has_iccp
int has_iccp
Definition: webp.c:201
get_huffman_group
static HuffReader * get_huffman_group(WebPContext *s, ImageContext *img, int x, int y)
Definition: webp.c:526
inv_predict_9
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
ALPHA_COMPRESSION_VP8L
@ ALPHA_COMPRESSION_VP8L
Definition: webp.c:100
inv_predict_1
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
PRED_MODE_T
@ PRED_MODE_T
Definition: webp.c:120
line
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:40
WebPContext::alpha_filter
enum AlphaFilter alpha_filter
Definition: webp.c:197
HUFF_IDX_RED
@ HUFF_IDX_RED
Definition: webp.c:136
IMAGE_ROLE_ARGB
@ IMAGE_ROLE_ARGB
Definition: webp.c:150
PRED_MODE_ADD_SUBTRACT_HALF
@ PRED_MODE_ADD_SUBTRACT_HALF
Definition: webp.c:131
IMAGE_ROLE_COLOR_TRANSFORM
@ IMAGE_ROLE_COLOR_TRANSFORM
Definition: webp.c:162