2 * Audio and Video frame extraction
3 * Copyright (c) 2003 Fabrice Bellard.
4 * Copyright (c) 2003 Michael Niedermayer.
6 * This file is part of FFmpeg.
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.
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.
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
25 AVCodecParser *av_first_parser = NULL;
27 void av_register_codec_parser(AVCodecParser *parser)
29 parser->next = av_first_parser;
30 av_first_parser = parser;
33 AVCodecParserContext *av_parser_init(int codec_id)
35 AVCodecParserContext *s;
36 AVCodecParser *parser;
39 if(codec_id == CODEC_ID_NONE)
42 for(parser = av_first_parser; parser != NULL; parser = parser->next) {
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)
52 s = av_mallocz(sizeof(AVCodecParserContext));
56 s->priv_data = av_mallocz(parser->priv_data_size);
61 if (parser->parser_init) {
62 ret = parser->parser_init(s);
64 av_free(s->priv_data);
70 s->pict_type = FF_I_TYPE;
77 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output)
78 * @param pts input presentation timestamp
79 * @param dts input decoding timestamp
80 * @param poutbuf will contain a pointer to the first byte of the output frame
81 * @param poutbuf_size will contain the length of the output frame
82 * @return the number of bytes of the input bitstream used
87 * len = av_parser_parse(myparser, AVCodecContext, &data, &size,
94 * decode_frame(data, size);
98 int av_parser_parse(AVCodecParserContext *s,
99 AVCodecContext *avctx,
100 uint8_t **poutbuf, int *poutbuf_size,
101 const uint8_t *buf, int buf_size,
102 int64_t pts, int64_t dts)
105 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
108 /* padding is always necessary even if EOF, so we add it here */
109 memset(dummy_buf, 0, sizeof(dummy_buf));
112 /* add a new packet descriptor */
113 k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
114 s->cur_frame_start_index = k;
115 s->cur_frame_offset[k] = s->cur_offset;
116 s->cur_frame_pts[k] = pts;
117 s->cur_frame_dts[k] = dts;
119 /* fill first PTS/DTS */
120 if (s->fetch_timestamp){
121 s->fetch_timestamp=0;
125 s->cur_frame_pts[k] =
126 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
130 /* WARNING: the returned index can be negative */
131 index = s->parser->parser_parse(s, avctx, (const uint8_t **)poutbuf, poutbuf_size, buf, buf_size);
132 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
133 /* update the file pointer */
135 /* fill the data for the current frame */
136 s->frame_offset = s->last_frame_offset;
137 s->pts = s->last_pts;
138 s->dts = s->last_dts;
139 s->offset = s->last_offset;
141 /* offset of the next frame */
142 s->last_frame_offset = s->cur_offset + index;
143 /* find the packet in which the new frame starts. It
144 is tricky because of MPEG video start codes
145 which can begin in one packet and finish in
146 another packet. In the worst case, an MPEG
147 video start code could be in 4 different
149 k = s->cur_frame_start_index;
150 for(i = 0; i < AV_PARSER_PTS_NB; i++) {
151 if (s->last_frame_offset >= s->cur_frame_offset[k])
153 k = (k - 1) & (AV_PARSER_PTS_NB - 1);
156 s->last_pts = s->cur_frame_pts[k];
157 s->last_dts = s->cur_frame_dts[k];
158 s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
160 /* some parsers tell us the packet size even before seeing the first byte of the next packet,
161 so the next pts/dts is in the next chunk */
162 if(index == buf_size){
163 s->fetch_timestamp=1;
168 s->cur_offset += index;
174 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
175 * @deprecated use AVBitstreamFilter
177 int av_parser_change(AVCodecParserContext *s,
178 AVCodecContext *avctx,
179 uint8_t **poutbuf, int *poutbuf_size,
180 const uint8_t *buf, int buf_size, int keyframe){
182 if(s && s->parser->split){
183 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
184 int i= s->parser->split(avctx, buf, buf_size);
190 /* cast to avoid warning about discarding qualifiers */
191 *poutbuf= (uint8_t *) buf;
192 *poutbuf_size= buf_size;
193 if(avctx->extradata){
194 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
195 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
196 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
197 int size= buf_size + avctx->extradata_size;
199 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
201 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
202 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
210 void av_parser_close(AVCodecParserContext *s)
212 if (s->parser->parser_close)
213 s->parser->parser_close(s);
214 av_free(s->priv_data);
218 /*****************************************************/
221 * combines the (truncated) bitstream to a complete frame
222 * @returns -1 if no complete frame could be created
224 int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
228 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
229 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
233 /* Copy overread bytes from last frame into buffer. */
234 for(; pc->overread>0; pc->overread--){
235 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
238 /* flush remaining if EOF */
239 if(!*buf_size && next == END_NOT_FOUND){
243 pc->last_index= pc->index;
245 /* copy into buffer end return */
246 if(next == END_NOT_FOUND){
247 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
249 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
250 pc->index += *buf_size;
255 pc->overread_index= pc->index + next;
257 /* append to buffer */
259 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
261 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
266 /* store overread bytes */
267 for(;next < 0; next++){
268 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
274 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
275 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
282 void ff_parse_close(AVCodecParserContext *s)
284 ParseContext *pc = s->priv_data;
289 void ff_parse1_close(AVCodecParserContext *s)
291 ParseContext1 *pc1 = s->priv_data;
293 av_free(pc1->pc.buffer);
297 /*************************/
299 int ff_mpeg4video_split(AVCodecContext *avctx,
300 const uint8_t *buf, int buf_size)
305 for(i=0; i<buf_size; i++){
306 state= (state<<8) | buf[i];
307 if(state == 0x1B3 || state == 0x1B6)