Set mm_flags in dct-test to fix floating math.
[libav.git] / libavcodec / parser.c
CommitLineData
8424cf50
FB
1/*
2 * Audio and Video frame extraction
3 * Copyright (c) 2003 Fabrice Bellard.
4 * Copyright (c) 2003 Michael Niedermayer.
5 *
b78e7197
DB
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
8424cf50
FB
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
b78e7197 11 * version 2.1 of the License, or (at your option) any later version.
8424cf50 12 *
b78e7197 13 * FFmpeg is distributed in the hope that it will be useful,
8424cf50
FB
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
b78e7197 19 * License along with FFmpeg; if not, write to the Free Software
5509bffa 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
8424cf50 21 */
1fddeecd 22
4067d81b 23#include "parser.h"
8424cf50
FB
24
25AVCodecParser *av_first_parser = NULL;
26
55b9e69a
MN
27AVCodecParser* av_parser_next(AVCodecParser *p){
28 if(p) return p->next;
29 else return av_first_parser;
30}
31
8424cf50
FB
32void av_register_codec_parser(AVCodecParser *parser)
33{
34 parser->next = av_first_parser;
35 av_first_parser = parser;
36}
37
38AVCodecParserContext *av_parser_init(int codec_id)
39{
40 AVCodecParserContext *s;
41 AVCodecParser *parser;
42 int ret;
115329f1 43
8845e427
MN
44 if(codec_id == CODEC_ID_NONE)
45 return NULL;
8424cf50
FB
46
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 ||
99f06236
MN
50 parser->codec_ids[2] == codec_id ||
51 parser->codec_ids[3] == codec_id ||
52 parser->codec_ids[4] == codec_id)
8424cf50
FB
53 goto found;
54 }
55 return NULL;
56 found:
57 s = av_mallocz(sizeof(AVCodecParserContext));
58 if (!s)
59 return NULL;
60 s->parser = parser;
61 s->priv_data = av_mallocz(parser->priv_data_size);
62 if (!s->priv_data) {
63 av_free(s);
64 return NULL;
65 }
66 if (parser->parser_init) {
67 ret = parser->parser_init(s);
68 if (ret != 0) {
69 av_free(s->priv_data);
70 av_free(s);
71 return NULL;
72 }
73 }
a62aecce 74 s->fetch_timestamp=1;
adcb72b5 75 s->pict_type = FF_I_TYPE;
8424cf50
FB
76 return s;
77}
78
6ab312da
MN
79/**
80 *
81 * @param buf input
82 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output)
83 * @param pts input presentation timestamp
84 * @param dts input decoding timestamp
85 * @param poutbuf will contain a pointer to the first byte of the output frame
86 * @param poutbuf_size will contain the length of the output frame
87 * @return the number of bytes of the input bitstream used
88 *
89 * Example:
90 * @code
91 * while(in_len){
92 * len = av_parser_parse(myparser, AVCodecContext, &data, &size,
93 * in_data, in_len,
94 * pts, dts);
95 * in_data += len;
96 * in_len -= len;
97 *
832a7b63
MN
98 * if(size)
99 * decode_frame(data, size);
6ab312da
MN
100 * }
101 * @endcode
102 */
115329f1 103int av_parser_parse(AVCodecParserContext *s,
8424cf50 104 AVCodecContext *avctx,
115329f1 105 uint8_t **poutbuf, int *poutbuf_size,
b84f2a35
FB
106 const uint8_t *buf, int buf_size,
107 int64_t pts, int64_t dts)
8424cf50 108{
b84f2a35 109 int index, i, k;
6e45e928 110 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
115329f1 111
6e45e928
FB
112 if (buf_size == 0) {
113 /* padding is always necessary even if EOF, so we add it here */
114 memset(dummy_buf, 0, sizeof(dummy_buf));
115 buf = dummy_buf;
b84f2a35
FB
116 } else {
117 /* add a new packet descriptor */
118 k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
119 s->cur_frame_start_index = k;
120 s->cur_frame_offset[k] = s->cur_offset;
121 s->cur_frame_pts[k] = pts;
122 s->cur_frame_dts[k] = dts;
123
124 /* fill first PTS/DTS */
a62aecce
MN
125 if (s->fetch_timestamp){
126 s->fetch_timestamp=0;
b84f2a35
FB
127 s->last_pts = pts;
128 s->last_dts = dts;
a74008a4 129 s->last_offset = 0;
c77a9a0e
MN
130 s->cur_frame_pts[k] =
131 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
b84f2a35 132 }
6e45e928
FB
133 }
134
8424cf50 135 /* WARNING: the returned index can be negative */
c53d2d90 136 index = s->parser->parser_parse(s, avctx, (const uint8_t **)poutbuf, poutbuf_size, buf, buf_size);
949b1a13 137//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);
8424cf50
FB
138 /* update the file pointer */
139 if (*poutbuf_size) {
b84f2a35 140 /* fill the data for the current frame */
8424cf50 141 s->frame_offset = s->last_frame_offset;
b84f2a35
FB
142 s->pts = s->last_pts;
143 s->dts = s->last_dts;
a74008a4 144 s->offset = s->last_offset;
115329f1 145
b84f2a35 146 /* offset of the next frame */
8424cf50 147 s->last_frame_offset = s->cur_offset + index;
b84f2a35
FB
148 /* find the packet in which the new frame starts. It
149 is tricky because of MPEG video start codes
150 which can begin in one packet and finish in
151 another packet. In the worst case, an MPEG
152 video start code could be in 4 different
153 packets. */
154 k = s->cur_frame_start_index;
155 for(i = 0; i < AV_PARSER_PTS_NB; i++) {
156 if (s->last_frame_offset >= s->cur_frame_offset[k])
157 break;
158 k = (k - 1) & (AV_PARSER_PTS_NB - 1);
159 }
a62aecce 160
b84f2a35
FB
161 s->last_pts = s->cur_frame_pts[k];
162 s->last_dts = s->cur_frame_dts[k];
a74008a4 163 s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
115329f1 164
a62aecce
MN
165 /* some parsers tell us the packet size even before seeing the first byte of the next packet,
166 so the next pts/dts is in the next chunk */
167 if(index == buf_size){
168 s->fetch_timestamp=1;
169 }
8424cf50
FB
170 }
171 if (index < 0)
172 index = 0;
173 s->cur_offset += index;
174 return index;
175}
176
73480a15
MN
177/**
178 *
179 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
748c2fca 180 * @deprecated use AVBitstreamFilter
73480a15 181 */
90ad92b3
MN
182int av_parser_change(AVCodecParserContext *s,
183 AVCodecContext *avctx,
115329f1 184 uint8_t **poutbuf, int *poutbuf_size,
90ad92b3 185 const uint8_t *buf, int buf_size, int keyframe){
115329f1 186
90ad92b3 187 if(s && s->parser->split){
73480a15 188 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
90ad92b3
MN
189 int i= s->parser->split(avctx, buf, buf_size);
190 buf += i;
191 buf_size -= i;
192 }
193 }
194
79396ac6
MR
195 /* cast to avoid warning about discarding qualifiers */
196 *poutbuf= (uint8_t *) buf;
90ad92b3
MN
197 *poutbuf_size= buf_size;
198 if(avctx->extradata){
199 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
9701840b 200 /*||(s->pict_type != FF_I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
90ad92b3
MN
201 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
202 int size= buf_size + avctx->extradata_size;
203 *poutbuf_size= size;
204 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
115329f1 205
90ad92b3 206 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
73480a15 207 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
90ad92b3
MN
208 return 1;
209 }
210 }
211
212 return 0;
213}
214
8424cf50
FB
215void av_parser_close(AVCodecParserContext *s)
216{
217 if (s->parser->parser_close)
218 s->parser->parser_close(s);
219 av_free(s->priv_data);
220 av_free(s);
221}
222
223/*****************************************************/
224
8424cf50
FB
225/**
226 * combines the (truncated) bitstream to a complete frame
227 * @returns -1 if no complete frame could be created
228 */
c53d2d90 229int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
8424cf50
FB
230{
231#if 0
232 if(pc->overread){
233 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
234 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
235 }
236#endif
237
e42dba48 238 /* Copy overread bytes from last frame into buffer. */
8424cf50
FB
239 for(; pc->overread>0; pc->overread--){
240 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
241 }
f48c0551
MN
242
243 /* flush remaining if EOF */
244 if(!*buf_size && next == END_NOT_FOUND){
245 next= 0;
246 }
247
8424cf50
FB
248 pc->last_index= pc->index;
249
250 /* copy into buffer end return */
251 if(next == END_NOT_FOUND){
252 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
253
254 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
255 pc->index += *buf_size;
256 return -1;
257 }
258
259 *buf_size=
260 pc->overread_index= pc->index + next;
115329f1 261
8424cf50
FB
262 /* append to buffer */
263 if(pc->index){
264 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
265
266 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
267 pc->index = 0;
268 *buf= pc->buffer;
269 }
270
271 /* store overread bytes */
272 for(;next < 0; next++){
273 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
274 pc->overread++;
275 }
276
277#if 0
278 if(pc->overread){
279 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
280 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
281 }
282#endif
283
284 return 0;
285}
286
e4cb187d 287void ff_parse_close(AVCodecParserContext *s)
8424cf50 288{
e4cb187d 289 ParseContext *pc = s->priv_data;
8424cf50
FB
290
291 av_free(pc->buffer);
8424cf50
FB
292}
293
4067d81b 294void ff_parse1_close(AVCodecParserContext *s)
8424cf50 295{
e4cb187d 296 ParseContext1 *pc1 = s->priv_data;
8424cf50 297
e4cb187d
MN
298 av_free(pc1->pc.buffer);
299 av_free(pc1->enc);
8424cf50
FB
300}
301
e4cb187d
MN
302/*************************/
303
d136d2fc 304int ff_mpeg4video_split(AVCodecContext *avctx,
90ad92b3
MN
305 const uint8_t *buf, int buf_size)
306{
307 int i;
308 uint32_t state= -1;
115329f1 309
90ad92b3
MN
310 for(i=0; i<buf_size; i++){
311 state= (state<<8) | buf[i];
312 if(state == 0x1B3 || state == 0x1B6)
73480a15 313 return i-3;
90ad92b3
MN
314 }
315 return 0;
316}