Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ db46c4e1

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

1469
    if (stream_index < 0)
1470
        return -1;
1471

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