Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 708ec8fb

History | View | Annotate | Download (96.8 KB)

1 de6d9b64 Fabrice Bellard
/*
2 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
3 19720f15 Fabrice Bellard
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 de6d9b64 Fabrice Bellard
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 19720f15 Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 de6d9b64 Fabrice Bellard
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16 de6d9b64 Fabrice Bellard
 *
17 19720f15 Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 de6d9b64 Fabrice Bellard
 */
21 8be1c656 Fabrice Bellard
#include "avformat.h"
22 f1c80e35 Ronald S. Bultje
#include "internal.h"
23 245976da Diego Biurrun
#include "libavcodec/opt.h"
24 06a7bd9a Michael Niedermayer
#include "metadata.h"
25 245976da Diego Biurrun
#include "libavutil/avstring.h"
26 45da8124 Aurelien Jacobs
#include "riff.h"
27 82e4ac2c Ramiro Polla
#include <sys/time.h>
28
#include <time.h>
29 ea452b54 Aurelien Jacobs
#include <strings.h>
30 c5510dd6 Philip Gladstone
31 b754978a Michael Niedermayer
#undef NDEBUG
32
#include <assert.h>
33
34 e36bdf8b Daniel Kristjansson
/**
35
 * @file libavformat/utils.c
36 a85736f2 Diego Biurrun
 * various utility functions for use within FFmpeg
37 e36bdf8b Daniel Kristjansson
 */
38
39 c97429e2 Stefano Sabatini
unsigned avformat_version(void)
40
{
41
    return LIBAVFORMAT_VERSION_INT;
42
}
43
44 8163c870 Stefano Sabatini
/* fraction handling */
45
46
/**
47
 * f = val + (num / den) + 0.5.
48
 *
49
 * 'num' is normalized so that it is such as 0 <= num < den.
50
 *
51
 * @param f fractional number
52
 * @param val integer value
53
 * @param num must be >= 0
54
 * @param den must be >= 1
55
 */
56
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
57
{
58
    num += (den >> 1);
59
    if (num >= den) {
60
        val += num / den;
61
        num = num % den;
62
    }
63
    f->val = val;
64
    f->num = num;
65
    f->den = den;
66
}
67
68
/**
69
 * Fractional addition to f: f = f + (incr / f->den).
70
 *
71
 * @param f fractional number
72
 * @param incr increment, can be positive or negative
73
 */
74
static void av_frac_add(AVFrac *f, int64_t incr)
75
{
76
    int64_t num, den;
77
78
    num = f->num + incr;
79
    den = f->den;
80
    if (num < 0) {
81
        f->val += num / den;
82
        num = num % den;
83
        if (num < 0) {
84
            num += den;
85
            f->val--;
86
        }
87
    } else if (num >= den) {
88
        f->val += num / den;
89
        num = num % den;
90
    }
91
    f->num = num;
92
}
93 f3a30e3a Luca Barbato
94 a85736f2 Diego Biurrun
/** head of registered input format linked list */
95 8b69867f Michael Niedermayer
AVInputFormat *first_iformat = NULL;
96 a85736f2 Diego Biurrun
/** head of registered output format linked list */
97 8b69867f Michael Niedermayer
AVOutputFormat *first_oformat = NULL;
98 de6d9b64 Fabrice Bellard
99 84be6e72 Michael Niedermayer
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
100
{
101
    if(f) return f->next;
102
    else  return first_iformat;
103
}
104
105
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
106
{
107
    if(f) return f->next;
108
    else  return first_oformat;
109
}
110
111 b9a281db Fabrice Bellard
void av_register_input_format(AVInputFormat *format)
112 de6d9b64 Fabrice Bellard
{
113 b9a281db Fabrice Bellard
    AVInputFormat **p;
114
    p = &first_iformat;
115
    while (*p != NULL) p = &(*p)->next;
116
    *p = format;
117
    format->next = NULL;
118
}
119
120
void av_register_output_format(AVOutputFormat *format)
121
{
122
    AVOutputFormat **p;
123
    p = &first_oformat;
124 de6d9b64 Fabrice Bellard
    while (*p != NULL) p = &(*p)->next;
125
    *p = format;
126
    format->next = NULL;
127
}
128
129 5b25dfa7 Fabrice Bellard
int match_ext(const char *filename, const char *extensions)
130 de6d9b64 Fabrice Bellard
{
131
    const char *ext, *p;
132
    char ext1[32], *q;
133
134 293ed23f Michael Niedermayer
    if(!filename)
135
        return 0;
136 115329f1 Diego Biurrun
137 de6d9b64 Fabrice Bellard
    ext = strrchr(filename, '.');
138
    if (ext) {
139
        ext++;
140
        p = extensions;
141
        for(;;) {
142
            q = ext1;
143 115329f1 Diego Biurrun
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
144 de6d9b64 Fabrice Bellard
                *q++ = *p++;
145
            *q = '\0';
146 115329f1 Diego Biurrun
            if (!strcasecmp(ext1, ext))
147 de6d9b64 Fabrice Bellard
                return 1;
148 115329f1 Diego Biurrun
            if (*p == '\0')
149 de6d9b64 Fabrice Bellard
                break;
150
            p++;
151
        }
152
    }
153
    return 0;
154
}
155
156 115329f1 Diego Biurrun
AVOutputFormat *guess_format(const char *short_name, const char *filename,
157 b9a281db Fabrice Bellard
                             const char *mime_type)
158 de6d9b64 Fabrice Bellard
{
159 b9a281db Fabrice Bellard
    AVOutputFormat *fmt, *fmt_found;
160 de6d9b64 Fabrice Bellard
    int score_max, score;
161
162 87a0a681 Fabrice Bellard
    /* specific test for image sequences */
163 ff70e601 Måns Rullgård
#ifdef CONFIG_IMAGE2_MUXER
164 115329f1 Diego Biurrun
    if (!short_name && filename &&
165 5c07cf53 Michel Bardiaux
        av_filename_number_test(filename) &&
166 5b6d5596 Michael Niedermayer
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
167
        return guess_format("image2", NULL, NULL);
168
    }
169 ff70e601 Måns Rullgård
#endif
170 a85736f2 Diego Biurrun
    /* Find the proper file type. */
171 de6d9b64 Fabrice Bellard
    fmt_found = NULL;
172
    score_max = 0;
173 b9a281db Fabrice Bellard
    fmt = first_oformat;
174 de6d9b64 Fabrice Bellard
    while (fmt != NULL) {
175
        score = 0;
176
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
177
            score += 100;
178
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
179
            score += 10;
180 115329f1 Diego Biurrun
        if (filename && fmt->extensions &&
181 de6d9b64 Fabrice Bellard
            match_ext(filename, fmt->extensions)) {
182
            score += 5;
183
        }
184
        if (score > score_max) {
185
            score_max = score;
186
            fmt_found = fmt;
187
        }
188
        fmt = fmt->next;
189
    }
190
    return fmt_found;
191 115329f1 Diego Biurrun
}
192 de6d9b64 Fabrice Bellard
193 115329f1 Diego Biurrun
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
194 c5510dd6 Philip Gladstone
                             const char *mime_type)
195
{
196
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
197
198
    if (fmt) {
199
        AVOutputFormat *stream_fmt;
200
        char stream_format_name[64];
201
202
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
203
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
204
205
        if (stream_fmt)
206
            fmt = stream_fmt;
207
    }
208
209
    return fmt;
210
}
211
212 115329f1 Diego Biurrun
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
213 5b6d5596 Michael Niedermayer
                            const char *filename, const char *mime_type, enum CodecType type){
214
    if(type == CODEC_TYPE_VIDEO){
215
        enum CodecID codec_id= CODEC_ID_NONE;
216
217 ff70e601 Måns Rullgård
#ifdef CONFIG_IMAGE2_MUXER
218 ae214ac3 Michael Niedermayer
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
219 5b6d5596 Michael Niedermayer
            codec_id= av_guess_image2_codec(filename);
220
        }
221 ff70e601 Måns Rullgård
#endif
222 5b6d5596 Michael Niedermayer
        if(codec_id == CODEC_ID_NONE)
223
            codec_id= fmt->video_codec;
224
        return codec_id;
225
    }else if(type == CODEC_TYPE_AUDIO)
226
        return fmt->audio_codec;
227
    else
228
        return CODEC_ID_NONE;
229
}
230
231 b9a281db Fabrice Bellard
AVInputFormat *av_find_input_format(const char *short_name)
232
{
233
    AVInputFormat *fmt;
234
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
235
        if (!strcmp(fmt->name, short_name))
236
            return fmt;
237
    }
238
    return NULL;
239
}
240
241 de6d9b64 Fabrice Bellard
/* memory handling */
242
243 90ad92b3 Michael Niedermayer
void av_destruct_packet(AVPacket *pkt)
244 6fa5a56c Fabrice Bellard
{
245
    av_free(pkt->data);
246
    pkt->data = NULL; pkt->size = 0;
247
}
248
249 659596f0 Ramiro Polla
void av_init_packet(AVPacket *pkt)
250
{
251
    pkt->pts   = AV_NOPTS_VALUE;
252
    pkt->dts   = AV_NOPTS_VALUE;
253
    pkt->pos   = -1;
254
    pkt->duration = 0;
255 a2636c0f Michael Niedermayer
    pkt->convergence_duration = 0;
256 659596f0 Ramiro Polla
    pkt->flags = 0;
257
    pkt->stream_index = 0;
258
    pkt->destruct= av_destruct_packet_nofree;
259
}
260
261 de6d9b64 Fabrice Bellard
int av_new_packet(AVPacket *pkt, int size)
262
{
263 55bdd34d Baptiste Coudurier
    uint8_t *data;
264 568e18b1 Michael Niedermayer
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
265 769e10f0 Panagiotis Issaris
        return AVERROR(ENOMEM);
266 568e18b1 Michael Niedermayer
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
267 6fa5a56c Fabrice Bellard
    if (!data)
268 769e10f0 Panagiotis Issaris
        return AVERROR(ENOMEM);
269 6fa5a56c Fabrice Bellard
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
270 8cd5be98 Michael Niedermayer
271 6fa5a56c Fabrice Bellard
    av_init_packet(pkt);
272 115329f1 Diego Biurrun
    pkt->data = data;
273 6fa5a56c Fabrice Bellard
    pkt->size = size;
274
    pkt->destruct = av_destruct_packet;
275 de6d9b64 Fabrice Bellard
    return 0;
276
}
277
278 2692067a Michael Niedermayer
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
279
{
280
    int ret= av_new_packet(pkt, size);
281
282
    if(ret<0)
283
        return ret;
284
285
    pkt->pos= url_ftell(s);
286
287
    ret= get_buffer(s, pkt->data, size);
288
    if(ret<=0)
289
        av_free_packet(pkt);
290
    else
291
        pkt->size= ret;
292
293
    return ret;
294
}
295
296 fb2758c8 Fabrice Bellard
int av_dup_packet(AVPacket *pkt)
297
{
298 65007a4f Luca Abeni
    if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
299 fb2758c8 Fabrice Bellard
        uint8_t *data;
300 a85736f2 Diego Biurrun
        /* We duplicate the packet and don't forget to add the padding again. */
301 568e18b1 Michael Niedermayer
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
302 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
303 8a56ac7b Fabrice Bellard
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
304 fb2758c8 Fabrice Bellard
        if (!data) {
305 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
306 fb2758c8 Fabrice Bellard
        }
307
        memcpy(data, pkt->data, pkt->size);
308 8a56ac7b Fabrice Bellard
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
309 fb2758c8 Fabrice Bellard
        pkt->data = data;
310
        pkt->destruct = av_destruct_packet;
311
    }
312
    return 0;
313
}
314
315 5c07cf53 Michel Bardiaux
int av_filename_number_test(const char *filename)
316 b9a281db Fabrice Bellard
{
317
    char buf[1024];
318 5c07cf53 Michel Bardiaux
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
319 b9a281db Fabrice Bellard
}
320
321 79750486 Michael Niedermayer
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
322 b9a281db Fabrice Bellard
{
323
    AVInputFormat *fmt1, *fmt;
324 79750486 Michael Niedermayer
    int score;
325 b9a281db Fabrice Bellard
326
    fmt = NULL;
327
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
328 b8e705ec Reimar Döffinger
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
329 b9a281db Fabrice Bellard
            continue;
330
        score = 0;
331 a8dbe951 Philip Gladstone
        if (fmt1->read_probe) {
332
            score = fmt1->read_probe(pd);
333
        } else if (fmt1->extensions) {
334 b9a281db Fabrice Bellard
            if (match_ext(pd->filename, fmt1->extensions)) {
335
                score = 50;
336
            }
337 115329f1 Diego Biurrun
        }
338 79750486 Michael Niedermayer
        if (score > *score_max) {
339
            *score_max = score;
340 b9a281db Fabrice Bellard
            fmt = fmt1;
341 4b3cca36 Michael Niedermayer
        }else if (score == *score_max)
342
            fmt = NULL;
343 b9a281db Fabrice Bellard
    }
344
    return fmt;
345
}
346
347 79750486 Michael Niedermayer
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
348
    int score=0;
349
    return av_probe_input_format2(pd, is_opened, &score);
350
}
351
352 64cd3108 Michael Niedermayer
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
353
{
354
    AVInputFormat *fmt;
355
    fmt = av_probe_input_format2(pd, 1, &score);
356
357
    if (fmt) {
358 f1588ed5 Andreas Öman
        if (!strcmp(fmt->name, "mp3")) {
359 64cd3108 Michael Niedermayer
            st->codec->codec_id = CODEC_ID_MP3;
360 f1588ed5 Andreas Öman
            st->codec->codec_type = CODEC_TYPE_AUDIO;
361
        } else if (!strcmp(fmt->name, "ac3")) {
362 64cd3108 Michael Niedermayer
            st->codec->codec_id = CODEC_ID_AC3;
363 f1588ed5 Andreas Öman
            st->codec->codec_type = CODEC_TYPE_AUDIO;
364
        } else if (!strcmp(fmt->name, "mpegvideo")) {
365 312d24d5 Michael Niedermayer
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
366 f1588ed5 Andreas Öman
            st->codec->codec_type = CODEC_TYPE_VIDEO;
367 74aa41ba Michael Niedermayer
        } else if (!strcmp(fmt->name, "m4v")) {
368
            st->codec->codec_id = CODEC_ID_MPEG4;
369
            st->codec->codec_type = CODEC_TYPE_VIDEO;
370 f1588ed5 Andreas Öman
        } else if (!strcmp(fmt->name, "h264")) {
371 312d24d5 Michael Niedermayer
            st->codec->codec_id = CODEC_ID_H264;
372 f1588ed5 Andreas Öman
            st->codec->codec_type = CODEC_TYPE_VIDEO;
373
        }
374 64cd3108 Michael Niedermayer
    }
375
    return !!fmt;
376
}
377
378 b9a281db Fabrice Bellard
/************************************************************/
379
/* input media file */
380 96baaa6a Fabrice Bellard
381 da24c5e3 Fabrice Bellard
/**
382 e36bdf8b Daniel Kristjansson
 * Open a media file from an IO stream. 'fmt' must be specified.
383 da24c5e3 Fabrice Bellard
 */
384 115329f1 Diego Biurrun
int av_open_input_stream(AVFormatContext **ic_ptr,
385
                         ByteIOContext *pb, const char *filename,
386 da24c5e3 Fabrice Bellard
                         AVInputFormat *fmt, AVFormatParameters *ap)
