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 static AVCodecParser
*av_first_parser
= NULL
;
27 AVCodecParser
* av_parser_next(AVCodecParser
*p
){
29 else return av_first_parser
;
32 void av_register_codec_parser(AVCodecParser
*parser
)
34 parser
->next
= av_first_parser
;
35 av_first_parser
= parser
;
38 AVCodecParserContext
*av_parser_init(int codec_id
)
40 AVCodecParserContext
*s
;
41 AVCodecParser
*parser
;
44 if(codec_id
== CODEC_ID_NONE
)
47 for(parser
= av_first_parser
; parser
!= NULL
; parser
= parser
->next
) {
48 if (parser
->codec_ids
[0] == codec_id
||
49 parser
->codec_ids
[1] == codec_id
||
50 parser
->codec_ids
[2] == codec_id
||
51 parser
->codec_ids
[3] == codec_id
||
52 parser
->codec_ids
[4] == codec_id
)
57 s
= av_mallocz(sizeof(AVCodecParserContext
));
61 s
->priv_data
= av_mallocz(parser
->priv_data_size
);
66 if (parser
->parser_init
) {
67 ret
= parser
->parser_init(s
);
69 av_free(s
->priv_data
);
75 s
->pict_type
= FF_I_TYPE
;
77 s
->convergence_duration
= AV_NOPTS_VALUE
;
78 s
->dts_sync_point
= INT_MIN
;
79 s
->dts_ref_dts_delta
= INT_MIN
;
80 s
->pts_dts_delta
= INT_MIN
;
84 void ff_fetch_timestamp(AVCodecParserContext
*s
, int off
, int remove
){
87 s
->dts
= s
->pts
= AV_NOPTS_VALUE
;
90 for(i
= 0; i
< AV_PARSER_PTS_NB
; i
++) {
91 if ( s
->cur_offset
+ off
>= s
->cur_frame_offset
[i
]
92 &&(s
-> frame_offset
< s
->cur_frame_offset
[i
] || !s
->frame_offset
)
93 //check is disabled becausue mpeg-ts doesnt send complete PES packets
94 && /*s->next_frame_offset + off <*/ s
->cur_frame_end
[i
]){
95 s
->dts
= s
->cur_frame_dts
[i
];
96 s
->pts
= s
->cur_frame_pts
[i
];
97 s
->pos
= s
->cur_frame_pos
[i
];
98 s
->offset
= s
->next_frame_offset
- s
->cur_frame_offset
[i
];
100 s
->cur_frame_offset
[i
]= INT64_MAX
;
101 if(s
->cur_offset
+ off
< s
->cur_frame_end
[i
])
110 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output)
111 * @param pts input presentation timestamp
112 * @param dts input decoding timestamp
113 * @param poutbuf will contain a pointer to the first byte of the output frame
114 * @param poutbuf_size will contain the length of the output frame
115 * @return the number of bytes of the input bitstream used
120 * len = av_parser_parse(myparser, AVCodecContext, &data, &size,
127 * decode_frame(data, size);
131 * @deprecated Use av_parser_parse2() instead.
133 int av_parser_parse(AVCodecParserContext
*s
,
134 AVCodecContext
*avctx
,
135 uint8_t **poutbuf
, int *poutbuf_size
,
136 const uint8_t *buf
, int buf_size
,
137 int64_t pts
, int64_t dts
)
139 return av_parser_parse2(s
, avctx
, poutbuf
, poutbuf_size
, buf
, buf_size
, pts
, dts
, AV_NOPTS_VALUE
);
142 int av_parser_parse2(AVCodecParserContext
*s
,
143 AVCodecContext
*avctx
,
144 uint8_t **poutbuf
, int *poutbuf_size
,
145 const uint8_t *buf
, int buf_size
,
146 int64_t pts
, int64_t dts
,
150 uint8_t dummy_buf
[FF_INPUT_BUFFER_PADDING_SIZE
];
153 /* padding is always necessary even if EOF, so we add it here */
154 memset(dummy_buf
, 0, sizeof(dummy_buf
));
156 } else if (s
->cur_offset
+ buf_size
!=
157 s
->cur_frame_end
[s
->cur_frame_start_index
]) { /* skip remainder packets */
158 /* add a new packet descriptor */
159 i
= (s
->cur_frame_start_index
+ 1) & (AV_PARSER_PTS_NB
- 1);
160 s
->cur_frame_start_index
= i
;
161 s
->cur_frame_offset
[i
] = s
->cur_offset
;
162 s
->cur_frame_end
[i
] = s
->cur_offset
+ buf_size
;
163 s
->cur_frame_pts
[i
] = pts
;
164 s
->cur_frame_dts
[i
] = dts
;
165 s
->cur_frame_pos
[i
] = pos
;
168 if (s
->fetch_timestamp
){
169 s
->fetch_timestamp
=0;
170 s
->last_pts
= s
->pts
;
171 s
->last_dts
= s
->dts
;
172 s
->last_pos
= s
->pos
;
173 ff_fetch_timestamp(s
, 0, 0);
176 /* WARNING: the returned index can be negative */
177 index
= s
->parser
->parser_parse(s
, avctx
, (const uint8_t **)poutbuf
, poutbuf_size
, buf
, buf_size
);
178 //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);
179 /* update the file pointer */
181 /* fill the data for the current frame */
182 s
->frame_offset
= s
->next_frame_offset
;
184 /* offset of the next frame */
185 s
->next_frame_offset
= s
->cur_offset
+ index
;
186 s
->fetch_timestamp
=1;
190 s
->cur_offset
+= index
;
196 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
197 * @deprecated use AVBitstreamFilter
199 int av_parser_change(AVCodecParserContext
*s
,
200 AVCodecContext
*avctx
,
201 uint8_t **poutbuf
, int *poutbuf_size
,
202 const uint8_t *buf
, int buf_size
, int keyframe
){
204 if(s
&& s
->parser
->split
){
205 if((avctx
->flags
& CODEC_FLAG_GLOBAL_HEADER
) || (avctx
->flags2
& CODEC_FLAG2_LOCAL_HEADER
)){
206 int i
= s
->parser
->split(avctx
, buf
, buf_size
);
212 /* cast to avoid warning about discarding qualifiers */
213 *poutbuf
= (uint8_t *) buf
;
214 *poutbuf_size
= buf_size
;
215 if(avctx
->extradata
){
216 if( (keyframe
&& (avctx
->flags2
& CODEC_FLAG2_LOCAL_HEADER
))
217 /*||(s->pict_type != FF_I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
218 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
219 int size
= buf_size
+ avctx
->extradata_size
;
221 *poutbuf
= av_malloc(size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
223 memcpy(*poutbuf
, avctx
->extradata
, avctx
->extradata_size
);
224 memcpy((*poutbuf
) + avctx
->extradata_size
, buf
, buf_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
232 void av_parser_close(AVCodecParserContext
*s
)
235 if (s
->parser
->parser_close
)
236 s
->parser
->parser_close(s
);
237 av_free(s
->priv_data
);
242 /*****************************************************/
245 * combines the (truncated) bitstream to a complete frame
246 * @returns -1 if no complete frame could be created, AVERROR(ENOMEM) if there was a memory allocation error
248 int ff_combine_frame(ParseContext
*pc
, int next
, const uint8_t **buf
, int *buf_size
)
252 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc
->overread
, pc
->state
, next
, pc
->index
, pc
->overread_index
);
253 printf("%X %X %X %X\n", (*buf
)[0], (*buf
)[1],(*buf
)[2],(*buf
)[3]);
257 /* Copy overread bytes from last frame into buffer. */
258 for(; pc
->overread
>0; pc
->overread
--){
259 pc
->buffer
[pc
->index
++]= pc
->buffer
[pc
->overread_index
++];
262 /* flush remaining if EOF */
263 if(!*buf_size
&& next
== END_NOT_FOUND
){
267 pc
->last_index
= pc
->index
;
269 /* copy into buffer end return */
270 if(next
== END_NOT_FOUND
){
271 void* new_buffer
= av_fast_realloc(pc
->buffer
, &pc
->buffer_size
, (*buf_size
) + pc
->index
+ FF_INPUT_BUFFER_PADDING_SIZE
);
274 return AVERROR(ENOMEM
);
275 pc
->buffer
= new_buffer
;
276 memcpy(&pc
->buffer
[pc
->index
], *buf
, *buf_size
);
277 pc
->index
+= *buf_size
;
282 pc
->overread_index
= pc
->index
+ next
;
284 /* append to buffer */
286 void* new_buffer
= av_fast_realloc(pc
->buffer
, &pc
->buffer_size
, next
+ pc
->index
+ FF_INPUT_BUFFER_PADDING_SIZE
);
289 return AVERROR(ENOMEM
);
290 pc
->buffer
= new_buffer
;
291 memcpy(&pc
->buffer
[pc
->index
], *buf
, next
+ FF_INPUT_BUFFER_PADDING_SIZE
);
296 /* store overread bytes */
297 for(;next
< 0; next
++){
298 pc
->state
= (pc
->state
<<8) | pc
->buffer
[pc
->last_index
+ next
];
299 pc
->state64
= (pc
->state64
<<8) | pc
->buffer
[pc
->last_index
+ next
];
305 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc
->overread
, pc
->state
, next
, pc
->index
, pc
->overread_index
);
306 printf("%X %X %X %X\n", (*buf
)[0], (*buf
)[1],(*buf
)[2],(*buf
)[3]);
313 void ff_parse_close(AVCodecParserContext
*s
)
315 ParseContext
*pc
= s
->priv_data
;
317 av_freep(&pc
->buffer
);
320 void ff_parse1_close(AVCodecParserContext
*s
)
322 ParseContext1
*pc1
= s
->priv_data
;
324 av_free(pc1
->pc
.buffer
);
328 /*************************/
330 int ff_mpeg4video_split(AVCodecContext
*avctx
,
331 const uint8_t *buf
, int buf_size
)
336 for(i
=0; i
<buf_size
; i
++){
337 state
= (state
<<8) | buf
[i
];
338 if(state
== 0x1B3 || state
== 0x1B6)