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 
41  if (codec_id == AV_CODEC_ID_NONE)
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:
55  s = av_mallocz(sizeof(AVCodecParserContext));
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;
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];
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;
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);
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 */
178 
179  /* offset of the next frame */
181  s->fetch_timestamp = 1;
182  }
183  if (index < 0)
184  index = 0;
185  s->cur_offset += index;
186  return index;
187 }
188 
190  uint8_t **poutbuf, int *poutbuf_size,
191  const uint8_t *buf, int buf_size, int keyframe)
192 {
193  if (s && s->parser->split) {
194  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ||
196  int i = s->parser->split(avctx, buf, buf_size);
197  buf += i;
198  buf_size -= i;
199  }
200  }
201 
202  /* cast to avoid warning about discarding qualifiers */
203  *poutbuf = (uint8_t *) buf;
204  *poutbuf_size = buf_size;
205  if (avctx->extradata) {
206  if (keyframe && (avctx->flags2 & AV_CODEC_FLAG2_LOCAL_HEADER)) {
207  int size = buf_size + avctx->extradata_size;
208 
209  *poutbuf_size = size;
210  *poutbuf = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
211  if (!*poutbuf)
212  return AVERROR(ENOMEM);
213 
214  memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
215  memcpy(*poutbuf + avctx->extradata_size, buf,
216  buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
217  return 1;
218  }
219  }
220 
221  return 0;
222 }
223 
225 {
226  if (s) {
227  if (s->parser->parser_close)
228  s->parser->parser_close(s);
229  av_freep(&s->priv_data);
230  av_free(s);
231  }
232 }
233 
234 int ff_combine_frame(ParseContext *pc, int next,
235  const uint8_t **buf, int *buf_size)
236 {
237  if (pc->overread) {
238  ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
239  pc->overread, pc->state, next, pc->index, pc->overread_index);
240  ff_dlog(NULL, "%X %X %X %X\n",
241  (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
242  }
243 
244  /* Copy overread bytes from last frame into buffer. */
245  for (; pc->overread > 0; pc->overread--)
246  pc->buffer[pc->index++] = pc->buffer[pc->overread_index++];
247 
248  if (next > *buf_size)
249  return AVERROR(EINVAL);
250 
251  /* flush remaining if EOF */
252  if (!*buf_size && next == END_NOT_FOUND)
253  next = 0;
254 
255  pc->last_index = pc->index;
256 
257  /* copy into buffer end return */
258  if (next == END_NOT_FOUND) {
259  void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
260  *buf_size + pc->index +
262 
263  if (!new_buffer) {
264  av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", *buf_size + pc->index + AV_INPUT_BUFFER_PADDING_SIZE);
265  pc->index = 0;
266  return AVERROR(ENOMEM);
267  }
268  pc->buffer = new_buffer;
269  memcpy(&pc->buffer[pc->index], *buf, *buf_size);
270  pc->index += *buf_size;
271  return -1;
272  }
273 
274  av_assert0(next >= 0 || pc->buffer);
275 
276  *buf_size =
277  pc->overread_index = pc->index + next;
278 
279  /* append to buffer */
280  if (pc->index) {
281  void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
282  next + pc->index +
284  if (!new_buffer) {
285  av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", next + pc->index + AV_INPUT_BUFFER_PADDING_SIZE);
286  pc->overread_index =
287  pc->index = 0;
288  return AVERROR(ENOMEM);
289  }
290  pc->buffer = new_buffer;
291  if (next > -AV_INPUT_BUFFER_PADDING_SIZE)
292  memcpy(&pc->buffer[pc->index], *buf,
294  pc->index = 0;
295  *buf = pc->buffer;
296  }
297 
298  if (next < -8) {
299  pc->overread += -8 - next;
300  next = -8;
301  }
302  /* store overread bytes */
303  for (; next < 0; next++) {
304  pc->state = pc->state << 8 | pc->buffer[pc->last_index + next];
305  pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next];
306  pc->overread++;
307  }
308 
309  if (pc->overread) {
310  ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
311  pc->overread, pc->state, next, pc->index, pc->overread_index);
312  ff_dlog(NULL, "%X %X %X %X\n",
313  (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
314  }
315 
316  return 0;
317 }
318 
320 {
321  ParseContext *pc = s->priv_data;
322 
323  av_freep(&pc->buffer);
324 }
325 
326 int ff_mpeg4video_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
327 {
328  uint32_t state = -1;
329  const uint8_t *ptr = buf, *end = buf + buf_size;
330 
331  while (ptr < end) {
332  ptr = avpriv_find_start_code(ptr, end, &state);
333  if (state == 0x1B3 || state == 0x1B6)
334  return ptr - 4 - buf;
335  }
336 
337  return 0;
338 }
#define NULL
Definition: coverity.c:32
void(* parser_close)(AVCodecParserContext *s)
Definition: avcodec.h:5298
Memory handling functions.
int64_t next_frame_offset
Definition: avcodec.h:5127
enum AVCodecID codec_id
Definition: qsv.c:77
int codec_ids[5]
Definition: avcodec.h:5289
int(* split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: avcodec.h:5299
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
int64_t cur_frame_pos[AV_PARSER_PTS_NB]
Position of the packet in file.
Definition: avcodec.h:5226
int dts_ref_dts_delta
Offset of the current timestamp against last timestamp sync point in units of AVCodecContext.time_base.
Definition: avcodec.h:5205
int ff_mpeg4video_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: parser.c:326
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
#define av_malloc(s)
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:189
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1671
#define ff_dlog(a,...)
ptrdiff_t size
Definition: opengl_enc.c:100
static struct @321 state
#define av_log(a,...)
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
#define FILL(name)
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
unsigned int buffer_size
Definition: parser.h:32
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int64_t pos
Byte position of currently parsed frame in stream.
Definition: avcodec.h:5231
int priv_data_size
Definition: avcodec.h:5290
struct AVCodecParser * parser
Definition: avcodec.h:5123
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:234
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1650
simple assert() macros that are a bit more flexible than ISO C assert().
int overread_index
the index into ParseContext.buffer of the overread bytes
Definition: parser.h:36
int64_t cur_frame_dts[AV_PARSER_PTS_NB]
Definition: avcodec.h:5152
int(* parser_parse)(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
Definition: avcodec.h:5294
void ff_parse_close(AVCodecParserContext *s)
Definition: parser.c:319
common internal API header
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int overread
the number of bytes which where irreversibly read from the next frame
Definition: parser.h:35
int last_index
Definition: parser.h:31
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
int64_t offset
byte offset from starting packet start
Definition: avcodec.h:5161
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:224
#define s(width, name)
Definition: cbs_vp9.c:257
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:476
int64_t cur_frame_end[AV_PARSER_PTS_NB]
Definition: avcodec.h:5162
int64_t cur_frame_pts[AV_PARSER_PTS_NB]
Definition: avcodec.h:5151
int64_t last_pos
Previous frame byte position.
Definition: avcodec.h:5236
if(ret)
int pts_dts_delta
Presentation delay of current frame in units of AVCodecContext.time_base.
Definition: avcodec.h:5219
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
uint8_t * buffer
Definition: parser.h:29
enum AVMediaType codec_type
Definition: avcodec.h:1578
enum AVCodecID codec_id
Definition: avcodec.h:1580
const AVCodecParser * av_parser_iterate(void **opaque)
Iterate over all registered codec parsers.
Definition: parsers.c:96
main external API structure.
Definition: avcodec.h:1570
#define AV_CODEC_FLAG2_LOCAL_HEADER
Place global headers at every keyframe instead of in extradata.
Definition: avcodec.h:936
#define PARSER_FLAG_FETCHED_OFFSET
Set if the parser has a valid file offset.
Definition: avcodec.h:5158
void * buf
Definition: avisynth_c.h:766
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
int extradata_size
Definition: avcodec.h:1672
int index
Definition: gxfenc.c:89
uint64_t state64
contains the last 8 bytes in MSB order
Definition: parser.h:37
#define END_NOT_FOUND
Definition: parser.h:40
#define AV_PARSER_PTS_NB
Definition: avcodec.h:5148
int(* parser_init)(AVCodecParserContext *s)
Definition: avcodec.h:5291
attribute_deprecated int64_t convergence_duration
Definition: avcodec.h:5177
static int64_t pts
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:909
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
int index
Definition: parser.h:30
int64_t cur_frame_offset[AV_PARSER_PTS_NB]
Definition: avcodec.h:5150
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:795
int64_t frame_offset
Definition: avcodec.h:5124
#define av_free(p)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int format
The format of the coded data, corresponds to enum AVPixelFormat for video and for enum AVSampleFormat...
Definition: avcodec.h:5285
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1657
#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
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
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:5170
int dts_sync_point
Synchronization point for start of timestamp generation.
Definition: avcodec.h:5190
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248