387
{
388
    int err;
389
    AVFormatContext *ic;
390 c04c3282 Michael Niedermayer
    AVFormatParameters default_ap;
391
392
    if(!ap){
393
        ap=&default_ap;
394
        memset(ap, 0, sizeof(default_ap));
395
    }
396 da24c5e3 Fabrice Bellard
397 4eb72c6b Nico Sabbi
    if(!ap->prealloced_context)
398
        ic = av_alloc_format_context();
399
    else
400
        ic = *ic_ptr;
401 da24c5e3 Fabrice Bellard
    if (!ic) {
402 769e10f0 Panagiotis Issaris
        err = AVERROR(ENOMEM);
403 da24c5e3 Fabrice Bellard
        goto fail;
404
    }
405
    ic->iformat = fmt;
406 899681cd Björn Axelsson
    ic->pb = pb;
407 da24c5e3 Fabrice Bellard
    ic->duration = AV_NOPTS_VALUE;
408
    ic->start_time = AV_NOPTS_VALUE;
409 75e61b0e Måns Rullgård
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
410 da24c5e3 Fabrice Bellard
411
    /* allocate private data */
412
    if (fmt->priv_data_size > 0) {
413
        ic->priv_data = av_mallocz(fmt->priv_data_size);
414
        if (!ic->priv_data) {
415 769e10f0 Panagiotis Issaris
            err = AVERROR(ENOMEM);
416 da24c5e3 Fabrice Bellard
            goto fail;
417
        }
418
    } else {
419
        ic->priv_data = NULL;
420
    }
421
422 e145ce20 Ronald S. Bultje
    if (ic->iformat->read_header) {
423 1e2802c5 Ronald S. Bultje
        err = ic->iformat->read_header(ic, ap);
424
        if (err < 0)
425
            goto fail;
426 e145ce20 Ronald S. Bultje
    }
427 fb2758c8 Fabrice Bellard
428 faf7cbf1 Michael Niedermayer
    if (pb && !ic->data_offset)
429 899681cd Björn Axelsson
        ic->data_offset = url_ftell(ic->pb);
430 fb2758c8 Fabrice Bellard
431 e99f76ab Aurelien Jacobs
#if LIBAVFORMAT_VERSION_MAJOR < 53
432
    ff_metadata_demux_compat(ic);
433
#endif
434
435 da24c5e3 Fabrice Bellard
    *ic_ptr = ic;
436
    return 0;
437
 fail:
438
    if (ic) {
439 ccafd472 Baptiste Coudurier
        int i;
440 da24c5e3 Fabrice Bellard
        av_freep(&ic->priv_data);
441 ccafd472 Baptiste Coudurier
        for(i=0;i<ic->nb_streams;i++) {
442
            AVStream *st = ic->streams[i];
443
            if (st) {
444
                av_free(st->priv_data);
445
                av_free(st->codec->extradata);
446
            }
447
            av_free(st);
448
        }
449 da24c5e3 Fabrice Bellard
    }
450
    av_free(ic);
451
    *ic_ptr = NULL;
452
    return err;
453
}
454
455 a85736f2 Diego Biurrun
/** size of probe buffer, for guessing file type from file contents */
456 a877eedc Michael Niedermayer
#define PROBE_BUF_MIN 2048
457 329b1e75 Michael Niedermayer
#define PROBE_BUF_MAX (1<<20)
458 b9a281db Fabrice Bellard
459 115329f1 Diego Biurrun
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
460 b9a281db Fabrice Bellard
                       AVInputFormat *fmt,
461
                       int buf_size,
462
                       AVFormatParameters *ap)
463 de6d9b64 Fabrice Bellard
{
464 17acc63a Reimar Döffinger
    int err, probe_size;
465 b9a281db Fabrice Bellard
    AVProbeData probe_data, *pd = &probe_data;
466 17acc63a Reimar Döffinger
    ByteIOContext *pb = NULL;
467 115329f1 Diego Biurrun
468 da24c5e3 Fabrice Bellard
    pd->filename = "";
469
    if (filename)
470
        pd->filename = filename;
471 a877eedc Michael Niedermayer
    pd->buf = NULL;
472 b9a281db Fabrice Bellard
    pd->buf_size = 0;
473
474
    if (!fmt) {
475 a85736f2 Diego Biurrun
        /* guess format if no file can be opened */
476 a25e098d Fabrice Bellard
        fmt = av_probe_input_format(pd, 0);
477 de6d9b64 Fabrice Bellard
    }
478
479 a85736f2 Diego Biurrun
    /* Do not open file if the format does not need it. XXX: specific
480 b6892136 Fabrice Bellard
       hack needed to handle RTSP/TCP */
481 17acc63a Reimar Döffinger
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
482 87a0a681 Fabrice Bellard
        /* if no file needed do not try to open one */
483 899681cd Björn Axelsson
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
484 96baaa6a Fabrice Bellard
            goto fail;
485 b9a281db Fabrice Bellard
        }
486 96baaa6a Fabrice Bellard
        if (buf_size > 0) {
487 da24c5e3 Fabrice Bellard
            url_setbufsize(pb, buf_size);
488 96baaa6a Fabrice Bellard
        }
489 a877eedc Michael Niedermayer
490
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
491 79750486 Michael Niedermayer
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
492 5b25dfa7 Fabrice Bellard
            /* read probe data */
493 87e87886 Michael Niedermayer
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
494 a877eedc Michael Niedermayer
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
495 9be51815 Wolfram Gloger
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
496 497244a8 Baptiste Coudurier
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
497 53e2f9ca Michael Niedermayer
                url_fclose(pb);
498 899681cd Björn Axelsson
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
499 17acc63a Reimar Döffinger
                    pb = NULL;
500 6f3e0b21 Panagiotis Issaris
                    err = AVERROR(EIO);
501 53e2f9ca Michael Niedermayer
                    goto fail;
502
                }
503
            }
504 a877eedc Michael Niedermayer
            /* guess file format */
505 79750486 Michael Niedermayer
            fmt = av_probe_input_format2(pd, 1, &score);
506 5b25dfa7 Fabrice Bellard
        }
507 a877eedc Michael Niedermayer
        av_freep(&pd->buf);
508 b9a281db Fabrice Bellard
    }
509
510
    /* if still no format found, error */
511
    if (!fmt) {
512
        err = AVERROR_NOFMT;
513 da24c5e3 Fabrice Bellard
        goto fail;
514 de6d9b64 Fabrice Bellard
    }
515 115329f1 Diego Biurrun
516 a85736f2 Diego Biurrun
    /* check filename in case an image number is expected */
517 da24c5e3 Fabrice Bellard
    if (fmt->flags & AVFMT_NEEDNUMBER) {
518 5c07cf53 Michel Bardiaux
        if (!av_filename_number_test(filename)) {
519 87a0a681 Fabrice Bellard
            err = AVERROR_NUMEXPECTED;
520 da24c5e3 Fabrice Bellard
            goto fail;
521 87a0a681 Fabrice Bellard
        }
522
    }
523 da24c5e3 Fabrice Bellard
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
524
    if (err)
525
        goto fail;
526 b9a281db Fabrice Bellard
    return 0;
527 de6d9b64 Fabrice Bellard
 fail:
528 a877eedc Michael Niedermayer
    av_freep(&pd->buf);
529 17acc63a Reimar Döffinger
    if (pb)
530 da24c5e3 Fabrice Bellard
        url_fclose(pb);
531 b9a281db Fabrice Bellard
    *ic_ptr = NULL;
532
    return err;
533 115329f1 Diego Biurrun
534 de6d9b64 Fabrice Bellard
}
535
536 da24c5e3 Fabrice Bellard
/*******************************************************/
537
538 5c5b1731 Måns Rullgård
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
539
                               AVPacketList **plast_pktl){
540
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
541 9d3b9f2c Michael Niedermayer
    if (!pktl)
542
        return NULL;
543
544 5c5b1731 Måns Rullgård
    if (*packet_buffer)
545
        (*plast_pktl)->next = pktl;
546
    else
547
        *packet_buffer = pktl;
548
549 9d3b9f2c Michael Niedermayer
    /* add the packet in the buffered packet list */
550
    *plast_pktl = pktl;
551
    pktl->pkt= *pkt;
552
    return &pktl->pkt;
553
}
554
555 de6d9b64 Fabrice Bellard
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
556
{
557 62600469 Michael Niedermayer
    int ret;
558
    AVStream *st;
559 0bef08e5 Michael Niedermayer
560
    for(;;){
561
        AVPacketList *pktl = s->raw_packet_buffer;
562
563
        if (pktl) {
564
            *pkt = pktl->pkt;
565
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
566
                s->raw_packet_buffer = pktl->next;
567
                av_free(pktl);
568
                return 0;
569
            }
570
        }
571
572 55823964 Michael Niedermayer
        av_init_packet(pkt);
573
        ret= s->iformat->read_packet(s, pkt);
574
        if (ret < 0)
575
            return ret;
576
        st= s->streams[pkt->stream_index];
577 62600469 Michael Niedermayer
578 55823964 Michael Niedermayer
        switch(st->codec->codec_type){
579
        case CODEC_TYPE_VIDEO:
580
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
581
            break;
582
        case CODEC_TYPE_AUDIO:
583
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
584
            break;
585
        case CODEC_TYPE_SUBTITLE:
586
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
587
            break;
588
        }
589 62600469 Michael Niedermayer
590 744b4c02 Michael Niedermayer
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
591
            return ret;
592
593 5c5b1731 Måns Rullgård
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
594 744b4c02 Michael Niedermayer
595 0bef08e5 Michael Niedermayer
        if(st->codec->codec_id == CODEC_ID_PROBE){
596
            AVProbeData *pd = &st->probe_data;
597
598
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
599
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
600
            pd->buf_size += pkt->size;
601
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
602
603 942de2f4 Michael Niedermayer
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
604 25d3fb73 Michael Niedermayer
                set_codec_from_probe_data(st, pd, 1);
605
                if(st->codec->codec_id != CODEC_ID_PROBE){
606
                    pd->buf_size=0;
607
                    av_freep(&pd->buf);
608
                }
609 942de2f4 Michael Niedermayer
            }
610 0bef08e5 Michael Niedermayer
        }
611
    }
612 fb2758c8 Fabrice Bellard
}
613
614
/**********************************************************/
615
616 e36bdf8b Daniel Kristjansson
/**
617 a85736f2 Diego Biurrun
 * Get the number of samples of an audio frame. Return -1 on error.
618 e36bdf8b Daniel Kristjansson
 */
619 fb2758c8 Fabrice Bellard
static int get_audio_frame_size(AVCodecContext *enc, int size)
620
{
621
    int frame_size;
622
623 c924ca78 Michael Niedermayer
    if(enc->codec_id == CODEC_ID_VORBIS)
624
        return -1;
625
626 fb2758c8 Fabrice Bellard
    if (enc->frame_size <= 1) {
627 ac3e1834 Baptiste Coudurier
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
628
629
        if (bits_per_sample) {
630 fb2758c8 Fabrice Bellard
            if (enc->channels == 0)
631
                return -1;
632 f1b163e0 Aurelien Jacobs
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
633 ac3e1834 Baptiste Coudurier
        } else {
634 fb2758c8 Fabrice Bellard
            /* used for example by ADPCM codecs */
635
            if (enc->bit_rate == 0)
636
                return -1;
637
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
638
        }
639
    } else {
640
        frame_size = enc->frame_size;
641
    }
642
    return frame_size;
643
}
644
645
646 e36bdf8b Daniel Kristjansson
/**
647 a85736f2 Diego Biurrun
 * Return the frame duration in seconds. Return 0 if not available.
648 e36bdf8b Daniel Kristjansson
 */
649 115329f1 Diego Biurrun
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
650 fb2758c8 Fabrice Bellard
                                   AVCodecParserContext *pc, AVPacket *pkt)
651
{
652
    int frame_size;
653
654
    *pnum = 0;
655
    *pden = 0;
656 01f4895c Michael Niedermayer
    switch(st->codec->codec_type) {
657 fb2758c8 Fabrice Bellard
    case CODEC_TYPE_VIDEO:
658 1677155d Michael Niedermayer
        if(st->time_base.num*1000LL > st->time_base.den){
659 c0df9d75 Michael Niedermayer
            *pnum = st->time_base.num;
660
            *pden = st->time_base.den;
661 01f4895c Michael Niedermayer
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
662
            *pnum = st->codec->time_base.num;
663
            *pden = st->codec->time_base.den;
664 327c4076 Michael Niedermayer
            if (pc && pc->repeat_pict) {
665
                *pden *= 2;
666
                *pnum = (*pnum) * (2 + pc->repeat_pict);
667
            }
668 fb2758c8 Fabrice Bellard
        }
669
        break;
670
    case CODEC_TYPE_AUDIO:
671 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
672 fb2758c8 Fabrice Bellard
        if (frame_size < 0)
673
            break;
674
        *pnum = frame_size;
675 01f4895c Michael Niedermayer
        *pden = st->codec->sample_rate;
676 fb2758c8 Fabrice Bellard
        break;
677
    default:
678
        break;
679
    }
680
}
681
682 5ba7c3d7 Michael Niedermayer
static int is_intra_only(AVCodecContext *enc){
683
    if(enc->codec_type == CODEC_TYPE_AUDIO){
684
        return 1;
685
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
686
        switch(enc->codec_id){
687
        case CODEC_ID_MJPEG:
688
        case CODEC_ID_MJPEGB:
689
        case CODEC_ID_LJPEG:
690
        case CODEC_ID_RAWVIDEO:
691
        case CODEC_ID_DVVIDEO:
692
        case CODEC_ID_HUFFYUV:
693 f37b9768 Loren Merritt
        case CODEC_ID_FFVHUFF:
694 5ba7c3d7 Michael Niedermayer
        case CODEC_ID_ASV1:
695
        case CODEC_ID_ASV2:
696
        case CODEC_ID_VCR1:
697 b774fdd7 Baptiste Coudurier
        case CODEC_ID_DNXHD:
698 5ba7c3d7 Michael Niedermayer
            return 1;
699
        default: break;
700
        }
701
    }
702
    return 0;
703
}
704
705 9fcbcca6 Neil Brown
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
706
                                      int64_t dts, int64_t pts)
707
{
708 82583548 Michael Niedermayer
    AVStream *st= s->streams[stream_index];
709
    AVPacketList *pktl= s->packet_buffer;
710
711 7efeb73a Michael Niedermayer
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
712 82583548 Michael Niedermayer
        return;
713
714
    st->first_dts= dts - st->cur_dts;
715
    st->cur_dts= dts;
716
717
    for(; pktl; pktl= pktl->next){
718
        if(pktl->pkt.stream_index != stream_index)
719
            continue;
720
        //FIXME think more about this check
721
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
722
            pktl->pkt.pts += st->first_dts;
723
724
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
725
            pktl->pkt.dts += st->first_dts;
726 48a59dfe Michael Niedermayer
727
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
728
            st->start_time= pktl->pkt.pts;
729 82583548 Michael Niedermayer
    }
730 9fcbcca6 Neil Brown
    if (st->start_time == AV_NOPTS_VALUE)
731
        st->start_time = pts;
732 82583548 Michael Niedermayer
}
733
734 83a9db42 Michael Niedermayer
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
735
{
736
    AVPacketList *pktl= s->packet_buffer;
737 820ad60c Michael Niedermayer
    int64_t cur_dts= 0;
738
739
    if(st->first_dts != AV_NOPTS_VALUE){
740
        cur_dts= st->first_dts;
741
        for(; pktl; pktl= pktl->next){
742
            if(pktl->pkt.stream_index == pkt->stream_index){
743
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
744
                    break;
745
                cur_dts -= pkt->duration;
746
            }
747
        }
748
        pktl= s->packet_buffer;
749
        st->first_dts = cur_dts;
750
    }else if(st->cur_dts)
751
        return;
752 83a9db42 Michael Niedermayer
753
    for(; pktl; pktl= pktl->next){
754
        if(pktl->pkt.stream_index != pkt->stream_index)
755
            continue;
756 91acf9a8 Michael Niedermayer
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
757
           && !pktl->pkt.duration){
758 820ad60c Michael Niedermayer
            pktl->pkt.dts= cur_dts;
759 5853423c Michael Niedermayer
            if(!st->codec->has_b_frames)
760 820ad60c Michael Niedermayer
                pktl->pkt.pts= cur_dts;
761
            cur_dts += pkt->duration;
762 83a9db42 Michael Niedermayer
            pktl->pkt.duration= pkt->duration;
763
        }else
764
            break;
765
    }
