FFmpeg
faxcompr.c
Go to the documentation of this file.
1 /*
2  * CCITT Fax Group 3 and 4 decompression
3  * Copyright (c) 2008 Konstantin Shishkov
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * CCITT Fax Group 3 and 4 decompression
25  * @author Konstantin Shishkov
26  */
27 #include "libavutil/thread.h"
28 #include "avcodec.h"
29 #include "get_bits.h"
30 #include "put_bits.h"
31 #include "faxcompr.h"
32 
33 #define CCITT_SYMS 104
34 
35 static const uint16_t ccitt_syms[CCITT_SYMS] = {
36  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
37  13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
38  26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39  39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
40  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
41  128, 192, 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896,
42  960, 1024, 1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728,
43  1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560
44 };
45 
47 {
48  {
49  0x35, 0x07, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, 0x13, 0x14, 0x07, 0x08, 0x08,
50  0x03, 0x34, 0x35, 0x2A, 0x2B, 0x27, 0x0C, 0x08, 0x17, 0x03, 0x04, 0x28, 0x2B,
51  0x13, 0x24, 0x18, 0x02, 0x03, 0x1A, 0x1B, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
52  0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x04, 0x05, 0x0A, 0x0B, 0x52, 0x53, 0x54,
53  0x55, 0x24, 0x25, 0x58, 0x59, 0x5A, 0x5B, 0x4A, 0x4B, 0x32, 0x33, 0x34, 0x1B,
54  0x12, 0x17, 0x37, 0x36, 0x37, 0x64, 0x65, 0x68, 0x67, 0xCC, 0xCD, 0xD2, 0xD3,
55  0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0x98, 0x99, 0x9A, 0x18, 0x9B,
56  0x08, 0x0C, 0x0D, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F
57  },
58  {
59  0x37, 0x02, 0x03, 0x02, 0x03, 0x03, 0x02, 0x03, 0x05, 0x04, 0x04, 0x05, 0x07,
60  0x04, 0x07, 0x18, 0x17, 0x18, 0x08, 0x67, 0x68, 0x6C, 0x37, 0x28, 0x17, 0x18,
61  0xCA, 0xCB, 0xCC, 0xCD, 0x68, 0x69, 0x6A, 0x6B, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
62  0xD7, 0x6C, 0x6D, 0xDA, 0xDB, 0x54, 0x55, 0x56, 0x57, 0x64, 0x65, 0x52, 0x53,
63  0x24, 0x37, 0x38, 0x27, 0x28, 0x58, 0x59, 0x2B, 0x2C, 0x5A, 0x66, 0x67, 0x0F,
64  0xC8, 0xC9, 0x5B, 0x33, 0x34, 0x35, 0x6C, 0x6D, 0x4A, 0x4B, 0x4C, 0x4D, 0x72,
65  0x73, 0x74, 0x75, 0x76, 0x77, 0x52, 0x53, 0x54, 0x55, 0x5A, 0x5B, 0x64, 0x65,
66  0x08, 0x0C, 0x0D, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F
67  }
68 };
69 
71 {
72  {
73  8, 6, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7,
74  7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76  8, 8, 8, 8, 5, 5, 6, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
77  9, 9, 9, 9, 9, 9, 9, 9, 9, 6, 9, 11, 11, 11, 12, 12, 12, 12, 12, 12,
78  12, 12, 12, 12
79  },
80  {
81  10, 3, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 7, 8, 8, 9, 10, 10, 10, 11,
82  11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
83  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
84  12, 12, 12, 12, 10, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13,
85  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 12, 12, 12, 12, 12, 12,
86  12, 12, 12, 12
87  }
88 };
89 
90 static const uint8_t ccitt_group3_2d_bits[11] = {
91  1, 1, 2, 2, 2, 1, 3, 3, 3, 1, 1
92 };
93 
94 static const uint8_t ccitt_group3_2d_lens[11] = {
95  4, 3, 7, 6, 3, 1, 3, 6, 7, 7, 9
96 };
97 
99 
100 static av_cold void ccitt_unpack_init(void)
101 {
102  static VLC_TYPE code_table1[528][2];
103  static VLC_TYPE code_table2[648][2];
104  int i;
105 
106  ccitt_vlc[0].table = code_table1;
107  ccitt_vlc[0].table_allocated = 528;
108  ccitt_vlc[1].table = code_table2;
109  ccitt_vlc[1].table_allocated = 648;
110  for (i = 0; i < 2; i++) {
111  ff_init_vlc_sparse(&ccitt_vlc[i], 9, CCITT_SYMS,
112  ccitt_codes_lens[i], 1, 1,
113  ccitt_codes_bits[i], 1, 1,
114  ccitt_syms, 2, 2,
116  }
117  INIT_VLC_STATIC(&ccitt_group3_2d_vlc, 9, 11,
118  ccitt_group3_2d_lens, 1, 1,
119  ccitt_group3_2d_bits, 1, 1, 512);
120 }
121 
123 {
124  static AVOnce init_static_once = AV_ONCE_INIT;
125  ff_thread_once(&init_static_once, ccitt_unpack_init);
126 }
127 
129  unsigned int *pix_left, int **runs,
130  const int *runend, int *mode)
131 {
132  int eob = 0;
133  int newmode;
134  int saved_run = 0;
135 
136  do {
137  int cwi, k;
138  int cw = 0;
139  int codes[2];
140  do {
141  cwi = show_bits(gb, 11);
142  if (!cwi) {
143  av_log(avctx, AV_LOG_ERROR, "Invalid uncompressed codeword\n");
144  return AVERROR_INVALIDDATA;
145  }
146  cwi = 10 - av_log2(cwi);
147  skip_bits(gb, cwi + 1);
148  if (cwi > 5) {
149  newmode = get_bits1(gb);
150  eob = 1;
151  cwi -= 6;
152  }
153  cw += cwi;
154  } while(cwi == 5);
155 
156  codes[0] = cw;
157  codes[1] = !eob;
158 
159  for (k = 0; k < 2; k++) {
160  if (codes[k]) {
161  if (*mode == !k) {
162  *(*runs)++ = saved_run;
163  if (*runs >= runend) {
164  av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");
165  return AVERROR_INVALIDDATA;
166  }
167  if (*pix_left <= saved_run) {
168  av_log(avctx, AV_LOG_ERROR, "uncompressed run went out of bounds\n");
169  return AVERROR_INVALIDDATA;
170  }
171  *pix_left -= saved_run;
172  saved_run = 0;
173  *mode = !*mode;
174  }
175  saved_run += codes[k];
176  }
177  }
178  } while (!eob);
179  *(*runs)++ = saved_run;
180  if (*runs >= runend) {
181  av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");
182  return AVERROR_INVALIDDATA;
183  }
184  if (*pix_left <= saved_run) {
185  if (*pix_left == saved_run)
186  return 1;
187  av_log(avctx, AV_LOG_ERROR, "uncompressed run went out of boundsE\n");
188  return AVERROR_INVALIDDATA;
189  }
190  *pix_left -= saved_run;
191  saved_run = 0;
192  *mode = !*mode;
193  if (newmode != *mode) { //FIXME CHECK
194  *(*runs)++ = 0;
195  if (*runs >= runend) {
196  av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");
197  return AVERROR_INVALIDDATA;
198  }
199  *mode = newmode;
200  }
201  return 0;
202 }
203 
205  unsigned int pix_left, int *runs,
206  const int *runend)
207 {
208  int mode = 0;
209  unsigned int run = 0;
210  unsigned int t;
211  for (;;) {
212  t = get_vlc2(gb, ccitt_vlc[mode].table, 9, 2);
213  run += t;
214  if (t < 64) {
215  *runs++ = run;
216  if (runs >= runend) {
217  av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
218  return AVERROR_INVALIDDATA;
219  }
220  if (pix_left <= run) {
221  if (pix_left == run)
222  break;
223  av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
224  return AVERROR_INVALIDDATA;
225  }
226  pix_left -= run;
227  run = 0;
228  mode = !mode;
229  } else if ((int)t == -1) {
230  if (show_bits(gb, 12) == 15) {
231  int ret;
232  skip_bits(gb, 12);
233  ret = decode_uncompressed(avctx, gb, &pix_left, &runs, runend, &mode);
234  if (ret < 0) {
235  return ret;
236  } else if (ret)
237  break;
238  } else {
239  av_log(avctx, AV_LOG_ERROR, "Incorrect code\n");
240  return AVERROR_INVALIDDATA;
241  }
242  }
243  }
244  *runs++ = 0;
245  return 0;
246 }
247 
249  unsigned int width, int *runs,
250  const int *runend, const int *ref)
251 {
252  int mode = 0, saved_run = 0, t;
253  int run_off = *ref++;
254  unsigned int offs = 0, run = 0;
255 
256  while (offs < width) {
257  int cmode = get_vlc2(gb, ccitt_group3_2d_vlc.table, 9, 1);
258  if (cmode == -1) {
259  av_log(avctx, AV_LOG_ERROR, "Incorrect mode VLC\n");
260  return AVERROR_INVALIDDATA;
261  }
262  if (!cmode) { //pass mode
263  if (run_off < width)
264  run_off += *ref++;
265  run = run_off - offs;
266  offs = run_off;
267  if (run_off < width)
268  run_off += *ref++;
269  if (offs > width) {
270  av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
271  return AVERROR_INVALIDDATA;
272  }
273  saved_run += run;
274  } else if (cmode == 1) { //horizontal mode
275  int k;
276  for (k = 0; k < 2; k++) {
277  run = 0;
278  for (;;) {
279  t = get_vlc2(gb, ccitt_vlc[mode].table, 9, 2);
280  if (t == -1) {
281  av_log(avctx, AV_LOG_ERROR, "Incorrect code\n");
282  return AVERROR_INVALIDDATA;
283  }
284  run += t;
285  if (t < 64)
286  break;
287  }
288  *runs++ = run + saved_run;
289  if (runs >= runend) {
290  av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
291  return AVERROR_INVALIDDATA;
292  }
293  saved_run = 0;
294  offs += run;
295  if (offs > width || run > width) {
296  av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
297  return AVERROR_INVALIDDATA;
298  }
299  mode = !mode;
300  }
301  } else if (cmode == 9 || cmode == 10) {
302  int xxx = get_bits(gb, 3);
303  if (cmode == 9 && xxx == 7) {
304  int ret;
305  int pix_left = width - offs;
306 
307  if (saved_run) {
308  av_log(avctx, AV_LOG_ERROR, "saved run %d on entering uncompressed mode\n", saved_run);
309  return AVERROR_INVALIDDATA;
310  }
311  ret = decode_uncompressed(avctx, gb, &pix_left, &runs, runend, &mode);
312  offs = width - pix_left;
313  if (ret < 0) {
314  return ret;
315  } else if (ret)
316  break;
317  } else {
318  avpriv_report_missing_feature(avctx, "Special mode %d xxx=%d support", cmode, xxx);
319  return AVERROR_PATCHWELCOME;
320  }
321  } else { //vertical mode
322  run = run_off - offs + (cmode - 5);
323  run_off -= *--ref;
324  offs += run;
325  if (offs > width || run > width) {
326  av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
327  return AVERROR_INVALIDDATA;
328  }
329  *runs++ = run + saved_run;
330  if (runs >= runend) {
331  av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
332  return AVERROR_INVALIDDATA;
333  }
334  saved_run = 0;
335  mode = !mode;
336  }
337  //sync line pointers
338  while (offs < width && run_off <= offs) {
339  run_off += *ref++;
340  run_off += *ref++;
341  }
342  }
343  *runs++ = saved_run;
344  if (saved_run) {
345  if (runs >= runend) {
346  av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
347  return -1;
348  }
349  *runs++ = 0;
350  }
351  return 0;
352 }
353 
354 static void put_line(uint8_t *dst, int size, int width, const int *runs)
355 {
356  PutBitContext pb;
357  int run, mode = ~0, pix_left = width, run_idx = 0;
358 
359  init_put_bits(&pb, dst, size);
360  while (pix_left > 0) {
361  run = runs[run_idx++];
362  mode = ~mode;
363  pix_left -= run;
364  for (; run > 16; run -= 16)
365  put_sbits(&pb, 16, mode);
366  if (run)
367  put_sbits(&pb, run, mode);
368  }
369  flush_put_bits(&pb);
370 }
371 
372 static int find_group3_syncmarker(GetBitContext *gb, int srcsize)
373 {
374  unsigned int state = -1;
375  srcsize -= get_bits_count(gb);
376  while (srcsize-- > 0) {
377  state += state + get_bits1(gb);
378  if ((state & 0xFFF) == 1)
379  return 0;
380  }
381  return -1;
382 }
383 
384 int ff_ccitt_unpack(AVCodecContext *avctx, const uint8_t *src, int srcsize,
385  uint8_t *dst, int height, int stride,
386  enum TiffCompr compr, int opts)
387 {
388  int j;
389  GetBitContext gb;
390  int *runs, *ref = NULL, *runend;
391  int ret;
392  int runsize = avctx->width + 2;
393  int has_eol;
394 
395  runs = av_malloc_array(runsize, sizeof(runs[0]));
396  ref = av_malloc_array(runsize, sizeof(ref[0]));
397  if (!runs || !ref) {
398  ret = AVERROR(ENOMEM);
399  goto fail;
400  }
401  ref[0] = avctx->width;
402  ref[1] = 0;
403  ref[2] = 0;
404  if ((ret = init_get_bits8(&gb, src, srcsize)) < 0)
405  goto fail;
406  has_eol = show_bits(&gb, 12) == 1 || show_bits(&gb, 16) == 1;
407 
408  for (j = 0; j < height; j++) {
409  runend = runs + runsize;
410  if (compr == TIFF_G4) {
411  ret = decode_group3_2d_line(avctx, &gb, avctx->width, runs, runend,
412  ref);
413  if (ret < 0)
414  goto fail;
415  } else {
416  int g3d1 = (compr == TIFF_G3) && !(opts & 1);
417  if (compr != TIFF_CCITT_RLE &&
418  has_eol &&
419  find_group3_syncmarker(&gb, srcsize * 8) < 0)
420  break;
421  if (compr == TIFF_CCITT_RLE || g3d1 || get_bits1(&gb))
422  ret = decode_group3_1d_line(avctx, &gb, avctx->width, runs,
423  runend);
424  else
425  ret = decode_group3_2d_line(avctx, &gb, avctx->width, runs,
426  runend, ref);
427  if (compr == TIFF_CCITT_RLE)
428  align_get_bits(&gb);
429  }
430  if (avctx->err_recognition & AV_EF_EXPLODE && ret < 0)
431  goto fail;
432 
433  if (ret < 0) {
434  put_line(dst, stride, avctx->width, ref);
435  } else {
436  put_line(dst, stride, avctx->width, runs);
437  FFSWAP(int *, runs, ref);
438  }
439  dst += stride;
440  }
441  ret = 0;
442 fail:
443  av_free(runs);
444  av_free(ref);
445  return ret;
446 }
#define CCITT_SYMS
Definition: faxcompr.c:33
#define NULL
Definition: coverity.c:32
static int find_group3_syncmarker(GetBitContext *gb, int srcsize)
Definition: faxcompr.c:372
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int decode_group3_1d_line(AVCodecContext *avctx, GetBitContext *gb, unsigned int pix_left, int *runs, const int *runend)
Definition: faxcompr.c:204
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:260
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:323
int av_log2(unsigned v)
Definition: intmath.c:26
static void put_line(uint8_t *dst, int size, int width, const int *runs)
Definition: faxcompr.c:354
uint8_t run
Definition: svq3.c:205
static int decode_group3_2d_line(AVCodecContext *avctx, GetBitContext *gb, unsigned int width, int *runs, const int *runend, const int *ref)
Definition: faxcompr.c:248
Definition: tiff.h:124
static const uint8_t ccitt_group3_2d_bits[11]
Definition: faxcompr.c:90
av_cold void ff_ccitt_unpack_init(void)
initialize unpacker code
Definition: faxcompr.c:122
uint8_t
#define av_cold
Definition: attributes.h:88
#define height
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:100
#define AVOnce
Definition: thread.h:172
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
#define src
Definition: vp8dsp.c:255
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static const uint16_t ccitt_syms[CCITT_SYMS]
Definition: faxcompr.c:35
static const uint8_t ccitt_codes_bits[2][CCITT_SYMS]
Definition: faxcompr.c:46
int ff_ccitt_unpack(AVCodecContext *avctx, const uint8_t *src, int srcsize, uint8_t *dst, int height, int stride, enum TiffCompr compr, int opts)
unpack data compressed with CCITT Group 3 1/2-D or Group 4 method
Definition: faxcompr.c:384
#define fail()
Definition: checkasm.h:123
Definition: vlc.h:26
AVDictionary * opts
Definition: movenc.c:50
static av_cold void ccitt_unpack_init(void)
Definition: faxcompr.c:100
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1660
#define width
int width
picture width / height.
Definition: avcodec.h:704
static int decode_uncompressed(AVCodecContext *avctx, GetBitContext *gb, unsigned int *pix_left, int **runs, const int *runend, int *mode)
Definition: faxcompr.c:128
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1671
static VLC ccitt_group3_2d_vlc
Definition: faxcompr.c:98
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int table_allocated
Definition: vlc.h:29
#define AV_ONCE_INIT
Definition: thread.h:173
TiffCompr
list of TIFF, TIFF/EP and DNG compression types
Definition: tiff.h:120
Libavcodec external API header.
static struct @320 state
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:531
Definition: tiff.h:123
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
static const uint8_t ccitt_group3_2d_lens[11]
Definition: faxcompr.c:94
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
static VLC ccitt_vlc[2]
Definition: faxcompr.c:98
static const uint8_t ccitt_codes_lens[2][CCITT_SYMS]
Definition: faxcompr.c:70
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:117
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:64
#define av_free(p)
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
#define VLC_TYPE
Definition: vlc.h:24
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
Definition: common.h:99
#define stride
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
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
CCITT Fax Group 3 and 4 decompression.
int i
Definition: input.c:407
bitstream writer API