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  }
108 
109  f->colorspace = ff_ffv1_get_symbol(&c, state, 0); //YUV cs type
110  f->avctx->bits_per_raw_sample = ff_ffv1_get_symbol(&c, state, 0);
111  f->chroma_planes = get_rac(&c, state);
112  f->chroma_h_shift = ff_ffv1_get_symbol(&c, state, 0);
113  f->chroma_v_shift = ff_ffv1_get_symbol(&c, state, 0);
114  f->transparency = get_rac(&c, state);
115  f->plane_count = 1 + (f->chroma_planes || f->version<4) + f->transparency;
116  f->num_h_slices = 1 + ff_ffv1_get_symbol(&c, state, 0);
117  f->num_v_slices = 1 + ff_ffv1_get_symbol(&c, state, 0);
118 
119  if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
120  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
121  f->chroma_h_shift, f->chroma_v_shift);
122  return AVERROR_INVALIDDATA;
123  }
124 
125  if (f->num_h_slices > (unsigned)f->width || !f->num_h_slices ||
126  f->num_v_slices > (unsigned)f->height || !f->num_v_slices
127  ) {
128  av_log(f->avctx, AV_LOG_ERROR, "slice count invalid\n");
129  return AVERROR_INVALIDDATA;
130  }
131 
132  if (f->num_h_slices > MAX_SLICES / f->num_v_slices) {
133  av_log(f->avctx, AV_LOG_ERROR, "slice count unsupported\n");
134  return AVERROR_PATCHWELCOME;
135  }
136 
137  f->quant_table_count = ff_ffv1_get_symbol(&c, state, 0);
138  if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
139  av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
140  f->quant_table_count = 0;
141  return AVERROR_INVALIDDATA;
142  }
143 
144  for (int i = 0; i < f->quant_table_count; i++) {
145  f->context_count[i] = ff_ffv1_read_quant_tables(&c, f->quant_tables[i]);
146  if (f->context_count[i] < 0) {
147  av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
148  return AVERROR_INVALIDDATA;
149  }
150  }
151  if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
152  return ret;
153 
154  for (int i = 0; i < f->quant_table_count; i++)
155  if (get_rac(&c, state)) {
156  for (int j = 0; j < f->context_count[i]; j++)
157  for (int k = 0; k < CONTEXT_SIZE; k++) {
158  int pred = j ? f->initial_states[i][j - 1][k] : 128;
159  f->initial_states[i][j][k] =
160  (pred + ff_ffv1_get_symbol(&c, state2[k], 1)) & 0xFF;
161  }
162  }
163 
164  if (f->version > 2) {
165  f->ec = ff_ffv1_get_symbol(&c, state, 0);
166  if (f->ec >= 2)
167  f->crcref = 0x7a8c4079;
168  if (f->combined_version >= 0x30003)
169  f->intra = ff_ffv1_get_symbol(&c, state, 0);
170  }
171 
172  if (f->version > 2) {
173  unsigned v;
174  v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref,
175  f->avctx->extradata, f->avctx->extradata_size);
176  if (v != f->crcref || f->avctx->extradata_size < 4) {
177  av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
178  return AVERROR_INVALIDDATA;
179  }
180  crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
181  }
182 
183  if (f->avctx->debug & FF_DEBUG_PICT_INFO)
184  av_log(f->avctx, AV_LOG_DEBUG,
185  "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",
186  f->version, f->micro_version,
187  f->ac,
188  f->colorspace,
189  f->avctx->bits_per_raw_sample,
190  f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift,
191  f->transparency,
192  f->num_h_slices, f->num_v_slices,
193  f->quant_table_count,
194  f->ec,
195  f->intra,
196  crc
197  );
198  return 0;
199 }
200 
201 int ff_ffv1_parse_header(FFV1Context *f, RangeCoder *c, uint8_t *state)
202 {
203  if (f->version < 2) {
204  int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
205  unsigned v= ff_ffv1_get_symbol(c, state, 0);
206  if (v >= 2) {
207  av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
208  return AVERROR_INVALIDDATA;
209  }
210  f->version = v;
211  f->ac = ff_ffv1_get_symbol(c, state, 0);
212 
213  if (f->ac == AC_RANGE_CUSTOM_TAB) {
214  for (int i = 1; i < 256; i++) {
215  int st = ff_ffv1_get_symbol(c, state, 1) + c->one_state[i];
216  if (st < 1 || st > 255) {
217  av_log(f->avctx, AV_LOG_ERROR, "invalid state transition %d\n", st);
218  return AVERROR_INVALIDDATA;
219  }
220  f->state_transition[i] = st;
221  }
222  }
223 
224  colorspace = ff_ffv1_get_symbol(c, state, 0); //YUV cs type
225  bits_per_raw_sample = f->version > 0 ? ff_ffv1_get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
226  chroma_planes = get_rac(c, state);
227  chroma_h_shift = ff_ffv1_get_symbol(c, state, 0);
228  chroma_v_shift = ff_ffv1_get_symbol(c, state, 0);
229  transparency = get_rac(c, state);
230  if (colorspace == 0 && f->avctx->skip_alpha)
231  transparency = 0;
232 
233  if (f->plane_count) {
234  if (colorspace != f->colorspace ||
235  bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
236  chroma_planes != f->chroma_planes ||
237  chroma_h_shift != f->chroma_h_shift ||
238  chroma_v_shift != f->chroma_v_shift ||
239  transparency != f->transparency) {
240  av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
241  return AVERROR_INVALIDDATA;
242  }
243  }
244 
245  if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
246  av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
247  chroma_h_shift, chroma_v_shift);
248  return AVERROR_INVALIDDATA;
249  }
250 
251  f->colorspace = colorspace;
252  f->avctx->bits_per_raw_sample = bits_per_raw_sample;
253  f->chroma_planes = chroma_planes;
254  f->chroma_h_shift = chroma_h_shift;
255  f->chroma_v_shift = chroma_v_shift;
256  f->transparency = transparency;
257 
258  f->plane_count = 2 + f->transparency;
259  }
260 
261  if (f->colorspace == 0) {
262  if (!f->transparency && !f->chroma_planes) {
263  if (f->avctx->bits_per_raw_sample <= 8)
264  f->pix_fmt = AV_PIX_FMT_GRAY8;
265  else if (f->avctx->bits_per_raw_sample == 9) {
266  f->packed_at_lsb = 1;
267  f->pix_fmt = AV_PIX_FMT_GRAY9;
268  } else if (f->avctx->bits_per_raw_sample == 10) {
269  f->packed_at_lsb = 1;
270  f->pix_fmt = AV_PIX_FMT_GRAY10;
271  } else if (f->avctx->bits_per_raw_sample == 12) {
272  f->packed_at_lsb = 1;
273  f->pix_fmt = AV_PIX_FMT_GRAY12;
274  } else if (f->avctx->bits_per_raw_sample == 14) {
275  f->packed_at_lsb = 1;
276  f->pix_fmt = AV_PIX_FMT_GRAY14;
277  } else if (f->avctx->bits_per_raw_sample == 16) {
278  f->packed_at_lsb = 1;
279  f->pix_fmt = AV_PIX_FMT_GRAY16;
280  } else if (f->avctx->bits_per_raw_sample < 16) {
281  f->pix_fmt = AV_PIX_FMT_GRAY16;
282  } else
283  return AVERROR(ENOSYS);
284  } else if (f->transparency && !f->chroma_planes) {
285  if (f->avctx->bits_per_raw_sample <= 8)
286  f->pix_fmt = AV_PIX_FMT_YA8;
287  else
288  return AVERROR(ENOSYS);
289  } else if (f->avctx->bits_per_raw_sample<=8 && !f->transparency) {
290  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
291  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P; break;
292  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P; break;
293  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P; break;
294  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P; break;
295  case 0x20: f->pix_fmt = AV_PIX_FMT_YUV411P; break;
296  case 0x22: f->pix_fmt = AV_PIX_FMT_YUV410P; break;
297  }
298  } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
299  switch(16*f->chroma_h_shift + f->chroma_v_shift) {
300  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P; break;
301  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P; break;
302  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P; break;
303  }
304  } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
305  f->packed_at_lsb = 1;
306  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
307  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P9; break;
308  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P9; break;
309  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P9; break;
310  }
311  } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) {
312  f->packed_at_lsb = 1;
313  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
314  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P9; break;
315  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P9; break;
316  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P9; break;
317  }
318  } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
319  f->packed_at_lsb = 1;
320  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
321  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P10; break;
322  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P10; break;
323  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P10; break;
324  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P10; break;
325  }
326  } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) {
327  f->packed_at_lsb = 1;
328  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
329  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P10; break;
330  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
331  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
332  }
333  } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
334  f->packed_at_lsb = 1;
335  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
336  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P12; break;
337  case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P12; break;
338  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P12; break;
339  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P12; break;
340  }
341  } else if (f->avctx->bits_per_raw_sample == 12 && f->transparency) {
342  f->packed_at_lsb = 1;
343  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
344  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P12; break;
345  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P12; break;
346  }
347  } else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency) {
348  f->packed_at_lsb = 1;
349  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
350  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P14; break;
351  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P14; break;
352  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P14; break;
353  }
354  } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
355  f->packed_at_lsb = 1;
356  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
357  case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P16; break;
358  case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P16; break;
359  case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P16; break;
360  }
361  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
362  f->packed_at_lsb = 1;
363  switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
364  case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
365  case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
366  case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P16; break;
367  }
368  }
369  } else if (f->colorspace == 1) {
370  if (f->chroma_h_shift || f->chroma_v_shift) {
371  av_log(f->avctx, AV_LOG_ERROR,
372  "chroma subsampling not supported in this colorspace\n");
373  return AVERROR(ENOSYS);
374  }
375  if ( f->avctx->bits_per_raw_sample <= 8 && !f->transparency)
376  f->pix_fmt = AV_PIX_FMT_0RGB32;
377  else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency)
378  f->pix_fmt = AV_PIX_FMT_RGB32;
379  else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency)
380  f->pix_fmt = AV_PIX_FMT_GBRP9;
381  else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
382  f->pix_fmt = AV_PIX_FMT_GBRP10;
383  else if (f->avctx->bits_per_raw_sample == 10 && f->transparency)
384  f->pix_fmt = AV_PIX_FMT_GBRAP10;
385  else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
386  f->pix_fmt = AV_PIX_FMT_GBRP12;
387  else if (f->avctx->bits_per_raw_sample == 12 && f->transparency)
388  f->pix_fmt = AV_PIX_FMT_GBRAP12;
389  else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
390  f->pix_fmt = AV_PIX_FMT_GBRP14;
391  else if (f->avctx->bits_per_raw_sample == 14 && f->transparency)
392  f->pix_fmt = AV_PIX_FMT_GBRAP14;
393  else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
394  f->pix_fmt = AV_PIX_FMT_GBRP16;
395  f->use32bit = 1;
396  } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency) {
397  f->pix_fmt = AV_PIX_FMT_GBRAP16;
398  f->use32bit = 1;
399  }
400  } else {
401  av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
402  return AVERROR(ENOSYS);
403  }
404  if (f->pix_fmt == AV_PIX_FMT_NONE) {
405  av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
406  return AVERROR(ENOSYS);
407  }
408 
409  return 0;
410 }
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:201
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
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 Tue Feb 11 2025 19:21:44 for FFmpeg by   doxygen 1.8.17