FFmpeg
ffv1_parse.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/crc.h"
20 #include "libavutil/mem.h"
21 #include "libavutil/pixdesc.h"
22 #include "rangecoder.h"
23 #include "ffv1.h"
24 
25 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
26 {
27  int v;
28  int i = 0;
29  uint8_t state[CONTEXT_SIZE];
30 
31  memset(state, 128, sizeof(state));
32 
33  for (v = 0; i < 128; v++) {
34  unsigned len = ff_ffv1_get_symbol(c, state, 0) + 1U;
35 
36  if (len > 128 - i || !len)
37  return AVERROR_INVALIDDATA;
38 
39  while (len--) {
40  quant_table[i] = scale * v;
41  i++;
42  }
43  }
44 
45  for (i = 1; i < 128; i++)
46  quant_table[256 - i] = -quant_table[i];
47  quant_table[128] = -quant_table[127];
48 
49  return 2 * v - 1;
50 }
51 
52 int ff_ffv1_read_quant_tables(RangeCoder *c,
53  int16_t quant_table[MAX_CONTEXT_INPUTS][256])
54 {
55  int i;
56  int context_count = 1;
57 
58  for (i = 0; i < 5; i++) {
59  int ret = read_quant_table(c, quant_table[i], context_count);
60  if (ret < 0)
61  return ret;
62  context_count *= ret;
63  if (context_count > 32768U) {
64  return AVERROR_INVALIDDATA;
65  }
66  }
67  return (context_count + 1) / 2;
68 }
69 
70 int ff_ffv1_read_extra_header(FFV1Context *f)
71 {
72  RangeCoder c;
73  uint8_t state[CONTEXT_SIZE];
74  int ret;
75  uint8_t state2[32][CONTEXT_SIZE];
76  unsigned crc = 0;
77 
78  memset(state2, 128, sizeof(state2));
79  memset(state, 128, sizeof(state));
80 
81  ff_init_range_decoder(&c, f->avctx->extradata, f->avctx->extradata_size);
82  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
83 
84  f->version = ff_ffv1_get_symbol(&c, state, 0);
85  if (f->version < 2) {
86  av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
87  return AVERROR_INVALIDDATA;
88  }
89  if (f->version > 4) {
90  av_log(f->avctx, AV_LOG_ERROR, "unsupported version %d\n",
91  f->version);
92  return AVERROR_PATCHWELCOME;
93  }
94  f->combined_version = f->version << 16;
95  if (f->version > 2) {
96  c.bytestream_end -= 4;
97  f->micro_version = ff_ffv1_get_symbol(&c, state, 0);
98  if (f->micro_version < 0 || f->micro_version > 65535)
99  return AVERROR_INVALIDDATA;
100  f->combined_version += f->micro_version;
101  }
102  f->ac = ff_ffv1_get_symbol(&c, state, 0);
103 
104  if (f->ac == AC_RANGE_CUSTOM_TAB) {
105  for (int i = 1; i < 256; i++)
106  f->state_transition[i] = ff_ffv1_get_symbol(&c, state, 1) + c.one_state[i];
107  } else {
108  RangeCoder rc;
109  ff_build_rac_states(&rc, 0.05 * (1LL << 32), 256 - 8);
110  for (int i = 1; i < 256; i++)
111  f->state_transition[i] = rc.one_state[i];
112  }
113 
114  f->colorspace = ff_ffv1_get_symbol(&c, state, 0); //YUV cs type
115  f->avctx->bits_per_raw_sample = ff_ffv1_get_symbol(&c, state, 0);
116  f->chroma_planes = get_rac(&c, state);
117  f->chroma_h_shift = ff_ffv1_get_symbol(&c, state, 0);
118  f->chroma_v_shift = ff_ffv1_get_symbol(&c, state, 0);
119  f->transparency = get_rac(&c, state);
120  f->plane_count = 1 + (f->chroma_planes || f->version<4) + f->transparency;
121  f->num_h_slices = 1 + ff_ffv1_get_symbol(&c, state, 0);
122  f->num_v_slices = 1 + ff_ffv1_get_symbol(&c, state, 0);
123 
124  if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
125  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
126  f->chroma_h_shift, f->chroma_v_shift);
127  return AVERROR_INVALIDDATA;
128  }
129 
130  if (f->num_h_slices > (unsigned)f->width || !f->num_h_slices ||
131  f->num_v_slices > (unsigned)f->height || !f->num_v_slices
132  ) {
133  av_log(f->avctx, AV_LOG_ERROR, "slice count invalid\n");
134  return AVERROR_INVALIDDATA;
135  }
136 
137  if (f->num_h_slices > MAX_SLICES / f->num_v_slices) {
138  av_log(f->avctx, AV_LOG_ERROR, "slice count unsupported\n");
139  return AVERROR_PATCHWELCOME;
140  }
141 
142  f->quant_table_count = ff_ffv1_get_symbol(&c, state, 0);
143  if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
144  av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
145  f->quant_table_count = 0;
146  return AVERROR_INVALIDDATA;
147  }
148 
149  for (int i = 0; i < f->quant_table_count; i++) {
150  f->context_count[i] = ff_ffv1_read_quant_tables(&c, f->quant_tables[i]);
151  if (f->context_count[i] < 0) {
152  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
153  return AVERROR_INVALIDDATA;
154  }
155  }
156  if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
157  return ret;
158 
159  for (int i = 0; i < f->quant_table_count; i++)
160  if (get_rac(&c, state)) {
161  for (int j = 0; j < f->context_count[i]; j++)
162  for (int k = 0; k < CONTEXT_SIZE; k++) {
163  int pred = j ? f->initial_states[i][j - 1][k] : 128;
164  f->initial_states[i][j][k] =
165  (pred + ff_ffv1_get_symbol(&c, state2[k], 1)) & 0xFF;
166  }
167  }
168 
169  if (f->version > 2) {
170  f->ec = ff_ffv1_get_symbol(&c, state, 0);
171  if (f->ec >= 2)
172  f->crcref = 0x7a8c4079;
173  if (f->combined_version >= 0x30003)
174  f->intra = ff_ffv1_get_symbol(&c, state, 0);
175  if (f->combined_version >= 0x40004)
176  f->flt = ff_ffv1_get_symbol(&c, state, 0);
177  }
178 
179  if (f->version > 2) {
180  unsigned v;
181  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref,
182  f->avctx->extradata, f->avctx->extradata_size);
183  if (v != f->crcref || f->avctx->extradata_size < 4) {
184  av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
185  return AVERROR_INVALIDDATA;
186  }
187  crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
188  }
189 
190  if (f->avctx->debug & FF_DEBUG_PICT_INFO)
191  av_log(f->avctx, AV_LOG_DEBUG,
192  "global: ver:%d.%d, coder:%d, colorspace: %d bpr:%d chroma:%d(%d:%d), alpha:%d slices:%dx%d qtabs:%d ec:%d intra:%d CRC:0x%08X\n",
193  f->version, f->micro_version,
194  f->ac,
195  f->colorspace,
196  f->avctx->bits_per_raw_sample,
197  f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift,
198  f->transparency,
199  f->num_h_slices, f->num_v_slices,
200  f->quant_table_count,
201  f->ec,
202  f->intra,
203  crc
204  );
205  return 0;
206 }
207 
208 int ff_ffv1_parse_header(FFV1Context *f, RangeCoder *c, uint8_t *state)
209 {
210  if (f->version < 2) {
211  int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
212  unsigned v= ff_ffv1_get_symbol(c, state, 0);
213  if (v >= 2) {
214  av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
215  return AVERROR_INVALIDDATA;
216  }
217  f->version = v;
218  f->ac = ff_ffv1_get_symbol(c, state, 0);
219 
220  if (f->ac == AC_RANGE_CUSTOM_TAB) {
221  for (int i = 1; i < 256; i++) {
222  int st = ff_ffv1_get_symbol(c, state, 1) + c->one_state[i];
223  if (st < 1 || st > 255) {
224  av_log(f->avctx, AV_LOG_ERROR, "invalid state transition %d\n", st);
225  return AVERROR_INVALIDDATA;
226  }
227  f->state_transition[i] = st;
228  }
229  } else {
230  RangeCoder rc;
231  ff_build_rac_states(&rc, 0.05 * (1LL << 32), 256 - 8);
232  for (int i = 1; i < 256; i++)
233  f->state_transition[i] = rc.one_state[i];
234  }
235 
236  colorspace = ff_ffv1_get_symbol(c, state, 0); //YUV cs type
237  bits_per_raw_sample = f->version > 0 ? ff_ffv1_get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
238  chroma_planes = get_rac(c, state);
239  chroma_h_shift = ff_ffv1_get_symbol(c, state, 0);
240  chroma_v_shift = ff_ffv1_get_symbol(c, state, 0);
241  transparency = get_rac(c, state);
242  if (colorspace == 0 && f->avctx->skip_alpha)
243  transparency = 0;
244 
245  if (f->plane_count) {
246  if (colorspace != f->colorspace ||
247  bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
248  chroma_planes != f->chroma_planes ||
249  chroma_h_shift != f->chroma_h_shift ||
250  chroma_v_shift != f->chroma_v_shift ||
251  transparency != f->transparency) {
252  av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
253  return AVERROR_INVALIDDATA;
254  }
255  }
256 
257  if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
258  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
259  chroma_h_shift, chroma_v_shift);
260  return AVERROR_INVALIDDATA;
261  }
262 
263  f->colorspace = colorspace;
264  f->avctx->bits_per_raw_sample = bits_per_raw_sample;
265  f->chroma_planes = chroma_planes;
266  f->chroma_h_shift = chroma_h_shift;
267  f->chroma_v_shift = chroma_v_shift;
268  f->transparency = transparency;
269 
270  f->plane_count = 2 + f->transparency;
271  }
272 
273  if (f->colorspace == 0) {
274  if (!f->transparency && !f->chroma_planes) {
275  if (f->avctx->bits_per_raw_sample <= 8)
276  f->pix_fmt = AV_PIX_FMT_GRAY8;
277  else if (f->avctx->bits_per_raw_sample == 9) {
278  f->packed_at_lsb = 1;
279  f->pix_fmt = AV_PIX_FMT_GRAY9;
280  } else if (f->avctx->bits_per_raw_sample == 10) {
281  f->packed_at_lsb = 1;
282  f->pix_fmt = AV_PIX_FMT_GRAY10;
283  } else if (f->avctx->bits_per_raw_sample == 12) {
284  f->packed_at_lsb = 1;
285  f->pix_fmt = AV_PIX_FMT_GRAY12;
286  } else if (f->avctx->bits_per_raw_sample == 14) {
287  f->packed_at_lsb = 1;
288  f->pix_fmt = AV_PIX_FMT_GRAY14;
289  } else if (f->avctx->bits_per_raw_sample == 16) {
290  f->packed_at_lsb = 1;
291  f->pix_fmt = AV_PIX_FMT_GRAY16;
292  } else if (f->avctx->bits_per_raw_sample < 16) {
293  f->pix_fmt = AV_PIX_FMT_GRAY16;
294  } else
295  return AVERROR(ENOSYS);
296  } else if (f->transparency && !f->chroma_planes) {
297  if (f->avctx->bits_per_raw_sample <= 8)
298  f->pix_fmt = AV_PIX_FMT_YA8;
299  else
300  return AVERROR(ENOSYS);
301  } else if (f->avctx->bits_per_raw_sample<=8 && !f->transparency) {
302  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
303  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P; break;
304  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P; break;
305  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P; break;
306  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P; break;
307  case 0x20: f->pix_fmt = AV_PIX_FMT_YUV411P; break;
308  case 0x22: f->pix_fmt = AV_PIX_FMT_YUV410P; break;
309  }
310  } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
311  switch(16*f->chroma_h_shift + f->chroma_v_shift) {
312  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P; break;
313  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P; break;
314  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P; break;
315  }
316  } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
317  f->packed_at_lsb = 1;
318  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
319  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P9; break;
320  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P9; break;
321  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P9; break;
322  }
323  } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) {
324  f->packed_at_lsb = 1;
325  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
326  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P9; break;
327  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P9; break;
328  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P9; break;
329  }
330  } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
331  f->packed_at_lsb = 1;
332  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
333  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P10; break;
334  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P10; break;
335  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P10; break;
336  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P10; break;
337  }
338  } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) {
339  f->packed_at_lsb = 1;
340  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
341  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P10; break;
342  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
343  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
344  }
345  } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
346  f->packed_at_lsb = 1;
347  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
348  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P12; break;
349  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P12; break;
350  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P12; break;
351  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P12; break;
352  }
353  } else if (f->avctx->bits_per_raw_sample == 12 && f->transparency) {
354  f->packed_at_lsb = 1;
355  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
356  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P12; break;
357  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P12; break;
358  }
359  } else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency) {
360  f->packed_at_lsb = 1;
361  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
362  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P14; break;
363  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P14; break;
364  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P14; break;
365  }
366  } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
367  f->packed_at_lsb = 1;
368  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
369  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P16; break;
370  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P16; break;
371  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P16; break;
372  }
373  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
374  f->packed_at_lsb = 1;
375  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
376  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
377  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
378  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P16; break;
379  }
380  }
381  } else if (f->colorspace == 1) {
382  if (f->chroma_h_shift || f->chroma_v_shift) {
383  av_log(f->avctx, AV_LOG_ERROR,
384  "chroma subsampling not supported in this colorspace\n");
385  return AVERROR(ENOSYS);
386  }
387  if ( f->avctx->bits_per_raw_sample <= 8 && !f->transparency)
388  f->pix_fmt = AV_PIX_FMT_0RGB32;
389  else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency)
390  f->pix_fmt = AV_PIX_FMT_RGB32;
391  else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency)
392  f->pix_fmt = AV_PIX_FMT_GBRP9;
393  else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
394  f->pix_fmt = AV_PIX_FMT_GBRP10;
395  else if (f->avctx->bits_per_raw_sample == 10 && f->transparency)
396  f->pix_fmt = AV_PIX_FMT_GBRAP10;
397  else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
398  f->pix_fmt = AV_PIX_FMT_GBRP12;
399  else if (f->avctx->bits_per_raw_sample == 12 && f->transparency)
400  f->pix_fmt = AV_PIX_FMT_GBRAP12;
401  else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
402  f->pix_fmt = AV_PIX_FMT_GBRP14;
403  else if (f->avctx->bits_per_raw_sample == 14 && f->transparency)
404  f->pix_fmt = AV_PIX_FMT_GBRAP14;
405  else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
406  if (f->flt) {
407  f->pix_fmt = AV_PIX_FMT_GBRPF16;
408  } else
409  f->pix_fmt = AV_PIX_FMT_GBRP16;
410  f->use32bit = 1;
411  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency) {
412  if (f->flt) {
413  f->pix_fmt = AV_PIX_FMT_GBRAPF16;
414  } else
415  f->pix_fmt = AV_PIX_FMT_GBRAP16;
416  f->use32bit = 1;
417  }
418  } else {
419  av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
420  return AVERROR(ENOSYS);
421  }
422  if (f->pix_fmt == AV_PIX_FMT_NONE) {
423  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
424  return AVERROR(ENOSYS);
425  }
426 
427  return 0;
428 }
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:575
ff_ffv1_parse_header
int ff_ffv1_parse_header(FFV1Context *f, RangeCoder *c, uint8_t *state)
Definition: ffv1_parse.c:208
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:548
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
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
ff_ffv1_read_extra_header
int ff_ffv1_read_extra_header(FFV1Context *f)
Definition: ffv1_parse.c:70
ff_ffv1_read_quant_tables
int ff_ffv1_read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256])
Definition: ffv1_parse.c:52
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:567
pixdesc.h
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:574
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:569
rangecoder.h
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:525
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:54
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:570
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1415
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:504
crc.h
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:566
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:543
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:541
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:576
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:523
MAX_SLICES
#define MAX_SLICES
Definition: d3d12va_hevc.c:33
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:508
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:528
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:537
RangeCoder::one_state
uint8_t one_state[256]
Definition: rangecoder.h:41
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:545
AV_PIX_FMT_GBRAP14
#define AV_PIX_FMT_GBRAP14
Definition: pixfmt.h:547
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:546
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
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:538
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:573
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:522
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:536
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:507
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
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:505
quant_table
static const int16_t quant_table[64]
Definition: intrax8.c:517
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:544
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:527
ff_ffv1_get_symbol
int ff_ffv1_get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: ffv1.c:222
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:526
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:540
AV_PIX_FMT_GBRPF16
#define AV_PIX_FMT_GBRPF16
Definition: pixfmt.h:555
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
ff_init_range_decoder
av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: rangecoder.c:53
f
f
Definition: af_crystalizer.c:122
state
static struct @474 state
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:530
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
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
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:532
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:497
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:571
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:542
ffv1.h
read_quant_table
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
Definition: ffv1_parse.c:25
len
int len
Definition: vorbis_enc_data.h:426
get_rac
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:118
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:524
MAX_CONTEXT_INPUTS
#define MAX_CONTEXT_INPUTS
Definition: ffv1.h:50
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:501
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:568
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:529
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:534
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:183
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:572
AV_PIX_FMT_GBRAPF16
#define AV_PIX_FMT_GBRAPF16
Definition: pixfmt.h:556
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
MAX_QUANT_TABLES
#define MAX_QUANT_TABLES
Definition: ffv1.h:47
FFV1Context
Definition: ffv1.h:112
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
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
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:531
RangeCoder
Definition: mss3.c:63
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:535
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:506
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:533
Generated on Fri Mar 14 2025 19:21:49 for FFmpeg by   doxygen 1.8.17