FFmpeg: libavcodec/parser.c Source File

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/mem.h"
29 
30 #include "parser.h"
31 
32  AVCodecParserContext *av_parser_init(int codec_id)
33 {
34  AVCodecParserContext *s = NULL;
35  const AVCodecParser *parser;
36  void *i = 0;
37  int ret;
38 
39  if (codec_id == AV_CODEC_ID_NONE)
40  return NULL;
41 
42  while ((parser = av_parser_iterate(&i))) {
43  if (parser->codec_ids[0] == codec_id ||
44  parser->codec_ids[1] == codec_id ||
45  parser->codec_ids[2] == codec_id ||
46  parser->codec_ids[3] == codec_id ||
47  parser->codec_ids[4] == codec_id ||
48  parser->codec_ids[5] == codec_id ||
49  parser->codec_ids[6] == 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 = 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  s->dts_sync_point = INT_MIN;
71  s->dts_ref_dts_delta = INT_MIN;
72  s->pts_dts_delta = INT_MIN;
73  s->format = -1;
74 
75  return s;
76 
77 err_out:
78  if (s)
79  av_freep(&s->priv_data);
80  av_free(s);
81  return NULL;
82 }
83 
84  void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy)
85 {
86  int i;
87 
88  if (!fuzzy) {
89  s->dts =
90  s->pts = AV_NOPTS_VALUE;
91  s->pos = -1;
92  s->offset = 0;
93  }
94  for (i = 0; i < AV_PARSER_PTS_NB; i++) {
95  if (s->cur_offset + off >= s->cur_frame_offset[i] &&
96  (s->frame_offset < s->cur_frame_offset[i] ||
97  (!s->frame_offset && !s->next_frame_offset)) && // first field/frame
98  // check disabled since MPEG-TS does not send complete PES packets
99  /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){
100 
101  if (!fuzzy || s->cur_frame_dts[i] != AV_NOPTS_VALUE) {
102  s->dts = s->cur_frame_dts[i];
103  s->pts = s->cur_frame_pts[i];
104  s->pos = s->cur_frame_pos[i];
105  s->offset = s->next_frame_offset - s->cur_frame_offset[i];
106  }
107  if (remove)
108  s->cur_frame_offset[i] = INT64_MAX;
109  if (s->cur_offset + off < s->cur_frame_end[i])
110  break;
111  }
112  }
113 }
114 
115  int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx,
116  uint8_t **poutbuf, int *poutbuf_size,
117  const uint8_t *buf, int buf_size,
118  int64_t pts, int64_t dts, int64_t pos)
119 {
120  int index, i;
121  uint8_t dummy_buf[AV_INPUT_BUFFER_PADDING_SIZE];
122 
123  av_assert1(avctx->codec_id != AV_CODEC_ID_NONE);
124 
125  /* Parsers only work for the specified codec ids. */
126  av_assert1(avctx->codec_id == s->parser->codec_ids[0] ||
127  avctx->codec_id == s->parser->codec_ids[1] ||
128  avctx->codec_id == s->parser->codec_ids[2] ||
129  avctx->codec_id == s->parser->codec_ids[3] ||
130  avctx->codec_id == s->parser->codec_ids[4] ||
131  avctx->codec_id == s->parser->codec_ids[5] ||
132  avctx->codec_id == s->parser->codec_ids[6]);
133 
134  if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) {
135  s->next_frame_offset =
136  s->cur_offset = pos;
137  s->flags |= PARSER_FLAG_FETCHED_OFFSET;
138  }
139 
140  if (buf_size == 0) {
141  /* padding is always necessary even if EOF, so we add it here */
142  memset(dummy_buf, 0, sizeof(dummy_buf));
143  buf = dummy_buf;
144  } else if (s->cur_offset + buf_size != s->cur_frame_end[s->cur_frame_start_index]) { /* skip remainder packets */
145  /* add a new packet descriptor */
146  i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
147  s->cur_frame_start_index = i;
148  s->cur_frame_offset[i] = s->cur_offset;
149  s->cur_frame_end[i] = s->cur_offset + buf_size;
150  s->cur_frame_pts[i] = pts;
151  s->cur_frame_dts[i] = dts;
152  s->cur_frame_pos[i] = pos;
153  }
154 
155  if (s->fetch_timestamp) {
156  s->fetch_timestamp = 0;
157  s->last_pts = s->pts;
158  s->last_dts = s->dts;
159  s->last_pos = s->pos;
160  ff_fetch_timestamp(s, 0, 0, 0);
161  }
162  /* WARNING: the returned index can be negative */
163  index = s->parser->parser_parse(s, avctx, (const uint8_t **) poutbuf,
164  poutbuf_size, buf, buf_size);
165  av_assert0(index > -0x20000000); // The API does not allow returning AVERROR codes
166 #define FILL(name) if(s->name > 0 && avctx->name <= 0) avctx->name = s->name
167  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
168  FILL(field_order);
169  FILL(coded_width);
170  FILL(coded_height);
171  FILL(width);
172  FILL(height);
173  }
174 
175  /* update the file pointer */
176  if (*poutbuf_size) {
177  /* fill the data for the current frame */
178  s->frame_offset = s->next_frame_offset;
179 
180  /* offset of the next frame */
181  s->next_frame_offset = s->cur_offset + index;
182  s->fetch_timestamp = 1;
183  } else {
184  /* Don't return a pointer to dummy_buf. */
185  *poutbuf = NULL;
186  }
187  if (index < 0)
188  index = 0;
189  s->cur_offset += index;
190  return index;
191 }
192 
193  void av_parser_close(AVCodecParserContext *s)
194 {
195  if (s) {
196  if (s->parser->parser_close)
197  s->parser->parser_close(s);
198  av_freep(&s->priv_data);
199  av_free(s);
200  }
201 }
202 
203  int ff_combine_frame(ParseContext *pc, int next,
204  const uint8_t **buf, int *buf_size)
205 {
206  if (pc->overread) {
207  ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
208  pc->overread, pc->state, next, pc->index, pc->overread_index);
209  ff_dlog(NULL, "%X %X %X %X\n",
210  (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
211  }
212 
213  /* Copy overread bytes from last frame into buffer. */
214  for (; pc->overread > 0; pc->overread--)
215  pc->buffer[pc->index++] = pc->buffer[pc->overread_index++];
216 
217  if (next > *buf_size)
218  return AVERROR(EINVAL);
219 
220  /* flush remaining if EOF */
221  if (!*buf_size && next == END_NOT_FOUND)
222  next = 0;
223 
224  pc->last_index = pc->index;
225 
226  /* copy into buffer end return */
227  if (next == END_NOT_FOUND) {
228  void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
229  *buf_size + pc->index +
230  AV_INPUT_BUFFER_PADDING_SIZE);
231 
232  if (!new_buffer) {
233  av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", *buf_size + pc->index + AV_INPUT_BUFFER_PADDING_SIZE);
234  pc->index = 0;
235  return AVERROR(ENOMEM);
236  }
237  pc->buffer = new_buffer;
238  memcpy(&pc->buffer[pc->index], *buf, *buf_size);
239  pc->index += *buf_size;
240  return -1;
241  }
242 
243  av_assert0(next >= 0 || pc->buffer);
244 
245  *buf_size =
246  pc->overread_index = pc->index + next;
247 
248  /* append to buffer */
249  if (pc->index) {
250  void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
251  next + pc->index +
252  AV_INPUT_BUFFER_PADDING_SIZE);
253  if (!new_buffer) {
254  av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", next + pc->index + AV_INPUT_BUFFER_PADDING_SIZE);
255  *buf_size =
256  pc->overread_index =
257  pc->index = 0;
258  return AVERROR(ENOMEM);
259  }
260  pc->buffer = new_buffer;
261  if (next > -AV_INPUT_BUFFER_PADDING_SIZE)
262  memcpy(&pc->buffer[pc->index], *buf,
263  next + AV_INPUT_BUFFER_PADDING_SIZE);
264  pc->index = 0;
265  *buf = pc->buffer;
266  }
267 
268  if (next < -8) {
269  pc->overread += -8 - next;
270  next = -8;
271  }
272  /* store overread bytes */
273  for (; next < 0; next++) {
274  pc->state = pc->state << 8 | pc->buffer[pc->last_index + next];
275  pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next];
276  pc->overread++;
277  }
278 
279  if (pc->overread) {
280  ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
281  pc->overread, pc->state, next, pc->index, pc->overread_index);
282  ff_dlog(NULL, "%X %X %X %X\n",
283  (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
284  }
285 
286  return 0;
287 }
288 
289  void ff_parse_close(AVCodecParserContext *s)
290 {
291  ParseContext *pc = s->priv_data;
292 
293  av_freep(&pc->buffer);
294 }
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
int64_t
long long int64_t
Definition: coverity.c:34
av_parser_iterate
const AVCodecParser * av_parser_iterate(void **opaque)
Iterate over all registered codec parsers.
Definition: parsers.c:86
ParseContext::overread_index
int overread_index
the index into ParseContext.buffer of the overread bytes
Definition: parser.h:36
ff_parse_close
void ff_parse_close(AVCodecParserContext *s)
Definition: parser.c:289
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
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:84
ParseContext
Definition: parser.h:28
av_parser_init
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:32
pts
static int64_t pts
Definition: transcode_aac.c:643
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:180
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:495
width
#define width
ParseContext::index
int index
Definition: parser.h:30
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:40
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:387
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
if
if(ret)
Definition: filter_design.txt:179
NULL
#define NULL
Definition: coverity.c:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
index
int index
Definition: gxfenc.c:89
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
AVCodecParser::codec_ids
int codec_ids[7]
Definition: avcodec.h:2867
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
height
#define height
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:203
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:255
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVCodecParser::parser_init
int(* parser_init)(AVCodecParserContext *s)
Definition: avcodec.h:2869
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:254
parser.h
AVCodecParserContext
Definition: avcodec.h:2707
ret
ret
Definition: filter_design.txt:187
pos
unsigned int pos
Definition: spdifenc.c:413
AVCodecParser::priv_data_size
int priv_data_size
Definition: avcodec.h:2868
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:445
PARSER_FLAG_FETCHED_OFFSET
#define PARSER_FLAG_FETCHED_OFFSET
Set if the parser has a valid file offset.
Definition: avcodec.h:2744
ParseContext::state64
uint64_t state64
contains the last 8 bytes in MSB order
Definition: parser.h:37
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
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:115
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
END_NOT_FOUND
#define END_NOT_FOUND
Definition: parser.h:40
AV_PARSER_PTS_NB
#define AV_PARSER_PTS_NB
Definition: avcodec.h:2734
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecParser
Definition: avcodec.h:2866
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_parser_close
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:193
Generated on Thu Sep 26 2024 23:15:16 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /