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

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