766 820ad60c Michael Niedermayer
    if(st->first_dts == AV_NOPTS_VALUE)
767
        st->cur_dts= cur_dts;
768 83a9db42 Michael Niedermayer
}
769
770 115329f1 Diego Biurrun
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
771 fb2758c8 Fabrice Bellard
                               AVCodecParserContext *pc, AVPacket *pkt)
772
{
773 d9e1efb7 Michael Niedermayer
    int num, den, presentation_delayed, delay, i;
774 a74008a4 Joakim Plate
    int64_t offset;
775 115329f1 Diego Biurrun
776 f781f748 Michael Niedermayer
    /* do we have a video B-frame ? */
777
    delay= st->codec->has_b_frames;
778
    presentation_delayed = 0;
779
    /* XXX: need has_b_frame, but cannot get it if the codec is
780
        not initialized */
781
    if (delay &&
782
        pc && pc->pict_type != FF_B_TYPE)
783
        presentation_delayed = 1;
784
785 10a7571b Michael Niedermayer
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
786
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
787
        pkt->dts -= 1LL<<st->pts_wrap_bits;
788
    }
789
790 9806f846 Michael Niedermayer
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
791
    // we take the conservative approach and discard both
792
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
793
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
794
        av_log(s, AV_LOG_ERROR, "invalid dts/pts combination\n");
795
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
796
    }
797
798 fb2758c8 Fabrice Bellard
    if (pkt->duration == 0) {
799 3c895fc0 Michael Niedermayer
        compute_frame_duration(&num, &den, st, pc, pkt);
800 fb2758c8 Fabrice Bellard
        if (den && num) {
801 77405fc8 Michael Niedermayer
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
802 83a9db42 Michael Niedermayer
803 820ad60c Michael Niedermayer
            if(pkt->duration != 0 && s->packet_buffer)
804 83a9db42 Michael Niedermayer
                update_initial_durations(s, st, pkt);
805 fb2758c8 Fabrice Bellard
        }
806
    }
807
808 a85736f2 Diego Biurrun
    /* correct timestamps with byte offset if demuxers only have timestamps
809
       on packet boundaries */
810 a74008a4 Joakim Plate
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
811
        /* this will estimate bitrate based on this frame's duration and size */
812
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
813
        if(pkt->pts != AV_NOPTS_VALUE)
814
            pkt->pts += offset;
815
        if(pkt->dts != AV_NOPTS_VALUE)
816
            pkt->dts += offset;
817
    }
818
819 755bfeab Diego Biurrun
    /* This may be redundant, but it should not hurt. */
820 7e4baa66 Michael Niedermayer
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
821
        presentation_delayed = 1;
822 115329f1 Diego Biurrun
823 949b1a13 Steve L'Homme
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
824 fb2758c8 Fabrice Bellard
    /* interpolate PTS and DTS if they are not present */
825 406a0fdc Michael Niedermayer
    if(delay==0 || (delay==1 && pc)){
826 7e4baa66 Michael Niedermayer
        if (presentation_delayed) {
827 a85736f2 Diego Biurrun
            /* DTS = decompression timestamp */
828
            /* PTS = presentation timestamp */
829 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
830 635fbcb1 Michael Niedermayer
                pkt->dts = st->last_IP_pts;
831 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
832 7e4baa66 Michael Niedermayer
            if (pkt->dts == AV_NOPTS_VALUE)
833
                pkt->dts = st->cur_dts;
834
835
            /* this is tricky: the dts must be incremented by the duration
836 a85736f2 Diego Biurrun
            of the frame we are displaying, i.e. the last I- or P-frame */
837 635fbcb1 Michael Niedermayer
            if (st->last_IP_duration == 0)
838
                st->last_IP_duration = pkt->duration;
839 7efeb73a Michael Niedermayer
            if(pkt->dts != AV_NOPTS_VALUE)
840 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->dts + st->last_IP_duration;
841 635fbcb1 Michael Niedermayer
            st->last_IP_duration  = pkt->duration;
842
            st->last_IP_pts= pkt->pts;
843 7e4baa66 Michael Niedermayer
            /* cannot compute PTS if not present (we can compute it only
844 a85736f2 Diego Biurrun
            by knowing the future */
845 028d6f3e Michael Niedermayer
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
846 7e4baa66 Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
847
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
848
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
849
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
850
                    pkt->pts += pkt->duration;
851
    //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
852
                }
853 90bb394d Michael Niedermayer
            }
854 115329f1 Diego Biurrun
855 7e4baa66 Michael Niedermayer
            /* presentation is not delayed : PTS and DTS are the same */
856
            if(pkt->pts == AV_NOPTS_VALUE)
857
                pkt->pts = pkt->dts;
858 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
859 7e4baa66 Michael Niedermayer
            if(pkt->pts == AV_NOPTS_VALUE)
860
                pkt->pts = st->cur_dts;
861
            pkt->dts = pkt->pts;
862 7efeb73a Michael Niedermayer
            if(pkt->pts != AV_NOPTS_VALUE)
863 cdb5af79 Michael Niedermayer
                st->cur_dts = pkt->pts + pkt->duration;
864 7e4baa66 Michael Niedermayer
        }
865 fb2758c8 Fabrice Bellard
    }
866 d9e1efb7 Michael Niedermayer
867 cb5b96cd Baptiste Coudurier
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
868 d9e1efb7 Michael Niedermayer
        st->pts_buffer[0]= pkt->pts;
869
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
870
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
871
        if(pkt->dts == AV_NOPTS_VALUE)
872
            pkt->dts= st->pts_buffer[0];
873 82583548 Michael Niedermayer
        if(delay>1){
874 9fcbcca6 Neil Brown
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
875 82583548 Michael Niedermayer
        }
876 d9e1efb7 Michael Niedermayer
        if(pkt->dts > st->cur_dts)
877
            st->cur_dts = pkt->dts;
878
    }
879
880
//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
881 115329f1 Diego Biurrun
882 fb2758c8 Fabrice Bellard
    /* update flags */
883 3a1d3588 Jeff Downs
    if(is_intra_only(st->codec))
884
        pkt->flags |= PKT_FLAG_KEY;
885
    else if (pc) {
886 fb2758c8 Fabrice Bellard
        pkt->flags = 0;
887 a85736f2 Diego Biurrun
        /* keyframe computation */
888 fb2758c8 Fabrice Bellard
            if (pc->pict_type == FF_I_TYPE)
889
                pkt->flags |= PKT_FLAG_KEY;
890
    }
891
}
892
893 63dd1377 Michael Niedermayer
void av_destruct_packet_nofree(AVPacket *pkt)
894 fb2758c8 Fabrice Bellard
{
895
    pkt->data = NULL; pkt->size = 0;
896
}
897
898
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
899
{
900
    AVStream *st;
901 37353960 Fabrice Bellard
    int len, ret, i;
902 fb2758c8 Fabrice Bellard
903 b237eb80 Michael Niedermayer
    av_init_packet(pkt);
904
905 fb2758c8 Fabrice Bellard
    for(;;) {
906
        /* select current input stream component */
907
        st = s->cur_st;
908
        if (st) {
909 90ad92b3 Michael Niedermayer
            if (!st->need_parsing || !st->parser) {
910 fb2758c8 Fabrice Bellard
                /* no parsing needed: we just output the packet as is */
911
                /* raw data support */
912
                *pkt = s->cur_pkt;
913
                compute_pkt_fields(s, st, NULL, pkt);
914
                s->cur_st = NULL;
915 434cab9e Michael Niedermayer
                break;
916 f3356e9c Michael Niedermayer
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
917 115329f1 Diego Biurrun
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
918 6ec87caa Fabrice Bellard
                                      s->cur_ptr, s->cur_len,
919
                                      s->cur_pkt.pts, s->cur_pkt.dts);
920
                s->cur_pkt.pts = AV_NOPTS_VALUE;
921
                s->cur_pkt.dts = AV_NOPTS_VALUE;
922 fb2758c8 Fabrice Bellard
                /* increment read pointer */
923
                s->cur_ptr += len;
924
                s->cur_len -= len;
925 115329f1 Diego Biurrun
926 fb2758c8 Fabrice Bellard
                /* return packet if any */
927
                if (pkt->size) {
928 37353960 Fabrice Bellard
                got_packet:
929 711737af Daniel Cardenas
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
930 fb2758c8 Fabrice Bellard
                    pkt->duration = 0;
931
                    pkt->stream_index = st->index;
932 6ec87caa Fabrice Bellard
                    pkt->pts = st->parser->pts;
933
                    pkt->dts = st->parser->dts;
934 fb2758c8 Fabrice Bellard
                    pkt->destruct = av_destruct_packet_nofree;
935
                    compute_pkt_fields(s, st, st->parser, pkt);
936 e9b78eeb Michael Niedermayer
937
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
938 3dea63bd Paul Kelly
                        ff_reduce_index(s, st->index);
939 e9b78eeb Michael Niedermayer
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
940
                                           0, 0, AVINDEX_KEYFRAME);
941
                    }
942
943 434cab9e Michael Niedermayer
                    break;
944 fb2758c8 Fabrice Bellard
                }
945
            } else {
946 bcbecff1 Fabrice Bellard
                /* free packet */
947 115329f1 Diego Biurrun
                av_free_packet(&s->cur_pkt);
948 fb2758c8 Fabrice Bellard
                s->cur_st = NULL;
949
            }
950
        } else {
951
            /* read next packet */
952
            ret = av_read_packet(s, &s->cur_pkt);
953 37353960 Fabrice Bellard
            if (ret < 0) {
954 8fa36ae0 François Revol
                if (ret == AVERROR(EAGAIN))
955 37353960 Fabrice Bellard
                    return ret;
956
                /* return the last frames, if any */
957
                for(i = 0; i < s->nb_streams; i++) {
958
                    st = s->streams[i];
959 90ad92b3 Michael Niedermayer
                    if (st->parser && st->need_parsing) {
960 115329f1 Diego Biurrun
                        av_parser_parse(st->parser, st->codec,
961
                                        &pkt->data, &pkt->size,
962
                                        NULL, 0,
963 6ec87caa Fabrice Bellard
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
964 37353960 Fabrice Bellard
                        if (pkt->size)
965
                            goto got_packet;
966
                    }
967
                }
968 a85736f2 Diego Biurrun
                /* no more packets: really terminate parsing */
969 fb2758c8 Fabrice Bellard
                return ret;
970 37353960 Fabrice Bellard
            }
971 115329f1 Diego Biurrun
972 b18a4ab2 Michael Niedermayer
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
973
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
974
               s->cur_pkt.pts < s->cur_pkt.dts){
975
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
976
                    s->cur_pkt.stream_index,
977
                    s->cur_pkt.pts,
978
                    s->cur_pkt.dts,
979
                    s->cur_pkt.size);
980
//                av_free_packet(&s->cur_pkt);
981
//                return -1;
982
            }
983
984 9ee91c2f Michael Niedermayer
            st = s->streams[s->cur_pkt.stream_index];
985 45b2b05f Michael Niedermayer
            if(s->debug & FF_FDEBUG_TS)
986 3041a4a1 Michael Niedermayer
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
987 434cab9e Michael Niedermayer
                    s->cur_pkt.stream_index,
988
                    s->cur_pkt.pts,
989
                    s->cur_pkt.dts,
990 3041a4a1 Michael Niedermayer
                    s->cur_pkt.size,
991
                    s->cur_pkt.flags);
992 fb2758c8 Fabrice Bellard
993
            s->cur_st = st;
994
            s->cur_ptr = s->cur_pkt.data;
995
            s->cur_len = s->cur_pkt.size;
996
            if (st->need_parsing && !st->parser) {
997 01f4895c Michael Niedermayer
                st->parser = av_parser_init(st->codec->codec_id);
998 fb2758c8 Fabrice Bellard
                if (!st->parser) {
999 a85736f2 Diego Biurrun
                    /* no parser available: just output the raw packets */
1000 57004ff1 Aurelien Jacobs
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1001
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1002 7cbaa7ba Michael Niedermayer
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1003 fb2758c8 Fabrice Bellard
                }
1004 e9b78eeb Michael Niedermayer
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1005 c5577c40 Baptiste Coudurier
                    st->parser->next_frame_offset=
1006 e9b78eeb Michael Niedermayer
                    st->parser->cur_offset= s->cur_pkt.pos;
1007
                }
1008 fb2758c8 Fabrice Bellard
            }
1009
        }
1010
    }
1011 45b2b05f Michael Niedermayer
    if(s->debug & FF_FDEBUG_TS)
1012 3041a4a1 Michael Niedermayer
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1013 434cab9e Michael Niedermayer
            pkt->stream_index,
1014
            pkt->pts,
1015
            pkt->dts,
1016 3041a4a1 Michael Niedermayer
            pkt->size,
1017
            pkt->flags);
1018 434cab9e Michael Niedermayer
1019
    return 0;
1020 fb2758c8 Fabrice Bellard
}
1021
1022
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1023
{
1024 de6d9b64 Fabrice Bellard
    AVPacketList *pktl;
1025 30bc6613 Michael Niedermayer
    int eof=0;
1026
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1027
1028
    for(;;){
1029
        pktl = s->packet_buffer;
1030
        if (pktl) {
1031
            AVPacket *next_pkt= &pktl->pkt;
1032
1033
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1034
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1035 115329f1 Diego Biurrun
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1036 30bc6613 Michael Niedermayer
                       && next_pkt->dts < pktl->pkt.dts
1037
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1038
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1039
                        next_pkt->pts= pktl->pkt.dts;
1040
                    }
1041
                    pktl= pktl->next;
1042
                }
1043
                pktl = s->packet_buffer;
1044
            }
1045 115329f1 Diego Biurrun
1046
            if(   next_pkt->pts != AV_NOPTS_VALUE
1047
               || next_pkt->dts == AV_NOPTS_VALUE
1048 30bc6613 Michael Niedermayer
               || !genpts || eof){
1049
                /* read packet from packet buffer, if there is data */
1050
                *pkt = *next_pkt;
1051
                s->packet_buffer = pktl->next;
1052
                av_free(pktl);
1053
                return 0;
1054
            }
1055
        }
1056
        if(genpts){
1057
            int ret= av_read_frame_internal(s, pkt);
1058
            if(ret<0){
1059 8fa36ae0 François Revol
                if(pktl && ret != AVERROR(EAGAIN)){
1060 30bc6613 Michael Niedermayer
                    eof=1;
1061
                    continue;
1062
                }else
1063
                    return ret;
1064
            }
1065 115329f1 Diego Biurrun
1066 5c5b1731 Måns Rullgård
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1067
                                           &s->packet_buffer_end)) < 0)
1068 769e10f0 Panagiotis Issaris
                return AVERROR(ENOMEM);
1069 30bc6613 Michael Niedermayer
        }else{
1070
            assert(!s->packet_buffer);
1071
            return av_read_frame_internal(s, pkt);
1072
        }
1073 fb2758c8 Fabrice Bellard
    }
1074
}
1075
1076
/* XXX: suppress the packet queue */
1077
static void flush_packet_queue(AVFormatContext *s)
1078
{
1079
    AVPacketList *pktl;
1080
1081
    for(;;) {
1082
        pktl = s->packet_buffer;
1083 115329f1 Diego Biurrun
        if (!pktl)
1084 fb2758c8 Fabrice Bellard
            break;
1085
        s->packet_buffer = pktl->next;
1086
        av_free_packet(&pktl->pkt);
1087
        av_free(pktl);
1088 b9a281db Fabrice Bellard
    }
1089
}
1090
1091 da24c5e3 Fabrice Bellard
/*******************************************************/
1092 fb2758c8 Fabrice Bellard
/* seek support */
1093
1094 b754978a Michael Niedermayer
int av_find_default_stream_index(AVFormatContext *s)
1095
{
1096 ca162a50 Aurelien Jacobs
    int first_audio_index = -1;
1097 b754978a Michael Niedermayer
    int i;
1098
    AVStream *st;
1099
1100
    if (s->nb_streams <= 0)
1101
        return -1;
1102
    for(i = 0; i < s->nb_streams; i++) {
1103
        st = s->streams[i];
1104 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1105 b754978a Michael Niedermayer
            return i;
1106
        }
1107 ca162a50 Aurelien Jacobs
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1108
            first_audio_index = i;
1109 b754978a Michael Niedermayer
    }
1110 ca162a50 Aurelien Jacobs
    return first_audio_index >= 0 ? first_audio_index : 0;
1111 b754978a Michael Niedermayer
}
1112
1113 e36bdf8b Daniel Kristjansson
/**
1114
 * Flush the frame reader.
1115
 */
1116 fb2758c8 Fabrice Bellard
static void av_read_frame_flush(AVFormatContext *s)
1117
{
1118
    AVStream *st;
1119
    int i;
1120
1121
    flush_packet_queue(s);
1122
1123
    /* free previous packet */
1124
    if (s->cur_st) {
1125
        if (s->cur_st->parser)
1126
            av_free_packet(&s->cur_pkt);
1127
        s->cur_st = NULL;
1128
    }
1129
    /* fail safe */
1130
    s->cur_ptr = NULL;
1131
    s->cur_len = 0;
1132 115329f1 Diego Biurrun
1133 fb2758c8 Fabrice Bellard
    /* for each stream, reset read state */
1134
    for(i = 0; i < s->nb_streams; i++) {
1135
        st = s->streams[i];
1136 115329f1 Diego Biurrun
1137 fb2758c8 Fabrice Bellard
        if (st->parser) {
1138
            av_parser_close(st->parser);
1139
            st->parser = NULL;
1140
        }
1141 635fbcb1 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
1142 a843d1ff Michael Niedermayer
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1143 fb2758c8 Fabrice Bellard
    }
1144
}
1145
1146 22ffac70 Reimar Döffinger
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1147 8bcb147f Michael Niedermayer
    int i;
1148
1149
    for(i = 0; i < s->nb_streams; i++) {
1150 1a1dc611 Nathan Kurz
        AVStream *st = s->streams[i];
1151 8bcb147f Michael Niedermayer
1152 115329f1 Diego Biurrun
        st->cur_dts = av_rescale(timestamp,
1153 1a1dc611 Nathan Kurz
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1154
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1155 8bcb147f Michael Niedermayer
    }
1156
}
1157
1158 3dea63bd Paul Kelly
void ff_reduce_index(AVFormatContext *s, int stream_index)
1159
{
1160
    AVStream *st= s->streams[stream_index];
1161
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1162
1163
    if((unsigned)st->nb_index_entries >= max_entries){
1164
        int i;
1165
        for(i=0; 2*i<st->nb_index_entries; i++)
1166
            st->index_entries[i]= st->index_entries[2*i];
1167
        st->nb_index_entries= i;
1168
    }
1169
}
1170
1171 3e9245a9 Michael Niedermayer
int av_add_index_entry(AVStream *st,
1172 30a43f2d Michael Niedermayer
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1173 fb2758c8 Fabrice Bellard
{
1174
    AVIndexEntry *entries, *ie;
1175 b754978a Michael Niedermayer
    int index;
1176 115329f1 Diego Biurrun
1177 568e18b1 Michael Niedermayer
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1178
        return -1;
1179 115329f1 Diego Biurrun
1180 fb2758c8 Fabrice Bellard
    entries = av_fast_realloc(st->index_entries,
1181
                              &st->index_entries_allocated_size,
1182 115329f1 Diego Biurrun
                              (st->nb_index_entries + 1) *
1183 fb2758c8 Fabrice Bellard
                              sizeof(AVIndexEntry));
1184 568e18b1 Michael Niedermayer
    if(!entries)
1185
        return -1;
1186
1187 b754978a Michael Niedermayer
    st->index_entries= entries;
1188
1189 27a5fe5f Michael Niedermayer
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1190 b754978a Michael Niedermayer
1191 3ba1438d Michael Niedermayer
    if(index<0){
1192 3e9245a9 Michael Niedermayer
        index= st->nb_index_entries++;
1193
        ie= &entries[index];
1194 3ba1438d Michael Niedermayer
        assert(index==0 || ie[-1].timestamp < timestamp);
1195
    }else{
1196
        ie= &entries[index];
1197
        if(ie->timestamp != timestamp){
1198 528c2c73 Michael Niedermayer
            if(ie->timestamp <= timestamp)
1199
                return -1;
1200 3ba1438d Michael Niedermayer
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1201
            st->nb_index_entries++;
1202 755bfeab Diego Biurrun
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1203 3ba1438d Michael Niedermayer
            distance= ie->min_distance;
1204 3e9245a9 Michael Niedermayer
    }
1205 3ba1438d Michael Niedermayer
1206 b754978a Michael Niedermayer
    ie->pos = pos;
1207
    ie->timestamp = timestamp;
1208 3e9245a9 Michael Niedermayer
    ie->min_distance= distance;
1209 30a43f2d Michael Niedermayer
    ie->size= size;
1210 b754978a Michael Niedermayer
    ie->flags = flags;
1211 115329f1 Diego Biurrun
1212 3e9245a9 Michael Niedermayer
    return index;
1213 fb2758c8 Fabrice Bellard
}
1214
1215 dc56fc38 Michael Niedermayer
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1216 27a5fe5f Michael Niedermayer
                              int flags)
1217 fb2758c8 Fabrice Bellard
{
1218 b754978a Michael Niedermayer
    AVIndexEntry *entries= st->index_entries;
1219
    int nb_entries= st->nb_index_entries;
1220 fb2758c8 Fabrice Bellard
    int a, b, m;
1221
    int64_t timestamp;
1222
1223 3ba1438d Michael Niedermayer
    a = - 1;
1224
    b = nb_entries;
1225 b754978a Michael Niedermayer
1226 3ba1438d Michael Niedermayer
    while (b - a > 1) {
1227
        m = (a + b) >> 1;
1228 fb2758c8 Fabrice Bellard
        timestamp = entries[m].timestamp;
1229 3ba1438d Michael Niedermayer
        if(timestamp >= wanted_timestamp)
1230
            b = m;
1231
        if(timestamp <= wanted_timestamp)
1232 b754978a Michael Niedermayer
            a = m;
1233 fb2758c8 Fabrice Bellard
    }
1234 27a5fe5f Michael Niedermayer
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1235 115329f1 Diego Biurrun
1236 27a5fe5f Michael Niedermayer
    if(!(flags & AVSEEK_FLAG_ANY)){
1237
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1238
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1239
        }
1240
    }
1241 3ba1438d Michael Niedermayer
1242 115329f1 Diego Biurrun
    if(m == nb_entries)
1243 3ba1438d Michael Niedermayer
        return -1;
1244
    return  m;
1245 fb2758c8 Fabrice Bellard
}
1246
1247 0f652a8e Benoit Fouet
#define DEBUG_SEEK
1248 8d14a25c Michael Niedermayer
1249 3ba1438d Michael Niedermayer
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1250 8d14a25c Michael Niedermayer
    AVInputFormat *avif= s->iformat;
1251
    int64_t pos_min, pos_max, pos, pos_limit;
1252
    int64_t ts_min, ts_max, ts;
1253 89ddd2a9 Michael Niedermayer
    int index;
1254 8d14a25c Michael Niedermayer
    AVStream *st;
1255
1256 cdd5034f Michael Niedermayer
    if (stream_index < 0)
1257
        return -1;
1258 115329f1 Diego Biurrun
1259 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1260 4733abcb Måns Rullgård
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1261 8d14a25c Michael Niedermayer
#endif
1262
1263
    ts_max=
1264
    ts_min= AV_NOPTS_VALUE;
1265 90b5b51e Diego Biurrun
    pos_limit= -1; //gcc falsely says it may be uninitialized
1266 8d14a25c Michael Niedermayer
1267
    st= s->streams[stream_index];
1268
    if(st->index_entries){
1269
        AVIndexEntry *e;
1270
1271 a85736f2 Diego Biurrun
        index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1272 3ba1438d Michael Niedermayer
        index= FFMAX(index, 0);
1273 8d14a25c Michael Niedermayer
        e= &st->index_entries[index];
1274
1275
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1276
            pos_min= e->pos;
1277
            ts_min= e->timestamp;
1278
#ifdef DEBUG_SEEK
1279 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1280 8d14a25c Michael Niedermayer
               pos_min,ts_min);
1281
#endif
1282
        }else{
1283
            assert(index==0);
1284
        }
1285 115329f1 Diego Biurrun
1286
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1287 27a5fe5f Michael Niedermayer
        assert(index < st->nb_index_entries);
1288
        if(index >= 0){
1289 8d14a25c Michael Niedermayer
            e= &st->index_entries[index];
1290
            assert(e->timestamp >= target_ts);
1291
            pos_max= e->pos;
1292
            ts_max= e->timestamp;
1293
            pos_limit= pos_max - e->min_distance;
1294
#ifdef DEBUG_SEEK
1295 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1296 8d14a25c Michael Niedermayer
               pos_max,pos_limit, ts_max);
1297
#endif
1298
        }
1299
    }
1300
1301 89ddd2a9 Michael Niedermayer
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1302
    if(pos<0)
1303
        return -1;
1304
1305
    /* do the seek */
1306 899681cd Björn Axelsson
    url_fseek(s->pb, pos, SEEK_SET);
1307 89ddd2a9 Michael Niedermayer
1308
    av_update_cur_dts(s, st, ts);
1309
1310
    return 0;
1311
}
1312
1313
int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1314
    int64_t pos, ts;
1315
    int64_t start_pos, filesize;
1316
    int no_change;
1317
1318
#ifdef DEBUG_SEEK
1319
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1320
#endif
1321
1322 8d14a25c Michael Niedermayer
    if(ts_min == AV_NOPTS_VALUE){
1323
        pos_min = s->data_offset;
1324 89ddd2a9 Michael Niedermayer
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1325 8d14a25c Michael Niedermayer
        if (ts_min == AV_NOPTS_VALUE)
1326
            return -1;
1327
    }
1328
1329
    if(ts_max == AV_NOPTS_VALUE){
1330
        int step= 1024;
1331 899681cd Björn Axelsson
        filesize = url_fsize(s->pb);
1332 6fd93ce2 Kenneth Aafløy
        pos_max = filesize - 1;
1333 8d14a25c Michael Niedermayer
        do{
1334
            pos_max -= step;
1335 89ddd2a9 Michael Niedermayer
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1336 8d14a25c Michael Niedermayer
            step += step;
1337
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1338
        if (ts_max == AV_NOPTS_VALUE)
1339
            return -1;
1340 115329f1 Diego Biurrun
1341 8d14a25c Michael Niedermayer
        for(;;){
1342
            int64_t tmp_pos= pos_max + 1;
1343 89ddd2a9 Michael Niedermayer
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1344 8d14a25c Michael Niedermayer
            if(tmp_ts == AV_NOPTS_VALUE)
1345
                break;
1346
            ts_max= tmp_ts;
1347
            pos_max= tmp_pos;
1348 6fd93ce2 Kenneth Aafløy
            if(tmp_pos >= filesize)
1349
                break;
1350 8d14a25c Michael Niedermayer
        }
1351
        pos_limit= pos_max;
1352
    }
1353
1354 53f7c43f Michael Niedermayer
    if(ts_min > ts_max){
1355
        return -1;
1356
    }else if(ts_min == ts_max){
1357
        pos_limit= pos_min;
1358
    }
1359
1360 8d14a25c Michael Niedermayer
    no_change=0;
1361
    while (pos_min < pos_limit) {
1362
#ifdef DEBUG_SEEK
1363 115329f1 Diego Biurrun
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1364 8d14a25c Michael Niedermayer
               pos_min, pos_max,
1365
               ts_min, ts_max);
1366
#endif
1367
        assert(pos_limit <= pos_max);
1368
1369
        if(no_change==0){
1370
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1371
            // interpolate position (better than dichotomy)
1372 3ba1438d Michael Niedermayer
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1373
                + pos_min - approximate_keyframe_distance;
1374 8d14a25c Michael Niedermayer
        }else if(no_change==1){
1375
            // bisection, if interpolation failed to change min or max pos last time
1376
            pos = (pos_min + pos_limit)>>1;
1377
        }else{
1378 a85736f2 Diego Biurrun
            /* linear search if bisection failed, can only happen if there
1379
               are very few or no keyframes between min/max */
1380 8d14a25c Michael Niedermayer
            pos=pos_min;
1381
        }
1382
        if(pos <= pos_min)
1383
            pos= pos_min + 1;
1384
        else if(pos > pos_limit)
1385
            pos= pos_limit;
1386
        start_pos= pos;
1387
1388 89ddd2a9 Michael Niedermayer
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1389 8d14a25c Michael Niedermayer
        if(pos == pos_max)
1390
            no_change++;
1391
        else
1392
            no_change=0;
1393
#ifdef DEBUG_SEEK
1394 4733abcb Måns Rullgård
av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1395 8d14a25c Michael Niedermayer
#endif
1396 db2a0e22 Michael Niedermayer
        if(ts == AV_NOPTS_VALUE){
1397
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1398
            return -1;
1399
        }
1400 8d14a25c Michael Niedermayer
        assert(ts != AV_NOPTS_VALUE);
1401 3ba1438d Michael Niedermayer
        if (target_ts <= ts) {
1402 8d14a25c Michael Niedermayer
            pos_limit = start_pos - 1;
1403
            pos_max = pos;
1404
            ts_max = ts;
1405 3ba1438d Michael Niedermayer
        }
1406
        if (target_ts >= ts) {
1407 8d14a25c Michael Niedermayer
            pos_min = pos;
1408
            ts_min = ts;
1409
        }
1410
    }
1411 115329f1 Diego Biurrun
1412 3ba1438d Michael Niedermayer
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1413
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1414 8d14a25c Michael Niedermayer
#ifdef DEBUG_SEEK
1415
    pos_min = pos;
