FFmpeg
parser.c
Go to the documentation of this file.
1 /*
2  * Audio and Video frame extraction
3  * Copyright (c) 2003 Fabrice Bellard
4  * Copyright (c) 2003 Michael Niedermayer
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <inttypes.h>
24 #include <stdint.h>
25 #include <string.h>
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/internal.h"
29 #include "libavutil/mem.h"
30 
31 #include "internal.h"
32 #include "parser.h"
33 
35 {
37  const AVCodecParser *parser;
38  void *i = 0;
39  int ret;
40 
42  return NULL;
43 
44  while ((parser = av_parser_iterate(&i))) {
45  if (parser->codec_ids[0] == codec_id ||
46  parser->codec_ids[1] == codec_id ||
47  parser->codec_ids[2] == codec_id ||
48  parser->codec_ids[3] == codec_id ||
49  parser->codec_ids[4] == codec_id)
50  goto found;
51  }
52  return NULL;
53 
54 found:
56  if (!s)
57  goto err_out;
58  s->parser = (AVCodecParser*)parser;
59  s->priv_data = av_mallocz(parser->priv_data_size);
60  if (!s->priv_data)
61  goto err_out;
62  s->fetch_timestamp=1;
63  s->pict_type = AV_PICTURE_TYPE_I;
64  if (parser->parser_init) {
65  ret = parser->parser_init(s);
66  if (ret != 0)
67  goto err_out;
68  }
69  s->key_frame = -1;
70 #if FF_API_CONVERGENCE_DURATION
72  s->convergence_duration = 0;
74 #endif
75  s->dts_sync_point = INT_MIN;
76  s->dts_ref_dts_delta = INT_MIN;
77  s->pts_dts_delta = INT_MIN;
78  s->format = -1;
79 
80  return s;
81 
82 err_out:
83  if (s)
84  av_freep(&s->priv_data);
85  av_free(s);
86  return NULL;
87 }
88 
89 void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy)
90 {
91  int i;
92 
93  if (!fuzzy) {
94  s->dts =
95  s->pts = AV_NOPTS_VALUE;
96  s->pos = -1;
97  s->offset = 0;
98  }
99  for (i = 0; i < AV_PARSER_PTS_NB; i++) {
100  if (s->cur_offset + off >= s->cur_frame_offset[i] &&
101  (s->frame_offset < s->cur_frame_offset[i] ||
102  (!s->frame_offset && !s->next_frame_offset)) && // first field/frame
103  // check disabled since MPEG-TS does not send complete PES packets
104  /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){
105 
106  if (!fuzzy || s->cur_frame_dts[i] != AV_NOPTS_VALUE) {
107  s->dts = s->cur_frame_dts[i];
108  s->pts = s->cur_frame_pts[i];
109  s->pos = s->cur_frame_pos[i];
110  s->offset = s->next_frame_offset - s->cur_frame_offset[i];
111  }
112  if (remove)
113  s->cur_frame_offset[i] = INT64_MAX;
114  if (s->cur_offset + off < s->cur_frame_end[i])
115  break;
116  }
117  }
118 }
119 
121  uint8_t **poutbuf, int *poutbuf_size,
122  const uint8_t *buf, int buf_size,
123  int64_t pts, int64_t dts, int64_t pos)
124 {
125  int index, i;
127 
129 
130  /* Parsers only work for the specified codec ids. */
131  av_assert1(avctx->codec_id == s->parser->codec_ids[0] ||
132  avctx->codec_id == s->parser->codec_ids[1] ||
133  avctx->codec_id == s->parser->codec_ids[2] ||
134  avctx->codec_id == s->parser->codec_ids[3] ||
135  avctx->codec_id == s->parser->codec_ids[4]);
136 
137  if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) {
138  s->next_frame_offset =
139  s->cur_offset = pos;
140  s->flags |= PARSER_FLAG_FETCHED_OFFSET;
141  }
142 
143  if (buf_size == 0) {
144  /* padding is always necessary even if EOF, so we add it here */
145  memset(dummy_buf, 0, sizeof(dummy_buf));
146  buf = dummy_buf;
147  } else if (s->cur_offset + buf_size != s->cur_frame_end[s->cur_frame_start_index]) { /* skip remainder packets */
148  /* add a new packet descriptor */
149  i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
150  s->cur_frame_start_index = i;
151  s->cur_frame_offset[i] = s->cur_offset;
152  s->cur_frame_end[i] = s->cur_offset + buf_size;
153  s->cur_frame_pts[i] = pts;
154  s->cur_frame_dts[i] = dts;
155  s->cur_frame_pos[i] = pos;
156  }
157 
158  if (s->fetch_timestamp) {
159  s->fetch_timestamp = 0;
160  s->last_pts = s->pts;
161  s->last_dts = s->dts;
162  s->last_pos = s->pos;
163  ff_fetch_timestamp(s, 0, 0, 0);
164  }
165  /* WARNING: the returned index can be negative */
166  index = s->parser->parser_parse(s, avctx, (const uint8_t **) poutbuf,
167  poutbuf_size, buf, buf_size);
168  av_assert0(index > -0x20000000); // The API does not allow returning AVERROR codes
169 #define FILL(name) if(s->name > 0 && avctx->name <= 0) avctx->name = s->name
170  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
171  FILL(field_order);
172  }
173 
174  /* update the file pointer */
175  if (*poutbuf_size) {
176  /* fill the data for the current frame */
177  s->frame_offset = s->next_frame_offset;
178 
179  /* offset of the next frame */
180  s->next_frame_offset = s->cur_offset + index;
181  s->fetch_timestamp = 1;
182  } else {
183  /* Don't return a pointer to dummy_buf. */
184  *poutbuf = NULL;
185  }
186  if (index < 0)
187  index = 0;
188  s->cur_offset += index;
189  return index;
190 }
191 
192 #if FF_API_PARSER_CHANGE
194  uint8_t **poutbuf, int *poutbuf_size,
195  const uint8_t *buf, int buf_size, int keyframe)
196 {
197  if (s && s->parser->split) {
198  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ||
200  int i = s->parser->split(avctx, buf, buf_size);
201  buf += i;
202  buf_size -= i;
203  }
204  }
205 
206  /* cast to avoid warning about discarding qualifiers */
207  *poutbuf = (uint8_t *) buf;
208  *poutbuf_size = buf_size;
209  if (avctx->extradata) {
210  if (keyframe && (avctx->flags2 & AV_CODEC_FLAG2_LOCAL_HEADER)) {
211  int size = buf_size + avctx->extradata_size;
212 
213  *poutbuf_size = size;
215  if (!*poutbuf)
216  return AVERROR(ENOMEM);
217 
218  memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
219  memcpy(*poutbuf + avctx->extradata_size, buf,
220  buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
221  return 1;
222  }
223  }
224 
225  return 0;
226 }
227 #endif
229 {
230  if (s) {
231  if (s->parser->parser_close)
232  s->parser->parser_close(s);
233  av_freep(&s->priv_data);
234  av_free(s);
235  }
236 }
237 
238 int ff_combine_frame(ParseContext *pc, int next,
239  const uint8_t **buf, int *buf_size)
240 {
241  if (pc->overread) {
242  ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
243  pc->overread, pc->state, next, pc->index, pc->overread_index);
244  ff_dlog(NULL, "%X %X %X %X\n",
245  (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
246  }
247 
248  /* Copy overread bytes from last frame into buffer. */
249  for (; pc->overread > 0; pc->overread--)
250  pc->buffer[pc->index++] = pc->buffer[pc->overread_index++];
251 
252  if (next > *buf_size)
253  return AVERROR(EINVAL);
254 
255  /* flush remaining if EOF */
256  if (!*buf_size && next == END_NOT_FOUND)
257  next = 0;
258 
259  pc->last_index = pc->index;
260 
261  /* copy into buffer end return */
262  if (next == END_NOT_FOUND) {
263  void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
264  *buf_size + pc->index +
266 
267  if (!new_buffer) {
268  av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", *buf_size + pc->index + AV_INPUT_BUFFER_PADDING_SIZE);
269  pc->index = 0;
270  return AVERROR(ENOMEM);
271  }
272  pc->buffer = new_buffer;
273  memcpy(&pc->buffer[pc->index], *buf, *buf_size);
274  pc->index += *buf_size;
275  return -1;
276  }
277 
278  av_assert0(next >= 0 || pc->buffer);
279 
280  *buf_size =
281  pc->overread_index = pc->index + next;
282 
283  /* append to buffer */
284  if (pc->index) {
285  void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
286  next + pc->index +
288  if (!new_buffer) {
289  av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", next + pc->index + AV_INPUT_BUFFER_PADDING_SIZE);
290  pc->overread_index =
291  pc->index = 0;
292  return AVERROR(ENOMEM);
293  }
294  pc->buffer = new_buffer;
295  if (next > -AV_INPUT_BUFFER_PADDING_SIZE)
296  memcpy(&pc->buffer[pc->index], *buf,
298  pc->index = 0;
299  *buf = pc->buffer;
300  }
301 
302  if (next < -8) {
303  pc->overread += -8 - next;
304  next = -8;
305  }
306  /* store overread bytes */
307  for (; next < 0; next++) {
308  pc->state = pc->state << 8 | pc->buffer[pc->last_index + next];
309  pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next];
310  pc->overread++;
311  }
312 
313  if (pc->overread) {
314  ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
315  pc->overread, pc->state, next, pc->index, pc->overread_index);
316  ff_dlog(NULL, "%X %X %X %X\n",
317  (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
318  }
319 
320  return 0;
321 }
322 
324 {
325  ParseContext *pc = s->priv_data;
326 
327  av_freep(&pc->buffer);
328 }
329 
330 int ff_mpeg4video_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
331 {
332  uint32_t state = -1;
333  const uint8_t *ptr = buf, *end = buf + buf_size;
334 
335  while (ptr < end) {
336  ptr = avpriv_find_start_code(ptr, end, &state);
337  if (state == 0x1B3 || state == 0x1B6)
338  return ptr - 4 - buf;
339  }
340 
341  return 0;
342 }
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
ff_mpeg4video_split
int ff_mpeg4video_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: parser.c:330
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
ParseContext::buffer_size
unsigned int buffer_size
Definition: parser.h:32
av_parser_iterate
const AVCodecParser * av_parser_iterate(void **opaque)
Iterate over all registered codec parsers.
Definition: parsers.c:113
ParseContext::overread_index
int overread_index
the index into ParseContext.buffer of the overread bytes
Definition: parser.h:36
state
static struct @321 state
ff_parse_close
void ff_parse_close(AVCodecParserContext *s)
Definition: parser.c:323
internal.h
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
ParseContext::state
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
FILL
#define FILL(name)
ParseContext::last_index
int last_index
Definition: parser.h:31
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
ff_fetch_timestamp
void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy)
Fetch timestamps for a specific byte within the current access unit.
Definition: parser.c:89
ParseContext
Definition: parser.h:28
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
av_parser_init
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
pts
static int64_t pts
Definition: transcode_aac.c:652
ParseContext::buffer
uint8_t * buffer
Definition: parser.h:29
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:638
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:478
ParseContext::index
int index
Definition: parser.h:30
s
#define s(width, name)
Definition: cbs_vp9.c:257
ParseContext::overread
int overread
the number of bytes which where irreversibly read from the next frame
Definition: parser.h:35
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:546
if
if(ret)
Definition: filter_design.txt:179
NULL
#define NULL
Definition: coverity.c:32
AVCodecParser::codec_ids
int codec_ids[5]
Definition: avcodec.h:3545
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
index
int index
Definition: gxfenc.c:89
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ff_combine_frame
int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
Combine the (truncated) bitstream to a complete frame.
Definition: parser.c:238
i
int i
Definition: input.c:407
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
internal.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVCodecParser::parser_init
int(* parser_init)(AVCodecParserContext *s)
Definition: avcodec.h:3547
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:237
parser.h
AVCodecParserContext
Definition: avcodec.h:3377
av_parser_change
int av_parser_change(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe)
Definition: parser.c:193
ret
ret
Definition: filter_design.txt:187
pos
unsigned int pos
Definition: spdifenc.c:412
AVCodecParser::priv_data_size
int priv_data_size
Definition: avcodec.h:3546
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AV_CODEC_FLAG2_LOCAL_HEADER
#define AV_CODEC_FLAG2_LOCAL_HEADER
Place global headers at every keyframe instead of in extradata.
Definition: avcodec.h:356
PARSER_FLAG_FETCHED_OFFSET
#define PARSER_FLAG_FETCHED_OFFSET
Set if the parser has a valid file offset.
Definition: avcodec.h:3414
ParseContext::state64
uint64_t state64
contains the last 8 bytes in MSB order
Definition: parser.h:37
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:544
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_parser_parse2
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:120
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
END_NOT_FOUND
#define END_NOT_FOUND
Definition: parser.h:40
AV_PARSER_PTS_NB
#define AV_PARSER_PTS_NB
Definition: avcodec.h:3404
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecParser
Definition: avcodec.h:3544
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
av_parser_close
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:228