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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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/intreadwrite.h"
25 #include "libavutil/mem.h"
26 #include "avcodec.h"
27 
28 typedef struct H264BSFContext {
33 
34 static int alloc_and_copy(uint8_t **poutbuf, int *poutbuf_size,
35  const uint8_t *sps_pps, uint32_t sps_pps_size,
36  const uint8_t *in, uint32_t in_size) {
37  uint32_t offset = *poutbuf_size;
38  uint8_t nal_header_size = offset ? 3 : 4;
39  void *tmp;
40 
41  *poutbuf_size += sps_pps_size+in_size+nal_header_size;
42  tmp = av_realloc(*poutbuf, *poutbuf_size);
43  if (!tmp)
44  return AVERROR(ENOMEM);
45  *poutbuf = tmp;
46  if (sps_pps)
47  memcpy(*poutbuf+offset, sps_pps, sps_pps_size);
48  memcpy(*poutbuf+sps_pps_size+nal_header_size+offset, in, in_size);
49  if (!offset) {
50  AV_WB32(*poutbuf+sps_pps_size, 1);
51  } else {
52  (*poutbuf+offset+sps_pps_size)[0] = (*poutbuf+offset+sps_pps_size)[1] = 0;
53  (*poutbuf+offset+sps_pps_size)[2] = 1;
54  }
55 
56  return 0;
57 }
58 
60  AVCodecContext *avctx, const char *args,
61  uint8_t **poutbuf, int *poutbuf_size,
62  const uint8_t *buf, int buf_size,
63  int keyframe) {
64  H264BSFContext *ctx = bsfc->priv_data;
65  uint8_t unit_type;
66  int32_t nal_size;
67  uint32_t cumul_size = 0;
68  const uint8_t *buf_end = buf + buf_size;
69 
70  /* nothing to filter */
71  if (!avctx->extradata || avctx->extradata_size < 6) {
72  *poutbuf = (uint8_t*) buf;
73  *poutbuf_size = buf_size;
74  return 0;
75  }
76 
77  /* retrieve sps and pps NAL units from extradata */
78  if (!ctx->extradata_parsed) {
79  uint16_t unit_size;
80  uint64_t total_size = 0;
81  uint8_t *out = NULL, unit_nb, sps_done = 0, sps_seen = 0, pps_seen = 0;
82  const uint8_t *extradata = avctx->extradata+4;
83  static const uint8_t nalu_header[4] = {0, 0, 0, 1};
84 
85  /* retrieve length coded size */
86  ctx->length_size = (*extradata++ & 0x3) + 1;
87  if (ctx->length_size == 3)
88  return AVERROR(EINVAL);
89 
90  /* retrieve sps and pps unit(s) */
91  unit_nb = *extradata++ & 0x1f; /* number of sps unit(s) */
92  if (!unit_nb) {
93  unit_nb = *extradata++; /* number of pps unit(s) */
94  sps_done++;
95 
96  if (unit_nb)
97  pps_seen = 1;
98  } else {
99  sps_seen = 1;
100  }
101 
102  while (unit_nb--) {
103  void *tmp;
104 
105  unit_size = AV_RB16(extradata);
106  total_size += unit_size+4;
107  if (total_size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE ||
108  extradata+2+unit_size > avctx->extradata+avctx->extradata_size) {
109  av_free(out);
110  return AVERROR(EINVAL);
111  }
112  tmp = av_realloc(out, total_size + FF_INPUT_BUFFER_PADDING_SIZE);
113  if (!tmp) {
114  av_free(out);
115  return AVERROR(ENOMEM);
116  }
117  out = tmp;
118  memcpy(out+total_size-unit_size-4, nalu_header, 4);
119  memcpy(out+total_size-unit_size, extradata+2, unit_size);
120  extradata += 2+unit_size;
121 
122  if (!unit_nb && !sps_done++) {
123  unit_nb = *extradata++; /* number of pps unit(s) */
124  if (unit_nb)
125  pps_seen = 1;
126  }
127  }
128 
129  if(out)
130  memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
131 
132  if (!sps_seen)
133  av_log(avctx, AV_LOG_WARNING, "Warning: SPS NALU missing or invalid. The resulting stream may not play.\n");
134  if (!pps_seen)
135  av_log(avctx, AV_LOG_WARNING, "Warning: PPS NALU missing or invalid. The resulting stream may not play.\n");
136 
137  av_free(avctx->extradata);
138  avctx->extradata = out;
139  avctx->extradata_size = total_size;
140  ctx->first_idr = 1;
141  ctx->extradata_parsed = 1;
142  }
143 
144  *poutbuf_size = 0;
145  *poutbuf = NULL;
146  do {
147  if (buf + ctx->length_size > buf_end)
148  goto fail;
149 
150  if (ctx->length_size == 1) {
151  nal_size = buf[0];
152  } else if (ctx->length_size == 2) {
153  nal_size = AV_RB16(buf);
154  } else
155  nal_size = AV_RB32(buf);
156 
157  buf += ctx->length_size;
158  unit_type = *buf & 0x1f;
159 
160  if (buf + nal_size > buf_end || nal_size < 0)
161  goto fail;
162 
163  /* prepend only to the first type 5 NAL unit of an IDR picture */
164  if (ctx->first_idr && unit_type == 5) {
165  if (alloc_and_copy(poutbuf, poutbuf_size,
166  avctx->extradata, avctx->extradata_size,
167  buf, nal_size) < 0)
168  goto fail;
169  ctx->first_idr = 0;
170  } else {
171  if (alloc_and_copy(poutbuf, poutbuf_size,
172  NULL, 0,
173  buf, nal_size) < 0)
174  goto fail;
175  if (!ctx->first_idr && unit_type == 1)
176  ctx->first_idr = 1;
177  }
178 
179  buf += nal_size;
180  cumul_size += nal_size + ctx->length_size;
181  } while (cumul_size < buf_size);
182 
183  return 1;
184 
185 fail:
186  av_freep(poutbuf);
187  *poutbuf_size = 0;
188  return AVERROR(EINVAL);
189 }
190 
192  "h264_mp4toannexb",
193  sizeof(H264BSFContext),
195 };
struct H264BSFContext H264BSFContext
memory handling functions
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
uint8_t
#define AV_WB32(p, d)
Definition: intreadwrite.h:239
#define AV_RB32
Definition: intreadwrite.h:130
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:139
static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe)
#define AV_RB16
Definition: intreadwrite.h:53
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
int32_t
NULL
Definition: eval.c:52
external API header
main external API structure.
Definition: avcodec.h:1339
int extradata_size
Definition: avcodec.h:1455
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:116
static int alloc_and_copy(uint8_t **poutbuf, int *poutbuf_size, const uint8_t *sps_pps, uint32_t sps_pps_size, const uint8_t *in, uint32_t in_size)
AVBitStreamFilter ff_h264_mp4toannexb_bsf