1416 89ddd2a9 Michael Niedermayer
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1417 8d14a25c Michael Niedermayer
    pos_min++;
1418 89ddd2a9 Michael Niedermayer
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1419 115329f1 Diego Biurrun
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1420 8d14a25c Michael Niedermayer
           pos, ts_min, target_ts, ts_max);
1421
#endif
1422 89ddd2a9 Michael Niedermayer
    *ts_ret= ts;
1423
    return pos;
1424 8d14a25c Michael Niedermayer
}
1425
1426 3ba1438d Michael Niedermayer
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1427
    int64_t pos_min, pos_max;
1428
#if 0
1429
    AVStream *st;
1430

1431
    if (stream_index < 0)
1432
        return -1;
1433

1434
    st= s->streams[stream_index];
1435
#endif
1436
1437
    pos_min = s->data_offset;
1438 899681cd Björn Axelsson
    pos_max = url_fsize(s->pb) - 1;
1439 3ba1438d Michael Niedermayer
1440
    if     (pos < pos_min) pos= pos_min;
1441
    else if(pos > pos_max) pos= pos_max;
1442
1443 899681cd Björn Axelsson
    url_fseek(s->pb, pos, SEEK_SET);
1444 3ba1438d Michael Niedermayer
1445
#if 0
1446 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ts);
1447 3ba1438d Michael Niedermayer
#endif
1448
    return 0;
1449
}
1450
1451 115329f1 Diego Biurrun
static int av_seek_frame_generic(AVFormatContext *s,
1452 3ba1438d Michael Niedermayer
                                 int stream_index, int64_t timestamp, int flags)
1453 fb2758c8 Fabrice Bellard
{
1454 aaec4e03 Baptiste Coudurier
    int index, ret;
1455 fb2758c8 Fabrice Bellard
    AVStream *st;
1456
    AVIndexEntry *ie;
1457
1458
    st = s->streams[stream_index];
1459 e9b78eeb Michael Niedermayer
1460 27a5fe5f Michael Niedermayer
    index = av_index_search_timestamp(st, timestamp, flags);
1461 e9b78eeb Michael Niedermayer
1462 b5a3541d Michael Niedermayer
    if(index < 0 || index==st->nb_index_entries-1){
1463 e9b78eeb Michael Niedermayer
        int i;
1464
        AVPacket pkt;
1465
1466 5e5c9086 Michael Niedermayer
        if(st->nb_index_entries){
1467
            assert(st->index_entries);
1468 e9b78eeb Michael Niedermayer
            ie= &st->index_entries[st->nb_index_entries-1];
1469 aaec4e03 Baptiste Coudurier
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1470
                return ret;
1471 e9b78eeb Michael Niedermayer
            av_update_cur_dts(s, st, ie->timestamp);
1472 aaec4e03 Baptiste Coudurier
        }else{
1473
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1474
                return ret;
1475
        }
1476 e9b78eeb Michael Niedermayer
        for(i=0;; i++) {
1477
            int ret = av_read_frame(s, &pkt);
1478
            if(ret<0)
1479
                break;
1480
            av_free_packet(&pkt);
1481
            if(stream_index == pkt.stream_index){
1482
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1483
                    break;
1484
            }
1485
        }
1486
        index = av_index_search_timestamp(st, timestamp, flags);
1487
    }
1488 fb2758c8 Fabrice Bellard
    if (index < 0)
1489
        return -1;
1490
1491
    av_read_frame_flush(s);
1492 e9b78eeb Michael Niedermayer
    if (s->iformat->read_seek){
1493
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1494
            return 0;
1495
    }
1496
    ie = &st->index_entries[index];
1497 aaec4e03 Baptiste Coudurier
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1498
        return ret;
1499 8bcb147f Michael Niedermayer
    av_update_cur_dts(s, st, ie->timestamp);
1500 cdd5034f Michael Niedermayer
1501 fb2758c8 Fabrice Bellard
    return 0;
1502
}
1503
1504 3ba1438d Michael Niedermayer
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1505 fb2758c8 Fabrice Bellard
{
1506
    int ret;
1507 cdd5034f Michael Niedermayer
    AVStream *st;
1508 115329f1 Diego Biurrun
1509 fb2758c8 Fabrice Bellard
    av_read_frame_flush(s);
1510 115329f1 Diego Biurrun
1511 3ba1438d Michael Niedermayer
    if(flags & AVSEEK_FLAG_BYTE)
1512
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1513 115329f1 Diego Biurrun
1514 cdd5034f Michael Niedermayer
    if(stream_index < 0){
1515
        stream_index= av_find_default_stream_index(s);
1516
        if(stream_index < 0)
1517
            return -1;
1518 115329f1 Diego Biurrun
1519 3ba1438d Michael Niedermayer
        st= s->streams[stream_index];
1520 eb497825 Nathan Kurz
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1521 3ba1438d Michael Niedermayer
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1522 cdd5034f Michael Niedermayer
    }
1523
1524 fb2758c8 Fabrice Bellard
    /* first, we try the format specific seek */
1525
    if (s->iformat->read_seek)
1526 3ba1438d Michael Niedermayer
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1527 fb2758c8 Fabrice Bellard
    else
1528
        ret = -1;
1529
    if (ret >= 0) {
1530
        return 0;
1531
    }
1532 8d14a25c Michael Niedermayer
1533
    if(s->iformat->read_timestamp)
1534 3ba1438d Michael Niedermayer
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1535 8d14a25c Michael Niedermayer
    else
1536 3ba1438d Michael Niedermayer
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1537 fb2758c8 Fabrice Bellard
}
1538
1539
/*******************************************************/
1540 12f996ed Fabrice Bellard
1541 e36bdf8b Daniel Kristjansson
/**
1542 c1e8b678 Neil Brown
 * Returns TRUE if the stream has accurate duration in any stream.
1543 e36bdf8b Daniel Kristjansson
 *
1544 c1e8b678 Neil Brown
 * @return TRUE if the stream has accurate duration for at least one component.
1545 e36bdf8b Daniel Kristjansson
 */
1546 c1e8b678 Neil Brown
static int av_has_duration(AVFormatContext *ic)
1547 12f996ed Fabrice Bellard
{
1548
    int i;
1549
    AVStream *st;
1550
1551
    for(i = 0;i < ic->nb_streams; i++) {
1552
        st = ic->streams[i];
1553 c1e8b678 Neil Brown
        if (st->duration != AV_NOPTS_VALUE)
1554 12f996ed Fabrice Bellard
            return 1;
1555
    }
1556
    return 0;
1557
}
1558
1559 e36bdf8b Daniel Kristjansson
/**
1560
 * Estimate the stream timings from the one of each components.
1561
 *
1562
 * Also computes the global bitrate if possible.
1563
 */
1564 12f996ed Fabrice Bellard
static void av_update_stream_timings(AVFormatContext *ic)
1565
{
1566 c0df9d75 Michael Niedermayer
    int64_t start_time, start_time1, end_time, end_time1;
1567 c1e8b678 Neil Brown
    int64_t duration, duration1;
1568 12f996ed Fabrice Bellard
    int i;
1569
    AVStream *st;
1570
1571 f27a7268 Måns Rullgård
    start_time = INT64_MAX;
1572
    end_time = INT64_MIN;
1573 c1e8b678 Neil Brown
    duration = INT64_MIN;
1574 12f996ed Fabrice Bellard
    for(i = 0;i < ic->nb_streams; i++) {
1575
        st = ic->streams[i];
1576 7f938dd3 Aurelien Jacobs
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1577 c0df9d75 Michael Niedermayer
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1578
            if (start_time1 < start_time)
1579
                start_time = start_time1;
1580 12f996ed Fabrice Bellard
            if (st->duration != AV_NOPTS_VALUE) {
1581 c0df9d75 Michael Niedermayer
                end_time1 = start_time1
1582
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1583 12f996ed Fabrice Bellard
                if (end_time1 > end_time)
1584
                    end_time = end_time1;
1585
            }
1586
        }
1587 c1e8b678 Neil Brown
        if (st->duration != AV_NOPTS_VALUE) {
1588
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1589
            if (duration1 > duration)
1590
                duration = duration1;
1591
        }
1592 12f996ed Fabrice Bellard
    }
1593 f27a7268 Måns Rullgård
    if (start_time != INT64_MAX) {
1594 12f996ed Fabrice Bellard
        ic->start_time = start_time;
1595 f27a7268 Måns Rullgård
        if (end_time != INT64_MIN) {
1596 c1e8b678 Neil Brown
            if (end_time - start_time > duration)
1597
                duration = end_time - start_time;
1598
        }
1599
    }
1600
    if (duration != INT64_MIN) {
1601
        ic->duration = duration;
1602
        if (ic->file_size > 0) {
1603 a85736f2 Diego Biurrun
            /* compute the bitrate */
1604 c1e8b678 Neil Brown
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1605
                (double)ic->duration;
1606 12f996ed Fabrice Bellard
        }
1607
    }
1608
}
1609
1610
static void fill_all_stream_timings(AVFormatContext *ic)
1611
{
1612
    int i;
1613
    AVStream *st;
1614
1615
    av_update_stream_timings(ic);
1616
    for(i = 0;i < ic->nb_streams; i++) {
1617
        st = ic->streams[i];
1618
        if (st->start_time == AV_NOPTS_VALUE) {
1619 c0df9d75 Michael Niedermayer
            if(ic->start_time != AV_NOPTS_VALUE)
1620
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1621
            if(ic->duration != AV_NOPTS_VALUE)
1622
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1623 12f996ed Fabrice Bellard
        }
1624
    }
1625
}
1626
1627
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1628
{
1629
    int64_t filesize, duration;
1630
    int bit_rate, i;
1631
    AVStream *st;
1632
1633
    /* if bit_rate is already set, we believe it */
1634
    if (ic->bit_rate == 0) {
1635
        bit_rate = 0;
1636
        for(i=0;i<ic->nb_streams;i++) {
1637
            st = ic->streams[i];
1638 01f4895c Michael Niedermayer
            bit_rate += st->codec->bit_rate;
1639 12f996ed Fabrice Bellard
        }
1640
        ic->bit_rate = bit_rate;
1641
    }
1642
1643
    /* if duration is already set, we believe it */
1644 115329f1 Diego Biurrun
    if (ic->duration == AV_NOPTS_VALUE &&
1645
        ic->bit_rate != 0 &&
1646 12f996ed Fabrice Bellard
        ic->file_size != 0)  {
1647
        filesize = ic->file_size;
1648
        if (filesize > 0) {
1649
            for(i = 0; i < ic->nb_streams; i++) {
1650
                st = ic->streams[i];
1651 c0df9d75 Michael Niedermayer
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1652 9f32041d Neil Brown
                if (st->duration == AV_NOPTS_VALUE)
1653 12f996ed Fabrice Bellard
                    st->duration = duration;
1654
            }
1655
        }
1656
    }
1657
}
1658
1659
#define DURATION_MAX_READ_SIZE 250000
1660
1661
/* only usable for MPEG-PS streams */
1662 bc5c918e Diego Biurrun
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1663 12f996ed Fabrice Bellard
{
1664
    AVPacket pkt1, *pkt = &pkt1;
1665
    AVStream *st;
1666
    int read_size, i, ret;
1667 bf4e3bd2 Måns Rullgård
    int64_t end_time;
1668 12f996ed Fabrice Bellard
    int64_t filesize, offset, duration;
1669 115329f1 Diego Biurrun
1670 578688fa Luca Abeni
    /* free previous packet */
1671
    if (ic->cur_st && ic->cur_st->parser)
1672
        av_free_packet(&ic->cur_pkt);
1673
    ic->cur_st = NULL;
1674
1675
    /* flush packet queue */
1676
    flush_packet_queue(ic);
1677
1678
    for(i=0;i<ic->nb_streams;i++) {
1679
        st = ic->streams[i];
1680
        if (st->parser) {
1681
            av_parser_close(st->parser);
1682
            st->parser= NULL;
1683
        }
1684
    }
1685 115329f1 Diego Biurrun
1686 12f996ed Fabrice Bellard
    /* we read the first packets to get the first PTS (not fully
1687
       accurate, but it is enough now) */
1688 899681cd Björn Axelsson
    url_fseek(ic->pb, 0, SEEK_SET);
1689 12f996ed Fabrice Bellard
    read_size = 0;
1690
    for(;;) {
1691
        if (read_size >= DURATION_MAX_READ_SIZE)
1692
            break;
1693
        /* if all info is available, we can stop */
1694
        for(i = 0;i < ic->nb_streams; i++) {
1695
            st = ic->streams[i];
1696
            if (st->start_time == AV_NOPTS_VALUE)
1697
                break;
1698
        }
1699
        if (i == ic->nb_streams)
1700
            break;
1701
1702
        ret = av_read_packet(ic, pkt);
1703
        if (ret != 0)
1704
            break;
1705
        read_size += pkt->size;
1706
        st = ic->streams[pkt->stream_index];
1707
        if (pkt->pts != AV_NOPTS_VALUE) {
1708
            if (st->start_time == AV_NOPTS_VALUE)
1709 c0df9d75 Michael Niedermayer
                st->start_time = pkt->pts;
1710 0a5f92a1 Michael Niedermayer
        }
1711
        av_free_packet(pkt);
1712
    }
1713 12f996ed Fabrice Bellard
1714
    /* estimate the end time (duration) */
1715
    /* XXX: may need to support wrapping */
1716
    filesize = ic->file_size;
1717
    offset = filesize - DURATION_MAX_READ_SIZE;
1718
    if (offset < 0)
1719
        offset = 0;
1720
1721 899681cd Björn Axelsson
    url_fseek(ic->pb, offset, SEEK_SET);
1722 12f996ed Fabrice Bellard
    read_size = 0;
1723
    for(;;) {
1724
        if (read_size >= DURATION_MAX_READ_SIZE)
1725
            break;
1726 115329f1 Diego Biurrun
1727 12f996ed Fabrice Bellard
        ret = av_read_packet(ic, pkt);
1728
        if (ret != 0)
1729
            break;
1730
        read_size += pkt->size;
1731
        st = ic->streams[pkt->stream_index];
1732 bf494092 Neil Brown
        if (pkt->pts != AV_NOPTS_VALUE &&
1733
            st->start_time != AV_NOPTS_VALUE) {
1734 c0df9d75 Michael Niedermayer
            end_time = pkt->pts;
1735 12f996ed Fabrice Bellard
            duration = end_time - st->start_time;
1736
            if (duration > 0) {
1737
                if (st->duration == AV_NOPTS_VALUE ||
1738
                    st->duration < duration)
1739
                    st->duration = duration;
1740
            }
1741
        }
1742
        av_free_packet(pkt);
1743
    }
1744 115329f1 Diego Biurrun
1745 c0df9d75 Michael Niedermayer
    fill_all_stream_timings(ic);
1746 12f996ed Fabrice Bellard
1747 899681cd Björn Axelsson
    url_fseek(ic->pb, old_offset, SEEK_SET);
1748 df886e7e Michael Niedermayer
    for(i=0; i<ic->nb_streams; i++){
1749
        st= ic->streams[i];
1750
        st->cur_dts= st->first_dts;
1751 635fbcb1 Michael Niedermayer
        st->last_IP_pts = AV_NOPTS_VALUE;
1752 df886e7e Michael Niedermayer
    }
1753 12f996ed Fabrice Bellard
}
1754
1755 bc5c918e Diego Biurrun
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1756 12f996ed Fabrice Bellard
{
1757
    int64_t file_size;
1758
1759
    /* get the file size, if possible */
1760
    if (ic->iformat->flags & AVFMT_NOFILE) {
1761
        file_size = 0;
1762
    } else {
1763 899681cd Björn Axelsson
        file_size = url_fsize(ic->pb);
1764 12f996ed Fabrice Bellard
        if (file_size < 0)
1765
            file_size = 0;
1766
    }
1767
    ic->file_size = file_size;
1768
1769 ff70e601 Måns Rullgård
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1770
         !strcmp(ic->iformat->name, "mpegts")) &&
