FFmpeg: libavcodec/h2645_parse.c Source File

FFmpeg
h2645_parse.c
Go to the documentation of this file.
1 /*
2  * H.264/HEVC common parsing code
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <string.h>
22 
23 #include "config.h"
24 
25 #include "libavutil/intmath.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/mem.h"
28 
29 #include "bytestream.h"
30 #include "h264.h"
31 #include "h2645_parse.h"
32 #include "vvc.h"
33 
34 #include "hevc/hevc.h"
35 
36  int ff_h2645_extract_rbsp(const uint8_t *src, int length,
37  H2645RBSP *rbsp, H2645NAL *nal, int small_padding)
38 {
39  int i, si, di;
40  uint8_t *dst;
41 
42  nal->skipped_bytes = 0;
43 #define STARTCODE_TEST \
44  if (i + 2 < length && src[i + 1] == 0 && \
45  (src[i + 2] == 3 || src[i + 2] == 1)) { \
46  if (src[i + 2] == 1) { \
47 /* startcode, so we must be past the end */ \
48  length = i; \
49  } \
50  break; \
51  }
52 #if HAVE_FAST_UNALIGNED
53 #define FIND_FIRST_ZERO \
54  if (i > 0 && !src[i]) \
55  i--; \
56  while (src[i]) \
57  i++
58 #if HAVE_FAST_64BIT
59  for (i = 0; i + 1 < length; i += 9) {
60  if (!((~AV_RN64(src + i) &
61  (AV_RN64(src + i) - 0x0100010001000101ULL)) &
62  0x8000800080008080ULL))
63  continue;
64  FIND_FIRST_ZERO;
65  STARTCODE_TEST;
66  i -= 7;
67  }
68 #else
69  for (i = 0; i + 1 < length; i += 5) {
70  if (!((~AV_RN32(src + i) &
71  (AV_RN32(src + i) - 0x01000101U)) &
72  0x80008080U))
73  continue;
74  FIND_FIRST_ZERO;
75  STARTCODE_TEST;
76  i -= 3;
77  }
78 #endif /* HAVE_FAST_64BIT */
79 #else
80  for (i = 0; i + 1 < length; i += 2) {
81  if (src[i])
82  continue;
83  if (i > 0 && src[i - 1] == 0)
84  i--;
85  STARTCODE_TEST;
86  }
87 #endif /* HAVE_FAST_UNALIGNED */
88 
89  if (i >= length - 1 && small_padding) { // no escaped 0
90  nal->data =
91  nal->raw_data = src;
92  nal->size =
93  nal->raw_size = length;
94  return length;
95  } else if (i > length)
96  i = length;
97 
98  dst = &rbsp->rbsp_buffer[rbsp->rbsp_buffer_size];
99 
100  memcpy(dst, src, i);
101  si = di = i;
102  while (si + 2 < length) {
103  // remove escapes (very rare 1:2^22)
104  if (src[si + 2] > 3) {
105  dst[di++] = src[si++];
106  dst[di++] = src[si++];
107  } else if (src[si] == 0 && src[si + 1] == 0 && src[si + 2] != 0) {
108  if (src[si + 2] == 3) { // escape
109  dst[di++] = 0;
110  dst[di++] = 0;
111  si += 3;
112 
113  if (nal->skipped_bytes_pos) {
114  nal->skipped_bytes++;
115  if (nal->skipped_bytes_pos_size < nal->skipped_bytes) {
116  nal->skipped_bytes_pos_size *= 2;
117  av_assert0(nal->skipped_bytes_pos_size >= nal->skipped_bytes);
118  av_reallocp_array(&nal->skipped_bytes_pos,
119  nal->skipped_bytes_pos_size,
120  sizeof(*nal->skipped_bytes_pos));
121  if (!nal->skipped_bytes_pos) {
122  nal->skipped_bytes_pos_size = 0;
123  return AVERROR(ENOMEM);
124  }
125  }
126  if (nal->skipped_bytes_pos)
127  nal->skipped_bytes_pos[nal->skipped_bytes-1] = di - 1;
128  }
129  continue;
130  } else // next start code
131  goto nsc;
132  }
133 
134  dst[di++] = src[si++];
135  }
136  while (si < length)
137  dst[di++] = src[si++];
138 
139 nsc:
140  memset(dst + di, 0, AV_INPUT_BUFFER_PADDING_SIZE);
141 
142  nal->data = dst;
143  nal->size = di;
144  nal->raw_data = src;
145  nal->raw_size = si;
146  rbsp->rbsp_buffer_size += si;
147 
148  return si;
149 }
150 
151  static const char *const vvc_nal_type_name[32] = {
152  "TRAIL_NUT", // VVC_TRAIL_NUT
153  "STSA_NUT", // VVC_STSA_NUT
154  "RADL_NUT", // VVC_RADL_NUT
155  "RASL_NUT", // VVC_RASL_NUT
156  "RSV_VCL4", // VVC_RSV_VCL_4
157  "RSV_VCL5", // VVC_RSV_VCL_5
158  "RSV_VCL6", // VVC_RSV_VCL_6
159  "IDR_W_RADL", // VVC_IDR_W_RADL
160  "IDR_N_LP", // VVC_IDR_N_LP
161  "CRA_NUT", // VVC_CRA_NUT
162  "GDR_NUT", // VVC_GDR_NUT
163  "RSV_IRAP_11", // VVC_RSV_IRAP_11
164  "OPI_NUT", // VVC_OPI_NUT
165  "DCI_NUT", // VVC_DCI_NUT
166  "VPS_NUT", // VVC_VPS_NUT
167  "SPS_NUT", // VVC_SPS_NUT
168  "PPS_NUT", // VVC_PPS_NUT
169  "APS_PREFIX", // VVC_PREFIX_APS_NUT
170  "APS_SUFFIX", // VVC_SUFFIX_APS_NUT
171  "PH_NUT", // VVC_PH_NUT
172  "AUD_NUT", // VVC_AUD_NUT
173  "EOS_NUT", // VVC_EOS_NUT
174  "EOB_NUT", // VVC_EOB_NUT
175  "SEI_PREFIX", // VVC_PREFIX_SEI_NUT
176  "SEI_SUFFIX", // VVC_SUFFIX_SEI_NUT
177  "FD_NUT", // VVC_FD_NUT
178  "RSV_NVCL26", // VVC_RSV_NVCL_26
179  "RSV_NVCL27", // VVC_RSV_NVCL_27
180  "UNSPEC28", // VVC_UNSPEC_28
181  "UNSPEC29", // VVC_UNSPEC_29
182  "UNSPEC30", // VVC_UNSPEC_30
183  "UNSPEC31", // VVC_UNSPEC_31
184 };
185 
186  static const char *vvc_nal_unit_name(int nal_type)
187 {
188  av_assert0(nal_type >= 0 && nal_type < 32);
189  return vvc_nal_type_name[nal_type];
190 }
191 
192  static const char *const hevc_nal_type_name[64] = {
193  "TRAIL_N", // HEVC_NAL_TRAIL_N
194  "TRAIL_R", // HEVC_NAL_TRAIL_R
195  "TSA_N", // HEVC_NAL_TSA_N
196  "TSA_R", // HEVC_NAL_TSA_R
197  "STSA_N", // HEVC_NAL_STSA_N
198  "STSA_R", // HEVC_NAL_STSA_R
199  "RADL_N", // HEVC_NAL_RADL_N
200  "RADL_R", // HEVC_NAL_RADL_R
201  "RASL_N", // HEVC_NAL_RASL_N
202  "RASL_R", // HEVC_NAL_RASL_R
203  "RSV_VCL_N10", // HEVC_NAL_VCL_N10
204  "RSV_VCL_R11", // HEVC_NAL_VCL_R11
205  "RSV_VCL_N12", // HEVC_NAL_VCL_N12
206  "RSV_VLC_R13", // HEVC_NAL_VCL_R13
207  "RSV_VCL_N14", // HEVC_NAL_VCL_N14
208  "RSV_VCL_R15", // HEVC_NAL_VCL_R15
209  "BLA_W_LP", // HEVC_NAL_BLA_W_LP
210  "BLA_W_RADL", // HEVC_NAL_BLA_W_RADL
211  "BLA_N_LP", // HEVC_NAL_BLA_N_LP
212  "IDR_W_RADL", // HEVC_NAL_IDR_W_RADL
213  "IDR_N_LP", // HEVC_NAL_IDR_N_LP
214  "CRA_NUT", // HEVC_NAL_CRA_NUT
215  "RSV_IRAP_VCL22", // HEVC_NAL_RSV_IRAP_VCL22
216  "RSV_IRAP_VCL23", // HEVC_NAL_RSV_IRAP_VCL23
217  "RSV_VCL24", // HEVC_NAL_RSV_VCL24
218  "RSV_VCL25", // HEVC_NAL_RSV_VCL25
219  "RSV_VCL26", // HEVC_NAL_RSV_VCL26
220  "RSV_VCL27", // HEVC_NAL_RSV_VCL27
221  "RSV_VCL28", // HEVC_NAL_RSV_VCL28
222  "RSV_VCL29", // HEVC_NAL_RSV_VCL29
223  "RSV_VCL30", // HEVC_NAL_RSV_VCL30
224  "RSV_VCL31", // HEVC_NAL_RSV_VCL31
225  "VPS", // HEVC_NAL_VPS
226  "SPS", // HEVC_NAL_SPS
227  "PPS", // HEVC_NAL_PPS
228  "AUD", // HEVC_NAL_AUD
229  "EOS_NUT", // HEVC_NAL_EOS_NUT
230  "EOB_NUT", // HEVC_NAL_EOB_NUT
231  "FD_NUT", // HEVC_NAL_FD_NUT
232  "SEI_PREFIX", // HEVC_NAL_SEI_PREFIX
233  "SEI_SUFFIX", // HEVC_NAL_SEI_SUFFIX
234  "RSV_NVCL41", // HEVC_NAL_RSV_NVCL41
235  "RSV_NVCL42", // HEVC_NAL_RSV_NVCL42
236  "RSV_NVCL43", // HEVC_NAL_RSV_NVCL43
237  "RSV_NVCL44", // HEVC_NAL_RSV_NVCL44
238  "RSV_NVCL45", // HEVC_NAL_RSV_NVCL45
239  "RSV_NVCL46", // HEVC_NAL_RSV_NVCL46
240  "RSV_NVCL47", // HEVC_NAL_RSV_NVCL47
241  "UNSPEC48", // HEVC_NAL_UNSPEC48
242  "UNSPEC49", // HEVC_NAL_UNSPEC49
243  "UNSPEC50", // HEVC_NAL_UNSPEC50
244  "UNSPEC51", // HEVC_NAL_UNSPEC51
245  "UNSPEC52", // HEVC_NAL_UNSPEC52
246  "UNSPEC53", // HEVC_NAL_UNSPEC53
247  "UNSPEC54", // HEVC_NAL_UNSPEC54
248  "UNSPEC55", // HEVC_NAL_UNSPEC55
249  "UNSPEC56", // HEVC_NAL_UNSPEC56
250  "UNSPEC57", // HEVC_NAL_UNSPEC57
251  "UNSPEC58", // HEVC_NAL_UNSPEC58
252  "UNSPEC59", // HEVC_NAL_UNSPEC59
253  "UNSPEC60", // HEVC_NAL_UNSPEC60
254  "UNSPEC61", // HEVC_NAL_UNSPEC61
255  "UNSPEC62", // HEVC_NAL_UNSPEC62
256  "UNSPEC63", // HEVC_NAL_UNSPEC63
257 };
258 
259  static const char *hevc_nal_unit_name(int nal_type)
260 {
261  av_assert0(nal_type >= 0 && nal_type < 64);
262  return hevc_nal_type_name[nal_type];
263 }
264 
265  static const char *const h264_nal_type_name[32] = {
266  "Unspecified 0", //H264_NAL_UNSPECIFIED
267  "Coded slice of a non-IDR picture", // H264_NAL_SLICE
268  "Coded slice data partition A", // H264_NAL_DPA
269  "Coded slice data partition B", // H264_NAL_DPB
270  "Coded slice data partition C", // H264_NAL_DPC
271  "IDR", // H264_NAL_IDR_SLICE
272  "SEI", // H264_NAL_SEI
273  "SPS", // H264_NAL_SPS
274  "PPS", // H264_NAL_PPS
275  "AUD", // H264_NAL_AUD
276  "End of sequence", // H264_NAL_END_SEQUENCE
277  "End of stream", // H264_NAL_END_STREAM
278  "Filler data", // H264_NAL_FILLER_DATA
279  "SPS extension", // H264_NAL_SPS_EXT
280  "Prefix", // H264_NAL_PREFIX
281  "Subset SPS", // H264_NAL_SUB_SPS
282  "Depth parameter set", // H264_NAL_DPS
283  "Reserved 17", // H264_NAL_RESERVED17
284  "Reserved 18", // H264_NAL_RESERVED18
285  "Auxiliary coded picture without partitioning", // H264_NAL_AUXILIARY_SLICE
286  "Slice extension", // H264_NAL_EXTEN_SLICE
287  "Slice extension for a depth view or a 3D-AVC texture view", // H264_NAL_DEPTH_EXTEN_SLICE
288  "Reserved 22", // H264_NAL_RESERVED22
289  "Reserved 23", // H264_NAL_RESERVED23
290  "Unspecified 24", // H264_NAL_UNSPECIFIED24
291  "Unspecified 25", // H264_NAL_UNSPECIFIED25
292  "Unspecified 26", // H264_NAL_UNSPECIFIED26
293  "Unspecified 27", // H264_NAL_UNSPECIFIED27
294  "Unspecified 28", // H264_NAL_UNSPECIFIED28
295  "Unspecified 29", // H264_NAL_UNSPECIFIED29
296  "Unspecified 30", // H264_NAL_UNSPECIFIED30
297  "Unspecified 31", // H264_NAL_UNSPECIFIED31
298 };
299 
300  static const char *h264_nal_unit_name(int nal_type)
301 {
302  av_assert0(nal_type >= 0 && nal_type < 32);
303  return h264_nal_type_name[nal_type];
304 }
305 
306  static int get_bit_length(H2645NAL *nal, int min_size, int skip_trailing_zeros)
307 {
308  int size = nal->size;
309  int trailing_padding = 0;
310 
311  while (skip_trailing_zeros && size > 0 && nal->data[size - 1] == 0)
312  size--;
313 
314  if (!size)
315  return 0;
316 
317  if (size <= min_size) {
318  if (nal->size < min_size)
319  return AVERROR_INVALIDDATA;
320  size = min_size;
321  } else {
322  int v = nal->data[size - 1];
323  /* remove the stop bit and following trailing zeros,
324  * or nothing for damaged bitstreams */
325  if (v)
326  trailing_padding = ff_ctz(v) + 1;
327  }
328 
329  if (size > INT_MAX / 8)
330  return AVERROR(ERANGE);
331  size *= 8;
332 
333  return size - trailing_padding;
334 }
335 
336 /**
337  * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
338  * 0 otherwise
339  */
340  static int vvc_parse_nal_header(H2645NAL *nal, void *logctx)
341 {
342  GetBitContext *gb = &nal->gb;
343 
344  if (get_bits1(gb) != 0) //forbidden_zero_bit
345  return AVERROR_INVALIDDATA;
346 
347  skip_bits1(gb); //nuh_reserved_zero_bit
348 
349  nal->nuh_layer_id = get_bits(gb, 6);
350  nal->type = get_bits(gb, 5);
351  nal->temporal_id = get_bits(gb, 3) - 1;
352  if (nal->temporal_id < 0)
353  return AVERROR_INVALIDDATA;
354 
355  if ((nal->type >= VVC_IDR_W_RADL && nal->type <= VVC_RSV_IRAP_11) && nal->temporal_id)
356  return AVERROR_INVALIDDATA;
357 
358  av_log(logctx, AV_LOG_DEBUG,
359  "nal_unit_type: %d(%s), nuh_layer_id: %d, temporal_id: %d\n",
360  nal->type, vvc_nal_unit_name(nal->type), nal->nuh_layer_id, nal->temporal_id);
361 
362  return 0;
363 }
364 
365  static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)
366 {
367  GetBitContext *gb = &nal->gb;
368 
369  if (get_bits1(gb) != 0)
370  return AVERROR_INVALIDDATA;
371 
372  nal->type = get_bits(gb, 6);
373 
374  nal->nuh_layer_id = get_bits(gb, 6);
375  nal->temporal_id = get_bits(gb, 3) - 1;
376  if (nal->temporal_id < 0)
377  return AVERROR_INVALIDDATA;
378 
379  av_log(logctx, AV_LOG_DEBUG,
380  "nal_unit_type: %d(%s), nuh_layer_id: %d, temporal_id: %d\n",
381  nal->type, hevc_nal_unit_name(nal->type), nal->nuh_layer_id, nal->temporal_id);
382 
383  return 0;
384 }
385 
386  static int h264_parse_nal_header(H2645NAL *nal, void *logctx)
387 {
388  GetBitContext *gb = &nal->gb;
389 
390  if (get_bits1(gb) != 0)
391  return AVERROR_INVALIDDATA;
392 
393  nal->ref_idc = get_bits(gb, 2);
394  nal->type = get_bits(gb, 5);
395 
396  av_log(logctx, AV_LOG_DEBUG,
397  "nal_unit_type: %d(%s), nal_ref_idc: %d\n",
398  nal->type, h264_nal_unit_name(nal->type), nal->ref_idc);
399 
400  return 0;
401 }
402 
403  static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)
404 {
405  int i = 0;
406 
407  if (buf + 3 >= next_avc)
408  return next_avc - buf;
409 
410  while (buf + i + 3 < next_avc) {
411  if (buf[i] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1)
412  break;
413  i++;
414  }
415  return i + 3;
416 }
417 
418  static void alloc_rbsp_buffer(H2645RBSP *rbsp, unsigned int size, int use_ref)
419 {
420  int min_size = size;
421 
422  if (size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
423  goto fail;
424  size += AV_INPUT_BUFFER_PADDING_SIZE;
425 
426  if (rbsp->rbsp_buffer_alloc_size >= size &&
427  (!rbsp->rbsp_buffer_ref || av_buffer_is_writable(rbsp->rbsp_buffer_ref))) {
428  av_assert0(rbsp->rbsp_buffer);
429  memset(rbsp->rbsp_buffer + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
430  return;
431  }
432 
433  size = FFMIN(size + size / 16 + 32, INT_MAX);
434 
435  if (rbsp->rbsp_buffer_ref)
436  av_buffer_unref(&rbsp->rbsp_buffer_ref);
437  else
438  av_free(rbsp->rbsp_buffer);
439 
440  rbsp->rbsp_buffer = av_mallocz(size);
441  if (!rbsp->rbsp_buffer)
442  goto fail;
443  rbsp->rbsp_buffer_alloc_size = size;
444 
445  if (use_ref) {
446  rbsp->rbsp_buffer_ref = av_buffer_create(rbsp->rbsp_buffer, size,
447  NULL, NULL, 0);
448  if (!rbsp->rbsp_buffer_ref)
449  goto fail;
450  }
451 
452  return;
453 
454 fail:
455  rbsp->rbsp_buffer_alloc_size = 0;
456  if (rbsp->rbsp_buffer_ref) {
457  av_buffer_unref(&rbsp->rbsp_buffer_ref);
458  rbsp->rbsp_buffer = NULL;
459  } else
460  av_freep(&rbsp->rbsp_buffer);
461 
462  return;
463 }
464 
465  int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length,
466  void *logctx, int nal_length_size,
467  enum AVCodecID codec_id, int flags)
468 {
469  GetByteContext bc;
470  int consumed, ret = 0;
471  int next_avc = (flags & H2645_FLAG_IS_NALFF) ? 0 : length;
472  int64_t padding = (flags & H2645_FLAG_SMALL_PADDING) ? 0 : MAX_MBPAIR_SIZE;
473 
474  bytestream2_init(&bc, buf, length);
475  alloc_rbsp_buffer(&pkt->rbsp, length + padding, !!(flags & H2645_FLAG_USE_REF));
476 
477  if (!pkt->rbsp.rbsp_buffer)
478  return AVERROR(ENOMEM);
479 
480  pkt->rbsp.rbsp_buffer_size = 0;
481  pkt->nb_nals = 0;
482  while (bytestream2_get_bytes_left(&bc) >= 4) {
483  H2645NAL *nal;
484  int extract_length = 0;
485  int skip_trailing_zeros = 1;
486 
487  if (bytestream2_tell(&bc) == next_avc) {
488  int i = 0;
489  extract_length = get_nalsize(nal_length_size,
490  bc.buffer, bytestream2_get_bytes_left(&bc), &i, logctx);
491  if (extract_length < 0)
492  return extract_length;
493 
494  bytestream2_skip(&bc, nal_length_size);
495 
496  next_avc = bytestream2_tell(&bc) + extract_length;
497  } else {
498  int buf_index;
499 
500  if (bytestream2_tell(&bc) > next_avc)
501  av_log(logctx, AV_LOG_WARNING, "Exceeded next NALFF position, re-syncing.\n");
502 
503  /* search start code */
504  buf_index = find_next_start_code(bc.buffer, buf + next_avc);
505 
506  bytestream2_skip(&bc, buf_index);
507 
508  if (!bytestream2_get_bytes_left(&bc)) {
509  if (pkt->nb_nals > 0) {
510  // No more start codes: we discarded some irrelevant
511  // bytes at the end of the packet.
512  return 0;
513  } else {
514  av_log(logctx, AV_LOG_ERROR, "No start code is found.\n");
515  return AVERROR_INVALIDDATA;
516  }
517  }
518 
519  extract_length = FFMIN(bytestream2_get_bytes_left(&bc), next_avc - bytestream2_tell(&bc));
520 
521  if (bytestream2_tell(&bc) >= next_avc) {
522  /* skip to the start of the next NAL */
523  bytestream2_skip(&bc, next_avc - bytestream2_tell(&bc));
524  continue;
525  }
526  }
527 
528  if (pkt->nals_allocated < pkt->nb_nals + 1) {
529  int new_size = pkt->nals_allocated + 1;
530  void *tmp;
531 
532  if (new_size >= INT_MAX / sizeof(*pkt->nals))
533  return AVERROR(ENOMEM);
534 
535  tmp = av_fast_realloc(pkt->nals, &pkt->nal_buffer_size, new_size * sizeof(*pkt->nals));
536  if (!tmp)
537  return AVERROR(ENOMEM);
538 
539  pkt->nals = tmp;
540  memset(pkt->nals + pkt->nals_allocated, 0, sizeof(*pkt->nals));
541 
542  nal = &pkt->nals[pkt->nb_nals];
543  nal->skipped_bytes_pos_size = FFMIN(1024, extract_length/3+1); // initial buffer size
544  nal->skipped_bytes_pos = av_malloc_array(nal->skipped_bytes_pos_size, sizeof(*nal->skipped_bytes_pos));
545  if (!nal->skipped_bytes_pos)
546  return AVERROR(ENOMEM);
547 
548  pkt->nals_allocated = new_size;
549  }
550  nal = &pkt->nals[pkt->nb_nals];
551 
552  consumed = ff_h2645_extract_rbsp(bc.buffer, extract_length, &pkt->rbsp, nal,
553  !!(flags & H2645_FLAG_SMALL_PADDING));
554  if (consumed < 0)
555  return consumed;
556 
557  if ((flags & H2645_FLAG_IS_NALFF) && (extract_length != consumed) && extract_length)
558  av_log(logctx, AV_LOG_DEBUG,
559  "NALFF: Consumed only %d bytes instead of %d\n",
560  consumed, extract_length);
561 
562  bytestream2_skip(&bc, consumed);
563 
564  /* see commit 3566042a0 */
565  if (bytestream2_get_bytes_left(&bc) >= 4 &&
566  bytestream2_peek_be32(&bc) == 0x000001E0)
567  skip_trailing_zeros = 0;
568 
569  nal->size_bits = get_bit_length(nal, 1 + (codec_id == AV_CODEC_ID_HEVC),
570  skip_trailing_zeros);
571 
572  if (nal->size <= 0 || nal->size_bits <= 0)
573  continue;
574 
575  ret = init_get_bits(&nal->gb, nal->data, nal->size_bits);
576  if (ret < 0)
577  return ret;
578 
579  /* Reset type in case it contains a stale value from a previously parsed NAL */
580  nal->type = 0;
581 
582  if (codec_id == AV_CODEC_ID_VVC)
583  ret = vvc_parse_nal_header(nal, logctx);
584  else if (codec_id == AV_CODEC_ID_HEVC) {
585  ret = hevc_parse_nal_header(nal, logctx);
586  if (nal->nuh_layer_id == 63)
587  continue;
588  } else
589  ret = h264_parse_nal_header(nal, logctx);
590  if (ret < 0) {
591  av_log(logctx, AV_LOG_WARNING, "Invalid NAL unit %d, skipping.\n",
592  nal->type);
593  continue;
594  }
595 
596  pkt->nb_nals++;
597  }
598 
599  return 0;
600 }
601 
602  void ff_h2645_packet_uninit(H2645Packet *pkt)
603 {
604  int i;
605  for (i = 0; i < pkt->nals_allocated; i++) {
606  av_freep(&pkt->nals[i].skipped_bytes_pos);
607  }
608  av_freep(&pkt->nals);
609  pkt->nals_allocated = pkt->nal_buffer_size = 0;
610  if (pkt->rbsp.rbsp_buffer_ref) {
611  av_buffer_unref(&pkt->rbsp.rbsp_buffer_ref);
612  pkt->rbsp.rbsp_buffer = NULL;
613  } else
614  av_freep(&pkt->rbsp.rbsp_buffer);
615  pkt->rbsp.rbsp_buffer_alloc_size = pkt->rbsp.rbsp_buffer_size = 0;
616 }
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
h2645_parse.h
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
H2645_FLAG_USE_REF
@ H2645_FLAG_USE_REF
Definition: h2645_parse.h:99
ff_ctz
#define ff_ctz
Definition: intmath.h:107
STARTCODE_TEST
#define STARTCODE_TEST
GetByteContext
Definition: bytestream.h:33
get_bit_length
static int get_bit_length(H2645NAL *nal, int min_size, int skip_trailing_zeros)
Definition: h2645_parse.c:306
int64_t
long long int64_t
Definition: coverity.c:34
H2645NAL::ref_idc
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:57
H2645NAL::nuh_layer_id
int nuh_layer_id
Definition: h2645_parse.h:67
AV_RN64
#define AV_RN64(p)
Definition: intreadwrite.h:364
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
h264_parse_nal_header
static int h264_parse_nal_header(H2645NAL *nal, void *logctx)
Definition: h2645_parse.c:386
ff_h2645_packet_uninit
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:602
find_next_start_code
static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)
Definition: h2645_parse.c:403
H2645NAL::skipped_bytes_pos_size
int skipped_bytes_pos_size
Definition: h2645_parse.h:70
H2645NAL::temporal_id
int temporal_id
HEVC only, nuh_temporal_id_plus_1 - 1.
Definition: h2645_parse.h:62
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
hevc_parse_nal_header
static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)
Definition: h2645_parse.c:365
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
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
hevc_nal_unit_name
static const char * hevc_nal_unit_name(int nal_type)
Definition: h2645_parse.c:259
fail
#define fail()
Definition: checkasm.h:188
GetBitContext
Definition: get_bits.h:108
VVC_IDR_W_RADL
@ VVC_IDR_W_RADL
Definition: vvc.h:36
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:180
H2645NAL::size
int size
Definition: h2645_parse.h:36
h264_nal_type_name
static const char *const h264_nal_type_name[32]
Definition: h2645_parse.c:265
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:497
intreadwrite.h
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
hevc.h
H2645NAL::data
const uint8_t * data
Definition: h2645_parse.h:35
H2645NAL::skipped_bytes_pos
int * skipped_bytes_pos
Definition: h2645_parse.h:71
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:394
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
H2645NAL::raw_size
int raw_size
Definition: h2645_parse.h:44
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:360
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
H2645NAL::skipped_bytes
int skipped_bytes
Definition: h2645_parse.h:69
H2645RBSP::rbsp_buffer
uint8_t * rbsp_buffer
Definition: h2645_parse.h:75
hevc_nal_type_name
static const char *const hevc_nal_type_name[64]
Definition: h2645_parse.c:192
vvc_nal_type_name
static const char *const vvc_nal_type_name[32]
Definition: h2645_parse.c:151
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
size
int size
Definition: twinvq_data.h:10344
H2645NAL::gb
GetBitContext gb
Definition: h2645_parse.h:47
vvc_nal_unit_name
static const char * vvc_nal_unit_name(int nal_type)
Definition: h2645_parse.c:186
H2645NAL
Definition: h2645_parse.h:34
H2645RBSP::rbsp_buffer_size
int rbsp_buffer_size
Definition: h2645_parse.h:78
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:225
AV_CODEC_ID_VVC
@ AV_CODEC_ID_VVC
Definition: codec_id.h:250
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
vvc.h
h264_nal_unit_name
static const char * h264_nal_unit_name(int nal_type)
Definition: h2645_parse.c:300
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_h2645_extract_rbsp
int ff_h2645_extract_rbsp(const uint8_t *src, int length, H2645RBSP *rbsp, H2645NAL *nal, int small_padding)
Extract the raw (unescaped) bitstream.
Definition: h2645_parse.c:36
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
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
H2645RBSP::rbsp_buffer_ref
AVBufferRef * rbsp_buffer_ref
Definition: h2645_parse.h:76
H2645RBSP::rbsp_buffer_alloc_size
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:77
av_buffer_is_writable
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:147
ret
ret
Definition: filter_design.txt:187
H2645NAL::raw_data
const uint8_t * raw_data
Definition: h2645_parse.h:45
VVC_RSV_IRAP_11
@ VVC_RSV_IRAP_11
Definition: vvc.h:40
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
vvc_parse_nal_header
static int vvc_parse_nal_header(H2645NAL *nal, void *logctx)
Definition: h2645_parse.c:340
MAX_MBPAIR_SIZE
#define MAX_MBPAIR_SIZE
Definition: h2645_parse.h:32
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
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
get_nalsize
static int get_nalsize(int nal_length_size, const uint8_t *buf, int buf_size, int *buf_index, void *logctx)
Definition: h2645_parse.h:126
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
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
H2645Packet
Definition: h2645_parse.h:82
H2645RBSP
Definition: h2645_parse.h:74
src
#define src
Definition: vp8dsp.c:248
alloc_rbsp_buffer
static void alloc_rbsp_buffer(H2645RBSP *rbsp, unsigned int size, int use_ref)
Definition: h2645_parse.c:418
intmath.h
Generated on Fri Aug 22 2025 13:58:22 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /