FFmpeg
h264_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/mem.h"
20 #include "bytestream.h"
21 #include "get_bits.h"
22 #include "golomb.h"
23 #include "h264.h"
24 #include "h264pred.h"
25 #include "h264_parse.h"
26 #include "h264_ps.h"
27 #include "h2645_parse.h"
28 #include "mpegutils.h"
29 
31  const int *ref_count, int slice_type_nos,
33  int picture_structure, void *logctx)
34 {
35  int list, i, j;
36  int luma_def, chroma_def;
37 
38  pwt->use_weight = 0;
39  pwt->use_weight_chroma = 0;
40 
42  if (pwt->luma_log2_weight_denom > 7U) {
43  av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom);
44  pwt->luma_log2_weight_denom = 0;
45  }
46  luma_def = 1 << pwt->luma_log2_weight_denom;
47 
48  if (sps->chroma_format_idc) {
50  if (pwt->chroma_log2_weight_denom > 7U) {
51  av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);
52  pwt->chroma_log2_weight_denom = 0;
53  }
54  chroma_def = 1 << pwt->chroma_log2_weight_denom;
55  }
56 
57  for (list = 0; list < 2; list++) {
58  pwt->luma_weight_flag[list] = 0;
59  pwt->chroma_weight_flag[list] = 0;
60  for (i = 0; i < ref_count[list]; i++) {
61  int luma_weight_flag, chroma_weight_flag;
62 
63  luma_weight_flag = get_bits1(gb);
64  if (luma_weight_flag) {
65  pwt->luma_weight[i][list][0] = get_se_golomb(gb);
66  pwt->luma_weight[i][list][1] = get_se_golomb(gb);
67  if ((int8_t)pwt->luma_weight[i][list][0] != pwt->luma_weight[i][list][0] ||
68  (int8_t)pwt->luma_weight[i][list][1] != pwt->luma_weight[i][list][1])
69  goto out_range_weight;
70  if (pwt->luma_weight[i][list][0] != luma_def ||
71  pwt->luma_weight[i][list][1] != 0) {
72  pwt->use_weight = 1;
73  pwt->luma_weight_flag[list] = 1;
74  }
75  } else {
76  pwt->luma_weight[i][list][0] = luma_def;
77  pwt->luma_weight[i][list][1] = 0;
78  }
79 
80  if (sps->chroma_format_idc) {
81  chroma_weight_flag = get_bits1(gb);
82  if (chroma_weight_flag) {
83  int j;
84  for (j = 0; j < 2; j++) {
85  pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);
86  pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);
87  if ((int8_t)pwt->chroma_weight[i][list][j][0] != pwt->chroma_weight[i][list][j][0] ||
88  (int8_t)pwt->chroma_weight[i][list][j][1] != pwt->chroma_weight[i][list][j][1]) {
89  pwt->chroma_weight[i][list][j][0] = chroma_def;
90  pwt->chroma_weight[i][list][j][1] = 0;
91  goto out_range_weight;
92  }
93  if (pwt->chroma_weight[i][list][j][0] != chroma_def ||
94  pwt->chroma_weight[i][list][j][1] != 0) {
95  pwt->use_weight_chroma = 1;
96  pwt->chroma_weight_flag[list] = 1;
97  }
98  }
99  } else {
100  int j;
101  for (j = 0; j < 2; j++) {
102  pwt->chroma_weight[i][list][j][0] = chroma_def;
103  pwt->chroma_weight[i][list][j][1] = 0;
104  }
105  }
106  }
107 
108  // for MBAFF
109  if (picture_structure == PICT_FRAME) {
110  pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0];
111  pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1];
112  if (sps->chroma_format_idc) {
113  for (j = 0; j < 2; j++) {
114  pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0];
115  pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1];
116  }
117  }
118  }
119  }
120  if (slice_type_nos != AV_PICTURE_TYPE_B)
121  break;
122  }
123  pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma;
124  return 0;
125 out_range_weight:
126  avpriv_request_sample(logctx, "Out of range weight");
127  return AVERROR_INVALIDDATA;
128 }
129 
130 /**
131  * Check if the top & left blocks are available if needed and
132  * change the dc mode so it only uses the available blocks.
133  */
134 int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx,
135  int top_samples_available, int left_samples_available)
136 {
137  static const int8_t top[12] = {
138  -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0
139  };
140  static const int8_t left[12] = {
141  0, -1, TOP_DC_PRED, 0, -1, -1, -1, 0, -1, DC_128_PRED
142  };
143  int i;
144 
145  if (!(top_samples_available & 0x8000)) {
146  for (i = 0; i < 4; i++) {
147  int status = top[pred_mode_cache[scan8[0] + i]];
148  if (status < 0) {
149  av_log(logctx, AV_LOG_ERROR,
150  "top block unavailable for requested intra mode %d\n",
151  status);
152  return AVERROR_INVALIDDATA;
153  } else if (status) {
154  pred_mode_cache[scan8[0] + i] = status;
155  }
156  }
157  }
158 
159  if ((left_samples_available & 0x8888) != 0x8888) {
160  static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 };
161  for (i = 0; i < 4; i++)
162  if (!(left_samples_available & mask[i])) {
163  int status = left[pred_mode_cache[scan8[0] + 8 * i]];
164  if (status < 0) {
165  av_log(logctx, AV_LOG_ERROR,
166  "left block unavailable for requested intra4x4 mode %d\n",
167  status);
168  return AVERROR_INVALIDDATA;
169  } else if (status) {
170  pred_mode_cache[scan8[0] + 8 * i] = status;
171  }
172  }
173  }
174 
175  return 0;
176 }
177 
178 /**
179  * Check if the top & left blocks are available if needed and
180  * change the dc mode so it only uses the available blocks.
181  */
182 int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available,
183  int left_samples_available,
184  int mode, int is_chroma)
185 {
186  static const int8_t top[4] = { LEFT_DC_PRED8x8, 1, -1, -1 };
187  static const int8_t left[5] = { TOP_DC_PRED8x8, -1, 2, -1, DC_128_PRED8x8 };
188 
189  if (mode > 3U) {
190  av_log(logctx, AV_LOG_ERROR,
191  "out of range intra chroma pred mode\n");
192  return AVERROR_INVALIDDATA;
193  }
194 
195  if (!(top_samples_available & 0x8000)) {
196  mode = top[mode];
197  if (mode < 0) {
198  av_log(logctx, AV_LOG_ERROR,
199  "top block unavailable for requested intra mode\n");
200  return AVERROR_INVALIDDATA;
201  }
202  }
203 
204  if ((left_samples_available & 0x8080) != 0x8080) {
205  mode = left[mode];
206  if (mode < 0) {
207  av_log(logctx, AV_LOG_ERROR,
208  "left block unavailable for requested intra mode\n");
209  return AVERROR_INVALIDDATA;
210  }
211  if (is_chroma && (left_samples_available & 0x8080)) {
212  // mad cow disease mode, aka MBAFF + constrained_intra_pred
214  (!(left_samples_available & 0x8000)) +
215  2 * (mode == DC_128_PRED8x8);
216  }
217  }
218 
219  return mode;
220 }
221 
222 int ff_h264_parse_ref_count(int *plist_count, int ref_count[2],
223  GetBitContext *gb, const PPS *pps,
224  int slice_type_nos, int picture_structure, void *logctx)
225 {
226  int list_count;
227  int num_ref_idx_active_override_flag;
228 
229  // set defaults, might be overridden a few lines later
230  ref_count[0] = pps->ref_count[0];
231  ref_count[1] = pps->ref_count[1];
232 
233  if (slice_type_nos != AV_PICTURE_TYPE_I) {
234  unsigned max[2];
235  max[0] = max[1] = picture_structure == PICT_FRAME ? 15 : 31;
236 
237  num_ref_idx_active_override_flag = get_bits1(gb);
238 
239  if (num_ref_idx_active_override_flag) {
240  ref_count[0] = get_ue_golomb(gb) + 1;
241  if (slice_type_nos == AV_PICTURE_TYPE_B) {
242  ref_count[1] = get_ue_golomb(gb) + 1;
243  } else
244  // full range is spec-ok in this case, even for frames
245  ref_count[1] = 1;
246  }
247 
248  if (slice_type_nos == AV_PICTURE_TYPE_B)
249  list_count = 2;
250  else
251  list_count = 1;
252 
253  if (ref_count[0] - 1 > max[0] || (list_count == 2 && (ref_count[1] - 1 > max[1]))) {
254  av_log(logctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n",
255  ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]);
256  ref_count[0] = ref_count[1] = 0;
257  *plist_count = 0;
258  goto fail;
259  } else if (ref_count[1] - 1 > max[1]) {
260  av_log(logctx, AV_LOG_DEBUG, "reference overflow %u > %u \n",
261  ref_count[1] - 1, max[1]);
262  ref_count[1] = 0;
263  }
264 
265  } else {
266  list_count = 0;
267  ref_count[0] = ref_count[1] = 0;
268  }
269 
270  *plist_count = list_count;
271 
272  return 0;
273 fail:
274  *plist_count = 0;
275  ref_count[0] = 0;
276  ref_count[1] = 0;
277  return AVERROR_INVALIDDATA;
278 }
279 
280 int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc,
281  const SPS *sps, H264POCContext *pc,
282  int picture_structure, int nal_ref_idc)
283 {
284  const int max_frame_num = 1 << sps->log2_max_frame_num;
285  int64_t field_poc[2];
286 
288  if (pc->frame_num < pc->prev_frame_num)
289  pc->frame_num_offset += max_frame_num;
290 
291  if (sps->poc_type == 0) {
292  const int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
293  if (pc->prev_poc_lsb < 0)
294  pc->prev_poc_lsb = pc->poc_lsb;
295 
296  if (pc->poc_lsb < pc->prev_poc_lsb &&
297  pc->prev_poc_lsb - pc->poc_lsb >= max_poc_lsb / 2)
298  pc->poc_msb = pc->prev_poc_msb + max_poc_lsb;
299  else if (pc->poc_lsb > pc->prev_poc_lsb &&
300  pc->prev_poc_lsb - pc->poc_lsb < -max_poc_lsb / 2)
301  pc->poc_msb = pc->prev_poc_msb - max_poc_lsb;
302  else
303  pc->poc_msb = pc->prev_poc_msb;
304  field_poc[0] =
305  field_poc[1] = pc->poc_msb + pc->poc_lsb;
306  if (picture_structure == PICT_FRAME)
307  field_poc[1] += pc->delta_poc_bottom;
308  } else if (sps->poc_type == 1) {
309  int abs_frame_num;
310  int64_t expected_delta_per_poc_cycle, expectedpoc;
311  int i;
312 
313  if (sps->poc_cycle_length != 0)
314  abs_frame_num = pc->frame_num_offset + pc->frame_num;
315  else
316  abs_frame_num = 0;
317 
318  if (nal_ref_idc == 0 && abs_frame_num > 0)
319  abs_frame_num--;
320 
321  expected_delta_per_poc_cycle = 0;
322  for (i = 0; i < sps->poc_cycle_length; i++)
323  // FIXME integrate during sps parse
324  expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i];
325 
326  if (abs_frame_num > 0) {
327  int poc_cycle_cnt = (abs_frame_num - 1) / sps->poc_cycle_length;
328  int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length;
329 
330  expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
331  for (i = 0; i <= frame_num_in_poc_cycle; i++)
332  expectedpoc = expectedpoc + sps->offset_for_ref_frame[i];
333  } else
334  expectedpoc = 0;
335 
336  if (nal_ref_idc == 0)
337  expectedpoc = expectedpoc + sps->offset_for_non_ref_pic;
338 
339  field_poc[0] = expectedpoc + pc->delta_poc[0];
340  field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field;
341 
342  if (picture_structure == PICT_FRAME)
343  field_poc[1] += pc->delta_poc[1];
344  } else {
345  int poc = 2 * (pc->frame_num_offset + pc->frame_num);
346 
347  if (!nal_ref_idc)
348  poc--;
349 
350  field_poc[0] = poc;
351  field_poc[1] = poc;
352  }
353 
354  if ( field_poc[0] != (int)field_poc[0]
355  || field_poc[1] != (int)field_poc[1])
356  return AVERROR_INVALIDDATA;
357 
358  if (picture_structure != PICT_BOTTOM_FIELD)
359  pic_field_poc[0] = field_poc[0];
360  if (picture_structure != PICT_TOP_FIELD)
361  pic_field_poc[1] = field_poc[1];
362  *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]);
363 
364  return 0;
365 }
366 
367 static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps,
368  int is_avc, void *logctx)
369 {
370  H2645Packet pkt = { 0 };
372  int i, ret = 0;
373 
375  if (ret < 0) {
376  ret = 0;
377  goto fail;
378  }
379 
380  for (i = 0; i < pkt.nb_nals; i++) {
381  H2645NAL *nal = &pkt.nals[i];
382  switch (nal->type) {
383  case H264_NAL_SPS: {
384  GetBitContext tmp_gb = nal->gb;
385  ret = ff_h264_decode_seq_parameter_set(&tmp_gb, logctx, ps, 0);
386  if (ret >= 0)
387  break;
388  av_log(logctx, AV_LOG_DEBUG,
389  "SPS decoding failure, trying again with the complete NAL\n");
390  init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
391  ret = ff_h264_decode_seq_parameter_set(&tmp_gb, logctx, ps, 0);
392  if (ret >= 0)
393  break;
394  ret = ff_h264_decode_seq_parameter_set(&nal->gb, logctx, ps, 1);
395  if (ret < 0)
396  goto fail;
397  break;
398  }
399  case H264_NAL_PPS:
400  ret = ff_h264_decode_picture_parameter_set(&nal->gb, logctx, ps,
401  nal->size_bits);
402  if (ret < 0)
403  goto fail;
404  break;
405  default:
406  av_log(logctx, AV_LOG_VERBOSE, "Ignoring NAL type %d in extradata\n",
407  nal->type);
408  break;
409  }
410  }
411 
412 fail:
414  return ret;
415 }
416 
417 /* There are (invalid) samples in the wild with mp4-style extradata, where the
418  * parameter sets are stored unescaped (i.e. as RBSP).
419  * This function catches the parameter set decoding failure and tries again
420  * after escaping it */
421 static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps,
422  int err_recognition, void *logctx)
423 {
424  int ret;
425 
426  ret = decode_extradata_ps(buf, buf_size, ps, 1, logctx);
427  if (ret < 0 && !(err_recognition & AV_EF_EXPLODE)) {
428  GetByteContext gbc;
429  PutByteContext pbc;
430  uint8_t *escaped_buf;
431  int escaped_buf_size;
432 
433  av_log(logctx, AV_LOG_WARNING,
434  "SPS decoding failure, trying again after escaping the NAL\n");
435 
436  if (buf_size / 2 >= (INT16_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 3)
437  return AVERROR(ERANGE);
438  escaped_buf_size = buf_size * 3 / 2 + AV_INPUT_BUFFER_PADDING_SIZE;
439  escaped_buf = av_mallocz(escaped_buf_size);
440  if (!escaped_buf)
441  return AVERROR(ENOMEM);
442 
443  bytestream2_init(&gbc, buf, buf_size);
444  bytestream2_init_writer(&pbc, escaped_buf, escaped_buf_size);
445 
446  while (bytestream2_get_bytes_left(&gbc)) {
447  if (bytestream2_get_bytes_left(&gbc) >= 3 &&
448  bytestream2_peek_be24(&gbc) <= 3) {
449  bytestream2_put_be24(&pbc, 3);
450  bytestream2_skip(&gbc, 2);
451  } else
452  bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc));
453  }
454 
455  escaped_buf_size = bytestream2_tell_p(&pbc);
456  AV_WB16(escaped_buf, escaped_buf_size - 2);
457 
458  (void)decode_extradata_ps(escaped_buf, escaped_buf_size, ps, 1, logctx);
459  // lorex.mp4 decodes ok even with extradata decoding failing
460  av_freep(&escaped_buf);
461  }
462 
463  return 0;
464 }
465 
466 int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps,
467  int *is_avc, int *nal_length_size,
468  int err_recognition, void *logctx)
469 {
470  int ret;
471 
472  if (!data || size <= 0)
473  return AVERROR(EINVAL);
474 
475  if (data[0] == 1) {
476  int i, cnt, nalsize;
477  const uint8_t *p = data;
478 
479  *is_avc = 1;
480 
481  if (size < 7) {
482  av_log(logctx, AV_LOG_ERROR, "avcC %d too short\n", size);
483  return AVERROR_INVALIDDATA;
484  }
485 
486  // Decode sps from avcC
487  cnt = *(p + 5) & 0x1f; // Number of sps
488  p += 6;
489  for (i = 0; i < cnt; i++) {
490  nalsize = AV_RB16(p) + 2;
491  if (nalsize > size - (p - data))
492  return AVERROR_INVALIDDATA;
493  ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
494  if (ret < 0) {
495  av_log(logctx, AV_LOG_ERROR,
496  "Decoding sps %d from avcC failed\n", i);
497  return ret;
498  }
499  p += nalsize;
500  }
501  // Decode pps from avcC
502  cnt = *(p++); // Number of pps
503  for (i = 0; i < cnt; i++) {
504  nalsize = AV_RB16(p) + 2;
505  if (nalsize > size - (p - data))
506  return AVERROR_INVALIDDATA;
507  ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
508  if (ret < 0) {
509  av_log(logctx, AV_LOG_ERROR,
510  "Decoding pps %d from avcC failed\n", i);
511  return ret;
512  }
513  p += nalsize;
514  }
515  // Store right nal length size that will be used to parse all other nals
516  *nal_length_size = (data[4] & 0x03) + 1;
517  } else {
518  *is_avc = 0;
519  ret = decode_extradata_ps(data, size, ps, 0, logctx);
520  if (ret < 0)
521  return ret;
522  }
523  return size;
524 }
525 
526 /**
527  * Compute profile from profile_idc and constraint_set?_flags.
528  *
529  * @param sps SPS
530  *
531  * @return profile as defined by AV_PROFILE_H264_*
532  */
534 {
535  int profile = sps->profile_idc;
536 
537  switch (sps->profile_idc) {
539  // constraint_set1_flag set to 1
540  profile |= (sps->constraint_set_flags & 1 << 1) ? AV_PROFILE_H264_CONSTRAINED : 0;
541  break;
545  // constraint_set3_flag set to 1
546  profile |= (sps->constraint_set_flags & 1 << 3) ? AV_PROFILE_H264_INTRA : 0;
547  break;
548  }
549 
550  return profile;
551 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
decode_extradata_ps_mp4
static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps, int err_recognition, void *logctx)
Definition: h264_parse.c:421
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
h2645_parse.h
H264POCContext::frame_num_offset
int frame_num_offset
for POC type 2
Definition: h264_parse.h:90
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
H2645_FLAG_SMALL_PADDING
@ H2645_FLAG_SMALL_PADDING
Definition: h2645_parse.h:98
H2645_FLAG_IS_NALFF
@ H2645_FLAG_IS_NALFF
Definition: h2645_parse.h:97
AV_PROFILE_H264_INTRA
#define AV_PROFILE_H264_INTRA
Definition: defs.h:108
DC_128_PRED
@ DC_128_PRED
Definition: vp9.h:58
GetByteContext
Definition: bytestream.h:33
H264POCContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264_parse.h:85
int64_t
long long int64_t
Definition: coverity.c:34
mask
int mask
Definition: mediacodecdec_common.c:154
h264_parse.h
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
ff_h2645_packet_uninit
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:600
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
data
const char data[16]
Definition: mxf.c:149
H264PredWeightTable::use_weight_chroma
int use_weight_chroma
Definition: h264_parse.h:71
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:32
max
#define max(a, b)
Definition: cuda_runtime.h:33
ff_h264_pred_weight_table
int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, const int *ref_count, int slice_type_nos, H264PredWeightTable *pwt, int picture_structure, void *logctx)
Definition: h264_parse.c:30
mpegutils.h
H264POCContext::prev_poc_lsb
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
Definition: h264_parse.h:89
H264POCContext::delta_poc
int delta_poc[2]
Definition: h264_parse.h:86
H2645NAL::size_bits
int size_bits
Size, in bits, of just the data, excluding the stop bit and any trailing padding.
Definition: h2645_parse.h:42
ff_h264_decode_picture_parameter_set
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
Definition: h264_ps.c:696
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
golomb.h
exp golomb vlc stuff
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
H264POCContext::prev_frame_num
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264_parse.h:92
fail
#define fail()
Definition: checkasm.h:188
GetBitContext
Definition: get_bits.h:108
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264_parse.h:40
H264PredWeightTable::luma_log2_weight_denom
int luma_log2_weight_denom
Definition: h264_parse.h:72
H264PredWeightTable::use_weight
int use_weight
Definition: h264_parse.h:70
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
H264PredWeightTable::chroma_weight
int chroma_weight[48][2][2][2]
Definition: h264_parse.h:78
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
H264POCContext::prev_frame_num_offset
int prev_frame_num_offset
for POC type 2
Definition: h264_parse.h:91
H264PredWeightTable::chroma_log2_weight_denom
int chroma_log2_weight_denom
Definition: h264_parse.h:73
ff_h264_decode_extradata
int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)
Definition: h264_parse.c:466
AV_PROFILE_H264_HIGH_10
#define AV_PROFILE_H264_HIGH_10
Definition: defs.h:115
LEFT_DC_PRED
@ LEFT_DC_PRED
Definition: vp9.h:56
H264PredWeightTable::chroma_weight_flag
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
Definition: h264_parse.h:75
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:31
get_bits.h
H264PredWeightTable::luma_weight
int luma_weight[48][2][2]
Definition: h264_parse.h:77
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AV_PROFILE_H264_HIGH_422
#define AV_PROFILE_H264_HIGH_422
Definition: defs.h:118
TOP_DC_PRED8x8
#define TOP_DC_PRED8x8
Definition: h264pred.h:75
if
if(ret)
Definition: filter_design.txt:179
H2645NAL::raw_size
int raw_size
Definition: h2645_parse.h:44
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:401
SPS
Sequence parameter set.
Definition: h264_ps.h:44
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
PPS
Picture parameter set.
Definition: h264_ps.h:110
list
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 list
Definition: filter_design.txt:25
h264_ps.h
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
PutByteContext
Definition: bytestream.h:37
size
int size
Definition: twinvq_data.h:10344
H2645NAL::gb
GetBitContext gb
Definition: h2645_parse.h:47
H2645NAL
Definition: h2645_parse.h:34
DC_128_PRED8x8
#define DC_128_PRED8x8
Definition: h264pred.h:76
decode_extradata_ps
static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps, int is_avc, void *logctx)
Definition: h264_parse.c:367
H264POCContext::frame_num
int frame_num
Definition: h264_parse.h:87
ff_h264_decode_seq_parameter_set
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:284
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
H264POCContext
Definition: h264_parse.h:82
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
profile
int profile
Definition: mxfenc.c:2228
ff_h264_parse_ref_count
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], GetBitContext *gb, const PPS *pps, int slice_type_nos, int picture_structure, void *logctx)
Definition: h264_parse.c:222
LEFT_DC_PRED8x8
#define LEFT_DC_PRED8x8
Definition: h264pred.h:74
AV_PROFILE_H264_HIGH_444_PREDICTIVE
#define AV_PROFILE_H264_HIGH_444_PREDICTIVE
Definition: defs.h:122
ret
ret
Definition: filter_design.txt:187
ff_h264_init_poc
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)
Definition: h264_parse.c:280
H2645NAL::raw_data
const uint8_t * raw_data
Definition: h2645_parse.h:45
ff_h264_get_profile
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
Definition: h264_parse.c:533
AV_PROFILE_H264_BASELINE
#define AV_PROFILE_H264_BASELINE
Definition: defs.h:110
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
AV_PROFILE_H264_CONSTRAINED
#define AV_PROFILE_H264_CONSTRAINED
Definition: defs.h:107
h264pred.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
U
#define U(x)
Definition: vpx_arith.h:37
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
mode
mode
Definition: ebur128.h:83
ff_h264_check_intra4x4_pred_mode
int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx, int top_samples_available, int left_samples_available)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264_parse.c:134
H264ParamSets
Definition: h264_ps.h:144
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
H264PredWeightTable
Definition: h264_parse.h:69
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
ALZHEIMER_DC_L0T_PRED8x8
#define ALZHEIMER_DC_L0T_PRED8x8
Definition: h264pred.h:79
H264POCContext::poc_lsb
int poc_lsb
Definition: h264_parse.h:83
TOP_DC_PRED
@ TOP_DC_PRED
Definition: vp9.h:57
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
bytestream.h
h264.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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
H264POCContext::poc_msb
int poc_msb
Definition: h264_parse.h:84
H264PredWeightTable::luma_weight_flag
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
Definition: h264_parse.h:74
ff_h2645_packet_split
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int nal_length_size, enum AVCodecID codec_id, int flags)
Split an input packet into NAL units.
Definition: h2645_parse.c:465
H264POCContext::prev_poc_msb
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:88
H2645Packet
Definition: h2645_parse.h:82
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
ff_h264_check_intra_pred_mode
int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available, int left_samples_available, int mode, int is_chroma)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264_parse.c:182
AV_RB16
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_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98