1771 ceeacce6 Aurelien Jacobs
        file_size && !url_is_streamed(ic->pb)) {
1772 12f996ed Fabrice Bellard
        /* get accurate estimate from the PTSes */
1773 9ecf7fad Wolfram Gloger
        av_estimate_timings_from_pts(ic, old_offset);
1774 c1e8b678 Neil Brown
    } else if (av_has_duration(ic)) {
1775 a85736f2 Diego Biurrun
        /* at least one component has timings - we use them for all
1776 12f996ed Fabrice Bellard
           the components */
1777
        fill_all_stream_timings(ic);
1778
    } else {
1779 a85736f2 Diego Biurrun
        /* less precise: use bitrate info */
1780 12f996ed Fabrice Bellard
        av_estimate_timings_from_bit_rate(ic);
1781
    }
1782
    av_update_stream_timings(ic);
1783
1784
#if 0
1785
    {
1786
        int i;
1787
        AVStream *st;
1788
        for(i = 0;i < ic->nb_streams; i++) {
1789
            st = ic->streams[i];
1790 115329f1 Diego Biurrun
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1791
               i, (double)st->start_time / AV_TIME_BASE,
1792 12f996ed Fabrice Bellard
               (double)st->duration / AV_TIME_BASE);
1793
        }
1794 115329f1 Diego Biurrun
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1795
               (double)ic->start_time / AV_TIME_BASE,
1796 12f996ed Fabrice Bellard
               (double)ic->duration / AV_TIME_BASE,
1797
               ic->bit_rate / 1000);
1798
    }
1799
#endif
1800
}
1801
1802 b9a281db Fabrice Bellard
static int has_codec_parameters(AVCodecContext *enc)
1803
{
1804
    int val;
1805
    switch(enc->codec_type) {
1806
    case CODEC_TYPE_AUDIO:
1807 ca9c5a4d Baptiste Coudurier
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1808 f3b5a1a2 Baptiste Coudurier
        if(!enc->frame_size &&
1809
           (enc->codec_id == CODEC_ID_VORBIS ||
1810
            enc->codec_id == CODEC_ID_AAC))
1811 4d35bf74 Michael Niedermayer
            return 0;
1812 b9a281db Fabrice Bellard
        break;
1813
    case CODEC_TYPE_VIDEO:
1814 644a9262 Michael Niedermayer
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1815 b9a281db Fabrice Bellard
        break;
1816
    default:
1817
        val = 1;
1818
        break;
1819
    }
1820 ccd425e7 Diego Biurrun
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1821 b9a281db Fabrice Bellard
}
1822
1823 fb2758c8 Fabrice Bellard
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1824
{
1825
    int16_t *samples;
1826
    AVCodec *codec;
1827 3fdb6af9 Baptiste Coudurier
    int got_picture, data_size, ret=0;
1828 fb2758c8 Fabrice Bellard
    AVFrame picture;
1829 115329f1 Diego Biurrun
1830 01f4895c Michael Niedermayer
  if(!st->codec->codec){
1831
    codec = avcodec_find_decoder(st->codec->codec_id);
1832 fb2758c8 Fabrice Bellard
    if (!codec)
1833
        return -1;
1834 01f4895c Michael Niedermayer
    ret = avcodec_open(st->codec, codec);
1835 fb2758c8 Fabrice Bellard
    if (ret < 0)
1836
        return ret;
1837 43c0040a Michael Niedermayer
  }
1838 644a9262 Michael Niedermayer
1839 01f4895c Michael Niedermayer
  if(!has_codec_parameters(st->codec)){
1840
    switch(st->codec->codec_type) {
1841 fb2758c8 Fabrice Bellard
    case CODEC_TYPE_VIDEO:
1842 115329f1 Diego Biurrun
        ret = avcodec_decode_video(st->codec, &picture,
1843 dc296223 Michael Niedermayer
                                   &got_picture, data, size);
1844 fb2758c8 Fabrice Bellard
        break;
1845
    case CODEC_TYPE_AUDIO:
1846 3fdb6af9 Baptiste Coudurier
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1847
        samples = av_malloc(data_size);
1848 fb2758c8 Fabrice Bellard
        if (!samples)
1849
            goto fail;
1850 3fdb6af9 Baptiste Coudurier
        ret = avcodec_decode_audio2(st->codec, samples,
1851 dc296223 Michael Niedermayer
                                    &data_size, data, size);
1852 fb2758c8 Fabrice Bellard
        av_free(samples);
1853
        break;
1854
    default:
1855
        break;
1856
    }
1857 644a9262 Michael Niedermayer
  }
1858 fb2758c8 Fabrice Bellard
 fail:
1859
    return ret;
1860
}
1861
1862 45da8124 Aurelien Jacobs
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1863
{
1864
    while (tags->id != CODEC_ID_NONE) {
1865
        if (tags->id == id)
1866
            return tags->tag;
1867
        tags++;
1868
    }
1869
    return 0;
1870
}
1871
1872
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1873
{
1874 41415d28 Michael Niedermayer
    int i;
1875
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1876
        if(tag == tags[i].tag)
1877
            return tags[i].id;
1878
    }
1879
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1880
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1881
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1882
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1883
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1884
            return tags[i].id;
1885 45da8124 Aurelien Jacobs
    }
1886
    return CODEC_ID_NONE;
1887
}
1888
1889 15545a09 Stefano Sabatini
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1890 45da8124 Aurelien Jacobs
{
1891
    int i;
1892
    for(i=0; tags && tags[i]; i++){
1893
        int tag= codec_get_tag(tags[i], id);
1894
        if(tag) return tag;
1895
    }
1896
    return 0;
1897
}
1898
1899 15545a09 Stefano Sabatini
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1900 45da8124 Aurelien Jacobs
{
1901
    int i;
1902
    for(i=0; tags && tags[i]; i++){
1903
        enum CodecID id= codec_get_id(tags[i], tag);
1904
        if(id!=CODEC_ID_NONE) return id;
1905
    }
1906
    return CODEC_ID_NONE;
1907
}
1908
1909 c2c3dedf Aurelien Jacobs
static void compute_chapters_end(AVFormatContext *s)
1910
{
1911
    unsigned int i;
1912
1913
    for (i=0; i+1<s->nb_chapters; i++)
1914
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1915
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1916
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1917
            s->chapters[i]->end = s->chapters[i+1]->start;
1918
        }
1919
1920
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1921
        assert(s->start_time != AV_NOPTS_VALUE);
1922
        assert(s->duration > 0);
1923
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1924
                                           AV_TIME_BASE_Q,
1925
                                           s->chapters[i]->time_base);
1926
    }
1927
}
1928
1929 fb2758c8 Fabrice Bellard
/* absolute maximum size we read until we abort */
1930
#define MAX_READ_SIZE        5000000
1931
1932 fd97f6a2 Michael Niedermayer
#define MAX_STD_TIMEBASES (60*12+5)
1933 4d43cbcc Michael Niedermayer
static int get_std_framerate(int i){
1934
    if(i<60*12) return i*1001;
1935 aecf157e Reimar Döffinger
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1936 4d43cbcc Michael Niedermayer
}
1937
1938 945208ca Michael Niedermayer
/*
1939
 * Is the time base unreliable.
1940
 * This is a heuristic to balance between quick acceptance of the values in
1941
 * the headers vs. some extra checks.
1942 a85736f2 Diego Biurrun
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1943
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1944 945208ca Michael Niedermayer
 * And there are "variable" fps files this needs to detect as well.
1945
 */
1946
static int tb_unreliable(AVCodecContext *c){
1947
    if(   c->time_base.den >= 101L*c->time_base.num
1948
       || c->time_base.den <    5L*c->time_base.num
1949
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1950
       || c->codec_tag == ff_get_fourcc("XVID")*/
1951
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1952
        return 1;
1953
    return 0;
1954
}
1955
1956 b9a281db Fabrice Bellard
int av_find_stream_info(AVFormatContext *ic)
1957
{
1958 9f75260e Michael Niedermayer
    int i, count, ret, read_size, j;
1959 b9a281db Fabrice Bellard
    AVStream *st;
1960 fb2758c8 Fabrice Bellard
    AVPacket pkt1, *pkt;
1961 15bc38e5 Michael Niedermayer
    int64_t last_dts[MAX_STREAMS];
1962 3c150d16 Michael Niedermayer
    int duration_count[MAX_STREAMS]={0};
1963 0cbff027 Kristian Amlie
    double (*duration_error)[MAX_STD_TIMEBASES];
1964 bc5c918e Diego Biurrun
    int64_t old_offset = url_ftell(ic->pb);
1965 ea486ab3 Baptiste Coudurier
    int64_t codec_info_duration[MAX_STREAMS]={0};
1966
    int codec_info_nb_frames[MAX_STREAMS]={0};
1967 b9a281db Fabrice Bellard
1968 0cbff027 Kristian Amlie
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1969 769e10f0 Panagiotis Issaris
    if (!duration_error) return AVERROR(ENOMEM);
1970 0cbff027 Kristian Amlie
1971 c0df9d75 Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
1972
        st = ic->streams[i];
1973 01f4895c Michael Niedermayer
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1974 c0df9d75 Michael Niedermayer
/*            if(!st->time_base.num)
1975
                st->time_base= */
1976 01f4895c Michael Niedermayer
            if(!st->codec->time_base.num)
1977
                st->codec->time_base= st->time_base;
1978 c0df9d75 Michael Niedermayer
        }
1979 90ad92b3 Michael Niedermayer
        //only for the split stuff
1980
        if (!st->parser) {
1981 01f4895c Michael Niedermayer
            st->parser = av_parser_init(st->codec->codec_id);
1982 57004ff1 Aurelien Jacobs
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1983 7cbaa7ba Michael Niedermayer
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1984
            }
1985 90ad92b3 Michael Niedermayer
        }
1986 c0df9d75 Michael Niedermayer
    }
1987
1988 15bc38e5 Michael Niedermayer
    for(i=0;i<MAX_STREAMS;i++){
1989
        last_dts[i]= AV_NOPTS_VALUE;
1990
    }
1991 115329f1 Diego Biurrun
1992 b9a281db Fabrice Bellard
    count = 0;
1993
    read_size = 0;
1994
    for(;;) {
1995
        /* check if one codec still needs to be handled */
1996
        for(i=0;i<ic->nb_streams;i++) {
1997
            st = ic->streams[i];
1998 01f4895c Michael Niedermayer
            if (!has_codec_parameters(st->codec))
1999 b9a281db Fabrice Bellard
                break;
2000 3e76d1b5 Michael Niedermayer
            /* variable fps and no guess at the real fps */
2001 945208ca Michael Niedermayer
            if(   tb_unreliable(st->codec)
2002 01f4895c Michael Niedermayer
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2003 3e76d1b5 Michael Niedermayer
                break;
2004 01f4895c Michael Niedermayer
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2005 90ad92b3 Michael Niedermayer
                break;
2006 82583548 Michael Niedermayer
            if(st->first_dts == AV_NOPTS_VALUE)
2007
                break;
2008 b9a281db Fabrice Bellard
        }
2009
        if (i == ic->nb_streams) {
2010
            /* NOTE: if the format has no header, then we need to read
2011
               some packets to get most of the streams, so we cannot
2012
               stop here */
2013 fb2758c8 Fabrice Bellard
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2014 b9a281db Fabrice Bellard
                /* if we found the info for all the codecs, we can stop */
2015
                ret = count;
2016
                break;
2017
            }
2018 5fb83c38 Michael Niedermayer
        }
2019 35eab0c0 Michael Niedermayer
        /* we did not get all the codec info, but we read too much data */
2020
        if (read_size >= MAX_READ_SIZE) {
2021
            ret = count;
2022
            break;
2023
        }
2024 b9a281db Fabrice Bellard
2025 fb2758c8 Fabrice Bellard
        /* NOTE: a new stream can be added there if no header in file
2026
           (AVFMTCTX_NOHEADER) */
2027
        ret = av_read_frame_internal(ic, &pkt1);
2028
        if (ret < 0) {
2029
            /* EOF or error */
2030
            ret = -1; /* we could not have all the codec parameters before EOF */
2031 e19456e3 Michael Niedermayer
            for(i=0;i<ic->nb_streams;i++) {
2032
                st = ic->streams[i];
2033 305ee50f Michael Niedermayer
                if (!has_codec_parameters(st->codec)){
2034
                    char buf[256];
2035
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2036
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2037 344a18c3 Måns Rullgård
                } else {
2038
                    ret = 0;
2039 305ee50f Michael Niedermayer
                }
2040 e19456e3 Michael Niedermayer
            }
2041 fb2758c8 Fabrice Bellard
            break;
2042
        }
2043
2044 5c5b1731 Måns Rullgård
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2045 be390a4e Erik Hovland
        if(av_dup_packet(pkt) < 0) {
2046
            av_free(duration_error);
2047 02b15cc8 Michael Niedermayer
            return AVERROR(ENOMEM);
2048 be390a4e Erik Hovland
        }
2049 b9a281db Fabrice Bellard
2050 fb2758c8 Fabrice Bellard
        read_size += pkt->size;
2051 b9a281db Fabrice Bellard
2052
        st = ic->streams[pkt->stream_index];
2053 ea486ab3 Baptiste Coudurier
        if(codec_info_nb_frames[st->index]>1)
2054
            codec_info_duration[st->index] += pkt->duration;
2055 fb2758c8 Fabrice Bellard
        if (pkt->duration != 0)
2056 ea486ab3 Baptiste Coudurier
            codec_info_nb_frames[st->index]++;
2057 fb2758c8 Fabrice Bellard
2058 cefe0607 Michael Niedermayer
        {
2059 3c150d16 Michael Niedermayer
            int index= pkt->stream_index;
2060
            int64_t last= last_dts[index];
2061
            int64_t duration= pkt->dts - last;
2062
2063
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2064 4d43cbcc Michael Niedermayer
                double dur= duration * av_q2d(st->time_base);
2065
2066
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2067
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2068 1694118b Michael Niedermayer
                if(duration_count[index] < 2)
2069 4c7981ba Baptiste Coudurier
                    memset(duration_error[index], 0, sizeof(*duration_error));
2070 69c262d1 Michael Niedermayer
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2071
                    int framerate= get_std_framerate(i);
2072
                    int ticks= lrintf(dur*framerate/(1001*12));
2073
                    double error= dur - ticks*1001*12/(double)framerate;
2074
                    duration_error[index][i] += error*error;
2075
                }
2076 4d43cbcc Michael Niedermayer
                duration_count[index]++;
2077 15bc38e5 Michael Niedermayer
            }
2078 fd97f6a2 Michael Niedermayer
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2079
                last_dts[pkt->stream_index]= pkt->dts;
2080 15bc38e5 Michael Niedermayer
        }
