Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ 1f96bafb

History | View | Annotate | Download (9.92 KB)

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
AVCodecParser* av_parser_next(AVCodecParser *p){
28
    if(p) return p->next;
29
    else  return av_first_parser;
30
}
31

    
32
void av_register_codec_parser(AVCodecParser *parser)
33
{
34
    parser->next = av_first_parser;
35
    av_first_parser = parser;
36
}
37

    
38
AVCodecParserContext *av_parser_init(int codec_id)
39
{
40
    AVCodecParserContext *s;
41
    AVCodecParser *parser;
42
    int ret;
43

    
44
    if(codec_id == CODEC_ID_NONE)
45
        return NULL;
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 ||
50
            parser->codec_ids[2] == codec_id ||
51
            parser->codec_ids[3] == codec_id ||
52
            parser->codec_ids[4] == codec_id)
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
    }
74
    s->fetch_timestamp=1;
75
    s->pict_type = FF_I_TYPE;
76
    return s;
77
}
78

    
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
 *
98
 *       if(size)
99
 *          decode_frame(data, size);
100
 *   }
101
 * @endcode
102
 */
103
int av_parser_parse(AVCodecParserContext *s,
104
                    AVCodecContext *avctx,
105
                    uint8_t **poutbuf, int *poutbuf_size,
106
                    const uint8_t *buf, int buf_size,
107
                    int64_t pts, int64_t dts)
108
{
109
    int index, i, k;
110
    uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
111

    
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;
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 */
125
        if (s->fetch_timestamp){
126
            s->fetch_timestamp=0;
127
            s->last_pts = pts;
128
            s->last_dts = dts;
129
            s->last_offset = 0;
130
            s->cur_frame_pts[k] =
131
            s->cur_frame_dts[k] = AV_NOPTS_VALUE;
132
        }
133
    }
134

    
135
    /* WARNING: the returned index can be negative */
136
    index = s->parser->parser_parse(s, avctx, (const uint8_t **)poutbuf, poutbuf_size, buf, buf_size);
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);
138
    /* update the file pointer */
139
    if (*poutbuf_size) {
140
        /* fill the data for the current frame */
141
        s->frame_offset = s->last_frame_offset;
142
        s->pts = s->last_pts;
143
        s->dts = s->last_dts;
144
        s->offset = s->last_offset;
145

    
146
        /* offset of the next frame */
147
        s->last_frame_offset = s->cur_offset + index;
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
        }
160

    
161
        s->last_pts = s->cur_frame_pts[k];
162
        s->last_dts = s->cur_frame_dts[k];
163
        s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
164

    
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
        }
170
    }
171
    if (index < 0)
172
        index = 0;
173
    s->cur_offset += index;
174
    return index;
175
}
176

    
177
/**
178
 *
179
 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
180
 * @deprecated use AVBitstreamFilter
181
 */
182
int av_parser_change(AVCodecParserContext *s,
183
                     AVCodecContext *avctx,
184
                     uint8_t **poutbuf, int *poutbuf_size,
185
                     const uint8_t *buf, int buf_size, int keyframe){
186

    
187
    if(s && s->parser->split){
188
        if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
189
            int i= s->parser->split(avctx, buf, buf_size);
190
            buf += i;
191
            buf_size -= i;
192
        }
193
    }
194

    
195
    /* cast to avoid warning about discarding qualifiers */
196
    *poutbuf= (uint8_t *) buf;
197
    *poutbuf_size= buf_size;
198
    if(avctx->extradata){
199
        if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
200
            /*||(s->pict_type != FF_I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
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);
205

    
206
            memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
207
            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
208
            return 1;
209
        }
210
    }
211

    
212
    return 0;
213
}
214

    
215
void 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

    
225
/**
226
 * combines the (truncated) bitstream to a complete frame
227
 * @returns -1 if no complete frame could be created, AVERROR(ENOMEM) if there was a memory allocation error
228
 */
229
int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
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

    
238
    /* Copy overread bytes from last frame into buffer. */
239
    for(; pc->overread>0; pc->overread--){
240
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
241
    }
242

    
243
    /* flush remaining if EOF */
244
    if(!*buf_size && next == END_NOT_FOUND){
245
        next= 0;
246
    }
247

    
248
    pc->last_index= pc->index;
249

    
250
    /* copy into buffer end return */
251
    if(next == END_NOT_FOUND){
252
        void* new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
253

    
254
        if(!new_buffer)
255
            return AVERROR(ENOMEM);
256
        pc->buffer = new_buffer;
257
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
258
        pc->index += *buf_size;
259
        return -1;
260
    }
261

    
262
    *buf_size=
263
    pc->overread_index= pc->index + next;
264

    
265
    /* append to buffer */
266
    if(pc->index){
267
        void* new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
268

    
269
        if(!new_buffer)
270
            return AVERROR(ENOMEM);
271
        pc->buffer = new_buffer;
272
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
273
        pc->index = 0;
274
        *buf= pc->buffer;
275
    }
276

    
277
    /* store overread bytes */
278
    for(;next < 0; next++){
279
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
280
        pc->overread++;
281
    }
282

    
283
#if 0
284
    if(pc->overread){
285
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
286
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
287
    }
288
#endif
289

    
290
    return 0;
291
}
292

    
293
void ff_parse_close(AVCodecParserContext *s)
294
{
295
    ParseContext *pc = s->priv_data;
296

    
297
    av_free(pc->buffer);
298
}
299

    
300
void ff_parse1_close(AVCodecParserContext *s)
301
{
302
    ParseContext1 *pc1 = s->priv_data;
303

    
304
    av_free(pc1->pc.buffer);
305
    av_free(pc1->enc);
306
}
307

    
308
/*************************/
309

    
310
int ff_mpeg4video_split(AVCodecContext *avctx,
311
                           const uint8_t *buf, int buf_size)
312
{
313
    int i;
314
    uint32_t state= -1;
315

    
316
    for(i=0; i<buf_size; i++){
317
        state= (state<<8) | buf[i];
318
        if(state == 0x1B3 || state == 0x1B6)
319
            return i-3;
320
    }
321
    return 0;
322
}