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 #include "libavutil/mem.h"
45 
46 #define BITSTREAM_READER_LE
47 #include "avcodec.h"
48 #include "bytestream.h"
49 #include "codec_internal.h"
50 #include "decode.h"
51 #include "exif.h"
52 #include "get_bits.h"
53 #include "thread.h"
54 #include "tiff_common.h"
55 #include "vp8.h"
56 
57 #define VP8X_FLAG_ANIMATION 0x02
58 #define VP8X_FLAG_XMP_METADATA 0x04
59 #define VP8X_FLAG_EXIF_METADATA 0x08
60 #define VP8X_FLAG_ALPHA 0x10
61 #define VP8X_FLAG_ICC 0x20
62 
63 #define MAX_PALETTE_SIZE 256
64 #define MAX_CACHE_BITS 11
65 #define NUM_CODE_LENGTH_CODES 19
66 #define HUFFMAN_CODES_PER_META_CODE 5
67 #define NUM_LITERAL_CODES 256
68 #define NUM_LENGTH_CODES 24
69 #define NUM_DISTANCE_CODES 40
70 #define NUM_SHORT_DISTANCES 120
71 #define MAX_HUFFMAN_CODE_LENGTH 15
72 
73 static const uint16_t alphabet_sizes[HUFFMAN_CODES_PER_META_CODE] = {
77 };
78 
80  17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
81 };
82 
83 static const int8_t lz77_distance_offsets[NUM_SHORT_DISTANCES][2] = {
84  { 0, 1 }, { 1, 0 }, { 1, 1 }, { -1, 1 }, { 0, 2 }, { 2, 0 }, { 1, 2 }, { -1, 2 },
85  { 2, 1 }, { -2, 1 }, { 2, 2 }, { -2, 2 }, { 0, 3 }, { 3, 0 }, { 1, 3 }, { -1, 3 },
86  { 3, 1 }, { -3, 1 }, { 2, 3 }, { -2, 3 }, { 3, 2 }, { -3, 2 }, { 0, 4 }, { 4, 0 },
87  { 1, 4 }, { -1, 4 }, { 4, 1 }, { -4, 1 }, { 3, 3 }, { -3, 3 }, { 2, 4 }, { -2, 4 },
88  { 4, 2 }, { -4, 2 }, { 0, 5 }, { 3, 4 }, { -3, 4 }, { 4, 3 }, { -4, 3 }, { 5, 0 },
89  { 1, 5 }, { -1, 5 }, { 5, 1 }, { -5, 1 }, { 2, 5 }, { -2, 5 }, { 5, 2 }, { -5, 2 },
90  { 4, 4 }, { -4, 4 }, { 3, 5 }, { -3, 5 }, { 5, 3 }, { -5, 3 }, { 0, 6 }, { 6, 0 },
91  { 1, 6 }, { -1, 6 }, { 6, 1 }, { -6, 1 }, { 2, 6 }, { -2, 6 }, { 6, 2 }, { -6, 2 },
92  { 4, 5 }, { -4, 5 }, { 5, 4 }, { -5, 4 }, { 3, 6 }, { -3, 6 }, { 6, 3 }, { -6, 3 },
93  { 0, 7 }, { 7, 0 }, { 1, 7 }, { -1, 7 }, { 5, 5 }, { -5, 5 }, { 7, 1 }, { -7, 1 },
94  { 4, 6 }, { -4, 6 }, { 6, 4 }, { -6, 4 }, { 2, 7 }, { -2, 7 }, { 7, 2 }, { -7, 2 },
95  { 3, 7 }, { -3, 7 }, { 7, 3 }, { -7, 3 }, { 5, 6 }, { -5, 6 }, { 6, 5 }, { -6, 5 },
96  { 8, 0 }, { 4, 7 }, { -4, 7 }, { 7, 4 }, { -7, 4 }, { 8, 1 }, { 8, 2 }, { 6, 6 },
97  { -6, 6 }, { 8, 3 }, { 5, 7 }, { -5, 7 }, { 7, 5 }, { -7, 5 }, { 8, 4 }, { 6, 7 },
98  { -6, 7 }, { 7, 6 }, { -7, 6 }, { 8, 5 }, { 7, 7 }, { -7, 7 }, { 8, 6 }, { 8, 7 }
99 };
100 
104 };
105 
111 };
112 
118 };
119 
135 };
136 
143 };
144 
145 /* The structure of WebP lossless is an optional series of transformation data,
146  * followed by the primary image. The primary image also optionally contains
147  * an entropy group mapping if there are multiple entropy groups. There is a
148  * basic image type called an "entropy coded image" that is used for all of
149  * these. The type of each entropy coded image is referred to by the
150  * specification as its role. */
151 enum ImageRole {
152  /* Primary Image: Stores the actual pixels of the image. */
154 
155  /* Entropy Image: Defines which Huffman group to use for different areas of
156  * the primary image. */
158 
159  /* Predictors: Defines which predictor type to use for different areas of
160  * the primary image. */
162 
163  /* Color Transform Data: Defines the color transformation for different
164  * areas of the primary image. */
166 
167  /* Color Index: Stored as an image of height == 1. */
169 
171 };
172 
173 typedef struct HuffReader {
174  VLC vlc; /* Huffman decoder context */
175  int simple; /* whether to use simple mode */
176  int nb_symbols; /* number of coded symbols */
177  uint16_t simple_symbols[2]; /* symbols for simple mode */
178 } HuffReader;
179 
180 typedef struct ImageContext {
181  enum ImageRole role; /* role of this image */
182  AVFrame *frame; /* AVFrame for data */
183  int color_cache_bits; /* color cache size, log2 */
184  uint32_t *color_cache; /* color cache data */
185  int nb_huffman_groups; /* number of huffman groups */
186  HuffReader *huffman_groups; /* reader for each huffman group */
187  /* relative size compared to primary image, log2.
188  * for IMAGE_ROLE_COLOR_INDEXING with <= 16 colors, this is log2 of the
189  * number of pixels per byte in the primary image (pixel packing) */
192 } ImageContext;
193 
194 typedef struct WebPContext {
195  VP8Context v; /* VP8 Context used for lossy decoding */
196  GetBitContext gb; /* bitstream reader for main image chunk */
197  AVFrame *alpha_frame; /* AVFrame for alpha data decompressed from VP8L */
198  AVPacket *pkt; /* AVPacket to be passed to the underlying VP8 decoder */
199  AVCodecContext *avctx; /* parent AVCodecContext */
200  int initialized; /* set once the VP8 context is initialized */
201  int has_alpha; /* has a separate alpha chunk */
202  enum AlphaCompression alpha_compression; /* compression type for alpha chunk */
203  enum AlphaFilter alpha_filter; /* filtering method for alpha chunk */
204  const uint8_t *alpha_data; /* alpha chunk data */
205  int alpha_data_size; /* alpha chunk data size */
206  int has_exif; /* set after an EXIF chunk has been processed */
207  int has_iccp; /* set after an ICCP chunk has been processed */
208  int width; /* image width */
209  int height; /* image height */
210  int lossless; /* indicates lossless or lossy */
211 
212  int nb_transforms; /* number of transforms */
213  enum TransformType transforms[4]; /* transformations used in the image, in order */
214  /* reduced width when using a color indexing transform with <= 16 colors (pixel packing)
215  * before pixels are unpacked, or same as width otherwise. */
217  int nb_huffman_groups; /* number of huffman groups in the primary image */
218  ImageContext image[IMAGE_ROLE_NB]; /* image context for each role */
219 } WebPContext;
220 
221 #define GET_PIXEL(frame, x, y) \
222  ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x))
223 
224 #define GET_PIXEL_COMP(frame, x, y, c) \
225  (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c))
226 
228 {
229  int i, j;
230 
231  av_free(img->color_cache);
232  if (img->role != IMAGE_ROLE_ARGB && !img->is_alpha_primary)
233  av_frame_free(&img->frame);
234  if (img->huffman_groups) {
235  for (i = 0; i < img->nb_huffman_groups; i++) {
236  for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++)
237  ff_vlc_free(&img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE + j].vlc);
238  }
239  av_free(img->huffman_groups);
240  }
241  memset(img, 0, sizeof(*img));
242 }
243 
245 {
246  if (r->simple) {
247  if (r->nb_symbols == 1)
248  return r->simple_symbols[0];
249  else
250  return r->simple_symbols[get_bits1(gb)];
251  } else
252  return get_vlc2(gb, r->vlc.table, 8, 2);
253 }
254 
255 static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths,
256  uint16_t len_counts[MAX_HUFFMAN_CODE_LENGTH + 1],
257  uint8_t lens[], uint16_t syms[],
258  int alphabet_size, void *logctx)
259 {
260  unsigned nb_codes = 0;
261  int ret;
262 
263  // Count the number of symbols of each length and transform len_counts
264  // into an array of offsets.
265  for (int len = 1; len <= MAX_HUFFMAN_CODE_LENGTH; ++len) {
266  unsigned cnt = len_counts[len];
267  len_counts[len] = nb_codes;
268  nb_codes += cnt;
269  }
270 
271  for (int sym = 0; sym < alphabet_size; ++sym) {
272  if (code_lengths[sym]) {
273  unsigned idx = len_counts[code_lengths[sym]]++;
274  syms[idx] = sym;
275  lens[idx] = code_lengths[sym];
276  }
277  }
278  if (nb_codes <= 1) {
279  if (nb_codes == 1) {
280  /* special-case 1 symbol since the vlc reader cannot handle it */
281  r->nb_symbols = 1;
282  r->simple = 1;
283  r->simple_symbols[0] = syms[0];
284  }
285  // No symbols
286  return AVERROR_INVALIDDATA;
287  }
288  ret = ff_vlc_init_from_lengths(&r->vlc, 8, nb_codes, lens, 1,
289  syms, 2, 2, 0, VLC_INIT_OUTPUT_LE, logctx);
290  if (ret < 0)
291  return ret;
292  r->simple = 0;
293 
294  return 0;
295 }
296 
298 {
299  hc->nb_symbols = get_bits1(&s->gb) + 1;
300 
301  if (get_bits1(&s->gb))
302  hc->simple_symbols[0] = get_bits(&s->gb, 8);
303  else
304  hc->simple_symbols[0] = get_bits1(&s->gb);
305 
306  if (hc->nb_symbols == 2)
307  hc->simple_symbols[1] = get_bits(&s->gb, 8);
308 
309  hc->simple = 1;
310 }
311 
313  int alphabet_size)
314 {
315  HuffReader code_len_hc = { { 0 }, 0, 0, { 0 } };
316  uint8_t *code_lengths;
317  uint8_t code_length_code_lengths[NUM_CODE_LENGTH_CODES] = { 0 };
318  uint8_t reordered_code_length_code_lengths[NUM_CODE_LENGTH_CODES];
319  uint16_t reordered_code_length_syms[NUM_CODE_LENGTH_CODES];
320  uint16_t len_counts[MAX_HUFFMAN_CODE_LENGTH + 1] = { 0 };
321  int symbol, max_symbol, prev_code_len, ret;
322  int num_codes = 4 + get_bits(&s->gb, 4);
323 
324  av_assert1(num_codes <= NUM_CODE_LENGTH_CODES);
325 
326  for (int i = 0; i < num_codes; i++) {
327  unsigned len = get_bits(&s->gb, 3);
328  code_length_code_lengths[code_length_code_order[i]] = len;
329  len_counts[len]++;
330  }
331 
332  if (get_bits1(&s->gb)) {
333  int bits = 2 + 2 * get_bits(&s->gb, 3);
334  max_symbol = 2 + get_bits(&s->gb, bits);
335  if (max_symbol > alphabet_size) {
336  av_log(s->avctx, AV_LOG_ERROR, "max symbol %d > alphabet size %d\n",
337  max_symbol, alphabet_size);
338  return AVERROR_INVALIDDATA;
339  }
340  } else {
341  max_symbol = alphabet_size;
342  }
343 
344  ret = huff_reader_build_canonical(&code_len_hc, code_length_code_lengths, len_counts,
345  reordered_code_length_code_lengths,
346  reordered_code_length_syms,
347  NUM_CODE_LENGTH_CODES, s->avctx);
348  if (ret < 0)
349  return ret;
350 
351  code_lengths = av_malloc_array(alphabet_size, 2 * sizeof(uint8_t) + sizeof(uint16_t));
352  if (!code_lengths) {
353  ret = AVERROR(ENOMEM);
354  goto finish;
355  }
356 
357  prev_code_len = 8;
358  symbol = 0;
359  memset(len_counts, 0, sizeof(len_counts));
360  while (symbol < alphabet_size) {
361  int code_len;
362 
363  if (!max_symbol--)
364  break;
365  code_len = huff_reader_get_symbol(&code_len_hc, &s->gb);
366  if (code_len < 16U) {
367  /* Code length code [0..15] indicates literal code lengths. */
368  code_lengths[symbol++] = code_len;
369  len_counts[code_len]++;
370  if (code_len)
371  prev_code_len = code_len;
372  } else {
373  int repeat = 0, length = 0;
374  switch (code_len) {
375  default:
377  goto finish;
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  len_counts[length] += repeat;
385  break;
386  case 17:
387  /* Code 17 emits a streak of zeros [3..10], i.e.,
388  * 3 + ReadBits(3) times. */
389  repeat = 3 + get_bits(&s->gb, 3);
390  break;
391  case 18:
392  /* Code 18 emits a streak of zeros of length [11..138], i.e.,
393  * 11 + ReadBits(7) times. */
394  repeat = 11 + get_bits(&s->gb, 7);
395  break;
396  }
397  if (symbol + repeat > alphabet_size) {
398  av_log(s->avctx, AV_LOG_ERROR,
399  "invalid symbol %d + repeat %d > alphabet size %d\n",
400  symbol, repeat, alphabet_size);
402  goto finish;
403  }
404  while (repeat-- > 0)
405  code_lengths[symbol++] = length;
406  }
407  }
408 
409  ret = huff_reader_build_canonical(hc, code_lengths, len_counts,
410  code_lengths + symbol,
411  (uint16_t*)(code_lengths + 2 * symbol),
412  symbol, s->avctx);
413 
414 finish:
415  ff_vlc_free(&code_len_hc.vlc);
416  av_free(code_lengths);
417  return ret;
418 }
419 
420 static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role,
421  int w, int h);
422 
423 #define PARSE_BLOCK_SIZE(w, h) do { \
424  block_bits = get_bits(&s->gb, 3) + 2; \
425  blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \
426  blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \
427 } while (0)
428 
430 {
431  ImageContext *img;
432  int ret, block_bits, blocks_w, blocks_h, x, y, max;
433 
434  PARSE_BLOCK_SIZE(s->reduced_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->reduced_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->reduced_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  ret = ff_thread_get_buffer(s->avctx, img->frame, 0);
571  } else
572  ret = av_frame_get_buffer(img->frame, 1);
573  if (ret < 0)
574  return ret;
575 
576  if (get_bits1(&s->gb)) {
577  img->color_cache_bits = get_bits(&s->gb, 4);
578  if (img->color_cache_bits < 1 || img->color_cache_bits > 11) {
579  av_log(s->avctx, AV_LOG_ERROR, "invalid color cache bits: %d\n",
580  img->color_cache_bits);
581  return AVERROR_INVALIDDATA;
582  }
583  img->color_cache = av_calloc(1 << img->color_cache_bits,
584  sizeof(*img->color_cache));
585  if (!img->color_cache)
586  return AVERROR(ENOMEM);
587  } else {
588  img->color_cache_bits = 0;
589  }
590 
591  img->nb_huffman_groups = 1;
592  if (role == IMAGE_ROLE_ARGB && get_bits1(&s->gb)) {
594  if (ret < 0)
595  return ret;
596  img->nb_huffman_groups = s->nb_huffman_groups;
597  }
598  img->huffman_groups = av_calloc(img->nb_huffman_groups,
600  sizeof(*img->huffman_groups));
601  if (!img->huffman_groups)
602  return AVERROR(ENOMEM);
603 
604  for (i = 0; i < img->nb_huffman_groups; i++) {
605  hg = &img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE];
606  for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++) {
607  int alphabet_size = alphabet_sizes[j];
608  if (!j && img->color_cache_bits > 0)
609  alphabet_size += 1 << img->color_cache_bits;
610 
611  if (get_bits1(&s->gb)) {
612  read_huffman_code_simple(s, &hg[j]);
613  } else {
614  ret = read_huffman_code_normal(s, &hg[j], alphabet_size);
615  if (ret < 0)
616  return ret;
617  }
618  }
619  }
620 
621  width = img->frame->width;
622  if (role == IMAGE_ROLE_ARGB)
623  width = s->reduced_width;
624 
625  x = 0; y = 0;
626  while (y < img->frame->height) {
627  int v;
628 
629  if (get_bits_left(&s->gb) < 0)
630  return AVERROR_INVALIDDATA;
631 
632  hg = get_huffman_group(s, img, x, y);
633  v = huff_reader_get_symbol(&hg[HUFF_IDX_GREEN], &s->gb);
634  if (v < NUM_LITERAL_CODES) {
635  /* literal pixel values */
636  uint8_t *p = GET_PIXEL(img->frame, x, y);
637  p[2] = v;
638  p[1] = huff_reader_get_symbol(&hg[HUFF_IDX_RED], &s->gb);
639  p[3] = huff_reader_get_symbol(&hg[HUFF_IDX_BLUE], &s->gb);
640  p[0] = huff_reader_get_symbol(&hg[HUFF_IDX_ALPHA], &s->gb);
641  if (img->color_cache_bits)
643  x++;
644  if (x == width) {
645  x = 0;
646  y++;
647  }
648  } else if (v < NUM_LITERAL_CODES + NUM_LENGTH_CODES) {
649  /* LZ77 backwards mapping */
650  int prefix_code, length, distance, ref_x, ref_y;
651 
652  /* parse length and distance */
653  prefix_code = v - NUM_LITERAL_CODES;
654  if (prefix_code < 4) {
655  length = prefix_code + 1;
656  } else {
657  int extra_bits = (prefix_code - 2) >> 1;
658  int offset = 2 + (prefix_code & 1) << extra_bits;
659  length = offset + get_bits(&s->gb, extra_bits) + 1;
660  }
661  prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->gb);
662  if (prefix_code > 39U) {
663  av_log(s->avctx, AV_LOG_ERROR,
664  "distance prefix code too large: %d\n", prefix_code);
665  return AVERROR_INVALIDDATA;
666  }
667  if (prefix_code < 4) {
668  distance = prefix_code + 1;
669  } else {
670  int extra_bits = prefix_code - 2 >> 1;
671  int offset = 2 + (prefix_code & 1) << extra_bits;
672  distance = offset + get_bits(&s->gb, extra_bits) + 1;
673  }
674 
675  /* find reference location */
676  if (distance <= NUM_SHORT_DISTANCES) {
677  int xi = lz77_distance_offsets[distance - 1][0];
678  int yi = lz77_distance_offsets[distance - 1][1];
679  distance = FFMAX(1, xi + yi * width);
680  } else {
682  }
683  ref_x = x;
684  ref_y = y;
685  if (distance <= x) {
686  ref_x -= distance;
687  distance = 0;
688  } else {
689  ref_x = 0;
690  distance -= x;
691  }
692  while (distance >= width) {
693  ref_y--;
694  distance -= width;
695  }
696  if (distance > 0) {
697  ref_x = width - distance;
698  ref_y--;
699  }
700  ref_x = FFMAX(0, ref_x);
701  ref_y = FFMAX(0, ref_y);
702 
703  if (ref_y == y && ref_x >= x)
704  return AVERROR_INVALIDDATA;
705 
706  /* copy pixels
707  * source and dest regions can overlap and wrap lines, so just
708  * copy per-pixel */
709  for (i = 0; i < length; i++) {
710  uint8_t *p_ref = GET_PIXEL(img->frame, ref_x, ref_y);
711  uint8_t *p = GET_PIXEL(img->frame, x, y);
712 
713  AV_COPY32(p, p_ref);
714  if (img->color_cache_bits)
716  x++;
717  ref_x++;
718  if (x == width) {
719  x = 0;
720  y++;
721  }
722  if (ref_x == width) {
723  ref_x = 0;
724  ref_y++;
725  }
726  if (y == img->frame->height || ref_y == img->frame->height)
727  break;
728  }
729  } else {
730  /* read from color cache */
731  uint8_t *p = GET_PIXEL(img->frame, x, y);
732  int cache_idx = v - (NUM_LITERAL_CODES + NUM_LENGTH_CODES);
733 
734  if (!img->color_cache_bits) {
735  av_log(s->avctx, AV_LOG_ERROR, "color cache not found\n");
736  return AVERROR_INVALIDDATA;
737  }
738  if (cache_idx >= 1 << img->color_cache_bits) {
739  av_log(s->avctx, AV_LOG_ERROR,
740  "color cache index out-of-bounds\n");
741  return AVERROR_INVALIDDATA;
742  }
743  AV_WB32(p, img->color_cache[cache_idx]);
744  x++;
745  if (x == width) {
746  x = 0;
747  y++;
748  }
749  }
750  }
751 
752  return 0;
753 }
754 
755 /* PRED_MODE_BLACK */
756 static void inv_predict_0(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
757  const uint8_t *p_t, const uint8_t *p_tr)
758 {
759  AV_WB32(p, 0xFF000000);
760 }
761 
762 /* PRED_MODE_L */
763 static void inv_predict_1(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
764  const uint8_t *p_t, const uint8_t *p_tr)
765 {
766  AV_COPY32(p, p_l);
767 }
768 
769 /* PRED_MODE_T */
770 static void inv_predict_2(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
771  const uint8_t *p_t, const uint8_t *p_tr)
772 {
773  AV_COPY32(p, p_t);
774 }
775 
776 /* PRED_MODE_TR */
777 static void inv_predict_3(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
778  const uint8_t *p_t, const uint8_t *p_tr)
779 {
780  AV_COPY32(p, p_tr);
781 }
782 
783 /* PRED_MODE_TL */
784 static void inv_predict_4(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
785  const uint8_t *p_t, const uint8_t *p_tr)
786 {
787  AV_COPY32(p, p_tl);
788 }
789 
790 /* PRED_MODE_AVG_T_AVG_L_TR */
791 static void inv_predict_5(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
792  const uint8_t *p_t, const uint8_t *p_tr)
793 {
794  p[0] = p_t[0] + (p_l[0] + p_tr[0] >> 1) >> 1;
795  p[1] = p_t[1] + (p_l[1] + p_tr[1] >> 1) >> 1;
796  p[2] = p_t[2] + (p_l[2] + p_tr[2] >> 1) >> 1;
797  p[3] = p_t[3] + (p_l[3] + p_tr[3] >> 1) >> 1;
798 }
799 
800 /* PRED_MODE_AVG_L_TL */
801 static void inv_predict_6(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
802  const uint8_t *p_t, const uint8_t *p_tr)
803 {
804  p[0] = p_l[0] + p_tl[0] >> 1;
805  p[1] = p_l[1] + p_tl[1] >> 1;
806  p[2] = p_l[2] + p_tl[2] >> 1;
807  p[3] = p_l[3] + p_tl[3] >> 1;
808 }
809 
810 /* PRED_MODE_AVG_L_T */
811 static void inv_predict_7(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
812  const uint8_t *p_t, const uint8_t *p_tr)
813 {
814  p[0] = p_l[0] + p_t[0] >> 1;
815  p[1] = p_l[1] + p_t[1] >> 1;
816  p[2] = p_l[2] + p_t[2] >> 1;
817  p[3] = p_l[3] + p_t[3] >> 1;
818 }
819 
820 /* PRED_MODE_AVG_TL_T */
821 static void inv_predict_8(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
822  const uint8_t *p_t, const uint8_t *p_tr)
823 {
824  p[0] = p_tl[0] + p_t[0] >> 1;
825  p[1] = p_tl[1] + p_t[1] >> 1;
826  p[2] = p_tl[2] + p_t[2] >> 1;
827  p[3] = p_tl[3] + p_t[3] >> 1;
828 }
829 
830 /* PRED_MODE_AVG_T_TR */
831 static void inv_predict_9(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
832  const uint8_t *p_t, const uint8_t *p_tr)
833 {
834  p[0] = p_t[0] + p_tr[0] >> 1;
835  p[1] = p_t[1] + p_tr[1] >> 1;
836  p[2] = p_t[2] + p_tr[2] >> 1;
837  p[3] = p_t[3] + p_tr[3] >> 1;
838 }
839 
840 /* PRED_MODE_AVG_AVG_L_TL_AVG_T_TR */
841 static void inv_predict_10(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
842  const uint8_t *p_t, const uint8_t *p_tr)
843 {
844  p[0] = (p_l[0] + p_tl[0] >> 1) + (p_t[0] + p_tr[0] >> 1) >> 1;
845  p[1] = (p_l[1] + p_tl[1] >> 1) + (p_t[1] + p_tr[1] >> 1) >> 1;
846  p[2] = (p_l[2] + p_tl[2] >> 1) + (p_t[2] + p_tr[2] >> 1) >> 1;
847  p[3] = (p_l[3] + p_tl[3] >> 1) + (p_t[3] + p_tr[3] >> 1) >> 1;
848 }
849 
850 /* PRED_MODE_SELECT */
851 static void inv_predict_11(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
852  const uint8_t *p_t, const uint8_t *p_tr)
853 {
854  int diff = (FFABS(p_l[0] - p_tl[0]) - FFABS(p_t[0] - p_tl[0])) +
855  (FFABS(p_l[1] - p_tl[1]) - FFABS(p_t[1] - p_tl[1])) +
856  (FFABS(p_l[2] - p_tl[2]) - FFABS(p_t[2] - p_tl[2])) +
857  (FFABS(p_l[3] - p_tl[3]) - FFABS(p_t[3] - p_tl[3]));
858  if (diff <= 0)
859  AV_COPY32(p, p_t);
860  else
861  AV_COPY32(p, p_l);
862 }
863 
864 /* PRED_MODE_ADD_SUBTRACT_FULL */
865 static void inv_predict_12(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
866  const uint8_t *p_t, const uint8_t *p_tr)
867 {
868  p[0] = av_clip_uint8(p_l[0] + p_t[0] - p_tl[0]);
869  p[1] = av_clip_uint8(p_l[1] + p_t[1] - p_tl[1]);
870  p[2] = av_clip_uint8(p_l[2] + p_t[2] - p_tl[2]);
871  p[3] = av_clip_uint8(p_l[3] + p_t[3] - p_tl[3]);
872 }
873 
874 static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
875 {
876  int d = a + b >> 1;
877  return av_clip_uint8(d + (d - c) / 2);
878 }
879 
880 /* PRED_MODE_ADD_SUBTRACT_HALF */
881 static void inv_predict_13(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
882  const uint8_t *p_t, const uint8_t *p_tr)
883 {
884  p[0] = clamp_add_subtract_half(p_l[0], p_t[0], p_tl[0]);
885  p[1] = clamp_add_subtract_half(p_l[1], p_t[1], p_tl[1]);
886  p[2] = clamp_add_subtract_half(p_l[2], p_t[2], p_tl[2]);
887  p[3] = clamp_add_subtract_half(p_l[3], p_t[3], p_tl[3]);
888 }
889 
890 typedef void (*inv_predict_func)(uint8_t *p, const uint8_t *p_l,
891  const uint8_t *p_tl, const uint8_t *p_t,
892  const uint8_t *p_tr);
893 
894 static const inv_predict_func inverse_predict[14] = {
899 };
900 
901 static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
902 {
903  uint8_t *dec, *p_l, *p_tl, *p_t, *p_tr;
904  uint8_t p[4];
905 
906  dec = GET_PIXEL(frame, x, y);
907  p_l = GET_PIXEL(frame, x - 1, y);
908  p_tl = GET_PIXEL(frame, x - 1, y - 1);
909  p_t = GET_PIXEL(frame, x, y - 1);
910  if (x == frame->width - 1)
911  p_tr = GET_PIXEL(frame, 0, y);
912  else
913  p_tr = GET_PIXEL(frame, x + 1, y - 1);
914 
915  inverse_predict[m](p, p_l, p_tl, p_t, p_tr);
916 
917  dec[0] += p[0];
918  dec[1] += p[1];
919  dec[2] += p[2];
920  dec[3] += p[3];
921 }
922 
924 {
925  ImageContext *img = &s->image[IMAGE_ROLE_ARGB];
926  ImageContext *pimg = &s->image[IMAGE_ROLE_PREDICTOR];
927  int x, y;
928 
929  for (y = 0; y < img->frame->height; y++) {
930  for (x = 0; x < s->reduced_width; x++) {
931  int tx = x >> pimg->size_reduction;
932  int ty = y >> pimg->size_reduction;
933  enum PredictionMode m = GET_PIXEL_COMP(pimg->frame, tx, ty, 2);
934 
935  if (x == 0) {
936  if (y == 0)
937  m = PRED_MODE_BLACK;
938  else
939  m = PRED_MODE_T;
940  } else if (y == 0)
941  m = PRED_MODE_L;
942 
943  if (m > 13) {
944  av_log(s->avctx, AV_LOG_ERROR,
945  "invalid predictor mode: %d\n", m);
946  return AVERROR_INVALIDDATA;
947  }
948  inverse_prediction(img->frame, m, x, y);
949  }
950  }
951  return 0;
952 }
953 
954 static av_always_inline uint8_t color_transform_delta(uint8_t color_pred,
955  uint8_t color)
956 {
957  return (int)ff_u8_to_s8(color_pred) * ff_u8_to_s8(color) >> 5;
958 }
959 
961 {
962  ImageContext *img, *cimg;
963  int x, y, cx, cy;
964  uint8_t *p, *cp;
965 
966  img = &s->image[IMAGE_ROLE_ARGB];
967  cimg = &s->image[IMAGE_ROLE_COLOR_TRANSFORM];
968 
969  for (y = 0; y < img->frame->height; y++) {
970  for (x = 0; x < s->reduced_width; x++) {
971  cx = x >> cimg->size_reduction;
972  cy = y >> cimg->size_reduction;
973  cp = GET_PIXEL(cimg->frame, cx, cy);
974  p = GET_PIXEL(img->frame, x, y);
975 
976  p[1] += color_transform_delta(cp[3], p[2]);
977  p[3] += color_transform_delta(cp[2], p[2]) +
978  color_transform_delta(cp[1], p[1]);
979  }
980  }
981  return 0;
982 }
983 
985 {
986  int x, y;
987  ImageContext *img = &s->image[IMAGE_ROLE_ARGB];
988 
989  for (y = 0; y < img->frame->height; y++) {
990  for (x = 0; x < s->reduced_width; x++) {
991  uint8_t *p = GET_PIXEL(img->frame, x, y);
992  p[1] += p[2];
993  p[3] += p[2];
994  }
995  }
996  return 0;
997 }
998 
1000 {
1001  ImageContext *img;
1002  ImageContext *pal;
1003  int i, x, y;
1004  uint8_t *p;
1005 
1006  img = &s->image[IMAGE_ROLE_ARGB];
1007  pal = &s->image[IMAGE_ROLE_COLOR_INDEXING];
1008 
1009  if (pal->size_reduction > 0) { // undo pixel packing
1010  GetBitContext gb_g;
1011  uint8_t *line;
1012  int pixel_bits = 8 >> pal->size_reduction;
1013 
1014  line = av_malloc(img->frame->linesize[0] + AV_INPUT_BUFFER_PADDING_SIZE);
1015  if (!line)
1016  return AVERROR(ENOMEM);
1017 
1018  for (y = 0; y < img->frame->height; y++) {
1019  p = GET_PIXEL(img->frame, 0, y);
1020  memcpy(line, p, img->frame->linesize[0]);
1021  init_get_bits(&gb_g, line, img->frame->linesize[0] * 8);
1022  skip_bits(&gb_g, 16);
1023  i = 0;
1024  for (x = 0; x < img->frame->width; x++) {
1025  p = GET_PIXEL(img->frame, x, y);
1026  p[2] = get_bits(&gb_g, pixel_bits);
1027  i++;
1028  if (i == 1 << pal->size_reduction) {
1029  skip_bits(&gb_g, 24);
1030  i = 0;
1031  }
1032  }
1033  }
1034  av_free(line);
1035  s->reduced_width = s->width; // we are back to full size
1036  }
1037 
1038  // switch to local palette if it's worth initializing it
1039  if (img->frame->height * img->frame->width > 300) {
1040  uint8_t palette[256 * 4];
1041  const int size = pal->frame->width * 4;
1042  av_assert0(size <= 1024U);
1043  memcpy(palette, GET_PIXEL(pal->frame, 0, 0), size); // copy palette
1044  // set extra entries to transparent black
1045  memset(palette + size, 0, 256 * 4 - size);
1046  for (y = 0; y < img->frame->height; y++) {
1047  for (x = 0; x < img->frame->width; x++) {
1048  p = GET_PIXEL(img->frame, x, y);
1049  i = p[2];
1050  AV_COPY32(p, &palette[i * 4]);
1051  }
1052  }
1053  } else {
1054  for (y = 0; y < img->frame->height; y++) {
1055  for (x = 0; x < img->frame->width; x++) {
1056  p = GET_PIXEL(img->frame, x, y);
1057  i = p[2];
1058  if (i >= pal->frame->width) {
1059  AV_WB32(p, 0x00000000);
1060  } else {
1061  const uint8_t *pi = GET_PIXEL(pal->frame, i, 0);
1062  AV_COPY32(p, pi);
1063  }
1064  }
1065  }
1066  }
1067 
1068  return 0;
1069 }
1070 
1071 static void update_canvas_size(AVCodecContext *avctx, int w, int h)
1072 {
1073  WebPContext *s = avctx->priv_data;
1074  if (s->width && s->width != w) {
1075  av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n",
1076  s->width, w);
1077  }
1078  s->width = w;
1079  if (s->height && s->height != h) {
1080  av_log(avctx, AV_LOG_WARNING, "Height mismatch. %d != %d\n",
1081  s->height, h);
1082  }
1083  s->height = h;
1084 }
1085 
1087  int *got_frame, const uint8_t *data_start,
1088  unsigned int data_size, int is_alpha_chunk)
1089 {
1090  WebPContext *s = avctx->priv_data;
1091  int w, h, ret, i, used;
1092 
1093  if (!is_alpha_chunk) {
1094  s->lossless = 1;
1095  avctx->pix_fmt = AV_PIX_FMT_ARGB;
1096  }
1097 
1098  ret = init_get_bits8(&s->gb, data_start, data_size);
1099  if (ret < 0)
1100  return ret;
1101 
1102  if (!is_alpha_chunk) {
1103  if (get_bits(&s->gb, 8) != 0x2F) {
1104  av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless signature\n");
1105  return AVERROR_INVALIDDATA;
1106  }
1107 
1108  w = get_bits(&s->gb, 14) + 1;
1109  h = get_bits(&s->gb, 14) + 1;
1110 
1111  update_canvas_size(avctx, w, h);
1112 
1113  ret = ff_set_dimensions(avctx, s->width, s->height);
1114  if (ret < 0)
1115  return ret;
1116 
1117  s->has_alpha = get_bits1(&s->gb);
1118 
1119  if (get_bits(&s->gb, 3) != 0x0) {
1120  av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless version\n");
1121  return AVERROR_INVALIDDATA;
1122  }
1123  } else {
1124  if (!s->width || !s->height)
1125  return AVERROR_BUG;
1126  w = s->width;
1127  h = s->height;
1128  }
1129 
1130  /* parse transformations */
1131  s->nb_transforms = 0;
1132  s->reduced_width = s->width;
1133  used = 0;
1134  while (get_bits1(&s->gb)) {
1135  enum TransformType transform = get_bits(&s->gb, 2);
1136  if (used & (1 << transform)) {
1137  av_log(avctx, AV_LOG_ERROR, "Transform %d used more than once\n",
1138  transform);
1140  goto free_and_return;
1141  }
1142  used |= (1 << transform);
1143  s->transforms[s->nb_transforms++] = transform;
1144  switch (transform) {
1145  case PREDICTOR_TRANSFORM:
1147  break;
1148  case COLOR_TRANSFORM:
1150  break;
1153  break;
1154  }
1155  if (ret < 0)
1156  goto free_and_return;
1157  }
1158 
1159  /* decode primary image */
1160  s->image[IMAGE_ROLE_ARGB].frame = p;
1161  if (is_alpha_chunk)
1162  s->image[IMAGE_ROLE_ARGB].is_alpha_primary = 1;
1164  if (ret < 0)
1165  goto free_and_return;
1166 
1167  /* apply transformations */
1168  for (i = s->nb_transforms - 1; i >= 0; i--) {
1169  switch (s->transforms[i]) {
1170  case PREDICTOR_TRANSFORM:
1172  break;
1173  case COLOR_TRANSFORM:
1175  break;
1176  case SUBTRACT_GREEN:
1178  break;
1181  break;
1182  }
1183  if (ret < 0)
1184  goto free_and_return;
1185  }
1186 
1187  *got_frame = 1;
1189  p->flags |= AV_FRAME_FLAG_KEY;
1191  ret = data_size;
1192 
1193 free_and_return:
1194  for (i = 0; i < IMAGE_ROLE_NB; i++)
1195  image_ctx_free(&s->image[i]);
1196 
1197  return ret;
1198 }
1199 
1201 {
1202  int x, y, ls;
1203  uint8_t *dec;
1204 
1205  ls = frame->linesize[3];
1206 
1207  /* filter first row using horizontal filter */
1208  dec = frame->data[3] + 1;
1209  for (x = 1; x < frame->width; x++, dec++)
1210  *dec += *(dec - 1);
1211 
1212  /* filter first column using vertical filter */
1213  dec = frame->data[3] + ls;
1214  for (y = 1; y < frame->height; y++, dec += ls)
1215  *dec += *(dec - ls);
1216 
1217  /* filter the rest using the specified filter */
1218  switch (m) {
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 - 1);
1224  }
1225  break;
1226  case ALPHA_FILTER_VERTICAL:
1227  for (y = 1; y < frame->height; y++) {
1228  dec = frame->data[3] + y * ls + 1;
1229  for (x = 1; x < frame->width; x++, dec++)
1230  *dec += *(dec - ls);
1231  }
1232  break;
1233  case ALPHA_FILTER_GRADIENT:
1234  for (y = 1; y < frame->height; y++) {
1235  dec = frame->data[3] + y * ls + 1;
1236  for (x = 1; x < frame->width; x++, dec++)
1237  dec[0] += av_clip_uint8(*(dec - 1) + *(dec - ls) - *(dec - ls - 1));
1238  }
1239  break;
1240  }
1241 }
1242 
1244  const uint8_t *data_start,
1245  unsigned int data_size)
1246 {
1247  WebPContext *s = avctx->priv_data;
1248  int x, y, ret;
1249 
1250  if (s->alpha_compression == ALPHA_COMPRESSION_NONE) {
1251  GetByteContext gb;
1252 
1253  bytestream2_init(&gb, data_start, data_size);
1254  for (y = 0; y < s->height; y++)
1255  bytestream2_get_buffer(&gb, p->data[3] + p->linesize[3] * y,
1256  s->width);
1257  } else if (s->alpha_compression == ALPHA_COMPRESSION_VP8L) {
1258  uint8_t *ap, *pp;
1259  int alpha_got_frame = 0;
1260 
1261  s->alpha_frame = av_frame_alloc();
1262  if (!s->alpha_frame)
1263  return AVERROR(ENOMEM);
1264 
1265  ret = vp8_lossless_decode_frame(avctx, s->alpha_frame, &alpha_got_frame,
1266  data_start, data_size, 1);
1267  if (ret < 0) {
1268  av_frame_free(&s->alpha_frame);
1269  return ret;
1270  }
1271  if (!alpha_got_frame) {
1272  av_frame_free(&s->alpha_frame);
1273  return AVERROR_INVALIDDATA;
1274  }
1275 
1276  /* copy green component of alpha image to alpha plane of primary image */
1277  for (y = 0; y < s->height; y++) {
1278  ap = GET_PIXEL(s->alpha_frame, 0, y) + 2;
1279  pp = p->data[3] + p->linesize[3] * y;
1280  for (x = 0; x < s->width; x++) {
1281  *pp = *ap;
1282  pp++;
1283  ap += 4;
1284  }
1285  }
1286  av_frame_free(&s->alpha_frame);
1287  }
1288 
1289  /* apply alpha filtering */
1290  if (s->alpha_filter)
1291  alpha_inverse_prediction(p, s->alpha_filter);
1292 
1293  return 0;
1294 }
1295 
1297  int *got_frame, uint8_t *data_start,
1298  unsigned int data_size)
1299 {
1300  WebPContext *s = avctx->priv_data;
1301  int ret;
1302 
1303  if (!s->initialized) {
1304  ff_vp8_decode_init(avctx);
1305  s->initialized = 1;
1306  s->v.actually_webp = 1;
1307  }
1308  avctx->pix_fmt = s->has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
1309  s->lossless = 0;
1310 
1311  if (data_size > INT_MAX) {
1312  av_log(avctx, AV_LOG_ERROR, "unsupported chunk size\n");
1313  return AVERROR_PATCHWELCOME;
1314  }
1315 
1316  av_packet_unref(s->pkt);
1317  s->pkt->data = data_start;
1318  s->pkt->size = data_size;
1319 
1320  ret = ff_vp8_decode_frame(avctx, p, got_frame, s->pkt);
1321  if (ret < 0)
1322  return ret;
1323 
1324  if (!*got_frame)
1325  return AVERROR_INVALIDDATA;
1326 
1327  update_canvas_size(avctx, avctx->width, avctx->height);
1328 
1329  if (s->has_alpha) {
1330  ret = vp8_lossy_decode_alpha(avctx, p, s->alpha_data,
1331  s->alpha_data_size);
1332  if (ret < 0)
1333  return ret;
1334  }
1335  return ret;
1336 }
1337 
1339  int *got_frame, AVPacket *avpkt)
1340 {
1341  WebPContext *s = avctx->priv_data;
1342  GetByteContext gb;
1343  int ret;
1344  uint32_t chunk_type, chunk_size;
1345  int vp8x_flags = 0;
1346 
1347  s->avctx = avctx;
1348  s->width = 0;
1349  s->height = 0;
1350  *got_frame = 0;
1351  s->has_alpha = 0;
1352  s->has_exif = 0;
1353  s->has_iccp = 0;
1354  bytestream2_init(&gb, avpkt->data, avpkt->size);
1355 
1356  if (bytestream2_get_bytes_left(&gb) < 12)
1357  return AVERROR_INVALIDDATA;
1358 
1359  if (bytestream2_get_le32(&gb) != MKTAG('R', 'I', 'F', 'F')) {
1360  av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n");
1361  return AVERROR_INVALIDDATA;
1362  }
1363 
1364  chunk_size = bytestream2_get_le32(&gb);
1365  if (bytestream2_get_bytes_left(&gb) < chunk_size)
1366  return AVERROR_INVALIDDATA;
1367 
1368  if (bytestream2_get_le32(&gb) != MKTAG('W', 'E', 'B', 'P')) {
1369  av_log(avctx, AV_LOG_ERROR, "missing WEBP tag\n");
1370  return AVERROR_INVALIDDATA;
1371  }
1372 
1373  while (bytestream2_get_bytes_left(&gb) > 8) {
1374  char chunk_str[5] = { 0 };
1375 
1376  chunk_type = bytestream2_get_le32(&gb);
1377  chunk_size = bytestream2_get_le32(&gb);
1378  if (chunk_size == UINT32_MAX)
1379  return AVERROR_INVALIDDATA;
1380  chunk_size += chunk_size & 1;
1381 
1382  if (bytestream2_get_bytes_left(&gb) < chunk_size) {
1383  /* we seem to be running out of data, but it could also be that the
1384  bitstream has trailing junk leading to bogus chunk_size. */
1385  break;
1386  }
1387 
1388  switch (chunk_type) {
1389  case MKTAG('V', 'P', '8', ' '):
1390  if (!*got_frame) {
1391  ret = vp8_lossy_decode_frame(avctx, p, got_frame,
1392  avpkt->data + bytestream2_tell(&gb),
1393  chunk_size);
1394  if (ret < 0)
1395  return ret;
1396  }
1397  bytestream2_skip(&gb, chunk_size);
1398  break;
1399  case MKTAG('V', 'P', '8', 'L'):
1400  if (!*got_frame) {
1401  ret = vp8_lossless_decode_frame(avctx, p, got_frame,
1402  avpkt->data + bytestream2_tell(&gb),
1403  chunk_size, 0);
1404  if (ret < 0)
1405  return ret;
1406 #if FF_API_CODEC_PROPS
1410 #endif
1411  }
1412  bytestream2_skip(&gb, chunk_size);
1413  break;
1414  case MKTAG('V', 'P', '8', 'X'):
1415  if (s->width || s->height || *got_frame) {
1416  av_log(avctx, AV_LOG_ERROR, "Canvas dimensions are already set\n");
1417  return AVERROR_INVALIDDATA;
1418  }
1419  vp8x_flags = bytestream2_get_byte(&gb);
1420  bytestream2_skip(&gb, 3);
1421  s->width = bytestream2_get_le24(&gb) + 1;
1422  s->height = bytestream2_get_le24(&gb) + 1;
1423  ret = av_image_check_size(s->width, s->height, 0, avctx);
1424  if (ret < 0)
1425  return ret;
1426  break;
1427  case MKTAG('A', 'L', 'P', 'H'): {
1428  int alpha_header, filter_m, compression;
1429 
1430  if (!(vp8x_flags & VP8X_FLAG_ALPHA)) {
1431  av_log(avctx, AV_LOG_WARNING,
1432  "ALPHA chunk present, but alpha bit not set in the "
1433  "VP8X header\n");
1434  }
1435  if (chunk_size == 0) {
1436  av_log(avctx, AV_LOG_ERROR, "invalid ALPHA chunk size\n");
1437  return AVERROR_INVALIDDATA;
1438  }
1439  alpha_header = bytestream2_get_byte(&gb);
1440  s->alpha_data = avpkt->data + bytestream2_tell(&gb);
1441  s->alpha_data_size = chunk_size - 1;
1442  bytestream2_skip(&gb, s->alpha_data_size);
1443 
1444  filter_m = (alpha_header >> 2) & 0x03;
1445  compression = alpha_header & 0x03;
1446 
1447  if (compression > ALPHA_COMPRESSION_VP8L) {
1448  av_log(avctx, AV_LOG_VERBOSE,
1449  "skipping unsupported ALPHA chunk\n");
1450  } else {
1451  s->has_alpha = 1;
1452  s->alpha_compression = compression;
1453  s->alpha_filter = filter_m;
1454  }
1455 
1456  break;
1457  }
1458  case MKTAG('E', 'X', 'I', 'F'): {
1459  int le, ifd_offset, exif_offset = bytestream2_tell(&gb);
1460  AVDictionary *exif_metadata = NULL;
1461  GetByteContext exif_gb;
1462 
1463  if (s->has_exif) {
1464  av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra EXIF chunk\n");
1465  goto exif_end;
1466  }
1467  if (!(vp8x_flags & VP8X_FLAG_EXIF_METADATA))
1468  av_log(avctx, AV_LOG_WARNING,
1469  "EXIF chunk present, but Exif bit not set in the "
1470  "VP8X header\n");
1471 
1472  s->has_exif = 1;
1473  bytestream2_init(&exif_gb, avpkt->data + exif_offset,
1474  avpkt->size - exif_offset);
1475  if (ff_tdecode_header(&exif_gb, &le, &ifd_offset) < 0) {
1476  av_log(avctx, AV_LOG_ERROR, "invalid TIFF header "
1477  "in Exif data\n");
1478  goto exif_end;
1479  }
1480 
1481  bytestream2_seek(&exif_gb, ifd_offset, SEEK_SET);
1482  if (ff_exif_decode_ifd(avctx, &exif_gb, le, 0, &exif_metadata) < 0) {
1483  av_log(avctx, AV_LOG_ERROR, "error decoding Exif data\n");
1484  goto exif_end;
1485  }
1486 
1487  av_dict_copy(&p->metadata, exif_metadata, 0);
1488 
1489 exif_end:
1490  av_dict_free(&exif_metadata);
1491  bytestream2_skip(&gb, chunk_size);
1492  break;
1493  }
1494  case MKTAG('I', 'C', 'C', 'P'): {
1495  AVFrameSideData *sd;
1496 
1497  if (s->has_iccp) {
1498  av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra ICCP chunk\n");
1499  bytestream2_skip(&gb, chunk_size);
1500  break;
1501  }
1502  if (!(vp8x_flags & VP8X_FLAG_ICC))
1503  av_log(avctx, AV_LOG_WARNING,
1504  "ICCP chunk present, but ICC Profile bit not set in the "
1505  "VP8X header\n");
1506 
1507  s->has_iccp = 1;
1508 
1509  ret = ff_frame_new_side_data(avctx, p, AV_FRAME_DATA_ICC_PROFILE, chunk_size, &sd);
1510  if (ret < 0)
1511  return ret;
1512 
1513  if (sd) {
1514  bytestream2_get_buffer(&gb, sd->data, chunk_size);
1515  } else {
1516  bytestream2_skip(&gb, chunk_size);
1517  }
1518  break;
1519  }
1520  case MKTAG('A', 'N', 'I', 'M'):
1521  case MKTAG('A', 'N', 'M', 'F'):
1522  case MKTAG('X', 'M', 'P', ' '):
1523  AV_WL32(chunk_str, chunk_type);
1524  av_log(avctx, AV_LOG_WARNING, "skipping unsupported chunk: %s\n",
1525  chunk_str);
1526  bytestream2_skip(&gb, chunk_size);
1527  break;
1528  default:
1529  AV_WL32(chunk_str, chunk_type);
1530  av_log(avctx, AV_LOG_VERBOSE, "skipping unknown chunk: %s\n",
1531  chunk_str);
1532  bytestream2_skip(&gb, chunk_size);
1533  break;
1534  }
1535  }
1536 
1537  if (!*got_frame) {
1538  av_log(avctx, AV_LOG_ERROR, "image data not found\n");
1539  return AVERROR_INVALIDDATA;
1540  }
1541 
1542  return avpkt->size;
1543 }
1544 
1546 {
1547  WebPContext *s = avctx->priv_data;
1548 
1549  s->pkt = av_packet_alloc();
1550  if (!s->pkt)
1551  return AVERROR(ENOMEM);
1552 
1553  return 0;
1554 }
1555 
1557 {
1558  WebPContext *s = avctx->priv_data;
1559 
1560  av_packet_free(&s->pkt);
1561 
1562  if (s->initialized)
1563  return ff_vp8_decode_free(avctx);
1564 
1565  return 0;
1566 }
1567 
1569  .p.name = "webp",
1570  CODEC_LONG_NAME("WebP image"),
1571  .p.type = AVMEDIA_TYPE_VIDEO,
1572  .p.id = AV_CODEC_ID_WEBP,
1573  .priv_data_size = sizeof(WebPContext),
1576  .close = webp_decode_close,
1577  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1578  .caps_internal = FF_CODEC_CAP_ICC_PROFILES |
1580 };
WebPContext::width
int width
Definition: webp.c:208
WebPContext::alpha_frame
AVFrame * alpha_frame
Definition: webp.c:197
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
ff_vp8_decode_free
av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
Definition: vp8.c:2819
HuffReader::vlc
VLC vlc
Definition: webp.c:174
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
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:865
ff_vlc_init_from_lengths
int ff_vlc_init_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: vlc.c:306
extra_bits
#define extra_bits(eb)
Definition: intrax8.c:120
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:678
r
const char * r
Definition: vf_curves.c:127
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:70
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
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:1296
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:205
color
Definition: vf_paletteuse.c:513
PRED_MODE_AVG_T_AVG_L_TR
@ PRED_MODE_AVG_T_AVG_L_TR
Definition: webp.c:126
ALPHA_FILTER_HORIZONTAL
@ ALPHA_FILTER_HORIZONTAL
Definition: webp.c:108
HuffReader::simple_symbols
uint16_t simple_symbols[2]
Definition: webp.c:177
GetByteContext
Definition: bytestream.h:33
ff_u8_to_s8
static int8_t ff_u8_to_s8(uint8_t a)
Definition: mathops.h:243
block_bits
static const uint8_t block_bits[]
Definition: imm4.c:103
PRED_MODE_BLACK
@ PRED_MODE_BLACK
Definition: webp.c:121
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:784
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:63
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:770
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:410
AVFrame::width
int width
Definition: frame.h:482
w
uint8_t w
Definition: llviddspenc.c:38
GET_PIXEL_COMP
#define GET_PIXEL_COMP(frame, x, y, c)
Definition: webp.c:224
AVPacket::data
uint8_t * data
Definition: packet.h:535
PRED_MODE_ADD_SUBTRACT_FULL
@ PRED_MODE_ADD_SUBTRACT_FULL
Definition: webp.c:133
COLOR_INDEXING_TRANSFORM
@ COLOR_INDEXING_TRANSFORM
Definition: webp.c:117
b
#define b
Definition: input.c:42
SUBTRACT_GREEN
@ SUBTRACT_GREEN
Definition: webp.c:116
ImageContext::nb_huffman_groups
int nb_huffman_groups
Definition: webp.c:185
parse_transform_color
static int parse_transform_color(WebPContext *s)
Definition: webp.c:475
FFCodec
Definition: codec_internal.h:127
PRED_MODE_AVG_TL_T
@ PRED_MODE_AVG_TL_T
Definition: webp.c:129
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVDictionary
Definition: dict.c:32
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:654
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
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:91
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:497
thread.h
WebPContext::transforms
enum TransformType transforms[4]
Definition: webp.c:213
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:75
PRED_MODE_TR
@ PRED_MODE_TR
Definition: webp.c:124
PRED_MODE_AVG_L_T
@ PRED_MODE_AVG_L_T
Definition: webp.c:128
vp8_lossless_decode_frame
static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, const uint8_t *data_start, unsigned int data_size, int is_alpha_chunk)
Definition: webp.c:1086
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:431
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
HuffReader::simple
int simple
Definition: webp.c:175
PRED_MODE_TL
@ PRED_MODE_TL
Definition: webp.c:125
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:364
WebPContext::alpha_compression
enum AlphaCompression alpha_compression
Definition: webp.c:202
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:841
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:318
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:821
WebPContext::avctx
AVCodecContext * avctx
Definition: webp.c:199
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
finish
static void finish(void)
Definition: movenc.c:374
ALPHA_COMPRESSION_NONE
@ ALPHA_COMPRESSION_NONE
Definition: webp.c:102
WebPContext::nb_transforms
int nb_transforms
Definition: webp.c:212
GetBitContext
Definition: get_bits.h:108
update_canvas_size
static void update_canvas_size(AVCodecContext *avctx, int w, int h)
Definition: webp.c:1071
WebPContext::alpha_data_size
int alpha_data_size
Definition: webp.c:205
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:890
COLOR_TRANSFORM
@ COLOR_TRANSFORM
Definition: webp.c:115
VP8X_FLAG_EXIF_METADATA
#define VP8X_FLAG_EXIF_METADATA
Definition: webp.c:59
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:777
ff_webp_decoder
const FFCodec ff_webp_decoder
Definition: webp.c:1568
color_transform_delta
static av_always_inline uint8_t color_transform_delta(uint8_t color_pred, uint8_t color)
Definition: webp.c:954
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:51
HUFF_IDX_GREEN
@ HUFF_IDX_GREEN
Definition: webp.c:138
WebPContext::has_exif
int has_exif
Definition: webp.c:206
read_huffman_code_normal
static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, int alphabet_size)
Definition: webp.c:312
WebPContext::has_alpha
int has_alpha
Definition: webp.c:201
ff_exif_decode_ifd
int ff_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le, int depth, AVDictionary **metadata)
Definition: exif.c:243
PredictionMode
PredictionMode
Definition: webp.c:120
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:68
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:90
ImageContext::frame
AVFrame * frame
Definition: webp.c:182
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:528
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:1638
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
inverse_prediction
static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
Definition: webp.c:901
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:341
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:108
TransformType
TransformType
Definition: webp.c:113
PRED_MODE_AVG_T_TR
@ PRED_MODE_AVG_T_TR
Definition: webp.c:130
transform
static const int8_t transform[32][32]
Definition: dsp.c:27
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1048
HUFFMAN_CODES_PER_META_CODE
#define HUFFMAN_CODES_PER_META_CODE
Definition: webp.c:66
code_length_code_order
static const uint8_t code_length_code_order[NUM_CODE_LENGTH_CODES]
Definition: webp.c:79
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:128
NUM_DISTANCE_CODES
#define NUM_DISTANCE_CODES
Definition: webp.c:69
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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:851
NUM_CODE_LENGTH_CODES
#define NUM_CODE_LENGTH_CODES
Definition: webp.c:65
ImageContext
Definition: webp.c:180
decode.h
get_bits.h
xi
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:418
ImageContext::color_cache
uint32_t * color_cache
Definition: webp.c:184
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:73
GET_PIXEL
#define GET_PIXEL(frame, x, y)
Definition: webp.c:221
ImageContext::is_alpha_primary
int is_alpha_primary
Definition: webp.c:191
PRED_MODE_AVG_L_TL
@ PRED_MODE_AVG_L_TL
Definition: webp.c:127
webp_decode_close
static av_cold int webp_decode_close(AVCodecContext *avctx)
Definition: webp.c:1556
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
ImageContext::huffman_groups
HuffReader * huffman_groups
Definition: webp.c:186
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
ff_vp8_decode_init
int ff_vp8_decode_init(AVCodecContext *avctx)
apply_subtract_green_transform
static int apply_subtract_green_transform(WebPContext *s)
Definition: webp.c:984
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
HuffReader::nb_symbols
int nb_symbols
Definition: webp.c:176
WebPContext::height
int height
Definition: webp.c:209
ALPHA_FILTER_NONE
@ ALPHA_FILTER_NONE
Definition: webp.c:107
clamp_add_subtract_half
static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
Definition: webp.c:874
HUFF_IDX_DIST
@ HUFF_IDX_DIST
Definition: webp.c:142
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
inverse_predict
static const inv_predict_func inverse_predict[14]
Definition: webp.c:894
tiff_common.h
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:371
ImageContext::color_cache_bits
int color_cache_bits
Definition: webp.c:183
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:144
webp_decode_init
static av_cold int webp_decode_init(AVCodecContext *avctx)
Definition: webp.c:1545
WebPContext::v
VP8Context v
Definition: webp.c:195
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:73
NUM_LITERAL_CODES
#define NUM_LITERAL_CODES
Definition: webp.c:67
IMAGE_ROLE_PREDICTOR
@ IMAGE_ROLE_PREDICTOR
Definition: webp.c:161
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:635
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
alpha_inverse_prediction
static void alpha_inverse_prediction(AVFrame *frame, enum AlphaFilter m)
Definition: webp.c:1200
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:415
IMAGE_ROLE_COLOR_INDEXING
@ IMAGE_ROLE_COLOR_INDEXING
Definition: webp.c:168
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:502
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:756
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:170
VP8X_FLAG_ICC
#define VP8X_FLAG_ICC
Definition: webp.c:61
AVPacket::size
int size
Definition: packet.h:536
codec_internal.h
AlphaCompression
AlphaCompression
Definition: webp.c:101
PREDICTOR_TRANSFORM
@ PREDICTOR_TRANSFORM
Definition: webp.c:114
ImageContext::size_reduction
int size_reduction
Definition: webp.c:190
size
int size
Definition: twinvq_data.h:10344
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition: decode.c:2003
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:267
ImageContext::role
enum ImageRole role
Definition: webp.c:181
decode_entropy_image
static int decode_entropy_image(WebPContext *s)
Definition: webp.c:429
apply_color_transform
static int apply_color_transform(WebPContext *s)
Definition: webp.c:960
VP8X_FLAG_ALPHA
#define VP8X_FLAG_ALPHA
Definition: webp.c:60
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
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:114
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: packet.c:64
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:233
HuffReader
Definition: webp.c:173
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:131
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
ALPHA_FILTER_GRADIENT
@ ALPHA_FILTER_GRADIENT
Definition: webp.c:110
WebPContext::nb_huffman_groups
int nb_huffman_groups
Definition: webp.c:217
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:791
WebPContext::lossless
int lossless
Definition: webp.c:210
WebPContext::reduced_width
int reduced_width
Definition: webp.c:216
NUM_LENGTH_CODES
#define NUM_LENGTH_CODES
Definition: webp.c:68
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
WebPContext::pkt
AVPacket * pkt
Definition: webp.c:198
AlphaFilter
AlphaFilter
Definition: webp.c:106
PRED_MODE_SELECT
@ PRED_MODE_SELECT
Definition: webp.c:132
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:83
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
WebPContext::gb
GetBitContext gb
Definition: webp.c:196
apply_predictor_transform
static int apply_predictor_transform(WebPContext *s)
Definition: webp.c:923
av_always_inline
#define av_always_inline
Definition: attributes.h:49
HuffmanIndex
HuffmanIndex
Definition: webp.c:137
AV_COPY32
#define AV_COPY32(d, s)
Definition: intreadwrite.h:634
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
AV_CODEC_ID_WEBP
@ AV_CODEC_ID_WEBP
Definition: codec_id.h:226
len
int len
Definition: vorbis_enc_data.h:426
exif.h
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
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:811
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
huff_reader_get_symbol
static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb)
Definition: webp.c:244
FF_CODEC_CAP_ICC_PROFILES
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
Definition: codec_internal.h:81
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:881
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:580
ret
ret
Definition: filter_design.txt:187
WebPContext::image
ImageContext image[IMAGE_ROLE_NB]
Definition: webp.c:218
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
ff_vp8_decode_frame
int ff_vp8_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
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:801
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
U
#define U(x)
Definition: vpx_arith.h:37
vp8_lossy_decode_alpha
static int vp8_lossy_decode_alpha(AVCodecContext *avctx, AVFrame *p, const uint8_t *data_start, unsigned int data_size)
Definition: webp.c:1243
AVCodecContext
main external API structure.
Definition: avcodec.h:431
HUFF_IDX_BLUE
@ HUFF_IDX_BLUE
Definition: webp.c:140
IMAGE_ROLE_ENTROPY
@ IMAGE_ROLE_ENTROPY
Definition: webp.c:157
VLC
Definition: vlc.h:50
webp_decode_frame
static int webp_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Definition: webp.c:1338
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:688
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:229
image_ctx_free
static void image_ctx_free(ImageContext *img)
Definition: webp.c:227
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
WebPContext::initialized
int initialized
Definition: webp.c:200
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:999
mem.h
WebPContext::alpha_data
const uint8_t * alpha_data
Definition: webp.c:204
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
VLC_INIT_OUTPUT_LE
#define VLC_INIT_OUTPUT_LE
Definition: vlc.h:196
MAX_HUFFMAN_CODE_LENGTH
#define MAX_HUFFMAN_CODE_LENGTH
Definition: webp.c:71
ALPHA_FILTER_VERTICAL
@ ALPHA_FILTER_VERTICAL
Definition: webp.c:109
PARSE_BLOCK_SIZE
#define PARSE_BLOCK_SIZE(w, h)
Definition: webp.c:423
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
PRED_MODE_L
@ PRED_MODE_L
Definition: webp.c:122
WebPContext
Definition: webp.c:194
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AVPacket
This structure stores compressed data.
Definition: packet.h:512
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:247
VP8Context
Definition: vp8.h:161
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
ImageRole
ImageRole
Definition: webp.c:151
bytestream.h
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:231
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:52
AVCodecContext::properties
attribute_deprecated unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1637
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:455
read_huffman_code_simple
static void read_huffman_code_simple(WebPContext *s, HuffReader *hc)
Definition: webp.c:297
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
HUFF_IDX_ALPHA
@ HUFF_IDX_ALPHA
Definition: webp.c:141
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
huff_reader_build_canonical
static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths, uint16_t len_counts[MAX_HUFFMAN_CODE_LENGTH+1], uint8_t lens[], uint16_t syms[], int alphabet_size, void *logctx)
Definition: webp.c:255
h
h
Definition: vp9dsp_template.c:2070
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:207
get_huffman_group
static HuffReader * get_huffman_group(WebPContext *s, ImageContext *img, int x, int y)
Definition: webp.c:526
width
#define width
Definition: dsp.h:85
AV_FRAME_FLAG_LOSSLESS
#define AV_FRAME_FLAG_LOSSLESS
A decoder can use this flag to mark frames which were originally encoded losslessly.
Definition: frame.h:646
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:831
ALPHA_COMPRESSION_VP8L
@ ALPHA_COMPRESSION_VP8L
Definition: webp.c:103
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:763
PRED_MODE_T
@ PRED_MODE_T
Definition: webp.c:123
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:203
HUFF_IDX_RED
@ HUFF_IDX_RED
Definition: webp.c:139
IMAGE_ROLE_ARGB
@ IMAGE_ROLE_ARGB
Definition: webp.c:153
PRED_MODE_ADD_SUBTRACT_HALF
@ PRED_MODE_ADD_SUBTRACT_HALF
Definition: webp.c:134
IMAGE_ROLE_COLOR_TRANSFORM
@ IMAGE_ROLE_COLOR_TRANSFORM
Definition: webp.c:165