2081 01f4895c Michael Niedermayer
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2082
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2083 90ad92b3 Michael Niedermayer
            if(i){
2084 01f4895c Michael Niedermayer
                st->codec->extradata_size= i;
2085 62c52121 Måns Rullgård
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2086 01f4895c Michael Niedermayer
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2087 62c52121 Måns Rullgård
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2088 90ad92b3 Michael Niedermayer
            }
2089
        }
2090 115329f1 Diego Biurrun
2091 fb2758c8 Fabrice Bellard
        /* if still no information, we try to open the codec and to
2092
           decompress the frame. We try to avoid that in most cases as
2093 a85736f2 Diego Biurrun
           it takes longer and uses more memory. For MPEG-4, we need to
2094
           decompress for QuickTime. */
2095 01f4895c Michael Niedermayer
        if (!has_codec_parameters(st->codec) /*&&
2096
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2097
             st->codec->codec_id == CODEC_ID_H264 ||
2098
             st->codec->codec_id == CODEC_ID_H263 ||
2099
             st->codec->codec_id == CODEC_ID_H261 ||
2100
             st->codec->codec_id == CODEC_ID_VORBIS ||
2101
             st->codec->codec_id == CODEC_ID_MJPEG ||
2102
             st->codec->codec_id == CODEC_ID_PNG ||
2103
             st->codec->codec_id == CODEC_ID_PAM ||
2104
             st->codec->codec_id == CODEC_ID_PGM ||
2105
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2106
             st->codec->codec_id == CODEC_ID_PBM ||
2107
             st->codec->codec_id == CODEC_ID_PPM ||
2108
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2109
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2110 fb2758c8 Fabrice Bellard
            try_decode_frame(st, pkt->data, pkt->size);
2111 115329f1 Diego Biurrun
2112 b3fc0925 Måns Rullgård
        if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2113 fb2758c8 Fabrice Bellard
            break;
2114 b9a281db Fabrice Bellard
        }
2115
        count++;
2116
    }
2117
2118 bd107136 Diego Biurrun
    // close codecs which were opened in try_decode_frame()
2119 43c0040a Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
2120
        st = ic->streams[i];
2121 01f4895c Michael Niedermayer
        if(st->codec->codec)
2122
            avcodec_close(st->codec);
2123 43c0040a Michael Niedermayer
    }
2124 b9a281db Fabrice Bellard
    for(i=0;i<ic->nb_streams;i++) {
2125
        st = ic->streams[i];
2126 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2127 dd1c8f3e Luca Abeni
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2128 01f4895c Michael Niedermayer
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2129 15bc38e5 Michael Niedermayer
2130 1694118b Michael Niedermayer
            if(duration_count[i]
2131 945208ca Michael Niedermayer
               && tb_unreliable(st->codec) /*&&
2132 a85736f2 Diego Biurrun
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2133 4d43cbcc Michael Niedermayer
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2134
                double best_error= 2*av_q2d(st->time_base);
2135
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2136
2137
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2138
                    double error= duration_error[i][j] * get_std_framerate(j);
2139
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2140
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2141 9f75260e Michael Niedermayer
                    if(error < best_error){
2142
                        best_error= error;
2143 4d43cbcc Michael Niedermayer
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2144 9f75260e Michael Niedermayer
                    }
2145 3c150d16 Michael Niedermayer
                }
2146 15bc38e5 Michael Niedermayer
            }
2147
2148 c0df9d75 Michael Niedermayer
            if (!st->r_frame_rate.num){
2149 5523d5f4 Michael Niedermayer
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2150
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2151
                    st->r_frame_rate.num = st->codec->time_base.den;
2152
                    st->r_frame_rate.den = st->codec->time_base.num;
2153
                }else{
2154
                    st->r_frame_rate.num = st->time_base.den;
2155
                    st->r_frame_rate.den = st->time_base.num;
2156
                }
2157 14bea432 Michael Niedermayer
            }
2158 a185f52a Michael Niedermayer
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2159 dd1c8f3e Luca Abeni
            if(!st->codec->bits_per_coded_sample)
2160
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2161 b9a281db Fabrice Bellard
        }
2162 de6d9b64 Fabrice Bellard
    }
2163 b9a281db Fabrice Bellard
2164 9ecf7fad Wolfram Gloger
    av_estimate_timings(ic, old_offset);
2165 6fea687e John Donaghy
2166 c2c3dedf Aurelien Jacobs
    compute_chapters_end(ic);
2167
2168 e928649b Michael Niedermayer
#if 0
2169 a85736f2 Diego Biurrun
    /* correct DTS for B-frame streams with no timestamps */
2170 e928649b Michael Niedermayer
    for(i=0;i<ic->nb_streams;i++) {
2171
        st = ic->streams[i];
2172 01f4895c Michael Niedermayer
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2173 e928649b Michael Niedermayer
            if(b-frames){
2174
                ppktl = &ic->packet_buffer;
2175
                while(ppkt1){
2176
                    if(ppkt1->stream_index != i)
2177
                        continue;
2178
                    if(ppkt1->pkt->dts < 0)
2179
                        break;
2180
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2181
                        break;
2182
                    ppkt1->pkt->dts -= delta;
2183
                    ppkt1= ppkt1->next;
2184
                }
2185
                if(ppkt1)
2186
                    continue;
2187
                st->cur_dts -= delta;
2188
            }
2189
        }
2190
    }
2191
#endif
2192 0cbff027 Kristian Amlie
2193
    av_free(duration_error);
2194
2195 b9a281db Fabrice Bellard
    return ret;
2196 de6d9b64 Fabrice Bellard
}
2197
2198 fb2758c8 Fabrice Bellard
/*******************************************************/
2199
2200
int av_read_play(AVFormatContext *s)
2201
{
2202 fa13095a Björn Axelsson
    if (s->iformat->read_play)
2203
        return s->iformat->read_play(s);
2204 fd2982a0 Aurelien Jacobs
    if (s->pb)
2205 502bdf68 Michael Niedermayer
        return av_url_read_fpause(s->pb, 0);
2206 fa13095a Björn Axelsson
    return AVERROR(ENOSYS);
2207 fb2758c8 Fabrice Bellard
}
2208
2209
int av_read_pause(AVFormatContext *s)
2210
{
2211 fa13095a Björn Axelsson
    if (s->iformat->read_pause)
2212
        return s->iformat->read_pause(s);
2213 fd2982a0 Aurelien Jacobs
    if (s->pb)
2214 502bdf68 Michael Niedermayer
        return av_url_read_fpause(s->pb, 1);
2215 fa13095a Björn Axelsson
    return AVERROR(ENOSYS);
2216 fb2758c8 Fabrice Bellard
}
2217
2218 2506fd54 Reimar Döffinger
void av_close_input_stream(AVFormatContext *s)
2219 de6d9b64 Fabrice Bellard
{
2220 ca75a923 Reimar Döffinger
    int i;
2221 da24c5e3 Fabrice Bellard
    AVStream *st;
2222 de6d9b64 Fabrice Bellard
2223 fb2758c8 Fabrice Bellard
    /* free previous packet */
2224
    if (s->cur_st && s->cur_st->parser)
2225 115329f1 Diego Biurrun
        av_free_packet(&s->cur_pkt);
2226 fb2758c8 Fabrice Bellard
2227 b9a281db Fabrice Bellard
    if (s->iformat->read_close)
2228
        s->iformat->read_close(s);
2229 de6d9b64 Fabrice Bellard
    for(i=0;i<s->nb_streams;i++) {
2230 da24c5e3 Fabrice Bellard
        /* free all data in a stream component */
2231
        st = s->streams[i];
2232 fb2758c8 Fabrice Bellard
        if (st->parser) {
2233
            av_parser_close(st->parser);
2234 de6d9b64 Fabrice Bellard
        }
2235 094d9df7 Aurelien Jacobs
        av_metadata_free(&st->metadata);
2236 fb2758c8 Fabrice Bellard
        av_free(st->index_entries);
2237 a5e9102b Måns Rullgård
        av_free(st->codec->extradata);
2238 01f4895c Michael Niedermayer
        av_free(st->codec);
2239 f8d7c9d3 Evgeniy Stepanov
        av_free(st->filename);
2240 ade8d8b9 Baptiste Coudurier
        av_free(st->priv_data);
2241 fb2758c8 Fabrice Bellard
        av_free(st);
2242 de6d9b64 Fabrice Bellard
    }
2243 15afa396 Nico Sabbi
    for(i=s->nb_programs-1; i>=0; i--) {
2244
        av_freep(&s->programs[i]->provider_name);
2245
        av_freep(&s->programs[i]->name);
2246 094d9df7 Aurelien Jacobs
        av_metadata_free(&s->programs[i]->metadata);
2247 526efa10 Nico Sabbi
        av_freep(&s->programs[i]->stream_index);
2248 15afa396 Nico Sabbi
        av_freep(&s->programs[i]);
2249
    }
2250 ceedda75 Michael Niedermayer
    av_freep(&s->programs);
2251 fb2758c8 Fabrice Bellard
    flush_packet_queue(s);
2252 a8dbe951 Philip Gladstone
    av_freep(&s->priv_data);
2253 7c8202cc Michael Niedermayer
    while(s->nb_chapters--) {
2254
        av_free(s->chapters[s->nb_chapters]->title);
2255 094d9df7 Aurelien Jacobs
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2256 7c8202cc Michael Niedermayer
        av_free(s->chapters[s->nb_chapters]);
2257 79d7836a Anton Khirnov
    }
2258
    av_freep(&s->chapters);
2259 094d9df7 Aurelien Jacobs
    av_metadata_free(&s->metadata);
2260 1ea4f593 Fabrice Bellard
    av_free(s);
2261 de6d9b64 Fabrice Bellard
}
2262
2263 2506fd54 Reimar Döffinger
void av_close_input_file(AVFormatContext *s)
2264
{
2265
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2266
    av_close_input_stream(s);
2267
    if (pb)
2268
        url_fclose(pb);
2269
}
2270
2271 b9a281db Fabrice Bellard
AVStream *av_new_stream(AVFormatContext *s, int id)
2272
{
2273
    AVStream *st;
2274 504ee036 Michael Niedermayer
    int i;
2275 b9a281db Fabrice Bellard
2276
    if (s->nb_streams >= MAX_STREAMS)
2277
        return NULL;
2278
2279
    st = av_mallocz(sizeof(AVStream));
2280
    if (!st)
2281
        return NULL;
2282 115329f1 Diego Biurrun
2283 01f4895c Michael Niedermayer
    st->codec= avcodec_alloc_context();
2284 48091512 Fabrice Bellard
    if (s->iformat) {
2285
        /* no default bitrate if decoding */
2286 01f4895c Michael Niedermayer
        st->codec->bit_rate = 0;
2287 48091512 Fabrice Bellard
    }
2288 b9a281db Fabrice Bellard
    st->index = s->nb_streams;
2289
    st->id = id;
2290 12f996ed Fabrice Bellard
    st->start_time = AV_NOPTS_VALUE;
2291
    st->duration = AV_NOPTS_VALUE;
2292 6d77d9ac Michael Niedermayer
        /* we set the current DTS to 0 so that formats without any timestamps
2293
           but durations get some timestamps, formats with some unknown
2294
           timestamps have their first few packets buffered and the
2295
           timestamps corrected before they are returned to the user */
2296
    st->cur_dts = 0;
2297 82583548 Michael Niedermayer
    st->first_dts = AV_NOPTS_VALUE;
2298 9ee91c2f Michael Niedermayer
2299 a85736f2 Diego Biurrun
    /* default pts setting is MPEG-like */
2300 9ee91c2f Michael Niedermayer
    av_set_pts_info(st, 33, 1, 90000);
2301 635fbcb1 Michael Niedermayer
    st->last_IP_pts = AV_NOPTS_VALUE;
2302 504ee036 Michael Niedermayer
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2303
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2304 9ee91c2f Michael Niedermayer
2305 c30a4489 Aurelien Jacobs
    st->sample_aspect_ratio = (AVRational){0,1};
2306
2307 b9a281db Fabrice Bellard
    s->streams[s->nb_streams++] = st;
2308
    return st;
2309
}
2310
2311 15afa396 Nico Sabbi
AVProgram *av_new_program(AVFormatContext *ac, int id)
2312
{
2313
    AVProgram *program=NULL;
2314
    int i;
2315
2316
#ifdef DEBUG_SI
2317
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2318
#endif
2319
2320
    for(i=0; i<ac->nb_programs; i++)
2321
        if(ac->programs[i]->id == id)
2322
            program = ac->programs[i];
2323
2324
    if(!program){
2325
        program = av_mallocz(sizeof(AVProgram));
2326
        if (!program)
2327
            return NULL;
2328
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2329
        program->discard = AVDISCARD_NONE;
2330
    }
2331
    program->id = id;
2332
2333
    return program;
2334
}
2335
2336
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2337
{
2338
    assert(!provider_name == !name);
2339
    if(name){
2340
        av_free(program->provider_name);
2341
        av_free(program->         name);
2342
        program->provider_name = av_strdup(provider_name);
2343
        program->         name = av_strdup(         name);
2344
    }
2345
}
2346
2347 abd2256d Michael Niedermayer
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2348 79d7836a Anton Khirnov
{
2349 7a2a3e8e Michael Niedermayer
    AVChapter *chapter = NULL;
2350
    int i;
2351
2352 7c8202cc Michael Niedermayer
    for(i=0; i<s->nb_chapters; i++)
2353 7a2a3e8e Michael Niedermayer
        if(s->chapters[i]->id == id)
2354
            chapter = s->chapters[i];
2355
2356
    if(!chapter){
2357
        chapter= av_mallocz(sizeof(AVChapter));
2358 6b43e2c7 Michael Niedermayer
        if(!chapter)
2359 5c37f43a Michael Niedermayer
            return NULL;
2360 7c8202cc Michael Niedermayer
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2361 7a2a3e8e Michael Niedermayer
    }
2362 ebea1d76 Aurelien Jacobs
    av_free(chapter->title);
2363 42720ee4 Michael Niedermayer
    chapter->title = av_strdup(title);
2364 7a2a3e8e Michael Niedermayer
    chapter->id    = id;
2365 abd2256d Michael Niedermayer
    chapter->time_base= time_base;
2366 79d7836a Anton Khirnov
    chapter->start = start;
2367 747fb6c6 Michael Niedermayer
    chapter->end   = end;
2368 79d7836a Anton Khirnov
2369 5c37f43a Michael Niedermayer
    return chapter;
2370 79d7836a Anton Khirnov
}
2371 15afa396 Nico Sabbi
2372 b9a281db Fabrice Bellard
/************************************************************/
2373
/* output media file */
2374 de6d9b64 Fabrice Bellard
2375 87a0a681 Fabrice Bellard
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2376
{
2377
    int ret;
2378 115329f1 Diego Biurrun
2379 98486a6b Roman Shaposhnik
    if (s->oformat->priv_data_size > 0) {
2380
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2381
        if (!s->priv_data)
2382 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
2383 98486a6b Roman Shaposhnik
    } else
2384
        s->priv_data = NULL;
2385 115329f1 Diego Biurrun
2386 87a0a681 Fabrice Bellard
    if (s->oformat->set_parameters) {
2387
        ret = s->oformat->set_parameters(s, ap);
2388
        if (ret < 0)
2389
            return ret;
2390
    }
2391
    return 0;
2392
}
2393
2394 b9a281db Fabrice Bellard
int av_write_header(AVFormatContext *s)
2395
{
2396 1e51d801 Fabrice Bellard
    int ret, i;
2397
    AVStream *st;
2398
2399 9450118b Michael Niedermayer
    // some sanity checks
2400
    for(i=0;i<s->nb_streams;i++) {
2401
        st = s->streams[i];
2402
2403
        switch (st->codec->codec_type) {
2404
        case CODEC_TYPE_AUDIO:
2405
            if(st->codec->sample_rate<=0){
2406
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2407
                return -1;
2408
            }
2409 bf912a48 Baptiste Coudurier
            if(!st->codec->block_align)
2410
                st->codec->block_align = st->codec->channels *
2411
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2412 9450118b Michael Niedermayer
            break;
2413
        case CODEC_TYPE_VIDEO:
2414
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2415
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2416
                return -1;
2417
            }
2418
            if(st->codec->width<=0 || st->codec->height<=0){
2419
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2420
                return -1;
2421
            }
2422 0354ddb7 Michael Niedermayer
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2423
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2424
                return -1;
2425
            }
2426 9450118b Michael Niedermayer
            break;
2427
        }
