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  "IRAP_IRAP_VCL22", // HEVC_NAL_IRAP_VCL22
173  "IRAP_IRAP_VCL23", // HEVC_NAL_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 if the unit should be skipped, 1 otherwise
291  */
292 static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)
293 {
294  GetBitContext *gb = &nal->gb;
295  int nuh_layer_id;
296 
297  if (get_bits1(gb) != 0)
298  return AVERROR_INVALIDDATA;
299 
300  nal->type = get_bits(gb, 6);
301 
302  nuh_layer_id = get_bits(gb, 6);
303  nal->temporal_id = get_bits(gb, 3) - 1;
304  if (nal->temporal_id < 0)
305  return AVERROR_INVALIDDATA;
306 
307  av_log(logctx, AV_LOG_DEBUG,
308  "nal_unit_type: %d(%s), nuh_layer_id: %d, temporal_id: %d\n",
309  nal->type, hevc_nal_unit_name(nal->type), nuh_layer_id, nal->temporal_id);
310 
311  return nuh_layer_id == 0;
312 }
313 
314 static int h264_parse_nal_header(H2645NAL *nal, void *logctx)
315 {
316  GetBitContext *gb = &nal->gb;
317 
318  if (get_bits1(gb) != 0)
319  return AVERROR_INVALIDDATA;
320 
321  nal->ref_idc = get_bits(gb, 2);
322  nal->type = get_bits(gb, 5);
323 
324  av_log(logctx, AV_LOG_DEBUG,
325  "nal_unit_type: %d(%s), nal_ref_idc: %d\n",
326  nal->type, h264_nal_unit_name(nal->type), nal->ref_idc);
327 
328  return 1;
329 }
330 
331 static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)
332 {
333  int i = 0;
334 
335  if (buf + 3 >= next_avc)
336  return next_avc - buf;
337 
338  while (buf + i + 3 < next_avc) {
339  if (buf[i] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1)
340  break;
341  i++;
342  }
343  return i + 3;
344 }
345 
346 static void alloc_rbsp_buffer(H2645RBSP *rbsp, unsigned int size, int use_ref)
347 {
348  int min_size = size;
349 
350  if (size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
351  goto fail;
353 
354  if (rbsp->rbsp_buffer_alloc_size >= size &&
356  av_assert0(rbsp->rbsp_buffer);
357  memset(rbsp->rbsp_buffer + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
358  return;
359  }
360 
361  size = FFMIN(size + size / 16 + 32, INT_MAX);
362 
363  if (rbsp->rbsp_buffer_ref)
365  else
366  av_free(rbsp->rbsp_buffer);
367 
368  rbsp->rbsp_buffer = av_mallocz(size);
369  if (!rbsp->rbsp_buffer)
370  goto fail;
372 
373  if (use_ref) {
375  NULL, NULL, 0);
376  if (!rbsp->rbsp_buffer_ref)
377  goto fail;
378  }
379 
380  return;
381 
382 fail:
383  rbsp->rbsp_buffer_alloc_size = 0;
384  if (rbsp->rbsp_buffer_ref) {
386  rbsp->rbsp_buffer = NULL;
387  } else
388  av_freep(&rbsp->rbsp_buffer);
389 
390  return;
391 }
392 
394  void *logctx, int is_nalff, int nal_length_size,
395  enum AVCodecID codec_id, int small_padding, int use_ref)
396 {
397  GetByteContext bc;
398  int consumed, ret = 0;
399  int next_avc = is_nalff ? 0 : length;
400  int64_t padding = small_padding ? 0 : MAX_MBPAIR_SIZE;
401 
402  bytestream2_init(&bc, buf, length);
403  alloc_rbsp_buffer(&pkt->rbsp, length + padding, use_ref);
404 
405  if (!pkt->rbsp.rbsp_buffer)
406  return AVERROR(ENOMEM);
407 
408  pkt->rbsp.rbsp_buffer_size = 0;
409  pkt->nb_nals = 0;
410  while (bytestream2_get_bytes_left(&bc) >= 4) {
411  H2645NAL *nal;
412  int extract_length = 0;
413  int skip_trailing_zeros = 1;
414 
415  if (bytestream2_tell(&bc) == next_avc) {
416  int i = 0;
417  extract_length = get_nalsize(nal_length_size,
418  bc.buffer, bytestream2_get_bytes_left(&bc), &i, logctx);
419  if (extract_length < 0)
420  return extract_length;
421 
422  bytestream2_skip(&bc, nal_length_size);
423 
424  next_avc = bytestream2_tell(&bc) + extract_length;
425  } else {
426  int buf_index;
427 
428  if (bytestream2_tell(&bc) > next_avc)
429  av_log(logctx, AV_LOG_WARNING, "Exceeded next NALFF position, re-syncing.\n");
430 
431  /* search start code */
432  buf_index = find_next_start_code(bc.buffer, buf + next_avc);
433 
434  bytestream2_skip(&bc, buf_index);
435 
436  if (!bytestream2_get_bytes_left(&bc)) {
437  if (pkt->nb_nals > 0) {
438  // No more start codes: we discarded some irrelevant
439  // bytes at the end of the packet.
440  return 0;
441  } else {
442  av_log(logctx, AV_LOG_ERROR, "No start code is found.\n");
443  return AVERROR_INVALIDDATA;
444  }
445  }
446 
447  extract_length = FFMIN(bytestream2_get_bytes_left(&bc), next_avc - bytestream2_tell(&bc));
448 
449  if (bytestream2_tell(&bc) >= next_avc) {
450  /* skip to the start of the next NAL */
451  bytestream2_skip(&bc, next_avc - bytestream2_tell(&bc));
452  continue;
453  }
454  }
455 
456  if (pkt->nals_allocated < pkt->nb_nals + 1) {
457  int new_size = pkt->nals_allocated + 1;
458  void *tmp = av_realloc_array(pkt->nals, new_size, sizeof(*pkt->nals));
459 
460  if (!tmp)
461  return AVERROR(ENOMEM);
462 
463  pkt->nals = tmp;
464  memset(pkt->nals + pkt->nals_allocated, 0,
465  (new_size - pkt->nals_allocated) * sizeof(*pkt->nals));
466 
467  nal = &pkt->nals[pkt->nb_nals];
468  nal->skipped_bytes_pos_size = 1024; // initial buffer size
470  if (!nal->skipped_bytes_pos)
471  return AVERROR(ENOMEM);
472 
473  pkt->nals_allocated = new_size;
474  }
475  nal = &pkt->nals[pkt->nb_nals];
476 
477  consumed = ff_h2645_extract_rbsp(bc.buffer, extract_length, &pkt->rbsp, nal, small_padding);
478  if (consumed < 0)
479  return consumed;
480 
481  if (is_nalff && (extract_length != consumed) && extract_length)
482  av_log(logctx, AV_LOG_DEBUG,
483  "NALFF: Consumed only %d bytes instead of %d\n",
484  consumed, extract_length);
485 
486  pkt->nb_nals++;
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  ret = init_get_bits(&nal->gb, nal->data, nal->size_bits);
498  if (ret < 0)
499  return ret;
500 
501  if (codec_id == AV_CODEC_ID_HEVC)
502  ret = hevc_parse_nal_header(nal, logctx);
503  else
504  ret = h264_parse_nal_header(nal, logctx);
505  if (ret <= 0 || nal->size <= 0 || nal->size_bits <= 0) {
506  if (ret < 0) {
507  av_log(logctx, AV_LOG_WARNING, "Invalid NAL unit %d, skipping.\n",
508  nal->type);
509  }
510  pkt->nb_nals--;
511  }
512  }
513 
514  return 0;
515 }
516 
518 {
519  int i;
520  for (i = 0; i < pkt->nals_allocated; i++) {
521  av_freep(&pkt->nals[i].skipped_bytes_pos);
522  }
523  av_freep(&pkt->nals);
524  pkt->nals_allocated = 0;
525  if (pkt->rbsp.rbsp_buffer_ref) {
526  av_buffer_unref(&pkt->rbsp.rbsp_buffer_ref);
527  pkt->rbsp.rbsp_buffer = NULL;
528  } else
529  av_freep(&pkt->rbsp.rbsp_buffer);
530  pkt->rbsp.rbsp_buffer_alloc_size = pkt->rbsp.rbsp_buffer_size = 0;
531 }
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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
codec_id
enum AVCodecID codec_id
Definition: qsv.c:72
ff_ctz
#define ff_ctz
Definition: intmath.h:106
STARTCODE_TEST
#define STARTCODE_TEST
GetByteContext
Definition: bytestream.h:33
H2645NAL::ref_idc
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:65
AV_RN64
#define AV_RN64(p)
Definition: intreadwrite.h:368
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
h264_parse_nal_header
static int h264_parse_nal_header(H2645NAL *nal, void *logctx)
Definition: h2645_parse.c:314
ff_h2645_packet_uninit
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:517
find_next_start_code
static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)
Definition: h2645_parse.c:331
av_buffer_create
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:28
H2645NAL::skipped_bytes_pos_size
int skipped_bytes_pos_size
Definition: h2645_parse.h:60
H2645NAL::temporal_id
int temporal_id
HEVC only, nuh_temporal_id_plus_1 - 1.
Definition: h2645_parse.h:57
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
hevc_parse_nal_header
static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)
Definition: h2645_parse.c:292
hevc_nal_type_name
static const char * hevc_nal_type_name[64]
Definition: h2645_parse.c:149
bytestream2_get_bytes_left
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
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:164
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
hevc_nal_unit_name
static const char * hevc_nal_unit_name(int nal_type)
Definition: h2645_parse.c:216
get_bit_length
static int get_bit_length(H2645NAL *nal, int skip_trailing_zeros)
Definition: h2645_parse.c:263
fail
#define fail()
Definition: checkasm.h:120
GetBitContext
Definition: get_bits.h:61
src
#define src
Definition: vp8dsp.c:254
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
H2645NAL::size
int size
Definition: h2645_parse.h:35
intreadwrite.h
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
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:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
H2645NAL::data
const uint8_t * data
Definition: h2645_parse.h:36
H2645NAL::skipped_bytes_pos
int * skipped_bytes_pos
Definition: h2645_parse.h:61
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:125
H2645NAL::rbsp_buffer
uint8_t * rbsp_buffer
Definition: h2645_parse.h:33
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
H2645NAL::skipped_bytes
int skipped_bytes
Definition: h2645_parse.h:59
H2645RBSP::rbsp_buffer
uint8_t * rbsp_buffer
Definition: h2645_parse.h:69
size
int size
Definition: twinvq_data.h:11134
H2645NAL::gb
GetBitContext gb
Definition: h2645_parse.h:47
H2645NAL
Definition: h2645_parse.h:32
H2645RBSP::rbsp_buffer_size
int rbsp_buffer_size
Definition: h2645_parse.h:72
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:393
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
av_reallocp_array
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:205
h264_nal_unit_name
static const char * h264_nal_unit_name(int nal_type)
Definition: h2645_parse.c:257
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:34
h264_nal_type_name
static const char * h264_nal_type_name[32]
Definition: h2645_parse.c:222
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: avcodec.h:392
uint8_t
uint8_t
Definition: audio_convert.c:194
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:236
H2645RBSP::rbsp_buffer_ref
AVBufferRef * rbsp_buffer_ref
Definition: h2645_parse.h:70
hevc.h
H2645RBSP::rbsp_buffer_alloc_size
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:71
av_buffer_is_writable
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:133
ret
ret
Definition: filter_design.txt:187
H2645NAL::raw_data
const uint8_t * raw_data
Definition: h2645_parse.h:45
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:790
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
config.h
MAX_MBPAIR_SIZE
#define MAX_MBPAIR_SIZE
Definition: h2645_parse.h:30
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:133
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:112
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
length
const char int length
Definition: avisynth_c.h:860
H2645Packet
Definition: h2645_parse.h:76
H2645RBSP
Definition: h2645_parse.h:68
alloc_rbsp_buffer
static void alloc_rbsp_buffer(H2645RBSP *rbsp, unsigned int size, int use_ref)
Definition: h2645_parse.c:346
intmath.h