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  }
176 
177  if (f->version > 2) {
178  unsigned v;
179  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref,
180  f->avctx->extradata, f->avctx->extradata_size);
181  if (v != f->crcref || f->avctx->extradata_size < 4) {
182  av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
183  return AVERROR_INVALIDDATA;
184  }
185  crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
186  }
187 
188  if (f->avctx->debug & FF_DEBUG_PICT_INFO)
189  av_log(f->avctx, AV_LOG_DEBUG,
190  "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",
191  f->version, f->micro_version,
192  f->ac,
193  f->colorspace,
194  f->avctx->bits_per_raw_sample,
195  f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift,
196  f->transparency,
197  f->num_h_slices, f->num_v_slices,
198  f->quant_table_count,
199  f->ec,
200  f->intra,
201  crc
202  );
203  return 0;
204 }
205 
206 int ff_ffv1_parse_header(FFV1Context *f, RangeCoder *c, uint8_t *state)
207 {
208  if (f->version < 2) {
209  int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
210  unsigned v= ff_ffv1_get_symbol(c, state, 0);
211  if (v >= 2) {
212  av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
213  return AVERROR_INVALIDDATA;
214  }
215  f->version = v;
216  f->ac = ff_ffv1_get_symbol(c, state, 0);
217 
218  if (f->ac == AC_RANGE_CUSTOM_TAB) {
219  for (int i = 1; i < 256; i++) {
220  int st = ff_ffv1_get_symbol(c, state, 1) + c->one_state[i];
221  if (st < 1 || st > 255) {
222  av_log(f->avctx, AV_LOG_ERROR, "invalid state transition %d\n", st);
223  return AVERROR_INVALIDDATA;
224  }
225  f->state_transition[i] = st;
226  }
227  } else {
228  RangeCoder rc;
229  ff_build_rac_states(&rc, 0.05 * (1LL << 32), 256 - 8);
230  for (int i = 1; i < 256; i++)
231  f->state_transition[i] = rc.one_state[i];
232  }
233 
234  colorspace = ff_ffv1_get_symbol(c, state, 0); //YUV cs type
235  bits_per_raw_sample = f->version > 0 ? ff_ffv1_get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
236  chroma_planes = get_rac(c, state);
237  chroma_h_shift = ff_ffv1_get_symbol(c, state, 0);
238  chroma_v_shift = ff_ffv1_get_symbol(c, state, 0);
239  transparency = get_rac(c, state);
240  if (colorspace == 0 && f->avctx->skip_alpha)
241  transparency = 0;
242 
243  if (f->plane_count) {
244  if (colorspace != f->colorspace ||
245  bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
246  chroma_planes != f->chroma_planes ||
247  chroma_h_shift != f->chroma_h_shift ||
248  chroma_v_shift != f->chroma_v_shift ||
249  transparency != f->transparency) {
250  av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
251  return AVERROR_INVALIDDATA;
252  }
253  }
254 
255  if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
256  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
257  chroma_h_shift, chroma_v_shift);
258  return AVERROR_INVALIDDATA;
259  }
260 
261  f->colorspace = colorspace;
262  f->avctx->bits_per_raw_sample = bits_per_raw_sample;
263  f->chroma_planes = chroma_planes;
264  f->chroma_h_shift = chroma_h_shift;
265  f->chroma_v_shift = chroma_v_shift;
266  f->transparency = transparency;
267 
268  f->plane_count = 2 + f->transparency;
269  }
270 
271  if (f->colorspace == 0) {
272  if (!f->transparency && !f->chroma_planes) {
273  if (f->avctx->bits_per_raw_sample <= 8)
274  f->pix_fmt = AV_PIX_FMT_GRAY8;
275  else if (f->avctx->bits_per_raw_sample == 9) {
276  f->packed_at_lsb = 1;
277  f->pix_fmt = AV_PIX_FMT_GRAY9;
278  } else if (f->avctx->bits_per_raw_sample == 10) {
279  f->packed_at_lsb = 1;
280  f->pix_fmt = AV_PIX_FMT_GRAY10;
281  } else if (f->avctx->bits_per_raw_sample == 12) {
282  f->packed_at_lsb = 1;
283  f->pix_fmt = AV_PIX_FMT_GRAY12;
284  } else if (f->avctx->bits_per_raw_sample == 14) {
285  f->packed_at_lsb = 1;
286  f->pix_fmt = AV_PIX_FMT_GRAY14;
287  } else if (f->avctx->bits_per_raw_sample == 16) {
288  f->packed_at_lsb = 1;
289  f->pix_fmt = AV_PIX_FMT_GRAY16;
290  } else if (f->avctx->bits_per_raw_sample < 16) {
291  f->pix_fmt = AV_PIX_FMT_GRAY16;
292  } else
293  return AVERROR(ENOSYS);
294  } else if (f->transparency && !f->chroma_planes) {
295  if (f->avctx->bits_per_raw_sample <= 8)
296  f->pix_fmt = AV_PIX_FMT_YA8;
297  else
298  return AVERROR(ENOSYS);
299  } else if (f->avctx->bits_per_raw_sample<=8 && !f->transparency) {
300  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
301  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P; break;
302  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P; break;
303  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P; break;
304  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P; break;
305  case 0x20: f->pix_fmt = AV_PIX_FMT_YUV411P; break;
306  case 0x22: f->pix_fmt = AV_PIX_FMT_YUV410P; break;
307  }
308  } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
309  switch(16*f->chroma_h_shift + f->chroma_v_shift) {
310  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P; break;
311  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P; break;
312  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P; break;
313  }
314  } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
315  f->packed_at_lsb = 1;
316  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
317  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P9; break;
318  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P9; break;
319  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P9; break;
320  }
321  } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) {
322  f->packed_at_lsb = 1;
323  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
324  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P9; break;
325  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P9; break;
326  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P9; break;
327  }
328  } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
329  f->packed_at_lsb = 1;
330  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
331  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P10; break;
332  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P10; break;
333  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P10; break;
334  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P10; break;
335  }
336  } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) {
337  f->packed_at_lsb = 1;
338  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
339  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P10; break;
340  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
341  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
342  }
343  } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
344  f->packed_at_lsb = 1;
345  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
346  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P12; break;
347  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P12; break;
348  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P12; break;
349  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P12; break;
350  }
351  } else if (f->avctx->bits_per_raw_sample == 12 && f->transparency) {
352  f->packed_at_lsb = 1;
353  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
354  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P12; break;
355  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P12; break;
356  }
357  } else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency) {
358  f->packed_at_lsb = 1;
359  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
360  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P14; break;
361  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P14; break;
362  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P14; break;
363  }
364  } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
365  f->packed_at_lsb = 1;
366  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
367  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P16; break;
368  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P16; break;
369  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P16; break;
370  }
371  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
372  f->packed_at_lsb = 1;
373  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
374  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
375  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
376  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P16; break;
377  }
378  }
379  } else if (f->colorspace == 1) {
380  if (f->chroma_h_shift || f->chroma_v_shift) {
381  av_log(f->avctx, AV_LOG_ERROR,
382  "chroma subsampling not supported in this colorspace\n");
383  return AVERROR(ENOSYS);
384  }
385  if ( f->avctx->bits_per_raw_sample <= 8 && !f->transparency)
386  f->pix_fmt = AV_PIX_FMT_0RGB32;
387  else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency)
388  f->pix_fmt = AV_PIX_FMT_RGB32;
389  else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency)
390  f->pix_fmt = AV_PIX_FMT_GBRP9;
391  else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
392  f->pix_fmt = AV_PIX_FMT_GBRP10;
393  else if (f->avctx->bits_per_raw_sample == 10 && f->transparency)
394  f->pix_fmt = AV_PIX_FMT_GBRAP10;
395  else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
396  f->pix_fmt = AV_PIX_FMT_GBRP12;
397  else if (f->avctx->bits_per_raw_sample == 12 && f->transparency)
398  f->pix_fmt = AV_PIX_FMT_GBRAP12;
399  else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
400  f->pix_fmt = AV_PIX_FMT_GBRP14;
401  else if (f->avctx->bits_per_raw_sample == 14 && f->transparency)
402  f->pix_fmt = AV_PIX_FMT_GBRAP14;
403  else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
404  f->pix_fmt = AV_PIX_FMT_GBRP16;
405  f->use32bit = 1;
406  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency) {
407  f->pix_fmt = AV_PIX_FMT_GBRAP16;
408  f->use32bit = 1;
409  }
410  } else {
411  av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
412  return AVERROR(ENOSYS);
413  }
414  if (f->pix_fmt == AV_PIX_FMT_NONE) {
415  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
416  return AVERROR(ENOSYS);
417  }
418 
419  return 0;
420 }
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:562
ff_ffv1_parse_header
int ff_ffv1_parse_header(FFV1Context *f, RangeCoder *c, uint8_t *state)
Definition: ffv1_parse.c:206
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:538
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:554
pixdesc.h
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:561
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:556
rangecoder.h
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:515
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:557
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:495
crc.h
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:553
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:533
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:531
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:563
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:513
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:499
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:518
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:527
RangeCoder::one_state
uint8_t one_state[256]
Definition: rangecoder.h:41
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:535
AV_PIX_FMT_GBRAP14
#define AV_PIX_FMT_GBRAP14
Definition: pixfmt.h:537
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:536
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:528
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:560
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:512
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:526
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:498
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:496
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:534
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:517
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:516
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:530
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:520
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:522
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:488
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:558
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:532
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:514
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:492
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:555
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:519
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:524
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:559
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:110
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:521
RangeCoder
Definition: mss3.c:63
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:525
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:497
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:523
Generated on Sun Feb 23 2025 19:21:46 for FFmpeg by   doxygen 1.8.17