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  int alphabet_size)
257 {
258  int len = 0, sym, code = 0, ret;
259  int max_code_length = 0;
260  uint16_t *codes;
261 
262  /* special-case 1 symbol since the vlc reader cannot handle it */
263  for (sym = 0; sym < alphabet_size; sym++) {
264  if (code_lengths[sym] > 0) {
265  len++;
266  code = sym;
267  if (len > 1)
268  break;
269  }
270  }
271  if (len == 1) {
272  r->nb_symbols = 1;
273  r->simple_symbols[0] = code;
274  r->simple = 1;
275  return 0;
276  }
277 
278  for (sym = 0; sym < alphabet_size; sym++)
279  max_code_length = FFMAX(max_code_length, code_lengths[sym]);
280 
281  if (max_code_length == 0 || max_code_length > MAX_HUFFMAN_CODE_LENGTH)
282  return AVERROR(EINVAL);
283 
284  codes = av_malloc_array(alphabet_size, sizeof(*codes));
285  if (!codes)
286  return AVERROR(ENOMEM);
287 
288  code = 0;
289  r->nb_symbols = 0;
290  for (len = 1; len <= max_code_length; len++) {
291  for (sym = 0; sym < alphabet_size; sym++) {
292  if (code_lengths[sym] != len)
293  continue;
294  codes[sym] = code++;
295  r->nb_symbols++;
296  }
297  code <<= 1;
298  }
299  if (!r->nb_symbols) {
300  av_free(codes);
301  return AVERROR_INVALIDDATA;
302  }
303 
304  ret = vlc_init(&r->vlc, 8, alphabet_size,
305  code_lengths, sizeof(*code_lengths), sizeof(*code_lengths),
306  codes, sizeof(*codes), sizeof(*codes), VLC_INIT_OUTPUT_LE);
307  if (ret < 0) {
308  av_free(codes);
309  return ret;
310  }
311  r->simple = 0;
312 
313  av_free(codes);
314  return 0;
315 }
316 
318 {
319  hc->nb_symbols = get_bits1(&s->gb) + 1;
320 
321  if (get_bits1(&s->gb))
322  hc->simple_symbols[0] = get_bits(&s->gb, 8);
323  else
324  hc->simple_symbols[0] = get_bits1(&s->gb);
325 
326  if (hc->nb_symbols == 2)
327  hc->simple_symbols[1] = get_bits(&s->gb, 8);
328 
329  hc->simple = 1;
330 }
331 
333  int alphabet_size)
334 {
335  HuffReader code_len_hc = { { 0 }, 0, 0, { 0 } };
336  uint8_t *code_lengths;
337  uint8_t code_length_code_lengths[NUM_CODE_LENGTH_CODES] = { 0 };
338  int i, symbol, max_symbol, prev_code_len, ret;
339  int num_codes = 4 + get_bits(&s->gb, 4);
340 
341  av_assert1(num_codes <= NUM_CODE_LENGTH_CODES);
342 
343  for (i = 0; i < num_codes; i++)
344  code_length_code_lengths[code_length_code_order[i]] = get_bits(&s->gb, 3);
345 
346  ret = huff_reader_build_canonical(&code_len_hc, code_length_code_lengths,
348  if (ret < 0)
349  return ret;
350 
351  code_lengths = av_mallocz(alphabet_size);
352  if (!code_lengths) {
353  ret = AVERROR(ENOMEM);
354  goto finish;
355  }
356 
357  if (get_bits1(&s->gb)) {
358  int bits = 2 + 2 * get_bits(&s->gb, 3);
359  max_symbol = 2 + get_bits(&s->gb, bits);
360  if (max_symbol > alphabet_size) {
361  av_log(s->avctx, AV_LOG_ERROR, "max symbol %d > alphabet size %d\n",
362  max_symbol, alphabet_size);
364  goto finish;
365  }
366  } else {
367  max_symbol = alphabet_size;
368  }
369 
370  prev_code_len = 8;
371  symbol = 0;
372  while (symbol < alphabet_size) {
373  int code_len;
374 
375  if (!max_symbol--)
376  break;
377  code_len = huff_reader_get_symbol(&code_len_hc, &s->gb);
378  if (code_len < 16) {
379  /* Code length code [0..15] indicates literal code lengths. */
380  code_lengths[symbol++] = code_len;
381  if (code_len)
382  prev_code_len = code_len;
383  } else {
384  int repeat = 0, length = 0;
385  switch (code_len) {
386  case 16:
387  /* Code 16 repeats the previous non-zero value [3..6] times,
388  * i.e., 3 + ReadBits(2) times. If code 16 is used before a
389  * non-zero value has been emitted, a value of 8 is repeated. */
390  repeat = 3 + get_bits(&s->gb, 2);
391  length = prev_code_len;
392  break;
393  case 17:
394  /* Code 17 emits a streak of zeros [3..10], i.e.,
395  * 3 + ReadBits(3) times. */
396  repeat = 3 + get_bits(&s->gb, 3);
397  break;
398  case 18:
399  /* Code 18 emits a streak of zeros of length [11..138], i.e.,
400  * 11 + ReadBits(7) times. */
401  repeat = 11 + get_bits(&s->gb, 7);
402  break;
403  }
404  if (symbol + repeat > alphabet_size) {
405  av_log(s->avctx, AV_LOG_ERROR,
406  "invalid symbol %d + repeat %d > alphabet size %d\n",
407  symbol, repeat, alphabet_size);
409  goto finish;
410  }
411  while (repeat-- > 0)
412  code_lengths[symbol++] = length;
413  }
414  }
415 
416  ret = huff_reader_build_canonical(hc, code_lengths, alphabet_size);
417 
418 finish:
419  ff_vlc_free(&code_len_hc.vlc);
420  av_free(code_lengths);
421  return ret;
422 }
423 
424 static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role,
425  int w, int h);
426 
427 #define PARSE_BLOCK_SIZE(w, h) do { \
428  block_bits = get_bits(&s->gb, 3) + 2; \
429  blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \
430  blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \
431 } while (0)
432 
434 {
435  ImageContext *img;
436  int ret, block_bits, blocks_w, blocks_h, x, y, max;
437 
438  PARSE_BLOCK_SIZE(s->reduced_width, s->height);
439 
440  ret = decode_entropy_coded_image(s, IMAGE_ROLE_ENTROPY, blocks_w, blocks_h);
441  if (ret < 0)
442  return ret;
443 
444  img = &s->image[IMAGE_ROLE_ENTROPY];
445  img->size_reduction = block_bits;
446 
447  /* the number of huffman groups is determined by the maximum group number
448  * coded in the entropy image */
449  max = 0;
450  for (y = 0; y < img->frame->height; y++) {
451  for (x = 0; x < img->frame->width; x++) {
452  int p0 = GET_PIXEL_COMP(img->frame, x, y, 1);
453  int p1 = GET_PIXEL_COMP(img->frame, x, y, 2);
454  int p = p0 << 8 | p1;
455  max = FFMAX(max, p);
456  }
457  }
458  s->nb_huffman_groups = max + 1;
459 
460  return 0;
461 }
462 
464 {
465  int block_bits, blocks_w, blocks_h, ret;
466 
467  PARSE_BLOCK_SIZE(s->reduced_width, s->height);
468 
470  blocks_h);
471  if (ret < 0)
472  return ret;
473 
474  s->image[IMAGE_ROLE_PREDICTOR].size_reduction = block_bits;
475 
476  return 0;
477 }
478 
480 {
481  int block_bits, blocks_w, blocks_h, ret;
482 
483  PARSE_BLOCK_SIZE(s->reduced_width, s->height);
484 
486  blocks_h);
487  if (ret < 0)
488  return ret;
489 
490  s->image[IMAGE_ROLE_COLOR_TRANSFORM].size_reduction = block_bits;
491 
492  return 0;
493 }
494 
496 {
497  ImageContext *img;
498  int width_bits, index_size, ret, x;
499  uint8_t *ct;
500 
501  index_size = get_bits(&s->gb, 8) + 1;
502 
503  if (index_size <= 2)
504  width_bits = 3;
505  else if (index_size <= 4)
506  width_bits = 2;
507  else if (index_size <= 16)
508  width_bits = 1;
509  else
510  width_bits = 0;
511 
513  index_size, 1);
514  if (ret < 0)
515  return ret;
516 
517  img = &s->image[IMAGE_ROLE_COLOR_INDEXING];
518  img->size_reduction = width_bits;
519  if (width_bits > 0)
520  s->reduced_width = (s->width + ((1 << width_bits) - 1)) >> width_bits;
521 
522  /* color index values are delta-coded */
523  ct = img->frame->data[0] + 4;
524  for (x = 4; x < img->frame->width * 4; x++, ct++)
525  ct[0] += ct[-4];
526 
527  return 0;
528 }
529 
531  int x, int y)
532 {
533  ImageContext *gimg = &s->image[IMAGE_ROLE_ENTROPY];
534  int group = 0;
535 
536  if (gimg->size_reduction > 0) {
537  int group_x = x >> gimg->size_reduction;
538  int group_y = y >> gimg->size_reduction;
539  int g0 = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 1);
540  int g1 = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 2);
541  group = g0 << 8 | g1;
542  }
543 
544  return &img->huffman_groups[group * HUFFMAN_CODES_PER_META_CODE];
545 }
546 
548 {
549  uint32_t cache_idx = (0x1E35A7BD * c) >> (32 - img->color_cache_bits);
550  img->color_cache[cache_idx] = c;
551 }
552 
554  int w, int h)
555 {
556  ImageContext *img;
557  HuffReader *hg;
558  int i, j, ret, x, y, width;
559 
560  img = &s->image[role];
561  img->role = role;
562 
563  if (!img->frame) {
564  img->frame = av_frame_alloc();
565  if (!img->frame)
566  return AVERROR(ENOMEM);
567  }
568 
569  img->frame->format = AV_PIX_FMT_ARGB;
570  img->frame->width = w;
571  img->frame->height = h;
572 
573  if (role == IMAGE_ROLE_ARGB && !img->is_alpha_primary) {
574  ret = ff_thread_get_buffer(s->avctx, img->frame, 0);
575  } else
576  ret = av_frame_get_buffer(img->frame, 1);
577  if (ret < 0)
578  return ret;
579 
580  if (get_bits1(&s->gb)) {
581  img->color_cache_bits = get_bits(&s->gb, 4);
582  if (img->color_cache_bits < 1 || img->color_cache_bits > 11) {
583  av_log(s->avctx, AV_LOG_ERROR, "invalid color cache bits: %d\n",
584  img->color_cache_bits);
585  return AVERROR_INVALIDDATA;
586  }
587  img->color_cache = av_calloc(1 << img->color_cache_bits,
588  sizeof(*img->color_cache));
589  if (!img->color_cache)
590  return AVERROR(ENOMEM);
591  } else {
592  img->color_cache_bits = 0;
593  }
594 
595  img->nb_huffman_groups = 1;
596  if (role == IMAGE_ROLE_ARGB && get_bits1(&s->gb)) {
598  if (ret < 0)
599  return ret;
600  img->nb_huffman_groups = s->nb_huffman_groups;
601  }
602  img->huffman_groups = av_calloc(img->nb_huffman_groups,
604  sizeof(*img->huffman_groups));
605  if (!img->huffman_groups)
606  return AVERROR(ENOMEM);
607 
608  for (i = 0; i < img->nb_huffman_groups; i++) {
609  hg = &img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE];
610  for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++) {
611  int alphabet_size = alphabet_sizes[j];
612  if (!j && img->color_cache_bits > 0)
613  alphabet_size += 1 << img->color_cache_bits;
614 
615  if (get_bits1(&s->gb)) {
616  read_huffman_code_simple(s, &hg[j]);
617  } else {
618  ret = read_huffman_code_normal(s, &hg[j], alphabet_size);
619  if (ret < 0)
620  return ret;
621  }
622  }
623  }
624 
625  width = img->frame->width;
626  if (role == IMAGE_ROLE_ARGB)
627  width = s->reduced_width;
628 
629  x = 0; y = 0;
630  while (y < img->frame->height) {
631  int v;
632 
633  if (get_bits_left(&s->gb) < 0)
634  return AVERROR_INVALIDDATA;
635 
636  hg = get_huffman_group(s, img, x, y);
637  v = huff_reader_get_symbol(&hg[HUFF_IDX_GREEN], &s->gb);
638  if (v < NUM_LITERAL_CODES) {
639  /* literal pixel values */
640  uint8_t *p = GET_PIXEL(img->frame, x, y);
641  p[2] = v;
642  p[1] = huff_reader_get_symbol(&hg[HUFF_IDX_RED], &s->gb);
643  p[3] = huff_reader_get_symbol(&hg[HUFF_IDX_BLUE], &s->gb);
644  p[0] = huff_reader_get_symbol(&hg[HUFF_IDX_ALPHA], &s->gb);
645  if (img->color_cache_bits)
647  x++;
648  if (x == width) {
649  x = 0;
650  y++;
651  }
652  } else if (v < NUM_LITERAL_CODES + NUM_LENGTH_CODES) {
653  /* LZ77 backwards mapping */
654  int prefix_code, length, distance, ref_x, ref_y;
655 
656  /* parse length and distance */
657  prefix_code = v - NUM_LITERAL_CODES;
658  if (prefix_code < 4) {
659  length = prefix_code + 1;
660  } else {
661  int extra_bits = (prefix_code - 2) >> 1;
662  int offset = 2 + (prefix_code & 1) << extra_bits;
663  length = offset + get_bits(&s->gb, extra_bits) + 1;
664  }
665  prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->gb);
666  if (prefix_code > 39U) {
667  av_log(s->avctx, AV_LOG_ERROR,
668  "distance prefix code too large: %d\n", prefix_code);
669  return AVERROR_INVALIDDATA;
670  }
671  if (prefix_code < 4) {
672  distance = prefix_code + 1;
673  } else {
674  int extra_bits = prefix_code - 2 >> 1;
675  int offset = 2 + (prefix_code & 1) << extra_bits;
676  distance = offset + get_bits(&s->gb, extra_bits) + 1;
677  }
678 
679  /* find reference location */
680  if (distance <= NUM_SHORT_DISTANCES) {
681  int xi = lz77_distance_offsets[distance - 1][0];
682  int yi = lz77_distance_offsets[distance - 1][1];
683  distance = FFMAX(1, xi + yi * width);
684  } else {
686  }
687  ref_x = x;
688  ref_y = y;
689  if (distance <= x) {
690  ref_x -= distance;
691  distance = 0;
692  } else {
693  ref_x = 0;
694  distance -= x;
695  }
696  while (distance >= width) {
697  ref_y--;
698  distance -= width;
699  }
700  if (distance > 0) {
701  ref_x = width - distance;
702  ref_y--;
703  }
704  ref_x = FFMAX(0, ref_x);
705  ref_y = FFMAX(0, ref_y);
706 
707  /* copy pixels
708  * source and dest regions can overlap and wrap lines, so just
709  * copy per-pixel */
710  for (i = 0; i < length; i++) {
711  uint8_t *p_ref = GET_PIXEL(img->frame, ref_x, ref_y);
712  uint8_t *p = GET_PIXEL(img->frame, x, y);
713 
714  AV_COPY32(p, p_ref);
715  if (img->color_cache_bits)
717  x++;
718  ref_x++;
719  if (x == width) {
720  x = 0;
721  y++;
722  }
723  if (ref_x == width) {
724  ref_x = 0;
725  ref_y++;
726  }
727  if (y == img->frame->height || ref_y == img->frame->height)
728  break;
729  }
730  } else {
731  /* read from color cache */
732  uint8_t *p = GET_PIXEL(img->frame, x, y);
733  int cache_idx = v - (NUM_LITERAL_CODES + NUM_LENGTH_CODES);
734 
735  if (!img->color_cache_bits) {
736  av_log(s->avctx, AV_LOG_ERROR, "color cache not found\n");
737  return AVERROR_INVALIDDATA;
738  }
739  if (cache_idx >= 1 << img->color_cache_bits) {
740  av_log(s->avctx, AV_LOG_ERROR,
741  "color cache index out-of-bounds\n");
742  return AVERROR_INVALIDDATA;
743  }
744  AV_WB32(p, img->color_cache[cache_idx]);
745  x++;
746  if (x == width) {
747  x = 0;
748  y++;
749  }
750  }
751  }
752 
753  return 0;
754 }
755 
756 /* PRED_MODE_BLACK */
757 static void inv_predict_0(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
758  const uint8_t *p_t, const uint8_t *p_tr)
759 {
760  AV_WB32(p, 0xFF000000);
761 }
762 
763 /* PRED_MODE_L */
764 static void inv_predict_1(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
765  const uint8_t *p_t, const uint8_t *p_tr)
766 {
767  AV_COPY32(p, p_l);
768 }
769 
770 /* PRED_MODE_T */
771 static void inv_predict_2(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
772  const uint8_t *p_t, const uint8_t *p_tr)
773 {
774  AV_COPY32(p, p_t);
775 }
776 
777 /* PRED_MODE_TR */
778 static void inv_predict_3(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
779  const uint8_t *p_t, const uint8_t *p_tr)
780 {
781  AV_COPY32(p, p_tr);
782 }
783 
784 /* PRED_MODE_TL */
785 static void inv_predict_4(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
786  const uint8_t *p_t, const uint8_t *p_tr)
787 {
788  AV_COPY32(p, p_tl);
789 }
790 
791 /* PRED_MODE_AVG_T_AVG_L_TR */
792 static void inv_predict_5(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
793  const uint8_t *p_t, const uint8_t *p_tr)
794 {
795  p[0] = p_t[0] + (p_l[0] + p_tr[0] >> 1) >> 1;
796  p[1] = p_t[1] + (p_l[1] + p_tr[1] >> 1) >> 1;
797  p[2] = p_t[2] + (p_l[2] + p_tr[2] >> 1) >> 1;
798  p[3] = p_t[3] + (p_l[3] + p_tr[3] >> 1) >> 1;
799 }
800 
801 /* PRED_MODE_AVG_L_TL */
802 static void inv_predict_6(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
803  const uint8_t *p_t, const uint8_t *p_tr)
804 {
805  p[0] = p_l[0] + p_tl[0] >> 1;
806  p[1] = p_l[1] + p_tl[1] >> 1;
807  p[2] = p_l[2] + p_tl[2] >> 1;
808  p[3] = p_l[3] + p_tl[3] >> 1;
809 }
810 
811 /* PRED_MODE_AVG_L_T */
812 static void inv_predict_7(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
813  const uint8_t *p_t, const uint8_t *p_tr)
814 {
815  p[0] = p_l[0] + p_t[0] >> 1;
816  p[1] = p_l[1] + p_t[1] >> 1;
817  p[2] = p_l[2] + p_t[2] >> 1;
818  p[3] = p_l[3] + p_t[3] >> 1;
819 }
820 
821 /* PRED_MODE_AVG_TL_T */
822 static void inv_predict_8(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
823  const uint8_t *p_t, const uint8_t *p_tr)
824 {
825  p[0] = p_tl[0] + p_t[0] >> 1;
826  p[1] = p_tl[1] + p_t[1] >> 1;
827  p[2] = p_tl[2] + p_t[2] >> 1;
828  p[3] = p_tl[3] + p_t[3] >> 1;
829 }
830 
831 /* PRED_MODE_AVG_T_TR */
832 static void inv_predict_9(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
833  const uint8_t *p_t, const uint8_t *p_tr)
834 {
835  p[0] = p_t[0] + p_tr[0] >> 1;
836  p[1] = p_t[1] + p_tr[1] >> 1;
837  p[2] = p_t[2] + p_tr[2] >> 1;
838  p[3] = p_t[3] + p_tr[3] >> 1;
839 }
840 
841 /* PRED_MODE_AVG_AVG_L_TL_AVG_T_TR */
842 static void inv_predict_10(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
843  const uint8_t *p_t, const uint8_t *p_tr)
844 {
845  p[0] = (p_l[0] + p_tl[0] >> 1) + (p_t[0] + p_tr[0] >> 1) >> 1;
846  p[1] = (p_l[1] + p_tl[1] >> 1) + (p_t[1] + p_tr[1] >> 1) >> 1;
847  p[2] = (p_l[2] + p_tl[2] >> 1) + (p_t[2] + p_tr[2] >> 1) >> 1;
848  p[3] = (p_l[3] + p_tl[3] >> 1) + (p_t[3] + p_tr[3] >> 1) >> 1;
849 }
850 
851 /* PRED_MODE_SELECT */
852 static void inv_predict_11(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
853  const uint8_t *p_t, const uint8_t *p_tr)
854 {
855  int diff = (FFABS(p_l[0] - p_tl[0]) - FFABS(p_t[0] - p_tl[0])) +
856  (FFABS(p_l[1] - p_tl[1]) - FFABS(p_t[1] - p_tl[1])) +
857  (FFABS(p_l[2] - p_tl[2]) - FFABS(p_t[2] - p_tl[2])) +
858  (FFABS(p_l[3] - p_tl[3]) - FFABS(p_t[3] - p_tl[3]));
859  if (diff <= 0)
860  AV_COPY32(p, p_t);
861  else
862  AV_COPY32(p, p_l);
863 }
864 
865 /* PRED_MODE_ADD_SUBTRACT_FULL */
866 static void inv_predict_12(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
867  const uint8_t *p_t, const uint8_t *p_tr)
868 {
869  p[0] = av_clip_uint8(p_l[0] + p_t[0] - p_tl[0]);
870  p[1] = av_clip_uint8(p_l[1] + p_t[1] - p_tl[1]);
871  p[2] = av_clip_uint8(p_l[2] + p_t[2] - p_tl[2]);
872  p[3] = av_clip_uint8(p_l[3] + p_t[3] - p_tl[3]);
873 }
874 
875 static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
876 {
877  int d = a + b >> 1;
878  return av_clip_uint8(d + (d - c) / 2);
879 }
880 
881 /* PRED_MODE_ADD_SUBTRACT_HALF */
882 static void inv_predict_13(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
883  const uint8_t *p_t, const uint8_t *p_tr)
884 {
885  p[0] = clamp_add_subtract_half(p_l[0], p_t[0], p_tl[0]);
886  p[1] = clamp_add_subtract_half(p_l[1], p_t[1], p_tl[1]);
887  p[2] = clamp_add_subtract_half(p_l[2], p_t[2], p_tl[2]);
888  p[3] = clamp_add_subtract_half(p_l[3], p_t[3], p_tl[3]);
889 }
890 
891 typedef void (*inv_predict_func)(uint8_t *p, const uint8_t *p_l,
892  const uint8_t *p_tl, const uint8_t *p_t,
893  const uint8_t *p_tr);
894 
895 static const inv_predict_func inverse_predict[14] = {
900 };
901 
902 static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
903 {
904  uint8_t *dec, *p_l, *p_tl, *p_t, *p_tr;
905  uint8_t p[4];
906 
907  dec = GET_PIXEL(frame, x, y);
908  p_l = GET_PIXEL(frame, x - 1, y);
909  p_tl = GET_PIXEL(frame, x - 1, y - 1);
910  p_t = GET_PIXEL(frame, x, y - 1);
911  if (x == frame->width - 1)
912  p_tr = GET_PIXEL(frame, 0, y);
913  else
914  p_tr = GET_PIXEL(frame, x + 1, y - 1);
915 
916  inverse_predict[m](p, p_l, p_tl, p_t, p_tr);
917 
918  dec[0] += p[0];
919  dec[1] += p[1];
920  dec[2] += p[2];
921  dec[3] += p[3];
922 }
923 
925 {
926  ImageContext *img = &s->image[IMAGE_ROLE_ARGB];
927  ImageContext *pimg = &s->image[IMAGE_ROLE_PREDICTOR];
928  int x, y;
929 
930  for (y = 0; y < img->frame->height; y++) {
931  for (x = 0; x < s->reduced_width; x++) {
932  int tx = x >> pimg->size_reduction;
933  int ty = y >> pimg->size_reduction;
934  enum PredictionMode m = GET_PIXEL_COMP(pimg->frame, tx, ty, 2);
935 
936  if (x == 0) {
937  if (y == 0)
938  m = PRED_MODE_BLACK;
939  else
940  m = PRED_MODE_T;
941  } else if (y == 0)
942  m = PRED_MODE_L;
943 
944  if (m > 13) {
945  av_log(s->avctx, AV_LOG_ERROR,
946  "invalid predictor mode: %d\n", m);
947  return AVERROR_INVALIDDATA;
948  }
949  inverse_prediction(img->frame, m, x, y);
950  }
951  }
952  return 0;
953 }
954 
955 static av_always_inline uint8_t color_transform_delta(uint8_t color_pred,
956  uint8_t color)
957 {
958  return (int)ff_u8_to_s8(color_pred) * ff_u8_to_s8(color) >> 5;
959 }
960 
962 {
963  ImageContext *img, *cimg;
964  int x, y, cx, cy;
965  uint8_t *p, *cp;
966 
967  img = &s->image[IMAGE_ROLE_ARGB];
968  cimg = &s->image[IMAGE_ROLE_COLOR_TRANSFORM];
969 
970  for (y = 0; y < img->frame->height; y++) {
971  for (x = 0; x < s->reduced_width; x++) {
972  cx = x >> cimg->size_reduction;
973  cy = y >> cimg->size_reduction;
974  cp = GET_PIXEL(cimg->frame, cx, cy);
975  p = GET_PIXEL(img->frame, x, y);
976 
977  p[1] += color_transform_delta(cp[3], p[2]);
978  p[3] += color_transform_delta(cp[2], p[2]) +
979  color_transform_delta(cp[1], p[1]);
980  }
981  }
982  return 0;
983 }
984 
986 {
987  int x, y;
988  ImageContext *img = &s->image[IMAGE_ROLE_ARGB];
989 
990  for (y = 0; y < img->frame->height; y++) {
991  for (x = 0; x < s->reduced_width; x++) {
992  uint8_t *p = GET_PIXEL(img->frame, x, y);
993  p[1] += p[2];
994  p[3] += p[2];
995  }
996  }
997  return 0;
998 }
999 
1001 {
1002  ImageContext *img;
1003  ImageContext *pal;
1004  int i, x, y;
1005  uint8_t *p;
1006 
1007  img = &s->image[IMAGE_ROLE_ARGB];
1008  pal = &s->image[IMAGE_ROLE_COLOR_INDEXING];
1009 
1010  if (pal->size_reduction > 0) { // undo pixel packing
1011  GetBitContext gb_g;
1012  uint8_t *line;
1013  int pixel_bits = 8 >> pal->size_reduction;
1014 
1015  line = av_malloc(img->frame->linesize[0] + AV_INPUT_BUFFER_PADDING_SIZE);
1016  if (!line)
1017  return AVERROR(ENOMEM);
1018 
1019  for (y = 0; y < img->frame->height; y++) {
1020  p = GET_PIXEL(img->frame, 0, y);
1021  memcpy(line, p, img->frame->linesize[0]);
1022  init_get_bits(&gb_g, line, img->frame->linesize[0] * 8);
1023  skip_bits(&gb_g, 16);
1024  i = 0;
1025  for (x = 0; x < img->frame->width; x++) {
1026  p = GET_PIXEL(img->frame, x, y);
1027  p[2] = get_bits(&gb_g, pixel_bits);
1028  i++;
1029  if (i == 1 << pal->size_reduction) {
1030  skip_bits(&gb_g, 24);
1031  i = 0;
1032  }
1033  }
1034  }
1035  av_free(line);
1036  s->reduced_width = s->width; // we are back to full size
1037  }
1038 
1039  // switch to local palette if it's worth initializing it
1040  if (img->frame->height * img->frame->width > 300) {
1041  uint8_t palette[256 * 4];
1042  const int size = pal->frame->width * 4;
1043  av_assert0(size <= 1024U);
1044  memcpy(palette, GET_PIXEL(pal->frame, 0, 0), size); // copy palette
1045  // set extra entries to transparent black
1046  memset(palette + size, 0, 256 * 4 - size);
1047  for (y = 0; y < img->frame->height; y++) {
1048  for (x = 0; x < img->frame->width; x++) {
1049  p = GET_PIXEL(img->frame, x, y);
1050  i = p[2];
1051  AV_COPY32(p, &palette[i * 4]);
1052  }
1053  }
1054  } else {
1055  for (y = 0; y < img->frame->height; y++) {
1056  for (x = 0; x < img->frame->width; x++) {
1057  p = GET_PIXEL(img->frame, x, y);
1058  i = p[2];
1059  if (i >= pal->frame->width) {
1060  AV_WB32(p, 0x00000000);
1061  } else {
1062  const uint8_t *pi = GET_PIXEL(pal->frame, i, 0);
1063  AV_COPY32(p, pi);
1064  }
1065  }
1066  }
1067  }
1068 
1069  return 0;
1070 }
1071 
1072 static void update_canvas_size(AVCodecContext *avctx, int w, int h)
1073 {
1074  WebPContext *s = avctx->priv_data;
1075  if (s->width && s->width != w) {
1076  av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n",
1077  s->width, w);
1078  }
1079  s->width = w;
1080  if (s->height && s->height != h) {
1081  av_log(avctx, AV_LOG_WARNING, "Height mismatch. %d != %d\n",
1082  s->height, h);
1083  }
1084  s->height = h;
1085 }
1086 
1088  int *got_frame, const uint8_t *data_start,
1089  unsigned int data_size, int is_alpha_chunk)
1090 {
1091  WebPContext *s = avctx->priv_data;
1092  int w, h, ret, i, used;
1093 
1094  if (!is_alpha_chunk) {
1095  s->lossless = 1;
1096  avctx->pix_fmt = AV_PIX_FMT_ARGB;
1097  }
1098 
1099  ret = init_get_bits8(&s->gb, data_start, data_size);
1100  if (ret < 0)
1101  return ret;
1102 
1103  if (!is_alpha_chunk) {
1104  if (get_bits(&s->gb, 8) != 0x2F) {
1105  av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless signature\n");
1106  return AVERROR_INVALIDDATA;
1107  }
1108 
1109  w = get_bits(&s->gb, 14) + 1;
1110  h = get_bits(&s->gb, 14) + 1;
1111 
1112  update_canvas_size(avctx, w, h);
1113 
1114  ret = ff_set_dimensions(avctx, s->width, s->height);
1115  if (ret < 0)
1116  return ret;
1117 
1118  s->has_alpha = get_bits1(&s->gb);
1119 
1120  if (get_bits(&s->gb, 3) != 0x0) {
1121  av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless version\n");
1122  return AVERROR_INVALIDDATA;
1123  }
1124  } else {
1125  if (!s->width || !s->height)
1126  return AVERROR_BUG;
1127  w = s->width;
1128  h = s->height;
1129  }
1130 
1131  /* parse transformations */
1132  s->nb_transforms = 0;
1133  s->reduced_width = s->width;
1134  used = 0;
1135  while (get_bits1(&s->gb)) {
1136  enum TransformType transform = get_bits(&s->gb, 2);
1137  if (used & (1 << transform)) {
1138  av_log(avctx, AV_LOG_ERROR, "Transform %d used more than once\n",
1139  transform);
1141  goto free_and_return;
1142  }
1143  used |= (1 << transform);
1144  s->transforms[s->nb_transforms++] = transform;
1145  switch (transform) {
1146  case PREDICTOR_TRANSFORM:
1148  break;
1149  case COLOR_TRANSFORM:
1151  break;
1154  break;
1155  }
1156  if (ret < 0)
1157  goto free_and_return;
1158  }
1159 
1160  /* decode primary image */
1161  s->image[IMAGE_ROLE_ARGB].frame = p;
1162  if (is_alpha_chunk)
1163  s->image[IMAGE_ROLE_ARGB].is_alpha_primary = 1;
1165  if (ret < 0)
1166  goto free_and_return;
1167 
1168  /* apply transformations */
1169  for (i = s->nb_transforms - 1; i >= 0; i--) {
1170  switch (s->transforms[i]) {
1171  case PREDICTOR_TRANSFORM:
1173  break;
1174  case COLOR_TRANSFORM:
1176  break;
1177  case SUBTRACT_GREEN:
1179  break;
1182  break;
1183  }
1184  if (ret < 0)
1185  goto free_and_return;
1186  }
1187 
1188  *got_frame = 1;
1190  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;
1407  }
1408  bytestream2_skip(&gb, chunk_size);
1409  break;
1410  case MKTAG('V', 'P', '8', 'X'):
1411  if (s->width || s->height || *got_frame) {
1412  av_log(avctx, AV_LOG_ERROR, "Canvas dimensions are already set\n");
1413  return AVERROR_INVALIDDATA;
1414  }
1415  vp8x_flags = bytestream2_get_byte(&gb);
1416  bytestream2_skip(&gb, 3);
1417  s->width = bytestream2_get_le24(&gb) + 1;
1418  s->height = bytestream2_get_le24(&gb) + 1;
1419  ret = av_image_check_size(s->width, s->height, 0, avctx);
1420  if (ret < 0)
1421  return ret;
1422  break;
1423  case MKTAG('A', 'L', 'P', 'H'): {
1424  int alpha_header, filter_m, compression;
1425 
1426  if (!(vp8x_flags & VP8X_FLAG_ALPHA)) {
1427  av_log(avctx, AV_LOG_WARNING,
1428  "ALPHA chunk present, but alpha bit not set in the "
1429  "VP8X header\n");
1430  }
1431  if (chunk_size == 0) {
1432  av_log(avctx, AV_LOG_ERROR, "invalid ALPHA chunk size\n");
1433  return AVERROR_INVALIDDATA;
1434  }
1435  alpha_header = bytestream2_get_byte(&gb);
1436  s->alpha_data = avpkt->data + bytestream2_tell(&gb);
1437  s->alpha_data_size = chunk_size - 1;
1438  bytestream2_skip(&gb, s->alpha_data_size);
1439 
1440  filter_m = (alpha_header >> 2) & 0x03;
1441  compression = alpha_header & 0x03;
1442 
1443  if (compression > ALPHA_COMPRESSION_VP8L) {
1444  av_log(avctx, AV_LOG_VERBOSE,
1445  "skipping unsupported ALPHA chunk\n");
1446  } else {
1447  s->has_alpha = 1;
1448  s->alpha_compression = compression;
1449  s->alpha_filter = filter_m;
1450  }
1451 
1452  break;
1453  }
1454  case MKTAG('E', 'X', 'I', 'F'): {
1455  int le, ifd_offset, exif_offset = bytestream2_tell(&gb);
1456  AVDictionary *exif_metadata = NULL;
1457  GetByteContext exif_gb;
1458 
1459  if (s->has_exif) {
1460  av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra EXIF chunk\n");
1461  goto exif_end;
1462  }
1463  if (!(vp8x_flags & VP8X_FLAG_EXIF_METADATA))
1464  av_log(avctx, AV_LOG_WARNING,
1465  "EXIF chunk present, but Exif bit not set in the "
1466  "VP8X header\n");
1467 
1468  s->has_exif = 1;
1469  bytestream2_init(&exif_gb, avpkt->data + exif_offset,
1470  avpkt->size - exif_offset);
1471  if (ff_tdecode_header(&exif_gb, &le, &ifd_offset) < 0) {
1472  av_log(avctx, AV_LOG_ERROR, "invalid TIFF header "
1473  "in Exif data\n");
1474  goto exif_end;
1475  }
1476 
1477  bytestream2_seek(&exif_gb, ifd_offset, SEEK_SET);
1478  if (ff_exif_decode_ifd(avctx, &exif_gb, le, 0, &exif_metadata) < 0) {
1479  av_log(avctx, AV_LOG_ERROR, "error decoding Exif data\n");
1480  goto exif_end;
1481  }
1482 
1483  av_dict_copy(&p->metadata, exif_metadata, 0);
1484 
1485 exif_end:
1486  av_dict_free(&exif_metadata);
1487  bytestream2_skip(&gb, chunk_size);
1488  break;
1489  }
1490  case MKTAG('I', 'C', 'C', 'P'): {
1491  AVFrameSideData *sd;
1492 
1493  if (s->has_iccp) {
1494  av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra ICCP chunk\n");
1495  bytestream2_skip(&gb, chunk_size);
1496  break;
1497  }
1498  if (!(vp8x_flags & VP8X_FLAG_ICC))
1499  av_log(avctx, AV_LOG_WARNING,
1500  "ICCP chunk present, but ICC Profile bit not set in the "
1501  "VP8X header\n");
1502 
1503  s->has_iccp = 1;
1504 
1505  ret = ff_frame_new_side_data(avctx, p, AV_FRAME_DATA_ICC_PROFILE, chunk_size, &sd);
1506  if (ret < 0)
1507  return ret;
1508 
1509  if (sd) {
1510  bytestream2_get_buffer(&gb, sd->data, chunk_size);
1511  } else {
1512  bytestream2_skip(&gb, chunk_size);
1513  }
1514  break;
1515  }
1516  case MKTAG('A', 'N', 'I', 'M'):
1517  case MKTAG('A', 'N', 'M', 'F'):
1518  case MKTAG('X', 'M', 'P', ' '):
1519  AV_WL32(chunk_str, chunk_type);
1520  av_log(avctx, AV_LOG_WARNING, "skipping unsupported chunk: %s\n",
1521  chunk_str);
1522  bytestream2_skip(&gb, chunk_size);
1523  break;
1524  default:
1525  AV_WL32(chunk_str, chunk_type);
1526  av_log(avctx, AV_LOG_VERBOSE, "skipping unknown chunk: %s\n",
1527  chunk_str);
1528  bytestream2_skip(&gb, chunk_size);
1529  break;
1530  }
1531  }
1532 
1533  if (!*got_frame) {
1534  av_log(avctx, AV_LOG_ERROR, "image data not found\n");
1535  return AVERROR_INVALIDDATA;
1536  }
1537 
1538  return avpkt->size;
1539 }
1540 
1542 {
1543  WebPContext *s = avctx->priv_data;
1544 
1545  s->pkt = av_packet_alloc();
1546  if (!s->pkt)
1547  return AVERROR(ENOMEM);
1548 
1549  return 0;
1550 }
1551 
1553 {
1554  WebPContext *s = avctx->priv_data;
1555 
1556  av_packet_free(&s->pkt);
1557 
1558  if (s->initialized)
1559  return ff_vp8_decode_free(avctx);
1560 
1561  return 0;
1562 }
1563 
1565  .p.name = "webp",
1566  CODEC_LONG_NAME("WebP image"),
1567  .p.type = AVMEDIA_TYPE_VIDEO,
1568  .p.id = AV_CODEC_ID_WEBP,
1569  .priv_data_size = sizeof(WebPContext),
1572  .close = webp_decode_close,
1573  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1574  .caps_internal = FF_CODEC_CAP_ICC_PROFILES |
1576 };
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:427
ff_vp8_decode_free
av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
Definition: vp8.c:2854
HuffReader::vlc
VLC vlc
Definition: webp.c:174
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:866
extra_bits
#define extra_bits(eb)
Definition: intrax8.c:120
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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:424
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:288
color
Definition: vf_paletteuse.c:512
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:245
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:785
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
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:771
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:374
AVFrame::width
int width
Definition: frame.h:446
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:520
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:41
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:479
FFCodec
Definition: codec_internal.h:126
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:196
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVDictionary
Definition: dict.c:34
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:646
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:94
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
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:255
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:74
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:1087
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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:381
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:842
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:335
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:822
WebPContext::avctx
AVCodecContext * avctx
Definition: webp.c:199
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
finish
static void finish(void)
Definition: movenc.c:373
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:1072
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:891
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:778
ff_webp_decoder
const FFCodec ff_webp_decoder
Definition: webp.c:1564
color_transform_delta
static av_always_inline uint8_t color_transform_delta(uint8_t color_pred, uint8_t color)
Definition: webp.c:955
decode_entropy_coded_image
static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, int w, int h)
Definition: webp.c:553
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
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:332
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:180
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:545
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:1797
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:902
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
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:986
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:547
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:852
vlc_init
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:62
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:1552
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
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:73
apply_subtract_green_transform
static int apply_subtract_green_transform(WebPContext *s)
Definition: webp.c:985
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
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:875
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:895
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:388
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:495
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:1541
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:652
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:2898
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:417
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:476
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:757
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:521
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:1959
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:252
ImageContext::role
enum ImageRole role
Definition: webp.c:181
decode_entropy_image
static int decode_entropy_image(WebPContext *s)
Definition: webp.c:433
apply_color_transform
static int apply_color_transform(WebPContext *s)
Definition: webp.c:961
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:165
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:63
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:223
HuffReader
Definition: webp.c:173
parse_transform_predictor
static int parse_transform_predictor(WebPContext *s)
Definition: webp.c:463
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:792
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
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:1796
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:31
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:924
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:597
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AV_CODEC_ID_WEBP
@ AV_CODEC_ID_WEBP
Definition: codec_id.h:224
len
int len
Definition: vorbis_enc_data.h:426
exif.h
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
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:812
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:882
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
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:802
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:445
HUFF_IDX_BLUE
@ HUFF_IDX_BLUE
Definition: webp.c:140
IMAGE_ROLE_ENTROPY
@ IMAGE_ROLE_ENTROPY
Definition: webp.c:157
VLC
Definition: vlc.h:36
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:692
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:105
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:1000
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:250
VLC_INIT_OUTPUT_LE
#define VLC_INIT_OUTPUT_LE
Definition: vlc.h:188
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:427
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
PRED_MODE_L
@ PRED_MODE_L
Definition: webp.c:122
WebPContext
Definition: webp.c:194
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:497
ff_vp8_decode_frame
int ff_vp8_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: vp8.c:2840
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:237
VP8Context
Definition: vp8.h:161
d
d
Definition: ffmpeg_filter.c:424
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
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
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:419
read_huffman_code_simple
static void read_huffman_code_simple(WebPContext *s, HuffReader *hc)
Definition: webp.c:317
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
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:207
get_huffman_group
static HuffReader * get_huffman_group(WebPContext *s, ImageContext *img, int x, int y)
Definition: webp.c:530
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:832
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:764
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