FFmpeg
h264_mp4toannexb_bsf.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 "avcodec.h"
29 #include "bsf.h"
30 #include "h264.h"
31 
32 typedef struct H264BSFContext {
41 
43  const uint8_t *sps_pps, uint32_t sps_pps_size,
44  const uint8_t *in, uint32_t in_size, int ps)
45 {
46  uint32_t offset = out->size;
47  uint8_t start_code_size = offset == 0 || ps ? 4 : 3;
48  int err;
49 
50  err = av_grow_packet(out, sps_pps_size + in_size + start_code_size);
51  if (err < 0)
52  return err;
53 
54  if (sps_pps)
55  memcpy(out->data + offset, sps_pps, sps_pps_size);
56  memcpy(out->data + sps_pps_size + start_code_size + offset, in, in_size);
57  if (start_code_size == 4) {
58  AV_WB32(out->data + offset + sps_pps_size, 1);
59  } else {
60  (out->data + offset + sps_pps_size)[0] =
61  (out->data + offset + sps_pps_size)[1] = 0;
62  (out->data + offset + sps_pps_size)[2] = 1;
63  }
64 
65  return 0;
66 }
67 
68 static int h264_extradata_to_annexb(AVBSFContext *ctx, const int padding)
69 {
70  H264BSFContext *s = ctx->priv_data;
71  uint16_t unit_size;
72  uint32_t total_size = 0;
73  uint8_t *out = NULL, unit_nb, sps_done = 0,
74  sps_seen = 0, pps_seen = 0;
75  const uint8_t *extradata = ctx->par_in->extradata + 4;
76  static const uint8_t nalu_header[4] = { 0, 0, 0, 1 };
77  int length_size = (*extradata++ & 0x3) + 1; // retrieve length coded size
78 
79  s->sps_offset = s->pps_offset = -1;
80 
81  /* retrieve sps and pps unit(s) */
82  unit_nb = *extradata++ & 0x1f; /* number of sps unit(s) */
83  if (!unit_nb) {
84  goto pps;
85  } else {
86  s->sps_offset = 0;
87  sps_seen = 1;
88  }
89 
90  while (unit_nb--) {
91  int err;
92 
93  unit_size = AV_RB16(extradata);
94  total_size += unit_size + 4;
95  av_assert1(total_size <= INT_MAX - padding);
96  if (extradata + 2 + unit_size > ctx->par_in->extradata + ctx->par_in->extradata_size) {
97  av_log(ctx, AV_LOG_ERROR, "Packet header is not contained in global extradata, "
98  "corrupted stream or invalid MP4/AVCC bitstream\n");
99  av_free(out);
100  return AVERROR(EINVAL);
101  }
102  if ((err = av_reallocp(&out, total_size + padding)) < 0)
103  return err;
104  memcpy(out + total_size - unit_size - 4, nalu_header, 4);
105  memcpy(out + total_size - unit_size, extradata + 2, unit_size);
106  extradata += 2 + unit_size;
107 pps:
108  if (!unit_nb && !sps_done++) {
109  unit_nb = *extradata++; /* number of pps unit(s) */
110  if (unit_nb) {
111  s->pps_offset = total_size;
112  pps_seen = 1;
113  }
114  }
115  }
116 
117  if (out)
118  memset(out + total_size, 0, padding);
119 
120  if (!sps_seen)
121  av_log(ctx, AV_LOG_WARNING,
122  "Warning: SPS NALU missing or invalid. "
123  "The resulting stream may not play.\n");
124 
125  if (!pps_seen)
126  av_log(ctx, AV_LOG_WARNING,
127  "Warning: PPS NALU missing or invalid. "
128  "The resulting stream may not play.\n");
129 
130  av_freep(&ctx->par_out->extradata);
131  ctx->par_out->extradata = out;
132  ctx->par_out->extradata_size = total_size;
133 
134  return length_size;
135 }
136 
138 {
139  H264BSFContext *s = ctx->priv_data;
140  int extra_size = ctx->par_in->extradata_size;
141  int ret;
142 
143  /* retrieve sps and pps NAL units from extradata */
144  if (!extra_size ||
145  (extra_size >= 3 && AV_RB24(ctx->par_in->extradata) == 1) ||
146  (extra_size >= 4 && AV_RB32(ctx->par_in->extradata) == 1)) {
147  av_log(ctx, AV_LOG_VERBOSE,
148  "The input looks like it is Annex B already\n");
149  } else if (extra_size >= 6) {
151  if (ret < 0)
152  return ret;
153 
154  s->length_size = ret;
155  s->new_idr = 1;
156  s->idr_sps_seen = 0;
157  s->idr_pps_seen = 0;
158  s->extradata_parsed = 1;
159  } else {
160  av_log(ctx, AV_LOG_ERROR, "Invalid extradata size: %d\n", extra_size);
161  return AVERROR_INVALIDDATA;
162  }
163 
164  return 0;
165 }
166 
168 {
169  H264BSFContext *s = ctx->priv_data;
170 
171  AVPacket *in;
172  uint8_t unit_type;
173  int32_t nal_size;
174  uint32_t cumul_size = 0;
175  const uint8_t *buf;
176  const uint8_t *buf_end;
177  int buf_size;
178  int ret = 0, i;
179 
180  ret = ff_bsf_get_packet(ctx, &in);
181  if (ret < 0)
182  return ret;
183 
184  /* nothing to filter */
185  if (!s->extradata_parsed) {
186  av_packet_move_ref(out, in);
187  av_packet_free(&in);
188  return 0;
189  }
190 
191  buf = in->data;
192  buf_size = in->size;
193  buf_end = in->data + in->size;
194 
195  do {
196  ret= AVERROR(EINVAL);
197  if (buf + s->length_size > buf_end)
198  goto fail;
199 
200  for (nal_size = 0, i = 0; i<s->length_size; i++)
201  nal_size = (nal_size << 8) | buf[i];
202 
203  buf += s->length_size;
204  unit_type = *buf & 0x1f;
205 
206  if (nal_size > buf_end - buf || nal_size < 0)
207  goto fail;
208 
209  if (unit_type == H264_NAL_SPS)
210  s->idr_sps_seen = s->new_idr = 1;
211  else if (unit_type == H264_NAL_PPS) {
212  s->idr_pps_seen = s->new_idr = 1;
213  /* if SPS has not been seen yet, prepend the AVCC one to PPS */
214  if (!s->idr_sps_seen) {
215  if (s->sps_offset == -1)
216  av_log(ctx, AV_LOG_WARNING, "SPS not present in the stream, nor in AVCC, stream may be unreadable\n");
217  else {
218  if ((ret = alloc_and_copy(out,
219  ctx->par_out->extradata + s->sps_offset,
220  s->pps_offset != -1 ? s->pps_offset : ctx->par_out->extradata_size - s->sps_offset,
221  buf, nal_size, 1)) < 0)
222  goto fail;
223  s->idr_sps_seen = 1;
224  goto next_nal;
225  }
226  }
227  }
228 
229  /* if this is a new IDR picture following an IDR picture, reset the idr flag.
230  * Just check first_mb_in_slice to be 0 as this is the simplest solution.
231  * This could be checking idr_pic_id instead, but would complexify the parsing. */
232  if (!s->new_idr && unit_type == H264_NAL_IDR_SLICE && (buf[1] & 0x80))
233  s->new_idr = 1;
234 
235  /* prepend only to the first type 5 NAL unit of an IDR picture, if no sps/pps are already present */
236  if (s->new_idr && unit_type == H264_NAL_IDR_SLICE && !s->idr_sps_seen && !s->idr_pps_seen) {
237  if ((ret=alloc_and_copy(out,
239  buf, nal_size, 1)) < 0)
240  goto fail;
241  s->new_idr = 0;
242  /* if only SPS has been seen, also insert PPS */
243  } else if (s->new_idr && unit_type == H264_NAL_IDR_SLICE && s->idr_sps_seen && !s->idr_pps_seen) {
244  if (s->pps_offset == -1) {
245  av_log(ctx, AV_LOG_WARNING, "PPS not present in the stream, nor in AVCC, stream may be unreadable\n");
246  if ((ret = alloc_and_copy(out, NULL, 0, buf, nal_size, 0)) < 0)
247  goto fail;
248  } else if ((ret = alloc_and_copy(out,
250  buf, nal_size, 1)) < 0)
251  goto fail;
252  } else {
253  if ((ret=alloc_and_copy(out, NULL, 0, buf, nal_size, unit_type == H264_NAL_SPS || unit_type == H264_NAL_PPS)) < 0)
254  goto fail;
255  if (!s->new_idr && unit_type == H264_NAL_SLICE) {
256  s->new_idr = 1;
257  s->idr_sps_seen = 0;
258  s->idr_pps_seen = 0;
259  }
260  }
261 
262 next_nal:
263  buf += nal_size;
264  cumul_size += nal_size + s->length_size;
265  } while (cumul_size < buf_size);
266 
267  ret = av_packet_copy_props(out, in);
268  if (ret < 0)
269  goto fail;
270 
271 fail:
272  if (ret < 0)
273  av_packet_unref(out);
274  av_packet_free(&in);
275 
276  return ret;
277 }
278 
280 {
281  H264BSFContext *s = ctx->priv_data;
282 
283  s->idr_sps_seen = 0;
284  s->idr_pps_seen = 0;
285  s->new_idr = s->extradata_parsed;
286 }
287 
288 static const enum AVCodecID codec_ids[] = {
290 };
291 
293  .name = "h264_mp4toannexb",
294  .priv_data_size = sizeof(H264BSFContext),
298  .codec_ids = codec_ids,
299 };
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5821
static void flush(AVCodecContext *avctx)
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
Memory handling functions.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
The bitstream filter state.
Definition: avcodec.h:5787
int size
Definition: avcodec.h:1494
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_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
static int h264_mp4toannexb_init(AVBSFContext *ctx)
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5808
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:62
uint8_t
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
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:87
const char * name
Definition: avcodec.h:5837
uint8_t * data
Definition: avcodec.h:1493
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:655
static int h264_extradata_to_annexb(AVBSFContext *ctx, const int padding)
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define av_log(a,...)
H.264 common definitions.
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
static void h264_mp4toannexb_flush(AVBSFContext *ctx)
simple assert() macros that are a bit more flexible than ISO C assert().
#define fail()
Definition: checkasm.h:122
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3999
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:565
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int alloc_and_copy(AVPacket *out, const uint8_t *sps_pps, uint32_t sps_pps_size, const uint8_t *in, uint32_t in_size, int ps)
static int h264_mp4toannexb_filter(AVBSFContext *ctx, AVPacket *out)
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:163
Libavcodec external API header.
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:87
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
void * buf
Definition: avisynth_c.h:766
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
static enum AVCodecID codec_ids[]
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:222
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:109
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:796
const AVBitStreamFilter ff_h264_mp4toannexb_bsf
#define av_free(p)
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3995
FILE * out
Definition: movenc.c:54
#define av_freep(p)
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
This structure stores compressed data.
Definition: avcodec.h:1470
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5815