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 "bytestream.h"
20 #include "get_bits.h"
21 #include "golomb.h"
22 #include "h264.h"
23 #include "h264pred.h"
24 #include "h264_parse.h"
25 #include "h264_ps.h"
26 #include "h2645_parse.h"
27 #include "mpegutils.h"
28 
30  const int *ref_count, int slice_type_nos,
32  int picture_structure, void *logctx)
33 {
34  int list, i, j;
35  int luma_def, chroma_def;
36 
37  pwt->use_weight = 0;
38  pwt->use_weight_chroma = 0;
39 
41  if (pwt->luma_log2_weight_denom > 7U) {
42  av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom);
43  pwt->luma_log2_weight_denom = 0;
44  }
45  luma_def = 1 << pwt->luma_log2_weight_denom;
46 
47  if (sps->chroma_format_idc) {
49  if (pwt->chroma_log2_weight_denom > 7U) {
50  av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);
51  pwt->chroma_log2_weight_denom = 0;
52  }
53  chroma_def = 1 << pwt->chroma_log2_weight_denom;
54  }
55 
56  for (list = 0; list < 2; list++) {
57  pwt->luma_weight_flag[list] = 0;
58  pwt->chroma_weight_flag[list] = 0;
59  for (i = 0; i < ref_count[list]; i++) {
60  int luma_weight_flag, chroma_weight_flag;
61 
62  luma_weight_flag = get_bits1(gb);
63  if (luma_weight_flag) {
64  pwt->luma_weight[i][list][0] = get_se_golomb(gb);
65  pwt->luma_weight[i][list][1] = get_se_golomb(gb);
66  if ((int8_t)pwt->luma_weight[i][list][0] != pwt->luma_weight[i][list][0] ||
67  (int8_t)pwt->luma_weight[i][list][1] != pwt->luma_weight[i][list][1])
68  goto out_range_weight;
69  if (pwt->luma_weight[i][list][0] != luma_def ||
70  pwt->luma_weight[i][list][1] != 0) {
71  pwt->use_weight = 1;
72  pwt->luma_weight_flag[list] = 1;
73  }
74  } else {
75  pwt->luma_weight[i][list][0] = luma_def;
76  pwt->luma_weight[i][list][1] = 0;
77  }
78 
79  if (sps->chroma_format_idc) {
80  chroma_weight_flag = get_bits1(gb);
81  if (chroma_weight_flag) {
82  int j;
83  for (j = 0; j < 2; j++) {
84  pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);
85  pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);
86  if ((int8_t)pwt->chroma_weight[i][list][j][0] != pwt->chroma_weight[i][list][j][0] ||
87  (int8_t)pwt->chroma_weight[i][list][j][1] != pwt->chroma_weight[i][list][j][1]) {
88  pwt->chroma_weight[i][list][j][0] = chroma_def;
89  pwt->chroma_weight[i][list][j][1] = 0;
90  goto out_range_weight;
91  }
92  if (pwt->chroma_weight[i][list][j][0] != chroma_def ||
93  pwt->chroma_weight[i][list][j][1] != 0) {
94  pwt->use_weight_chroma = 1;
95  pwt->chroma_weight_flag[list] = 1;
96  }
97  }
98  } else {
99  int j;
100  for (j = 0; j < 2; j++) {
101  pwt->chroma_weight[i][list][j][0] = chroma_def;
102  pwt->chroma_weight[i][list][j][1] = 0;
103  }
104  }
105  }
106 
107  // for MBAFF
108  if (picture_structure == PICT_FRAME) {
109  pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0];
110  pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1];
111  if (sps->chroma_format_idc) {
112  for (j = 0; j < 2; j++) {
113  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];
114  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];
115  }
116  }
117  }
118  }
119  if (slice_type_nos != AV_PICTURE_TYPE_B)
120  break;
121  }
122  pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma;
123  return 0;
124 out_range_weight:
125  avpriv_request_sample(logctx, "Out of range weight");
126  return AVERROR_INVALIDDATA;
127 }
128 
129 /**
130  * Check if the top & left blocks are available if needed and
131  * change the dc mode so it only uses the available blocks.
132  */
133 int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx,
134  int top_samples_available, int left_samples_available)
135 {
136  static const int8_t top[12] = {
137  -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0
138  };
139  static const int8_t left[12] = {
140  0, -1, TOP_DC_PRED, 0, -1, -1, -1, 0, -1, DC_128_PRED
141  };
142  int i;
143 
144  if (!(top_samples_available & 0x8000)) {
145  for (i = 0; i < 4; i++) {
146  int status = top[pred_mode_cache[scan8[0] + i]];
147  if (status < 0) {
148  av_log(logctx, AV_LOG_ERROR,
149  "top block unavailable for requested intra mode %d\n",
150  status);
151  return AVERROR_INVALIDDATA;
152  } else if (status) {
153  pred_mode_cache[scan8[0] + i] = status;
154  }
155  }
156  }
157 
158  if ((left_samples_available & 0x8888) != 0x8888) {
159  static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 };
160  for (i = 0; i < 4; i++)
161  if (!(left_samples_available & mask[i])) {
162  int status = left[pred_mode_cache[scan8[0] + 8 * i]];
163  if (status < 0) {
164  av_log(logctx, AV_LOG_ERROR,
165  "left block unavailable for requested intra4x4 mode %d\n",
166  status);
167  return AVERROR_INVALIDDATA;
168  } else if (status) {
169  pred_mode_cache[scan8[0] + 8 * i] = status;
170  }
171  }
172  }
173 
174  return 0;
175 }
176 
177 /**
178  * Check if the top & left blocks are available if needed and
179  * change the dc mode so it only uses the available blocks.
180  */
181 int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available,
182  int left_samples_available,
183  int mode, int is_chroma)
184 {
185  static const int8_t top[4] = { LEFT_DC_PRED8x8, 1, -1, -1 };
186  static const int8_t left[5] = { TOP_DC_PRED8x8, -1, 2, -1, DC_128_PRED8x8 };
187 
188  if (mode > 3U) {
189  av_log(logctx, AV_LOG_ERROR,
190  "out of range intra chroma pred mode\n");
191  return AVERROR_INVALIDDATA;
192  }
193 
194  if (!(top_samples_available & 0x8000)) {
195  mode = top[mode];
196  if (mode < 0) {
197  av_log(logctx, AV_LOG_ERROR,
198  "top block unavailable for requested intra mode\n");
199  return AVERROR_INVALIDDATA;
200  }
201  }
202 
203  if ((left_samples_available & 0x8080) != 0x8080) {
204  mode = left[mode];
205  if (mode < 0) {
206  av_log(logctx, AV_LOG_ERROR,
207  "left block unavailable for requested intra mode\n");
208  return AVERROR_INVALIDDATA;
209  }
210  if (is_chroma && (left_samples_available & 0x8080)) {
211  // mad cow disease mode, aka MBAFF + constrained_intra_pred
213  (!(left_samples_available & 0x8000)) +
214  2 * (mode == DC_128_PRED8x8);
215  }
216  }
217 
218  return mode;
219 }
220 
221 int ff_h264_parse_ref_count(int *plist_count, int ref_count[2],
222  GetBitContext *gb, const PPS *pps,
223  int slice_type_nos, int picture_structure, void *logctx)
224 {
225  int list_count;
226  int num_ref_idx_active_override_flag;
227 
228  // set defaults, might be overridden a few lines later
229  ref_count[0] = pps->ref_count[0];
230  ref_count[1] = pps->ref_count[1];
231 
232  if (slice_type_nos != AV_PICTURE_TYPE_I) {
233  unsigned max[2];
234  max[0] = max[1] = picture_structure == PICT_FRAME ? 15 : 31;
235 
236  num_ref_idx_active_override_flag = get_bits1(gb);
237 
238  if (num_ref_idx_active_override_flag) {
239  ref_count[0] = get_ue_golomb(gb) + 1;
240  if (slice_type_nos == AV_PICTURE_TYPE_B) {
241  ref_count[1] = get_ue_golomb(gb) + 1;
242  } else
243  // full range is spec-ok in this case, even for frames
244  ref_count[1] = 1;
245  }
246 
247  if (slice_type_nos == AV_PICTURE_TYPE_B)
248  list_count = 2;
249  else
250  list_count = 1;
251 
252  if (ref_count[0] - 1 > max[0] || (list_count == 2 && (ref_count[1] - 1 > max[1]))) {
253  av_log(logctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n",
254  ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]);
255  ref_count[0] = ref_count[1] = 0;
256  *plist_count = 0;
257  goto fail;
258  } else if (ref_count[1] - 1 > max[1]) {
259  av_log(logctx, AV_LOG_DEBUG, "reference overflow %u > %u \n",
260  ref_count[1] - 1, max[1]);
261  ref_count[1] = 0;
262  }
263 
264  } else {
265  list_count = 0;
266  ref_count[0] = ref_count[1] = 0;
267  }
268 
269  *plist_count = list_count;
270 
271  return 0;
272 fail:
273  *plist_count = 0;
274  ref_count[0] = 0;
275  ref_count[1] = 0;
276  return AVERROR_INVALIDDATA;
277 }
278 
279 int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc,
280  const SPS *sps, H264POCContext *pc,
281  int picture_structure, int nal_ref_idc)
282 {
283  const int max_frame_num = 1 << sps->log2_max_frame_num;
284  int64_t field_poc[2];
285 
287  if (pc->frame_num < pc->prev_frame_num)
288  pc->frame_num_offset += max_frame_num;
289 
290  if (sps->poc_type == 0) {
291  const int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
292  if (pc->prev_poc_lsb < 0)
293  pc->prev_poc_lsb = pc->poc_lsb;
294 
295  if (pc->poc_lsb < pc->prev_poc_lsb &&
296  pc->prev_poc_lsb - pc->poc_lsb >= max_poc_lsb / 2)
297  pc->poc_msb = pc->prev_poc_msb + max_poc_lsb;
298  else if (pc->poc_lsb > pc->prev_poc_lsb &&
299  pc->prev_poc_lsb - pc->poc_lsb < -max_poc_lsb / 2)
300  pc->poc_msb = pc->prev_poc_msb - max_poc_lsb;
301  else
302  pc->poc_msb = pc->prev_poc_msb;
303  field_poc[0] =
304  field_poc[1] = pc->poc_msb + pc->poc_lsb;
305  if (picture_structure == PICT_FRAME)
306  field_poc[1] += pc->delta_poc_bottom;
307  } else if (sps->poc_type == 1) {
308  int abs_frame_num;
309  int64_t expected_delta_per_poc_cycle, expectedpoc;
310  int i;
311 
312  if (sps->poc_cycle_length != 0)
313  abs_frame_num = pc->frame_num_offset + pc->frame_num;
314  else
315  abs_frame_num = 0;
316 
317  if (nal_ref_idc == 0 && abs_frame_num > 0)
318  abs_frame_num--;
319 
320  expected_delta_per_poc_cycle = 0;
321  for (i = 0; i < sps->poc_cycle_length; i++)
322  // FIXME integrate during sps parse
323  expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i];
324 
325  if (abs_frame_num > 0) {
326  int poc_cycle_cnt = (abs_frame_num - 1) / sps->poc_cycle_length;
327  int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length;
328 
329  expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
330  for (i = 0; i <= frame_num_in_poc_cycle; i++)
331  expectedpoc = expectedpoc + sps->offset_for_ref_frame[i];
332  } else
333  expectedpoc = 0;
334 
335  if (nal_ref_idc == 0)
336  expectedpoc = expectedpoc + sps->offset_for_non_ref_pic;
337 
338  field_poc[0] = expectedpoc + pc->delta_poc[0];
339  field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field;
340 
341  if (picture_structure == PICT_FRAME)
342  field_poc[1] += pc->delta_poc[1];
343  } else {
344  int poc = 2 * (pc->frame_num_offset + pc->frame_num);
345 
346  if (!nal_ref_idc)
347  poc--;
348 
349  field_poc[0] = poc;
350  field_poc[1] = poc;
351  }
352 
353  if ( field_poc[0] != (int)field_poc[0]
354  || field_poc[1] != (int)field_poc[1])
355  return AVERROR_INVALIDDATA;
356 
357  if (picture_structure != PICT_BOTTOM_FIELD)
358  pic_field_poc[0] = field_poc[0];
359  if (picture_structure != PICT_TOP_FIELD)
360  pic_field_poc[1] = field_poc[1];
361  *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]);
362 
363  return 0;
364 }
365 
366 static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps,
367  int is_avc, void *logctx)
368 {
369  H2645Packet pkt = { 0 };
370  int i, ret = 0;
371 
372  ret = ff_h2645_packet_split(&pkt, data, size, logctx, is_avc, 2, AV_CODEC_ID_H264, 1, 0);
373  if (ret < 0) {
374  ret = 0;
375  goto fail;
376  }
377 
378  for (i = 0; i < pkt.nb_nals; i++) {
379  H2645NAL *nal = &pkt.nals[i];
380  switch (nal->type) {
381  case H264_NAL_SPS: {
382  GetBitContext tmp_gb = nal->gb;
383  ret = ff_h264_decode_seq_parameter_set(&tmp_gb, logctx, ps, 0);
384  if (ret >= 0)
385  break;
386  av_log(logctx, AV_LOG_DEBUG,
387  "SPS decoding failure, trying again with the complete NAL\n");
388  init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
389  ret = ff_h264_decode_seq_parameter_set(&tmp_gb, logctx, ps, 0);
390  if (ret >= 0)
391  break;
392  ret = ff_h264_decode_seq_parameter_set(&nal->gb, logctx, ps, 1);
393  if (ret < 0)
394  goto fail;
395  break;
396  }
397  case H264_NAL_PPS:
398  ret = ff_h264_decode_picture_parameter_set(&nal->gb, logctx, ps,
399  nal->size_bits);
400  if (ret < 0)
401  goto fail;
402  break;
403  default:
404  av_log(logctx, AV_LOG_VERBOSE, "Ignoring NAL type %d in extradata\n",
405  nal->type);
406  break;
407  }
408  }
409 
410 fail:
412  return ret;
413 }
414 
415 /* There are (invalid) samples in the wild with mp4-style extradata, where the
416  * parameter sets are stored unescaped (i.e. as RBSP).
417  * This function catches the parameter set decoding failure and tries again
418  * after escaping it */
419 static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps,
420  int err_recognition, void *logctx)
421 {
422  int ret;
423 
424  ret = decode_extradata_ps(buf, buf_size, ps, 1, logctx);
425  if (ret < 0 && !(err_recognition & AV_EF_EXPLODE)) {
426  GetByteContext gbc;
427  PutByteContext pbc;
428  uint8_t *escaped_buf;
429  int escaped_buf_size;
430 
431  av_log(logctx, AV_LOG_WARNING,
432  "SPS decoding failure, trying again after escaping the NAL\n");
433 
434  if (buf_size / 2 >= (INT16_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 3)
435  return AVERROR(ERANGE);
436  escaped_buf_size = buf_size * 3 / 2 + AV_INPUT_BUFFER_PADDING_SIZE;
437  escaped_buf = av_mallocz(escaped_buf_size);
438  if (!escaped_buf)
439  return AVERROR(ENOMEM);
440 
441  bytestream2_init(&gbc, buf, buf_size);
442  bytestream2_init_writer(&pbc, escaped_buf, escaped_buf_size);
443 
444  while (bytestream2_get_bytes_left(&gbc)) {
445  if (bytestream2_get_bytes_left(&gbc) >= 3 &&
446  bytestream2_peek_be24(&gbc) <= 3) {
447  bytestream2_put_be24(&pbc, 3);
448  bytestream2_skip(&gbc, 2);
449  } else
450  bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc));
451  }
452 
453  escaped_buf_size = bytestream2_tell_p(&pbc);
454  AV_WB16(escaped_buf, escaped_buf_size - 2);
455 
456  (void)decode_extradata_ps(escaped_buf, escaped_buf_size, ps, 1, logctx);
457  // lorex.mp4 decodes ok even with extradata decoding failing
458  av_freep(&escaped_buf);
459  }
460 
461  return 0;
462 }
463 
464 int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps,
465  int *is_avc, int *nal_length_size,
466  int err_recognition, void *logctx)
467 {
468  int ret;
469 
470  if (!data || size <= 0)
471  return -1;
472 
473  if (data[0] == 1) {
474  int i, cnt, nalsize;
475  const uint8_t *p = data;
476 
477  *is_avc = 1;
478 
479  if (size < 7) {
480  av_log(logctx, AV_LOG_ERROR, "avcC %d too short\n", size);
481  return AVERROR_INVALIDDATA;
482  }
483 
484  // Decode sps from avcC
485  cnt = *(p + 5) & 0x1f; // Number of sps
486  p += 6;
487  for (i = 0; i < cnt; i++) {
488  nalsize = AV_RB16(p) + 2;
489  if (nalsize > size - (p - data))
490  return AVERROR_INVALIDDATA;
491  ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
492  if (ret < 0) {
493  av_log(logctx, AV_LOG_ERROR,
494  "Decoding sps %d from avcC failed\n", i);
495  return ret;
496  }
497  p += nalsize;
498  }
499  // Decode pps from avcC
500  cnt = *(p++); // Number of pps
501  for (i = 0; i < cnt; i++) {
502  nalsize = AV_RB16(p) + 2;
503  if (nalsize > size - (p - data))
504  return AVERROR_INVALIDDATA;
505  ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
506  if (ret < 0) {
507  av_log(logctx, AV_LOG_ERROR,
508  "Decoding pps %d from avcC failed\n", i);
509  return ret;
510  }
511  p += nalsize;
512  }
513  // Store right nal length size that will be used to parse all other nals
514  *nal_length_size = (data[4] & 0x03) + 1;
515  } else {
516  *is_avc = 0;
517  ret = decode_extradata_ps(data, size, ps, 0, logctx);
518  if (ret < 0)
519  return ret;
520  }
521  return size;
522 }
523 
524 /**
525  * Compute profile from profile_idc and constraint_set?_flags.
526  *
527  * @param sps SPS
528  *
529  * @return profile as defined by FF_PROFILE_H264_*
530  */
532 {
533  int profile = sps->profile_idc;
534 
535  switch (sps->profile_idc) {
537  // constraint_set1_flag set to 1
538  profile |= (sps->constraint_set_flags & 1 << 1) ? FF_PROFILE_H264_CONSTRAINED : 0;
539  break;
543  // constraint_set3_flag set to 1
544  profile |= (sps->constraint_set_flags & 1 << 3) ? FF_PROFILE_H264_INTRA : 0;
545  break;
546  }
547 
548  return profile;
549 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:419
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
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
DC_128_PRED
@ DC_128_PRED
Definition: vp9.h:58
FF_PROFILE_H264_INTRA
#define FF_PROFILE_H264_INTRA
Definition: avcodec.h:1587
GetByteContext
Definition: bytestream.h:33
H264POCContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264_parse.h:85
FF_PROFILE_H264_BASELINE
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:1589
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:528
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:146
FF_PROFILE_H264_HIGH_444_PREDICTIVE
#define FF_PROFILE_H264_HIGH_444_PREDICTIVE
Definition: avcodec.h:1601
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:196
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
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:29
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:695
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:134
GetBitContext
Definition: get_bits.h:61
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:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:667
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
mask
static const uint16_t mask[17]
Definition: lzw.c:38
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:464
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:201
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
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
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:405
SPS
Sequence parameter set.
Definition: h264_ps.h:45
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
PPS
Picture parameter set.
Definition: h264_ps.h:105
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
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
FF_PROFILE_H264_HIGH_422
#define FF_PROFILE_H264_HIGH_422
Definition: avcodec.h:1597
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
ff_h2645_packet_split
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)
Split an input packet into NAL units.
Definition: h2645_parse.c:396
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:366
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:280
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:264
profile
int profile
Definition: mxfenc.c:2006
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:221
LEFT_DC_PRED8x8
#define LEFT_DC_PRED8x8
Definition: h264pred.h:74
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:279
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:531
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
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
FF_PROFILE_H264_CONSTRAINED
#define FF_PROFILE_H264_CONSTRAINED
Definition: avcodec.h:1586
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
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
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:133
H264ParamSets
Definition: h264_ps.h:137
H264PredWeightTable
Definition: h264_parse.h:69
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
FF_PROFILE_H264_HIGH_10
#define FF_PROFILE_H264_HIGH_10
Definition: avcodec.h:1594
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
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
H264POCContext::prev_poc_msb
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:88
int
int
Definition: ffmpeg_filter.c:156
H2645Packet
Definition: h2645_parse.h:82
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
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:181
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