2428 5ecfa9f5 Michael Niedermayer
2429
        if(s->oformat->codec_tag){
2430
            if(st->codec->codec_tag){
2431
                //FIXME
2432
                //check that tag + id is in the table
2433 a85736f2 Diego Biurrun
                //if neither is in the table -> OK
2434 5ecfa9f5 Michael Niedermayer
                //if tag is in the table with another id -> FAIL
2435
                //if id is in the table with another tag -> FAIL unless strict < ?
2436
            }else
2437
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2438
        }
2439 9450118b Michael Niedermayer
    }
2440
2441 8fae2df5 Baptiste Coudurier
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2442 c6efa4b5 Baptiste Coudurier
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2443
        if (!s->priv_data)
2444 769e10f0 Panagiotis Issaris
            return AVERROR(ENOMEM);
2445 8fae2df5 Baptiste Coudurier
    }
2446 c6efa4b5 Baptiste Coudurier
2447 176aee82 Aurelien Jacobs
#if LIBAVFORMAT_VERSION_MAJOR < 53
2448 5ce00433 Aurelien Jacobs
    ff_metadata_mux_compat(s);
2449 176aee82 Aurelien Jacobs
#endif
2450
2451 31e11451 Michael Niedermayer
    if(s->oformat->write_header){
2452
        ret = s->oformat->write_header(s);
2453
        if (ret < 0)
2454
            return ret;
2455
    }
2456 1e51d801 Fabrice Bellard
2457
    /* init PTS generation */
2458
    for(i=0;i<s->nb_streams;i++) {
2459 f0ff20a1 Wolfram Gloger
        int64_t den = AV_NOPTS_VALUE;
2460 1e51d801 Fabrice Bellard
        st = s->streams[i];
2461
2462 01f4895c Michael Niedermayer
        switch (st->codec->codec_type) {
2463 1e51d801 Fabrice Bellard
        case CODEC_TYPE_AUDIO:
2464 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2465 1e51d801 Fabrice Bellard
            break;
2466
        case CODEC_TYPE_VIDEO:
2467 f0ff20a1 Wolfram Gloger
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2468 1e51d801 Fabrice Bellard
            break;
2469
        default:
2470
            break;
2471
        }
2472 f0ff20a1 Wolfram Gloger
        if (den != AV_NOPTS_VALUE) {
2473
            if (den <= 0)
2474
                return AVERROR_INVALIDDATA;
2475
            av_frac_init(&st->pts, 0, 0, den);
2476
        }
2477 1e51d801 Fabrice Bellard
    }
2478
    return 0;
2479 b9a281db Fabrice Bellard
}
2480
2481 3c895fc0 Michael Niedermayer
//FIXME merge with compute_pkt_fields
2482 5edea431 Michael Niedermayer
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2483 504ee036 Michael Niedermayer
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2484
    int num, den, frame_size, i;
2485 b0c7f5a9 Michael Niedermayer
2486 949b1a13 Steve L'Homme
//    av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2487 115329f1 Diego Biurrun
2488 e928649b Michael Niedermayer
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2489
        return -1;*/
2490 115329f1 Diego Biurrun
2491 e928649b Michael Niedermayer
    /* duration field */
2492 3c895fc0 Michael Niedermayer
    if (pkt->duration == 0) {
2493
        compute_frame_duration(&num, &den, st, NULL, pkt);
2494
        if (den && num) {
2495
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2496
        }
2497
    }
2498 e928649b Michael Niedermayer
2499 6e1aa0f3 Michael Niedermayer
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2500
        pkt->pts= pkt->dts;
2501
2502 e928649b Michael Niedermayer
    //XXX/FIXME this is a temporary hack until all encoders output pts
2503 504ee036 Michael Niedermayer
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2504 e928649b Michael Niedermayer
        pkt->dts=
2505
//        pkt->pts= st->cur_dts;
2506
        pkt->pts= st->pts.val;
2507
    }
2508
2509 115329f1 Diego Biurrun
    //calculate dts from pts
2510 cb5b96cd Baptiste Coudurier
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2511 504ee036 Michael Niedermayer
        st->pts_buffer[0]= pkt->pts;
2512
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2513
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2514
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2515 1345f4ed Diego Biurrun
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2516 504ee036 Michael Niedermayer
2517
        pkt->dts= st->pts_buffer[0];
2518 e928649b Michael Niedermayer
    }
2519 115329f1 Diego Biurrun
2520 5edea431 Michael Niedermayer
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2521 15061147 Baptiste Coudurier
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2522 5edea431 Michael Niedermayer
        return -1;
2523
    }
2524
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2525 15061147 Baptiste Coudurier
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2526 5edea431 Michael Niedermayer
        return -1;
2527
    }
2528
2529 949b1a13 Steve L'Homme
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2530 e928649b Michael Niedermayer
    st->cur_dts= pkt->dts;
2531
    st->pts.val= pkt->dts;
2532
2533 1e51d801 Fabrice Bellard
    /* update pts */
2534 01f4895c Michael Niedermayer
    switch (st->codec->codec_type) {
2535 1e51d801 Fabrice Bellard
    case CODEC_TYPE_AUDIO:
2536 01f4895c Michael Niedermayer
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2537 6d8f985e Michael Niedermayer
2538 a85736f2 Diego Biurrun
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2539
           likely equal to the encoder delay, but it would be better if we
2540
           had the real timestamps from the encoder */
2541 e928649b Michael Niedermayer
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2542 9ee91c2f Michael Niedermayer
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2543 7feb950a Fabrice Bellard
        }
2544 1e51d801 Fabrice Bellard
        break;
2545
    case CODEC_TYPE_VIDEO:
2546 01f4895c Michael Niedermayer
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2547 1e51d801 Fabrice Bellard
        break;
2548
    default:
2549
        break;
2550
    }
2551 5edea431 Michael Niedermayer
    return 0;
2552 3c895fc0 Michael Niedermayer
}
2553
2554
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2555
{
2556 fc9c2d53 Ramiro Polla
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2557 576ae256 Michael Niedermayer
2558 494bbf58 Michael Niedermayer
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2559 5edea431 Michael Niedermayer
        return ret;
2560 115329f1 Diego Biurrun
2561 576ae256 Michael Niedermayer
    ret= s->oformat->write_packet(s, pkt);
2562
    if(!ret)
2563 899681cd Björn Axelsson
        ret= url_ferror(s->pb);
2564 576ae256 Michael Niedermayer
    return ret;
2565 3c895fc0 Michael Niedermayer
}
2566
2567 f21c0b4c Baptiste Coudurier
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2568 fe2d6fe2 Michael Niedermayer
    AVPacketList *pktl, **next_point, *this_pktl;
2569
    int stream_count=0;
2570
    int streams[MAX_STREAMS];
2571
2572
    if(pkt){
2573
        AVStream *st= s->streams[ pkt->stream_index];
2574
2575 2577897d Michael Niedermayer
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2576 fe2d6fe2 Michael Niedermayer
2577
        this_pktl = av_mallocz(sizeof(AVPacketList));
2578
        this_pktl->pkt= *pkt;
2579 2577897d Michael Niedermayer
        if(pkt->destruct == av_destruct_packet)
2580 a85736f2 Diego Biurrun
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2581 2577897d Michael Niedermayer
        else
2582
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2583 fe2d6fe2 Michael Niedermayer
2584
        next_point = &s->packet_buffer;
2585
        while(*next_point){
2586
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2587
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2588
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2589
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2590
                break;
2591
            next_point= &(*next_point)->next;
2592
        }
2593
        this_pktl->next= *next_point;
2594
        *next_point= this_pktl;
2595
    }
2596 115329f1 Diego Biurrun
2597 fe2d6fe2 Michael Niedermayer
    memset(streams, 0, sizeof(streams));
2598
    pktl= s->packet_buffer;
2599
    while(pktl){
2600 949b1a13 Steve L'Homme
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2601 fe2d6fe2 Michael Niedermayer
        if(streams[ pktl->pkt.stream_index ] == 0)
2602
            stream_count++;
2603
        streams[ pktl->pkt.stream_index ]++;
2604
        pktl= pktl->next;
2605
    }
2606 115329f1 Diego Biurrun
2607 6919e54c Art Clarke
    if(stream_count && (s->nb_streams == stream_count || flush)){
2608 fe2d6fe2 Michael Niedermayer
        pktl= s->packet_buffer;
2609
        *out= pktl->pkt;
2610 115329f1 Diego Biurrun
2611
        s->packet_buffer= pktl->next;
2612 fe2d6fe2 Michael Niedermayer
        av_freep(&pktl);
2613
        return 1;
2614
    }else{
2615
        av_init_packet(out);
2616
        return 0;
2617
    }
2618
}
2619
2620
/**
2621 a85736f2 Diego Biurrun
 * Interleaves an AVPacket correctly so it can be muxed.
2622 fe2d6fe2 Michael Niedermayer
 * @param out the interleaved packet will be output here
2623
 * @param in the input packet
2624
 * @param flush 1 if no further packets are available as input and all
2625
 *              remaining packets should be output
2626 115329f1 Diego Biurrun
 * @return 1 if a packet was output, 0 if no packet could be output,
2627 d9526386 Diego Biurrun
 *         < 0 if an error occurred
2628 fe2d6fe2 Michael Niedermayer
 */
2629
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2630
    if(s->oformat->interleave_packet)
2631
        return s->oformat->interleave_packet(s, out, in, flush);
2632
    else
2633
        return av_interleave_packet_per_dts(s, out, in, flush);
2634
}
2635
2636 3c895fc0 Michael Niedermayer
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2637
    AVStream *st= s->streams[ pkt->stream_index];
2638
2639 6f824977 Michael Niedermayer
    //FIXME/XXX/HACK drop zero sized packets
2640 01f4895c Michael Niedermayer
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2641 6f824977 Michael Niedermayer
        return 0;
2642 3ce16b30 Michael Niedermayer
2643 949b1a13 Steve L'Homme
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2644 494bbf58 Michael Niedermayer
    if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2645 3ce16b30 Michael Niedermayer
        return -1;
2646 115329f1 Diego Biurrun
2647 3c895fc0 Michael Niedermayer
    if(pkt->dts == AV_NOPTS_VALUE)
2648
        return -1;
2649
2650 fe2d6fe2 Michael Niedermayer
    for(;;){
2651
        AVPacket opkt;
2652
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2653
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2654
            return ret;
2655 115329f1 Diego Biurrun
2656 fe2d6fe2 Michael Niedermayer
        ret= s->oformat->write_packet(s, &opkt);
2657 115329f1 Diego Biurrun
2658 fe2d6fe2 Michael Niedermayer
        av_free_packet(&opkt);
2659
        pkt= NULL;
2660 115329f1 Diego Biurrun
2661 3c895fc0 Michael Niedermayer
        if(ret<0)
2662
            return ret;
2663 899681cd Björn Axelsson
        if(url_ferror(s->pb))
2664
            return url_ferror(s->pb);
2665 3c895fc0 Michael Niedermayer
    }
2666 b9a281db Fabrice Bellard
}
2667
2668
int av_write_trailer(AVFormatContext *s)
2669
{
2670 c40a3a42 Michael Niedermayer
    int ret, i;
2671 115329f1 Diego Biurrun
2672 fe2d6fe2 Michael Niedermayer
    for(;;){
2673
        AVPacket pkt;
2674
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2675
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2676 c40a3a42 Michael Niedermayer
            goto fail;
2677 fe2d6fe2 Michael Niedermayer
        if(!ret)
2678
            break;
2679 115329f1 Diego Biurrun
2680 fe2d6fe2 Michael Niedermayer
        ret= s->oformat->write_packet(s, &pkt);
2681 115329f1 Diego Biurrun
2682 fe2d6fe2 Michael Niedermayer
        av_free_packet(&pkt);
2683 115329f1 Diego Biurrun
2684 3c895fc0 Michael Niedermayer
        if(ret<0)
2685 c40a3a42 Michael Niedermayer
            goto fail;
2686 899681cd Björn Axelsson
        if(url_ferror(s->pb))
2687 576ae256 Michael Niedermayer
            goto fail;
2688 3c895fc0 Michael Niedermayer
    }
2689
2690 31e11451 Michael Niedermayer
    if(s->oformat->write_trailer)
2691
        ret = s->oformat->write_trailer(s);
2692 c40a3a42 Michael Niedermayer
fail:
2693 576ae256 Michael Niedermayer
    if(ret == 0)
2694 899681cd Björn Axelsson
       ret=url_ferror(s->pb);
2695 c40a3a42 Michael Niedermayer
    for(i=0;i<s->nb_streams;i++)
2696
        av_freep(&s->streams[i]->priv_data);
2697 b9a281db Fabrice Bellard
    av_freep(&s->priv_data);
2698
    return ret;
2699 de6d9b64 Fabrice Bellard
}
2700
2701 526efa10 Nico Sabbi
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2702
{
2703
    int i, j;
2704
    AVProgram *program=NULL;
2705
    void *tmp;
2706
2707
    for(i=0; i<ac->nb_programs; i++){
2708
        if(ac->programs[i]->id != progid)
2709
            continue;
2710
        program = ac->programs[i];
2711
        for(j=0; j<program->nb_stream_indexes; j++)
2712
            if(program->stream_index[j] == idx)
2713
                return;
2714
2715
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2716
        if(!tmp)
2717
            return;
2718
        program->stream_index = tmp;
2719
        program->stream_index[program->nb_stream_indexes++] = idx;
2720
        return;
2721
    }
2722
}
2723
2724 de6d9b64 Fabrice Bellard
/* "user interface" functions */
2725 4e745a3b Baptiste Coudurier
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2726 fad0e030 Nico Sabbi
{
2727 4e745a3b Baptiste Coudurier
    char buf[256];
2728 fad0e030 Nico Sabbi
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2729
    AVStream *st = ic->streams[i];
2730
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2731
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2732
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2733
    /* the pid is an important information, so we display it */
2734
    /* XXX: add a generic system */
2735
    if (flags & AVFMT_SHOW_IDS)
2736
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2737
    if (strlen(st->language) > 0)
2738
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2739
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2740
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2741
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2742
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2743 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2744 fad0e030 Nico Sabbi
/*      else if(st->time_base.den && st->time_base.num)
2745 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2746 fad0e030 Nico Sabbi
        else
2747 5fba300d Michael Niedermayer
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2748 fad0e030 Nico Sabbi
    }
2749
    av_log(NULL, AV_LOG_INFO, "\n")