192241987e350c230b69572528056f97dfd86a1e
[ffmpeg.git] / libavcodec / parser.c
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 "parser.h"
24
25 AVCodecParser *av_first_parser = NULL;
26
27 void av_register_codec_parser(AVCodecParser *parser)
28 {
29     parser->next = av_first_parser;
30     av_first_parser = parser;
31 }
32
33 AVCodecParserContext *av_parser_init(int codec_id)
34 {
35     AVCodecParserContext *s;
36     AVCodecParser *parser;
37     int ret;
38
39     if(codec_id == CODEC_ID_NONE)
40         return NULL;
41
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)
48             goto found;
49     }
50     return NULL;
51  found:
52     s = av_mallocz(sizeof(AVCodecParserContext));
53     if (!s)
54         return NULL;
55     s->parser = parser;
56     s->priv_data = av_mallocz(parser->priv_data_size);
57     if (!s->priv_data) {
58         av_free(s);
59         return NULL;
60     }
61     if (parser->parser_init) {
62         ret = parser->parser_init(s);
63         if (ret != 0) {
64             av_free(s->priv_data);
65             av_free(s);
66             return NULL;
67         }
68     }
69     s->fetch_timestamp=1;
70     s->pict_type = FF_I_TYPE;
71     return s;
72 }
73
74 /**
75  *
76  * @param buf           input
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
83  *
84  * Example:
85  * @code
86  *   while(in_len){
87  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
88  *                                       in_data, in_len,
89  *                                       pts, dts);
90  *       in_data += len;
91  *       in_len  -= len;
92  *
93  *       if(size)
94  *          decode_frame(data, size);
95  *   }
96  * @endcode
97  */
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)
103 {
104     int index, i, k;
105     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
106
107     if (buf_size == 0) {
108         /* padding is always necessary even if EOF, so we add it here */
109         memset(dummy_buf, 0, sizeof(dummy_buf));
110         buf = dummy_buf;
111     } else {
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;
118
119         /* fill first PTS/DTS */
120         if (s->fetch_timestamp){
121             s->fetch_timestamp=0;
122             s->last_pts = pts;
123             s->last_dts = dts;
124             s->last_offset = 0;
125             s->cur_frame_pts[k] =
126             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
127         }
128     }
129
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 */
134     if (*poutbuf_size) {
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;
140
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
148            packets. */
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])
152                 break;
153             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
154         }
155
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];
159
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;
164         }
165     }
166     if (index < 0)
167         index = 0;
168     s->cur_offset += index;
169     return index;
170 }
171
172 /**
173  *
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
176  */
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){
181
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);
185             buf += i;
186             buf_size -= i;
187         }
188     }
189
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;
198             *poutbuf_size= size;
199             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
200
201             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
202             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
203             return 1;
204         }
205     }
206
207     return 0;
208 }
209
210 void av_parser_close(AVCodecParserContext *s)
211 {
212     if (s->parser->parser_close)
213         s->parser->parser_close(s);
214     av_free(s->priv_data);
215     av_free(s);
216 }
217
218 /*****************************************************/
219
220 /**
221  * combines the (truncated) bitstream to a complete frame
222  * @returns -1 if no complete frame could be created
223  */
224 int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
225 {
226 #if 0
227     if(pc->overread){
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]);
230     }
231 #endif
232
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++];
236     }
237
238     /* flush remaining if EOF */
239     if(!*buf_size && next == END_NOT_FOUND){
240         next= 0;
241     }
242
243     pc->last_index= pc->index;
244
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);
248
249         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
250         pc->index += *buf_size;
251         return -1;
252     }
253
254     *buf_size=
255     pc->overread_index= pc->index + next;
256
257     /* append to buffer */
258     if(pc->index){
259         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
260
261         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
262         pc->index = 0;
263         *buf= pc->buffer;
264     }
265
266     /* store overread bytes */
267     for(;next < 0; next++){
268         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
269         pc->overread++;
270     }
271
272 #if 0
273     if(pc->overread){
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]);
276     }
277 #endif
278
279     return 0;
280 }
281
282 void ff_parse_close(AVCodecParserContext *s)
283 {
284     ParseContext *pc = s->priv_data;
285
286     av_free(pc->buffer);
287 }
288
289 void ff_parse1_close(AVCodecParserContext *s)
290 {
291     ParseContext1 *pc1 = s->priv_data;
292
293     av_free(pc1->pc.buffer);
294     av_free(pc1->enc);
295 }
296
297 /*************************/
298
299 int ff_mpeg4video_split(AVCodecContext *avctx,
300                            const uint8_t *buf, int buf_size)
301 {
302     int i;
303     uint32_t state= -1;
304
305     for(i=0; i<buf_size; i++){
306         state= (state<<8) | buf[i];
307         if(state == 0x1B3 || state == 0x1B6)
308             return i-3;
309     }
310     return 0;
311 }