FFmpeg
h264_mp4toannexb.c
Go to the documentation of this file.
1 /*
2  * H.264 MP4 to Annex B byte stream format filter
3  * Copyright (c) 2007 Benoit Fouet <benoit.fouet@free.fr>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <string.h>
23 
24 #include "libavutil/avassert.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/mem.h"
27 
28 #include "bsf.h"
29 #include "bsf_internal.h"
30 #include "bytestream.h"
31 #include "defs.h"
32 #include "h264.h"
33 #include "sei.h"
34 
35 typedef struct H264BSFContext {
36  uint8_t *sps;
37  uint8_t *pps;
38  int sps_size;
39  int pps_size;
40  unsigned sps_buf_size;
41  unsigned pps_buf_size;
42  uint8_t length_size;
43  uint8_t new_idr;
44  uint8_t idr_sps_seen;
45  uint8_t idr_pps_seen;
48 
49 enum PsSource {
51  PS_NONE = 0,
53 };
54 
55 static void count_or_copy(uint8_t **out, uint64_t *out_size,
56  const uint8_t *in, int in_size, enum PsSource ps, int copy)
57 {
58  uint8_t start_code_size;
59 
60  if (ps == PS_OUT_OF_BAND)
61  /* start code already present in out-of-band ps data, so don't need to
62  * add it manually again
63  */
64  start_code_size = 0;
65  else if (ps == PS_IN_BAND || *out_size == 0)
66  start_code_size = 4;
67  else
68  start_code_size = 3;
69 
70  if (copy) {
71  memcpy(*out + start_code_size, in, in_size);
72  if (start_code_size == 4) {
73  AV_WB32(*out, 1);
74  } else if (start_code_size) {
75  (*out)[0] =
76  (*out)[1] = 0;
77  (*out)[2] = 1;
78  }
79  *out += start_code_size + in_size;
80  }
81  *out_size += start_code_size + in_size;
82 }
83 
85  uint8_t *extradata, int extradata_size)
86 {
88  GetByteContext ogb, *gb = &ogb;
89  uint16_t unit_size;
90  uint32_t total_size = 0;
91  uint8_t *out = NULL, unit_nb, sps_done = 0;
92  static const uint8_t nalu_header[4] = { 0, 0, 0, 1 };
93  const int padding = AV_INPUT_BUFFER_PADDING_SIZE;
94  int length_size, pps_offset = 0;
95 
96  if (extradata_size < 7) {
97  av_log(ctx, AV_LOG_ERROR, "Invalid extradata size: %d\n", extradata_size);
98  return AVERROR_INVALIDDATA;
99  }
100 
101  bytestream2_init(gb, extradata, extradata_size);
102 
103  bytestream2_skipu(gb, 4);
104 
105  /* retrieve length coded size */
106  length_size = (bytestream2_get_byteu(gb) & 0x3) + 1;
107 
108  /* retrieve sps and pps unit(s) */
109  unit_nb = bytestream2_get_byteu(gb) & 0x1f; /* number of sps unit(s) */
110  if (!unit_nb) {
111  goto pps;
112  }
113 
114  while (unit_nb--) {
115  int err;
116 
117  /* possible overread ok due to padding */
118  unit_size = bytestream2_get_be16u(gb);
119  total_size += unit_size + 4;
120  av_assert1(total_size <= INT_MAX - padding);
121  if (bytestream2_get_bytes_left(gb) < unit_size + !sps_done) {
122  av_log(ctx, AV_LOG_ERROR, "Global extradata truncated, "
123  "corrupted stream or invalid MP4/AVCC bitstream\n");
124  av_free(out);
125  return AVERROR_INVALIDDATA;
126  }
127  if ((err = av_reallocp(&out, total_size + padding)) < 0)
128  return err;
129  memcpy(out + total_size - unit_size - 4, nalu_header, 4);
130  bytestream2_get_bufferu(gb, out + total_size - unit_size, unit_size);
131 pps:
132  if (!unit_nb && !sps_done++) {
133  unit_nb = bytestream2_get_byteu(gb); /* number of pps unit(s) */
134  pps_offset = total_size;
135  }
136  }
137 
138  if (out)
139  memset(out + total_size, 0, padding);
140 
141  if (pps_offset) {
142  uint8_t *sps;
143 
144  s->sps_size = pps_offset;
145  sps = av_fast_realloc(s->sps, &s->sps_buf_size, s->sps_size);
146  if (!sps) {
147  av_free(out);
148  return AVERROR(ENOMEM);
149  }
150  s->sps = sps;
151  memcpy(s->sps, out, s->sps_size);
152  } else {
154  "Warning: SPS NALU missing or invalid. "
155  "The resulting stream may not play.\n");
156  }
157  if (pps_offset < total_size) {
158  uint8_t *pps;
159 
160  s->pps_size = total_size - pps_offset;
161  pps = av_fast_realloc(s->pps, &s->pps_buf_size, s->pps_size);
162  if (!pps) {
163  av_freep(&s->sps);
164  av_free(out);
165  return AVERROR(ENOMEM);
166  }
167  s->pps = pps;
168  memcpy(s->pps, out + pps_offset, s->pps_size);
169  } else {
171  "Warning: PPS NALU missing or invalid. "
172  "The resulting stream may not play.\n");
173  }
174 
175  av_freep(&ctx->par_out->extradata);
176  ctx->par_out->extradata = out;
177  ctx->par_out->extradata_size = total_size;
178 
179  s->length_size = length_size;
180  s->new_idr = 1;
181  s->idr_sps_seen = 0;
182  s->idr_pps_seen = 0;
183  s->extradata_parsed = 1;
184 
185  return 0;
186 }
187 
188 static int h264_mp4toannexb_save_ps(uint8_t **dst, int *dst_size,
189  unsigned *dst_buf_size,
190  const uint8_t *nal, uint32_t nal_size,
191  int first)
192 {
193  static const uint8_t nalu_header[4] = { 0, 0, 0, 1 };
194  const int start_code_size = sizeof(nalu_header);
195  uint8_t *ptr;
196  uint32_t size;
197 
198  if (first)
199  size = 0;
200  else
201  size = *dst_size;
202 
203  ptr = av_fast_realloc(*dst, dst_buf_size, size + nal_size + start_code_size);
204  if (!ptr)
205  return AVERROR(ENOMEM);
206 
207  memcpy(ptr + size, nalu_header, start_code_size);
208  size += start_code_size;
209  memcpy(ptr + size, nal, nal_size);
210  size += nal_size;
211 
212  *dst = ptr;
213  *dst_size = size;
214  return 0;
215 }
216 
218  const uint8_t *buf,
219  const uint8_t *buf_end)
220 {
221  int sps_count = 0;
222  int pps_count = 0;
223  uint8_t unit_type;
224 
225  do {
226  uint32_t nal_size = 0;
227 
228  /* possible overread ok due to padding */
229  for (int i = 0; i < s->length_size; i++)
230  nal_size = (nal_size << 8) | buf[i];
231 
232  buf += s->length_size;
233 
234  /* This check requires the cast as the right side might
235  * otherwise be promoted to an unsigned value. */
236  if ((int64_t)nal_size > buf_end - buf)
237  return AVERROR_INVALIDDATA;
238 
239  if (!nal_size)
240  continue;
241 
242  unit_type = *buf & 0x1f;
243 
244  if (unit_type == H264_NAL_SPS) {
245  h264_mp4toannexb_save_ps(&s->sps, &s->sps_size, &s->sps_buf_size, buf,
246  nal_size, !sps_count);
247  sps_count++;
248  } else if (unit_type == H264_NAL_PPS) {
249  h264_mp4toannexb_save_ps(&s->pps, &s->pps_size, &s->pps_buf_size, buf,
250  nal_size, !pps_count);
251  pps_count++;
252  }
253 
254  buf += nal_size;
255  } while (buf < buf_end);
256 
257  return 0;
258 }
259 
261 {
262  int extra_size = ctx->par_in->extradata_size;
263 
264  /* retrieve sps and pps NAL units from extradata */
265  if (!extra_size ||
266  (extra_size >= 3 && AV_RB24(ctx->par_in->extradata) == 1) ||
267  (extra_size >= 4 && AV_RB32(ctx->par_in->extradata) == 1)) {
269  "The input looks like it is Annex B already\n");
270  return 0;
271  }
273  ctx->par_in->extradata,
274  ctx->par_in->extradata_size);
275 }
276 
278 {
280  AVPacket *in;
281  uint8_t unit_type, new_idr, sps_seen, pps_seen;
282  const uint8_t *buf;
283  const uint8_t *buf_end;
284  uint8_t *out;
285  uint64_t out_size;
286  int ret;
287  size_t extradata_size;
288  uint8_t *extradata;
289 
290  ret = ff_bsf_get_packet(ctx, &in);
291  if (ret < 0)
292  return ret;
293 
295  &extradata_size);
296  if (extradata && extradata[0] == 1) {
297  ret = h264_extradata_to_annexb(ctx, extradata, extradata_size);
298  if (ret < 0)
299  goto fail;
302  }
303 
304  /* nothing to filter */
305  if (!s->extradata_parsed) {
306  av_packet_move_ref(opkt, in);
307  av_packet_free(&in);
308  return 0;
309  }
310 
311  buf_end = in->data + in->size;
312  ret = h264_mp4toannexb_filter_ps(s, in->data, buf_end);
313  if (ret < 0)
314  goto fail;
315 
316 #define LOG_ONCE(...) \
317  if (j) \
318  av_log(__VA_ARGS__)
319  for (int j = 0; j < 2; j++) {
320  buf = in->data;
321  new_idr = s->new_idr;
322  sps_seen = s->idr_sps_seen;
323  pps_seen = s->idr_pps_seen;
324  out_size = 0;
325 
326  do {
327  uint32_t nal_size = 0;
328  enum PsSource ps;
329 
330  /* possible overread ok due to padding */
331  for (int i = 0; i < s->length_size; i++)
332  nal_size = (nal_size << 8) | buf[i];
333 
334  buf += s->length_size;
335 
336  /* This check requires the cast as the right side might
337  * otherwise be promoted to an unsigned value. */
338  if ((int64_t)nal_size > buf_end - buf) {
340  goto fail;
341  }
342 
343  if (!nal_size)
344  continue;
345 
346  unit_type = *buf & 0x1f;
347 
348  if (unit_type == H264_NAL_SPS) {
349  sps_seen = new_idr = 1;
350  } else if (unit_type == H264_NAL_PPS) {
351  pps_seen = new_idr = 1;
352  /* if SPS has not been seen yet, prepend the AVCC one to PPS */
353  if (!sps_seen) {
354  if (!s->sps_size) {
355  LOG_ONCE(ctx, AV_LOG_WARNING, "SPS not present in the stream, nor in AVCC, stream may be unreadable\n");
356  } else {
357  count_or_copy(&out, &out_size, s->sps, s->sps_size, PS_OUT_OF_BAND, j);
358  sps_seen = 1;
359  }
360  }
361  }
362 
363  /* If this is a new IDR picture following an IDR picture, reset the idr flag.
364  * Just check first_mb_in_slice to be 0 as this is the simplest solution.
365  * This could be checking idr_pic_id instead, but would complexify the parsing. */
366  if (!new_idr && unit_type == H264_NAL_IDR_SLICE && (buf[1] & 0x80))
367  new_idr = 1;
368 
369  /* If this is a buffering period SEI without a corresponding sps/pps
370  * then prepend any existing sps/pps before the SEI */
371  if (unit_type == H264_NAL_SEI && buf[1] == SEI_TYPE_BUFFERING_PERIOD &&
372  !sps_seen && !pps_seen) {
373  if (s->sps_size) {
374  count_or_copy(&out, &out_size, s->sps, s->sps_size, PS_OUT_OF_BAND, j);
375  sps_seen = 1;
376  }
377  if (s->pps_size) {
378  count_or_copy(&out, &out_size, s->pps, s->pps_size, PS_OUT_OF_BAND, j);
379  pps_seen = 1;
380  }
381  }
382 
383  /* prepend only to the first type 5 NAL unit of an IDR picture, if no sps/pps are already present */
384  if (new_idr && unit_type == H264_NAL_IDR_SLICE && !sps_seen && !pps_seen) {
385  if (s->sps_size)
386  count_or_copy(&out, &out_size, s->sps, s->sps_size, PS_OUT_OF_BAND, j);
387  if (s->pps_size)
388  count_or_copy(&out, &out_size, s->pps, s->pps_size, PS_OUT_OF_BAND, j);
389  new_idr = 0;
390  /* if only SPS has been seen, also insert PPS */
391  } else if (new_idr && unit_type == H264_NAL_IDR_SLICE && sps_seen && !pps_seen) {
392  if (!s->pps_size) {
393  LOG_ONCE(ctx, AV_LOG_WARNING, "PPS not present in the stream, nor in AVCC, stream may be unreadable\n");
394  } else {
395  count_or_copy(&out, &out_size, s->pps, s->pps_size, PS_OUT_OF_BAND, j);
396  }
397  }
398 
399  if (unit_type == H264_NAL_SPS || unit_type == H264_NAL_PPS)
400  ps = PS_IN_BAND;
401  else
402  ps = PS_NONE;
403  count_or_copy(&out, &out_size, buf, nal_size, ps, j);
404  if (unit_type == H264_NAL_SLICE) {
405  new_idr = 1;
406  sps_seen = 0;
407  pps_seen = 0;
408  }
409 
410  buf += nal_size;
411  } while (buf < buf_end);
412 
413  if (!j) {
414  if (out_size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
416  goto fail;
417  }
418  ret = av_new_packet(opkt, out_size);
419  if (ret < 0)
420  goto fail;
421  out = opkt->data;
422  }
423  }
424 #undef LOG_ONCE
425 
426  av_assert1(out_size == opkt->size);
427 
428  s->new_idr = new_idr;
429  s->idr_sps_seen = sps_seen;
430  s->idr_pps_seen = pps_seen;
431 
432  ret = av_packet_copy_props(opkt, in);
433  if (ret < 0)
434  goto fail;
435 
436 fail:
437  if (ret < 0)
438  av_packet_unref(opkt);
439  av_packet_free(&in);
440 
441  return ret;
442 }
443 
445 {
447 
448  av_freep(&s->sps);
449  av_freep(&s->pps);
450 }
451 
453 {
455 
456  s->idr_sps_seen = 0;
457  s->idr_pps_seen = 0;
458  s->new_idr = s->extradata_parsed;
459 }
460 
461 static const enum AVCodecID codec_ids[] = {
463 };
464 
466  .p.name = "h264_mp4toannexb",
467  .p.codec_ids = codec_ids,
468  .priv_data_size = sizeof(H264BSFContext),
473 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
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
bsf_internal.h
out
FILE * out
Definition: movenc.c:55
GetByteContext
Definition: bytestream.h:33
count_or_copy
static void count_or_copy(uint8_t **out, uint64_t *out_size, const uint8_t *in, int in_size, enum PsSource ps, int copy)
Definition: h264_mp4toannexb.c:55
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
H264BSFContext::sps
uint8_t * sps
Definition: h264_mp4toannexb.c:36
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
int64_t
long long int64_t
Definition: coverity.c:34
out_size
int out_size
Definition: movenc.c:56
AVPacket::data
uint8_t * data
Definition: packet.h:535
av_packet_side_data_remove
void av_packet_side_data_remove(AVPacketSideData *sd, int *pnb_sd, enum AVPacketSideDataType type)
Remove side data of the given type from a side data array.
Definition: packet.c:729
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
H264BSFContext::extradata_parsed
int extradata_parsed
Definition: h264_mp4toannexb.c:46
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
ff_bsf_get_packet
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:235
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:75
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
H264BSFContext::pps_buf_size
unsigned pps_buf_size
Definition: h264_mp4toannexb.c:41
bsf.h
H264BSFContext::idr_sps_seen
uint8_t idr_sps_seen
Definition: h264_mp4toannexb.c:44
fail
#define fail()
Definition: checkasm.h:195
codec_ids
static enum AVCodecID codec_ids[]
Definition: h264_mp4toannexb.c:461
h264_mp4toannexb_filter_ps
static int h264_mp4toannexb_filter_ps(H264BSFContext *s, const uint8_t *buf, const uint8_t *buf_end)
Definition: h264_mp4toannexb.c:217
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
h264_mp4toannexb_init
static int h264_mp4toannexb_init(AVBSFContext *ctx)
Definition: h264_mp4toannexb.c:260
H264BSFContext::pps_size
int pps_size
Definition: h264_mp4toannexb.c:39
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
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:99
PS_OUT_OF_BAND
@ PS_OUT_OF_BAND
Definition: h264_mp4toannexb.c:50
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
ctx
AVFormatContext * ctx
Definition: movenc.c:49
H264BSFContext
Definition: h264_mp4toannexb.c:35
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
ff_h264_mp4toannexb_bsf
const FFBitStreamFilter ff_h264_mp4toannexb_bsf
Definition: h264_mp4toannexb.c:465
H264BSFContext::sps_buf_size
unsigned sps_buf_size
Definition: h264_mp4toannexb.c:40
NULL
#define NULL
Definition: coverity.c:32
FFBitStreamFilter
Definition: bsf_internal.h:27
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:370
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: packet.c:487
PS_NONE
@ PS_NONE
Definition: h264_mp4toannexb.c:51
close
av_cold void CBS_FUNC() close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:146
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
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:415
FFBitStreamFilter::p
AVBitStreamFilter p
The public AVBitStreamFilter.
Definition: bsf_internal.h:31
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AVPacket::size
int size
Definition: packet.h:536
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:186
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
size
int size
Definition: twinvq_data.h:10344
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:188
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
LOG_ONCE
#define LOG_ONCE(...)
h264_mp4toannexb_save_ps
static int h264_mp4toannexb_save_ps(uint8_t **dst, int *dst_size, unsigned *dst_buf_size, const uint8_t *nal, uint32_t nal_size, int first)
Definition: h264_mp4toannexb.c:188
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: packet.c:393
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:253
H264BSFContext::length_size
uint8_t length_size
Definition: h264_mp4toannexb.c:42
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
h264_mp4toannexb_close
static void h264_mp4toannexb_close(AVBSFContext *ctx)
Definition: h264_mp4toannexb.c:444
PsSource
PsSource
Definition: h264_mp4toannexb.c:49
H264BSFContext::new_idr
uint8_t new_idr
Definition: h264_mp4toannexb.c:43
ret
ret
Definition: filter_design.txt:187
H264BSFContext::pps
uint8_t * pps
Definition: h264_mp4toannexb.c:37
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:546
h264_mp4toannexb_filter
static int h264_mp4toannexb_filter(AVBSFContext *ctx, AVPacket *opkt)
Definition: h264_mp4toannexb.c:277
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
SEI_TYPE_BUFFERING_PERIOD
@ SEI_TYPE_BUFFERING_PERIOD
Definition: sei.h:30
defs.h
h264_extradata_to_annexb
static int h264_extradata_to_annexb(AVBSFContext *ctx, uint8_t *extradata, int extradata_size)
Definition: h264_mp4toannexb.c:84
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
mem.h
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVPacket
This structure stores compressed data.
Definition: packet.h:512
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
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
PS_IN_BAND
@ PS_IN_BAND
Definition: h264_mp4toannexb.c:52
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
H264BSFContext::sps_size
int sps_size
Definition: h264_mp4toannexb.c:38
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1293
h264_mp4toannexb_flush
static void h264_mp4toannexb_flush(AVBSFContext *ctx)
Definition: h264_mp4toannexb.c:452
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:547
H264BSFContext::idr_pps_seen
uint8_t idr_pps_seen
Definition: h264_mp4toannexb.c:45