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 
35  H2645RBSP *rbsp, H2645NAL *nal, int small_padding)
36 {
37  int i, si, di;
38  uint8_t *dst;
39 
40  nal->skipped_bytes = 0;
41 #define STARTCODE_TEST \
42  if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
43  if (src[i + 2] != 3 && src[i + 2] != 0) { \
44  /* startcode, so we must be past the end */ \
45  length = i; \
46  } \
47  break; \
48  }
49 #if HAVE_FAST_UNALIGNED
50 #define FIND_FIRST_ZERO \
51  if (i > 0 && !src[i]) \
52  i--; \
53  while (src[i]) \
54  i++
55 #if HAVE_FAST_64BIT
56  for (i = 0; i + 1 < length; i += 9) {
57  if (!((~AV_RN64(src + i) &
58  (AV_RN64(src + i) - 0x0100010001000101ULL)) &
59  0x8000800080008080ULL))
60  continue;
61  FIND_FIRST_ZERO;
63  i -= 7;
64  }
65 #else
66  for (i = 0; i + 1 < length; i += 5) {
67  if (!((~AV_RN32(src + i) &
68  (AV_RN32(src + i) - 0x01000101U)) &
69  0x80008080U))
70  continue;
71  FIND_FIRST_ZERO;
73  i -= 3;
74  }
75 #endif /* HAVE_FAST_64BIT */
76 #else
77  for (i = 0; i + 1 < length; i += 2) {
78  if (src[i])
79  continue;
80  if (i > 0 && src[i - 1] == 0)
81  i--;
83  }
84 #endif /* HAVE_FAST_UNALIGNED */
85 
86  if (i >= length - 1 && small_padding) { // no escaped 0
87  nal->data =
88  nal->raw_data = src;
89  nal->size =
90  nal->raw_size = length;
91  return length;
92  } else if (i > length)
93  i = length;
94 
95  nal->rbsp_buffer = &rbsp->rbsp_buffer[rbsp->rbsp_buffer_size];
96  dst = nal->rbsp_buffer;
97 
98  memcpy(dst, src, i);
99  si = di = i;
100  while (si + 2 < length) {
101  // remove escapes (very rare 1:2^22)
102  if (src[si + 2] > 3) {
103  dst[di++] = src[si++];
104  dst[di++] = src[si++];
105  } else if (src[si] == 0 && src[si + 1] == 0 && src[si + 2] != 0) {
106  if (src[si + 2] == 3) { // escape
107  dst[di++] = 0;
108  dst[di++] = 0;
109  si += 3;
110 
111  if (nal->skipped_bytes_pos) {
112  nal->skipped_bytes++;
113  if (nal->skipped_bytes_pos_size < nal->skipped_bytes) {
114  nal->skipped_bytes_pos_size *= 2;
118  sizeof(*nal->skipped_bytes_pos));
119  if (!nal->skipped_bytes_pos) {
120  nal->skipped_bytes_pos_size = 0;
121  return AVERROR(ENOMEM);
122  }
123  }
124  if (nal->skipped_bytes_pos)
125  nal->skipped_bytes_pos[nal->skipped_bytes-1] = di - 1;
126  }
127  continue;
128  } else // next start code
129  goto nsc;
130  }
131 
132  dst[di++] = src[si++];
133  }
134  while (si < length)
135  dst[di++] = src[si++];
136 
137 nsc:
138  memset(dst + di, 0, AV_INPUT_BUFFER_PADDING_SIZE);
139 
140  nal->data = dst;
141  nal->size = di;
142  nal->raw_data = src;
143  nal->raw_size = si;
144  rbsp->rbsp_buffer_size += si;
145 
146  return si;
147 }
148 
149 static const char *hevc_nal_type_name[64] = {
150  "TRAIL_N", // HEVC_NAL_TRAIL_N
151  "TRAIL_R", // HEVC_NAL_TRAIL_R
152  "TSA_N", // HEVC_NAL_TSA_N
153  "TSA_R", // HEVC_NAL_TSA_R
154  "STSA_N", // HEVC_NAL_STSA_N
155  "STSA_R", // HEVC_NAL_STSA_R
156  "RADL_N", // HEVC_NAL_RADL_N
157  "RADL_R", // HEVC_NAL_RADL_R
158  "RASL_N", // HEVC_NAL_RASL_N
159  "RASL_R", // HEVC_NAL_RASL_R
160  "RSV_VCL_N10", // HEVC_NAL_VCL_N10
161  "RSV_VCL_R11", // HEVC_NAL_VCL_R11
162  "RSV_VCL_N12", // HEVC_NAL_VCL_N12
163  "RSV_VLC_R13", // HEVC_NAL_VCL_R13
164  "RSV_VCL_N14", // HEVC_NAL_VCL_N14
165  "RSV_VCL_R15", // HEVC_NAL_VCL_R15
166  "BLA_W_LP", // HEVC_NAL_BLA_W_LP
167  "BLA_W_RADL", // HEVC_NAL_BLA_W_RADL
168  "BLA_N_LP", // HEVC_NAL_BLA_N_LP
169  "IDR_W_RADL", // HEVC_NAL_IDR_W_RADL
170  "IDR_N_LP", // HEVC_NAL_IDR_N_LP
171  "CRA_NUT", // HEVC_NAL_CRA_NUT
172  "RSV_IRAP_VCL22", // HEVC_NAL_RSV_IRAP_VCL22
173  "RSV_IRAP_VCL23", // HEVC_NAL_RSV_IRAP_VCL23
174  "RSV_VCL24", // HEVC_NAL_RSV_VCL24
175  "RSV_VCL25", // HEVC_NAL_RSV_VCL25
176  "RSV_VCL26", // HEVC_NAL_RSV_VCL26
177  "RSV_VCL27", // HEVC_NAL_RSV_VCL27
178  "RSV_VCL28", // HEVC_NAL_RSV_VCL28
179  "RSV_VCL29", // HEVC_NAL_RSV_VCL29
180  "RSV_VCL30", // HEVC_NAL_RSV_VCL30
181  "RSV_VCL31", // HEVC_NAL_RSV_VCL31
182  "VPS", // HEVC_NAL_VPS
183  "SPS", // HEVC_NAL_SPS
184  "PPS", // HEVC_NAL_PPS
185  "AUD", // HEVC_NAL_AUD
186  "EOS_NUT", // HEVC_NAL_EOS_NUT
187  "EOB_NUT", // HEVC_NAL_EOB_NUT
188  "FD_NUT", // HEVC_NAL_FD_NUT
189  "SEI_PREFIX", // HEVC_NAL_SEI_PREFIX
190  "SEI_SUFFIX", // HEVC_NAL_SEI_SUFFIX
191  "RSV_NVCL41", // HEVC_NAL_RSV_NVCL41
192  "RSV_NVCL42", // HEVC_NAL_RSV_NVCL42
193  "RSV_NVCL43", // HEVC_NAL_RSV_NVCL43
194  "RSV_NVCL44", // HEVC_NAL_RSV_NVCL44
195  "RSV_NVCL45", // HEVC_NAL_RSV_NVCL45
196  "RSV_NVCL46", // HEVC_NAL_RSV_NVCL46
197  "RSV_NVCL47", // HEVC_NAL_RSV_NVCL47
198  "UNSPEC48", // HEVC_NAL_UNSPEC48
199  "UNSPEC49", // HEVC_NAL_UNSPEC49
200  "UNSPEC50", // HEVC_NAL_UNSPEC50
201  "UNSPEC51", // HEVC_NAL_UNSPEC51
202  "UNSPEC52", // HEVC_NAL_UNSPEC52
203  "UNSPEC53", // HEVC_NAL_UNSPEC53
204  "UNSPEC54", // HEVC_NAL_UNSPEC54
205  "UNSPEC55", // HEVC_NAL_UNSPEC55
206  "UNSPEC56", // HEVC_NAL_UNSPEC56
207  "UNSPEC57", // HEVC_NAL_UNSPEC57
208  "UNSPEC58", // HEVC_NAL_UNSPEC58
209  "UNSPEC59", // HEVC_NAL_UNSPEC59
210  "UNSPEC60", // HEVC_NAL_UNSPEC60
211  "UNSPEC61", // HEVC_NAL_UNSPEC61
212  "UNSPEC62", // HEVC_NAL_UNSPEC62
213  "UNSPEC63", // HEVC_NAL_UNSPEC63
214 };
215 
216 static const char *hevc_nal_unit_name(int nal_type)
217 {
218  av_assert0(nal_type >= 0 && nal_type < 64);
219  return hevc_nal_type_name[nal_type];
220 }
221 
222 static const char *h264_nal_type_name[32] = {
223  "Unspecified 0", //H264_NAL_UNSPECIFIED
224  "Coded slice of a non-IDR picture", // H264_NAL_SLICE
225  "Coded slice data partition A", // H264_NAL_DPA
226  "Coded slice data partition B", // H264_NAL_DPB
227  "Coded slice data partition C", // H264_NAL_DPC
228  "IDR", // H264_NAL_IDR_SLICE
229  "SEI", // H264_NAL_SEI
230  "SPS", // H264_NAL_SPS
231  "PPS", // H264_NAL_PPS
232  "AUD", // H264_NAL_AUD
233  "End of sequence", // H264_NAL_END_SEQUENCE
234  "End of stream", // H264_NAL_END_STREAM
235  "Filler data", // H264_NAL_FILLER_DATA
236  "SPS extension", // H264_NAL_SPS_EXT
237  "Prefix", // H264_NAL_PREFIX
238  "Subset SPS", // H264_NAL_SUB_SPS
239  "Depth parameter set", // H264_NAL_DPS
240  "Reserved 17", // H264_NAL_RESERVED17
241  "Reserved 18", // H264_NAL_RESERVED18
242  "Auxiliary coded picture without partitioning", // H264_NAL_AUXILIARY_SLICE
243  "Slice extension", // H264_NAL_EXTEN_SLICE
244  "Slice extension for a depth view or a 3D-AVC texture view", // H264_NAL_DEPTH_EXTEN_SLICE
245  "Reserved 22", // H264_NAL_RESERVED22
246  "Reserved 23", // H264_NAL_RESERVED23
247  "Unspecified 24", // H264_NAL_UNSPECIFIED24
248  "Unspecified 25", // H264_NAL_UNSPECIFIED25
249  "Unspecified 26", // H264_NAL_UNSPECIFIED26
250  "Unspecified 27", // H264_NAL_UNSPECIFIED27
251  "Unspecified 28", // H264_NAL_UNSPECIFIED28
252  "Unspecified 29", // H264_NAL_UNSPECIFIED29
253  "Unspecified 30", // H264_NAL_UNSPECIFIED30
254  "Unspecified 31", // H264_NAL_UNSPECIFIED31
255 };
256 
257 static const char *h264_nal_unit_name(int nal_type)
258 {
259  av_assert0(nal_type >= 0 && nal_type < 32);
260  return h264_nal_type_name[nal_type];
261 }
262 
263 static int get_bit_length(H2645NAL *nal, int skip_trailing_zeros)
264 {
265  int size = nal->size;
266  int v;
267 
268  while (skip_trailing_zeros && size > 0 && nal->data[size - 1] == 0)
269  size--;
270 
271  if (!size)
272  return 0;
273 
274  v = nal->data[size - 1];
275 
276  if (size > INT_MAX / 8)
277  return AVERROR(ERANGE);
278  size *= 8;
279 
280  /* remove the stop bit and following trailing zeros,
281  * or nothing for damaged bitstreams */
282  if (v)
283  size -= ff_ctz(v) + 1;
284 
285  return size;
286 }
287 
288 /**
289  * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
290  * 0 otherwise
291  */
292 static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)
293 {
294  GetBitContext *gb = &nal->gb;
295 
296  if (get_bits1(gb) != 0)
297  return AVERROR_INVALIDDATA;
298 
299  nal->type = get_bits(gb, 6);
300 
301  nal->nuh_layer_id = get_bits(gb, 6);
302  nal->temporal_id = get_bits(gb, 3) - 1;
303  if (nal->temporal_id < 0)
304  return AVERROR_INVALIDDATA;
305 
306  av_log(logctx, AV_LOG_DEBUG,
307  "nal_unit_type: %d(%s), nuh_layer_id: %d, temporal_id: %d\n",
308  nal->type, hevc_nal_unit_name(nal->type), nal->nuh_layer_id, nal->temporal_id);
309 
310  return 0;
311 }
312 
313 static int h264_parse_nal_header(H2645NAL *nal, void *logctx)
314 {
315  GetBitContext *gb = &nal->gb;
316 
317  if (get_bits1(gb) != 0)
318  return AVERROR_INVALIDDATA;
319 
320  nal->ref_idc = get_bits(gb, 2);
321  nal->type = get_bits(gb, 5);
322 
323  av_log(logctx, AV_LOG_DEBUG,
324  "nal_unit_type: %d(%s), nal_ref_idc: %d\n",
325  nal->type, h264_nal_unit_name(nal->type), nal->ref_idc);
326 
327  return 0;
328 }
329 
330 static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)
331 {
332  int i = 0;
333 
334  if (buf + 3 >= next_avc)
335  return next_avc - buf;
336 
337  while (buf + i + 3 < next_avc) {
338  if (buf[i] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1)
339  break;
340  i++;
341  }
342  return i + 3;
343 }
344 
345 static void alloc_rbsp_buffer(H2645RBSP *rbsp, unsigned int size, int use_ref)
346 {
347  int min_size = size;
348 
349  if (size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
350  goto fail;
352 
353  if (rbsp->rbsp_buffer_alloc_size >= size &&
355  av_assert0(rbsp->rbsp_buffer);
356  memset(rbsp->rbsp_buffer + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
357  return;
358  }
359 
360  size = FFMIN(size + size / 16 + 32, INT_MAX);
361 
362  if (rbsp->rbsp_buffer_ref)
364  else
365  av_free(rbsp->rbsp_buffer);
366 
367  rbsp->rbsp_buffer = av_mallocz(size);
368  if (!rbsp->rbsp_buffer)
369  goto fail;
371 
372  if (use_ref) {
373  rbsp->rbsp_buffer_ref = av_buffer_create(rbsp->rbsp_buffer, size,
374  NULL, NULL, 0);
375  if (!rbsp->rbsp_buffer_ref)
376  goto fail;
377  }
378 
379  return;
380 
381 fail:
382  rbsp->rbsp_buffer_alloc_size = 0;
383  if (rbsp->rbsp_buffer_ref) {
385  rbsp->rbsp_buffer = NULL;
386  } else
387  av_freep(&rbsp->rbsp_buffer);
388 
389  return;
390 }
391 
393  void *logctx, int is_nalff, int nal_length_size,
394  enum AVCodecID codec_id, int small_padding, int use_ref)
395 {
396  GetByteContext bc;
397  int consumed, ret = 0;
398  int next_avc = is_nalff ? 0 : length;
399  int64_t padding = small_padding ? 0 : MAX_MBPAIR_SIZE;
400 
401  bytestream2_init(&bc, buf, length);
402  alloc_rbsp_buffer(&pkt->rbsp, length + padding, use_ref);
403 
404  if (!pkt->rbsp.rbsp_buffer)
405  return AVERROR(ENOMEM);
406 
407  pkt->rbsp.rbsp_buffer_size = 0;
408  pkt->nb_nals = 0;
409  while (bytestream2_get_bytes_left(&bc) >= 4) {
410  H2645NAL *nal;
411  int extract_length = 0;
412  int skip_trailing_zeros = 1;
413 
414  if (bytestream2_tell(&bc) == next_avc) {
415  int i = 0;
416  extract_length = get_nalsize(nal_length_size,
417  bc.buffer, bytestream2_get_bytes_left(&bc), &i, logctx);
418  if (extract_length < 0)
419  return extract_length;
420 
421  bytestream2_skip(&bc, nal_length_size);
422 
423  next_avc = bytestream2_tell(&bc) + extract_length;
424  } else {
425  int buf_index;
426 
427  if (bytestream2_tell(&bc) > next_avc)
428  av_log(logctx, AV_LOG_WARNING, "Exceeded next NALFF position, re-syncing.\n");
429 
430  /* search start code */
431  buf_index = find_next_start_code(bc.buffer, buf + next_avc);
432 
433  bytestream2_skip(&bc, buf_index);
434 
435  if (!bytestream2_get_bytes_left(&bc)) {
436  if (pkt->nb_nals > 0) {
437  // No more start codes: we discarded some irrelevant
438  // bytes at the end of the packet.
439  return 0;
440  } else {
441  av_log(logctx, AV_LOG_ERROR, "No start code is found.\n");
442  return AVERROR_INVALIDDATA;
443  }
444  }
445 
446  extract_length = FFMIN(bytestream2_get_bytes_left(&bc), next_avc - bytestream2_tell(&bc));
447 
448  if (bytestream2_tell(&bc) >= next_avc) {
449  /* skip to the start of the next NAL */
450  bytestream2_skip(&bc, next_avc - bytestream2_tell(&bc));
451  continue;
452  }
453  }
454 
455  if (pkt->nals_allocated < pkt->nb_nals + 1) {
456  int new_size = pkt->nals_allocated + 1;
457  void *tmp;
458 
459  if (new_size >= INT_MAX / sizeof(*pkt->nals))
460  return AVERROR(ENOMEM);
461 
462  tmp = av_fast_realloc(pkt->nals, &pkt->nal_buffer_size, new_size * sizeof(*pkt->nals));
463  if (!tmp)
464  return AVERROR(ENOMEM);
465 
466  pkt->nals = tmp;
467  memset(pkt->nals + pkt->nals_allocated, 0, sizeof(*pkt->nals));
468 
469  nal = &pkt->nals[pkt->nb_nals];
470  nal->skipped_bytes_pos_size = 1024; // initial buffer size
472  if (!nal->skipped_bytes_pos)
473  return AVERROR(ENOMEM);
474 
475  pkt->nals_allocated = new_size;
476  }
477  nal = &pkt->nals[pkt->nb_nals];
478 
479  consumed = ff_h2645_extract_rbsp(bc.buffer, extract_length, &pkt->rbsp, nal, small_padding);
480  if (consumed < 0)
481  return consumed;
482 
483  if (is_nalff && (extract_length != consumed) && extract_length)
484  av_log(logctx, AV_LOG_DEBUG,
485  "NALFF: Consumed only %d bytes instead of %d\n",
486  consumed, extract_length);
487 
488  bytestream2_skip(&bc, consumed);
489 
490  /* see commit 3566042a0 */
491  if (bytestream2_get_bytes_left(&bc) >= 4 &&
492  bytestream2_peek_be32(&bc) == 0x000001E0)
493  skip_trailing_zeros = 0;
494 
495  nal->size_bits = get_bit_length(nal, skip_trailing_zeros);
496 
497  if (nal->size <= 0 || nal->size_bits <= 0)
498  continue;
499 
500  ret = init_get_bits(&nal->gb, nal->data, nal->size_bits);
501  if (ret < 0)
502  return ret;
503 
504  /* Reset type in case it contains a stale value from a previously parsed NAL */
505  nal->type = 0;
506 
507  if (codec_id == AV_CODEC_ID_HEVC)
508  ret = hevc_parse_nal_header(nal, logctx);
509  else
510  ret = h264_parse_nal_header(nal, logctx);
511  if (ret < 0) {
512  av_log(logctx, AV_LOG_WARNING, "Invalid NAL unit %d, skipping.\n",
513  nal->type);
514  continue;
515  }
516 
517  pkt->nb_nals++;
518  }
519 
520  return 0;
521 }
522 
524 {
525  int i;
526  for (i = 0; i < pkt->nals_allocated; i++) {
527  av_freep(&pkt->nals[i].skipped_bytes_pos);
528  }
529  av_freep(&pkt->nals);
530  pkt->nals_allocated = pkt->nal_buffer_size = 0;
531  if (pkt->rbsp.rbsp_buffer_ref) {
533  pkt->rbsp.rbsp_buffer = NULL;
534  } else
535  av_freep(&pkt->rbsp.rbsp_buffer);
537 }
#define NULL
Definition: coverity.c:32
#define ff_ctz
Definition: intmath.h:106
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:125
int size
Definition: h2645_parse.h:35
static int get_bit_length(H2645NAL *nal, int skip_trailing_zeros)
Definition: h2645_parse.c:263
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
Memory handling functions.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static AVPacket pkt
static void alloc_rbsp_buffer(H2645RBSP *rbsp, unsigned int size, int use_ref)
Definition: h2645_parse.c:345
int size_bits
Size, in bits, of just the data, excluding the stop bit and any trailing padding. ...
Definition: h2645_parse.h:42
int skipped_bytes_pos_size
Definition: h2645_parse.h:65
#define STARTCODE_TEST
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
static const char * h264_nal_type_name[32]
Definition: h2645_parse.c:222
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:392
unsigned nal_buffer_size
Definition: h2645_parse.h:86
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:523
const uint8_t * buffer
Definition: bytestream.h:34
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
H.264 common definitions.
#define src
Definition: vp8dsp.c:254
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int * skipped_bytes_pos
Definition: h2645_parse.h:66
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
GLsizei GLsizei * length
Definition: opengl_enc.c:114
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
#define fail()
Definition: checkasm.h:123
int raw_size
Definition: h2645_parse.h:44
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:206
#define MAX_MBPAIR_SIZE
Definition: h2645_parse.h:30
#define FFMIN(a, b)
Definition: common.h:96
static int get_nalsize(int nal_length_size, const uint8_t *buf, int buf_size, int *buf_index, void *logctx)
Definition: h2645_parse.h:118
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:478
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:133
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:70
int type
NAL unit type.
Definition: h2645_parse.h:52
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
int nals_allocated
Definition: h2645_parse.h:85
AVBufferRef * rbsp_buffer_ref
Definition: h2645_parse.h:75
static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)
Definition: h2645_parse.c:292
static int h264_parse_nal_header(H2645NAL *nal, void *logctx)
Definition: h2645_parse.c:313
const uint8_t * data
Definition: h2645_parse.h:36
int rbsp_buffer_size
Definition: h2645_parse.h:77
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:76
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
uint8_t * rbsp_buffer
Definition: h2645_parse.h:74
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#define AV_RN32(p)
Definition: intreadwrite.h:364
H2645RBSP rbsp
Definition: h2645_parse.h:83
static const char * hevc_nal_unit_name(int nal_type)
Definition: h2645_parse.c:216
int skipped_bytes
Definition: h2645_parse.h:64
GetBitContext gb
Definition: h2645_parse.h:47
static const char * h264_nal_unit_name(int nal_type)
Definition: h2645_parse.c:257
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
const uint8_t * raw_data
Definition: h2645_parse.h:45
#define av_free(p)
H2645NAL * nals
Definition: h2645_parse.h:82
#define AV_RN64(p)
Definition: intreadwrite.h:368
int temporal_id
HEVC only, nuh_temporal_id_plus_1 - 1.
Definition: h2645_parse.h:57
uint8_t * rbsp_buffer
Definition: h2645_parse.h:33
#define av_freep(p)
#define av_malloc_array(a, b)
int nuh_layer_id
Definition: h2645_parse.h:62
static const char * hevc_nal_type_name[64]
Definition: h2645_parse.c:149
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
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:34
static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)
Definition: h2645_parse.c:330
int i
Definition: input.c:407
static uint8_t tmp[11]
Definition: aes_ctr.c:26