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