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