Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ b38f008e

History | View | Annotate | Download (123 KB)

1
/*
2
 * various utility functions for use within FFmpeg
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#include "avformat.h"
22
#include "internal.h"
23
#include "libavcodec/internal.h"
24
#include "libavutil/opt.h"
25
#include "metadata.h"
26
#include "id3v2.h"
27
#include "libavutil/avstring.h"
28
#include "riff.h"
29
#include "audiointerleave.h"
30
#include <sys/time.h>
31
#include <time.h>
32
#include <strings.h>
33
#include <stdarg.h>
34
#if CONFIG_NETWORK
35
#include "network.h"
36
#endif
37

    
38
#undef NDEBUG
39
#include <assert.h>
40

    
41
/**
42
 * @file
43
 * various utility functions for use within FFmpeg
44
 */
45

    
46
unsigned avformat_version(void)
47
{
48
    return LIBAVFORMAT_VERSION_INT;
49
}
50

    
51
const char *avformat_configuration(void)
52
{
53
    return FFMPEG_CONFIGURATION;
54
}
55

    
56
const char *avformat_license(void)
57
{
58
#define LICENSE_PREFIX "libavformat license: "
59
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
60
}
61

    
62
/* fraction handling */
63

    
64
/**
65
 * f = val + (num / den) + 0.5.
66
 *
67
 * 'num' is normalized so that it is such as 0 <= num < den.
68
 *
69
 * @param f fractional number
70
 * @param val integer value
71
 * @param num must be >= 0
72
 * @param den must be >= 1
73
 */
74
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
75
{
76
    num += (den >> 1);
77
    if (num >= den) {
78
        val += num / den;
79
        num = num % den;
80
    }
81
    f->val = val;
82
    f->num = num;
83
    f->den = den;
84
}
85

    
86
/**
87
 * Fractional addition to f: f = f + (incr / f->den).
88
 *
89
 * @param f fractional number
90
 * @param incr increment, can be positive or negative
91
 */
92
static void av_frac_add(AVFrac *f, int64_t incr)
93
{
94
    int64_t num, den;
95

    
96
    num = f->num + incr;
97
    den = f->den;
98
    if (num < 0) {
99
        f->val += num / den;
100
        num = num % den;
101
        if (num < 0) {
102
            num += den;
103
            f->val--;
104
        }
105
    } else if (num >= den) {
106
        f->val += num / den;
107
        num = num % den;
108
    }
109
    f->num = num;
110
}
111

    
112
/** head of registered input format linked list */
113
#if !FF_API_FIRST_FORMAT
114
static
115
#endif
116
AVInputFormat *first_iformat = NULL;
117
/** head of registered output format linked list */
118
#if !FF_API_FIRST_FORMAT
119
static
120
#endif
121
AVOutputFormat *first_oformat = NULL;
122

    
123
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
124
{
125
    if(f) return f->next;
126
    else  return first_iformat;
127
}
128

    
129
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
130
{
131
    if(f) return f->next;
132
    else  return first_oformat;
133
}
134

    
135
void av_register_input_format(AVInputFormat *format)
136
{
137
    AVInputFormat **p;
138
    p = &first_iformat;
139
    while (*p != NULL) p = &(*p)->next;
140
    *p = format;
141
    format->next = NULL;
142
}
143

    
144
void av_register_output_format(AVOutputFormat *format)
145
{
146
    AVOutputFormat **p;
147
    p = &first_oformat;
148
    while (*p != NULL) p = &(*p)->next;
149
    *p = format;
150
    format->next = NULL;
151
}
152

    
153
int av_match_ext(const char *filename, const char *extensions)
154
{
155
    const char *ext, *p;
156
    char ext1[32], *q;
157

    
158
    if(!filename)
159
        return 0;
160

    
161
    ext = strrchr(filename, '.');
162
    if (ext) {
163
        ext++;
164
        p = extensions;
165
        for(;;) {
166
            q = ext1;
167
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
168
                *q++ = *p++;
169
            *q = '\0';
170
            if (!strcasecmp(ext1, ext))
171
                return 1;
172
            if (*p == '\0')
173
                break;
174
            p++;
175
        }
176
    }
177
    return 0;
178
}
179

    
180
static int match_format(const char *name, const char *names)
181
{
182
    const char *p;
183
    int len, namelen;
184

    
185
    if (!name || !names)
186
        return 0;
187

    
188
    namelen = strlen(name);
189
    while ((p = strchr(names, ','))) {
190
        len = FFMAX(p - names, namelen);
191
        if (!strncasecmp(name, names, len))
192
            return 1;
193
        names = p+1;
194
    }
195
    return !strcasecmp(name, names);
196
}
197

    
198
#if FF_API_GUESS_FORMAT
199
AVOutputFormat *guess_format(const char *short_name, const char *filename,
200
                             const char *mime_type)
201
{
202
    return av_guess_format(short_name, filename, mime_type);
203
}
204
#endif
205

    
206
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
207
                                const char *mime_type)
208
{
209
    AVOutputFormat *fmt = NULL, *fmt_found;
210
    int score_max, score;
211

    
212
    /* specific test for image sequences */
213
#if CONFIG_IMAGE2_MUXER
214
    if (!short_name && filename &&
215
        av_filename_number_test(filename) &&
216
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
217
        return av_guess_format("image2", NULL, NULL);
218
    }
219
#endif
220
    /* Find the proper file type. */
221
    fmt_found = NULL;
222
    score_max = 0;
223
    while ((fmt = av_oformat_next(fmt))) {
224
        score = 0;
225
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
226
            score += 100;
227
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
228
            score += 10;
229
        if (filename && fmt->extensions &&
230
            av_match_ext(filename, fmt->extensions)) {
231
            score += 5;
232
        }
233
        if (score > score_max) {
234
            score_max = score;
235
            fmt_found = fmt;
236
        }
237
    }
238
    return fmt_found;
239
}
240

    
241
#if FF_API_GUESS_FORMAT
242
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
243
                             const char *mime_type)
244
{
245
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
246

    
247
    if (fmt) {
248
        AVOutputFormat *stream_fmt;
249
        char stream_format_name[64];
250

    
251
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
252
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
253

    
254
        if (stream_fmt)
255
            fmt = stream_fmt;
256
    }
257

    
258
    return fmt;
259
}
260
#endif
261

    
262
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
263
                            const char *filename, const char *mime_type, enum AVMediaType type){
264
    if(type == AVMEDIA_TYPE_VIDEO){
265
        enum CodecID codec_id= CODEC_ID_NONE;
266

    
267
#if CONFIG_IMAGE2_MUXER
268
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
269
            codec_id= av_guess_image2_codec(filename);
270
        }
271
#endif
272
        if(codec_id == CODEC_ID_NONE)
273
            codec_id= fmt->video_codec;
274
        return codec_id;
275
    }else if(type == AVMEDIA_TYPE_AUDIO)
276
        return fmt->audio_codec;
277
    else if (type == AVMEDIA_TYPE_SUBTITLE)
278
        return fmt->subtitle_codec;
279
    else
280
        return CODEC_ID_NONE;
281
}
282

    
283
AVInputFormat *av_find_input_format(const char *short_name)
284
{
285
    AVInputFormat *fmt = NULL;
286
    while ((fmt = av_iformat_next(fmt))) {
287
        if (match_format(short_name, fmt->name))
288
            return fmt;
289
    }
290
    return NULL;
291
}
292

    
293
#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
294
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
295
{
296
    av_destruct_packet_nofree(pkt);
297
}
298

    
299
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
300
{
301
    av_destruct_packet(pkt);
302
}
303

    
304
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
305
{
306
    return av_new_packet(pkt, size);
307
}
308

    
309
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
310
{
311
    return av_dup_packet(pkt);
312
}
313

    
314
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
315
{
316
    av_free_packet(pkt);
317
}
318

    
319
FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
320
{
321
    av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
322
    av_init_packet(pkt);
323
}
324
#endif
325

    
326
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
327
{
328
    int ret= av_new_packet(pkt, size);
329

    
330
    if(ret<0)
331
        return ret;
332

    
333
    pkt->pos= url_ftell(s);
334

    
335
    ret= get_buffer(s, pkt->data, size);
336
    if(ret<=0)
337
        av_free_packet(pkt);
338
    else
339
        av_shrink_packet(pkt, ret);
340

    
341
    return ret;
342
}
343

    
344
int av_append_packet(ByteIOContext *s, AVPacket *pkt, int size)
345
{
346
    int ret;
347
    int old_size;
348
    if (!pkt->size)
349
        return av_get_packet(s, pkt, size);
350
    old_size = pkt->size;
351
    ret = av_grow_packet(pkt, size);
352
    if (ret < 0)
353
        return ret;
354
    ret = get_buffer(s, pkt->data + old_size, size);
355
    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
356
    return ret;
357
}
358

    
359

    
360
int av_filename_number_test(const char *filename)
361
{
362
    char buf[1024];
363
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
364
}
365

    
366
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
367
{
368
    AVProbeData lpd = *pd;
369
    AVInputFormat *fmt1 = NULL, *fmt;
370
    int score;
371

    
372
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
373
        int id3len = ff_id3v2_tag_len(lpd.buf);
374
        if (lpd.buf_size > id3len + 16) {
375
            lpd.buf += id3len;
376
            lpd.buf_size -= id3len;
377
        }
378
    }
379

    
380
    fmt = NULL;
381
    while ((fmt1 = av_iformat_next(fmt1))) {
382
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
383
            continue;
384
        score = 0;
385
        if (fmt1->read_probe) {
386
            score = fmt1->read_probe(&lpd);
387
        } else if (fmt1->extensions) {
388
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
389
                score = 50;
390
            }
391
        }
392
        if (score > *score_max) {
393
            *score_max = score;
394
            fmt = fmt1;
395
        }else if (score == *score_max)
396
            fmt = NULL;
397
    }
398
    return fmt;
399
}
400

    
401
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
402
    int score=0;
403
    return av_probe_input_format2(pd, is_opened, &score);
404
}
405

    
406
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
407
{
408
    static const struct {
409
        const char *name; enum CodecID id; enum AVMediaType type;
410
    } fmt_id_type[] = {
411
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
412
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
413
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
414
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
415
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
416
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
417
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
418
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
419
        { 0 }
420
    };
421
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
422

    
423
    if (fmt) {
424
        int i;
425
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
426
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
427
        for (i = 0; fmt_id_type[i].name; i++) {
428
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
429
                st->codec->codec_id   = fmt_id_type[i].id;
430
                st->codec->codec_type = fmt_id_type[i].type;
431
                break;
432
            }
433
        }
434
    }
435
    return !!fmt;
436
}
437

    
438
/************************************************************/
439
/* input media file */
440

    
441
/**
442
 * Open a media file from an IO stream. 'fmt' must be specified.
443
 */
444
int av_open_input_stream(AVFormatContext **ic_ptr,
445
                         ByteIOContext *pb, const char *filename,
446
                         AVInputFormat *fmt, AVFormatParameters *ap)
447
{
448
    int err;
449
    AVFormatContext *ic;
450
    AVFormatParameters default_ap;
451

    
452
    if(!ap){
453
        ap=&default_ap;
454
        memset(ap, 0, sizeof(default_ap));
455
    }
456

    
457
    if(!ap->prealloced_context)
458
        ic = avformat_alloc_context();
459
    else
460
        ic = *ic_ptr;
461
    if (!ic) {
462
        err = AVERROR(ENOMEM);
463
        goto fail;
464
    }
465
    ic->iformat = fmt;
466
    ic->pb = pb;
467
    ic->duration = AV_NOPTS_VALUE;
468
    ic->start_time = AV_NOPTS_VALUE;
469
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
470

    
471
    /* allocate private data */
472
    if (fmt->priv_data_size > 0) {
473
        ic->priv_data = av_mallocz(fmt->priv_data_size);
474
        if (!ic->priv_data) {
475
            err = AVERROR(ENOMEM);
476
            goto fail;
477
        }
478
    } else {
479
        ic->priv_data = NULL;
480
    }
481

    
482
    // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
483
    if (ic->pb)
484
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
485

    
486
    if (ic->iformat->read_header) {
487
        err = ic->iformat->read_header(ic, ap);
488
        if (err < 0)
489
            goto fail;
490
    }
491

    
492
    if (pb && !ic->data_offset)
493
        ic->data_offset = url_ftell(ic->pb);
494

    
495
#if FF_API_OLD_METADATA
496
    ff_metadata_demux_compat(ic);
497
#endif
498

    
499
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
500

    
501
    *ic_ptr = ic;
502
    return 0;
503
 fail:
504
    if (ic) {
505
        int i;
506
        av_freep(&ic->priv_data);
507
        for(i=0;i<ic->nb_streams;i++) {
508
            AVStream *st = ic->streams[i];
509
            if (st) {
510
                av_free(st->priv_data);
511
                av_free(st->codec->extradata);
512
                av_free(st->codec);
513
                av_free(st->info);
514
            }
515
            av_free(st);
516
        }
517
    }
518
    av_free(ic);
519
    *ic_ptr = NULL;
520
    return err;
521
}
522

    
523
/** size of probe buffer, for guessing file type from file contents */
524
#define PROBE_BUF_MIN 2048
525
#define PROBE_BUF_MAX (1<<20)
526

    
527
int av_probe_input_buffer(ByteIOContext *pb, AVInputFormat **fmt,
528
                          const char *filename, void *logctx,
529
                          unsigned int offset, unsigned int max_probe_size)
530
{
531
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
532
    unsigned char *buf = NULL;
533
    int ret = 0, probe_size;
534

    
535
    if (!max_probe_size) {
536
        max_probe_size = PROBE_BUF_MAX;
537
    } else if (max_probe_size > PROBE_BUF_MAX) {
538
        max_probe_size = PROBE_BUF_MAX;
539
    } else if (max_probe_size < PROBE_BUF_MIN) {
540
        return AVERROR(EINVAL);
541
    }
542

    
543
    if (offset >= max_probe_size) {
544
        return AVERROR(EINVAL);
545
    }
546

    
547
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
548
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
549
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
550
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
551

    
552
        if (probe_size < offset) {
553
            continue;
554
        }
555

    
556
        /* read probe data */
557
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
558
        if ((ret = get_buffer(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
559
            /* fail if error was not end of file, otherwise, lower score */
560
            if (ret != AVERROR_EOF) {
561
                av_free(buf);
562
                return ret;
563
            }
564
            score = 0;
565
            ret = 0;            /* error was end of file, nothing read */
566
        }
567
        pd.buf_size += ret;
568
        pd.buf = &buf[offset];
569

    
570
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
571

    
572
        /* guess file format */
573
        *fmt = av_probe_input_format2(&pd, 1, &score);
574
        if(*fmt){
575
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
576
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
577
            }else
578
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
579
        }
580
    }
581

    
582
    if (!*fmt) {
583
        av_free(buf);
584
        return AVERROR_INVALIDDATA;
585
    }
586

    
587
    /* rewind. reuse probe buffer to avoid seeking */
588
    if ((ret = ff_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
589
        av_free(buf);
590

    
591
    return ret;
592
}
593

    
594
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
595
                       AVInputFormat *fmt,
596
                       int buf_size,
597
                       AVFormatParameters *ap)
598
{
599
    int err;
600
    AVProbeData probe_data, *pd = &probe_data;
601
    ByteIOContext *pb = NULL;
602
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
603

    
604
    pd->filename = "";
605
    if (filename)
606
        pd->filename = filename;
607
    pd->buf = NULL;
608
    pd->buf_size = 0;
609

    
610
    if (!fmt) {
611
        /* guess format if no file can be opened */
612
        fmt = av_probe_input_format(pd, 0);
613
    }
614

    
615
    /* Do not open file if the format does not need it. XXX: specific
616
       hack needed to handle RTSP/TCP */
617
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
618
        /* if no file needed do not try to open one */
619
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
620
            goto fail;
621
        }
622
        if (buf_size > 0) {
623
            url_setbufsize(pb, buf_size);
624
        }
625
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
626
            goto fail;
627
        }
628
    }
629

    
630
    /* if still no format found, error */
631
    if (!fmt) {
632
        err = AVERROR_INVALIDDATA;
633
        goto fail;
634
    }
635

    
636
    /* check filename in case an image number is expected */
637
    if (fmt->flags & AVFMT_NEEDNUMBER) {
638
        if (!av_filename_number_test(filename)) {
639
            err = AVERROR_NUMEXPECTED;
640
            goto fail;
641
        }
642
    }
643
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
644
    if (err)
645
        goto fail;
646
    return 0;
647
 fail:
648
    av_freep(&pd->buf);
649
    if (pb)
650
        url_fclose(pb);
651
    if (ap && ap->prealloced_context)
652
        av_free(*ic_ptr);
653
    *ic_ptr = NULL;
654
    return err;
655

    
656
}
657

    
658
/*******************************************************/
659

    
660
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
661
                               AVPacketList **plast_pktl){
662
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
663
    if (!pktl)
664
        return NULL;
665

    
666
    if (*packet_buffer)
667
        (*plast_pktl)->next = pktl;
668
    else
669
        *packet_buffer = pktl;
670

    
671
    /* add the packet in the buffered packet list */
672
    *plast_pktl = pktl;
673
    pktl->pkt= *pkt;
674
    return &pktl->pkt;
675
}
676

    
677
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
678
{
679
    int ret, i;
680
    AVStream *st;
681

    
682
    for(;;){
683
        AVPacketList *pktl = s->raw_packet_buffer;
684

    
685
        if (pktl) {
686
            *pkt = pktl->pkt;
687
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
688
               !s->streams[pkt->stream_index]->probe_packets ||
689
               s->raw_packet_buffer_remaining_size < pkt->size){
690
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
691
                av_freep(&pd->buf);
692
                pd->buf_size = 0;
693
                s->raw_packet_buffer = pktl->next;
694
                s->raw_packet_buffer_remaining_size += pkt->size;
695
                av_free(pktl);
696
                return 0;
697
            }
698
        }
699

    
700
        av_init_packet(pkt);
701
        ret= s->iformat->read_packet(s, pkt);
702
        if (ret < 0) {
703
            if (!pktl || ret == AVERROR(EAGAIN))
704
                return ret;
705
            for (i = 0; i < s->nb_streams; i++)
706
                s->streams[i]->probe_packets = 0;
707
            continue;
708
        }
709
        st= s->streams[pkt->stream_index];
710

    
711
        switch(st->codec->codec_type){
712
        case AVMEDIA_TYPE_VIDEO:
713
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
714
            break;
715
        case AVMEDIA_TYPE_AUDIO:
716
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
717
            break;
718
        case AVMEDIA_TYPE_SUBTITLE:
719
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
720
            break;
721
        }
722

    
723
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
724
                     !st->probe_packets))
725
            return ret;
726

    
727
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
728
        s->raw_packet_buffer_remaining_size -= pkt->size;
729

    
730
        if(st->codec->codec_id == CODEC_ID_PROBE){
731
            AVProbeData *pd = &st->probe_data;
732
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
733
            --st->probe_packets;
734

    
735
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
736
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
737
            pd->buf_size += pkt->size;
738
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
739

    
740
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
741
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
742
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
743
                if(st->codec->codec_id != CODEC_ID_PROBE){
744
                    pd->buf_size=0;
745
                    av_freep(&pd->buf);
746
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
747
                }
748
            }
749
        }
750
    }
751
}
752

    
753
/**********************************************************/
754

    
755
/**
756
 * Get the number of samples of an audio frame. Return -1 on error.
757
 */
758
static int get_audio_frame_size(AVCodecContext *enc, int size)
759
{
760
    int frame_size;
761

    
762
    if(enc->codec_id == CODEC_ID_VORBIS)
763
        return -1;
764

    
765
    if (enc->frame_size <= 1) {
766
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
767

    
768
        if (bits_per_sample) {
769
            if (enc->channels == 0)
770
                return -1;
771
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
772
        } else {
773
            /* used for example by ADPCM codecs */
774
            if (enc->bit_rate == 0)
775
                return -1;
776
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
777
        }
778
    } else {
779
        frame_size = enc->frame_size;
780
    }
781
    return frame_size;
782
}
783

    
784

    
785
/**
786
 * Return the frame duration in seconds. Return 0 if not available.
787
 */
788
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
789
                                   AVCodecParserContext *pc, AVPacket *pkt)
790
{
791
    int frame_size;
792

    
793
    *pnum = 0;
794
    *pden = 0;
795
    switch(st->codec->codec_type) {
796
    case AVMEDIA_TYPE_VIDEO:
797
        if(st->time_base.num*1000LL > st->time_base.den){
798
            *pnum = st->time_base.num;
799
            *pden = st->time_base.den;
800
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
801
            *pnum = st->codec->time_base.num;
802
            *pden = st->codec->time_base.den;
803
            if (pc && pc->repeat_pict) {
804
                *pnum = (*pnum) * (1 + pc->repeat_pict);
805
            }
806
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
807
            //Thus if we have no parser in such case leave duration undefined.
808
            if(st->codec->ticks_per_frame>1 && !pc){
809
                *pnum = *pden = 0;
810
            }
811
        }
812
        break;
813
    case AVMEDIA_TYPE_AUDIO:
814
        frame_size = get_audio_frame_size(st->codec, pkt->size);
815
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
816
            break;
817
        *pnum = frame_size;
818
        *pden = st->codec->sample_rate;
819
        break;
820
    default:
821
        break;
822
    }
823
}
824

    
825
static int is_intra_only(AVCodecContext *enc){
826
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
827
        return 1;
828
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
829
        switch(enc->codec_id){
830
        case CODEC_ID_MJPEG:
831
        case CODEC_ID_MJPEGB:
832
        case CODEC_ID_LJPEG:
833
        case CODEC_ID_RAWVIDEO:
834
        case CODEC_ID_DVVIDEO:
835
        case CODEC_ID_HUFFYUV:
836
        case CODEC_ID_FFVHUFF:
837
        case CODEC_ID_ASV1:
838
        case CODEC_ID_ASV2:
839
        case CODEC_ID_VCR1:
840
        case CODEC_ID_DNXHD:
841
        case CODEC_ID_JPEG2000:
842
            return 1;
843
        default: break;
844
        }
845
    }
846
    return 0;
847
}
848

    
849
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
850
                                      int64_t dts, int64_t pts)
851
{
852
    AVStream *st= s->streams[stream_index];
853
    AVPacketList *pktl= s->packet_buffer;
854

    
855
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
856
        return;
857

    
858
    st->first_dts= dts - st->cur_dts;
859
    st->cur_dts= dts;
860

    
861
    for(; pktl; pktl= pktl->next){
862
        if(pktl->pkt.stream_index != stream_index)
863
            continue;
864
        //FIXME think more about this check
865
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
866
            pktl->pkt.pts += st->first_dts;
867

    
868
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
869
            pktl->pkt.dts += st->first_dts;
870

    
871
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
872
            st->start_time= pktl->pkt.pts;
873
    }
874
    if (st->start_time == AV_NOPTS_VALUE)
875
        st->start_time = pts;
876
}
877

    
878
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
879
{
880
    AVPacketList *pktl= s->packet_buffer;
881
    int64_t cur_dts= 0;
882

    
883
    if(st->first_dts != AV_NOPTS_VALUE){
884
        cur_dts= st->first_dts;
885
        for(; pktl; pktl= pktl->next){
886
            if(pktl->pkt.stream_index == pkt->stream_index){
887
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
888
                    break;
889
                cur_dts -= pkt->duration;
890
            }
891
        }
892
        pktl= s->packet_buffer;
893
        st->first_dts = cur_dts;
894
    }else if(st->cur_dts)
895
        return;
896

    
897
    for(; pktl; pktl= pktl->next){
898
        if(pktl->pkt.stream_index != pkt->stream_index)
899
            continue;
900
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
901
           && !pktl->pkt.duration){
902
            pktl->pkt.dts= cur_dts;
903
            if(!st->codec->has_b_frames)
904
                pktl->pkt.pts= cur_dts;
905
            cur_dts += pkt->duration;
906
            pktl->pkt.duration= pkt->duration;
907
        }else
908
            break;
909
    }
910
    if(st->first_dts == AV_NOPTS_VALUE)
911
        st->cur_dts= cur_dts;
912
}
913

    
914
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
915
                               AVCodecParserContext *pc, AVPacket *pkt)
916
{
917
    int num, den, presentation_delayed, delay, i;
918
    int64_t offset;
919

    
920
    if (s->flags & AVFMT_FLAG_NOFILLIN)
921
        return;
922

    
923
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
924
        pkt->dts= AV_NOPTS_VALUE;
925

    
926
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
927
        //FIXME Set low_delay = 0 when has_b_frames = 1
928
        st->codec->has_b_frames = 1;
929

    
930
    /* do we have a video B-frame ? */
931
    delay= st->codec->has_b_frames;
932
    presentation_delayed = 0;
933

    
934
    // ignore delay caused by frame threading so that the mpeg2-without-dts
935
    // warning will not trigger
936
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
937
        delay -= st->codec->thread_count-1;
938

    
939
    /* XXX: need has_b_frame, but cannot get it if the codec is
940
        not initialized */
941
    if (delay &&
942
        pc && pc->pict_type != FF_B_TYPE)
943
        presentation_delayed = 1;
944

    
945
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
946
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
947
        pkt->dts -= 1LL<<st->pts_wrap_bits;
948
    }
949

    
950
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
951
    // we take the conservative approach and discard both
952
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
953
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
954
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
955
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
956
    }
957

    
958
    if (pkt->duration == 0) {
959
        compute_frame_duration(&num, &den, st, pc, pkt);
960
        if (den && num) {
961
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
962

    
963
            if(pkt->duration != 0 && s->packet_buffer)
964
                update_initial_durations(s, st, pkt);
965
        }
966
    }
967

    
968
    /* correct timestamps with byte offset if demuxers only have timestamps
969
       on packet boundaries */
970
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
971
        /* this will estimate bitrate based on this frame's duration and size */
972
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
973
        if(pkt->pts != AV_NOPTS_VALUE)
974
            pkt->pts += offset;
975
        if(pkt->dts != AV_NOPTS_VALUE)
976
            pkt->dts += offset;
977
    }
978

    
979
    if (pc && pc->dts_sync_point >= 0) {
980
        // we have synchronization info from the parser
981
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
982
        if (den > 0) {
983
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
984
            if (pkt->dts != AV_NOPTS_VALUE) {
985
                // got DTS from the stream, update reference timestamp
986
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
987
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
988
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
989
                // compute DTS based on reference timestamp
990
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
991
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
992
            }
993
            if (pc->dts_sync_point > 0)
994
                st->reference_dts = pkt->dts; // new reference
995
        }
996
    }
997

    
998
    /* This may be redundant, but it should not hurt. */
999
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1000
        presentation_delayed = 1;
1001

    
1002
//    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);
1003
    /* interpolate PTS and DTS if they are not present */
1004
    //We skip H264 currently because delay and has_b_frames are not reliably set
1005
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1006
        if (presentation_delayed) {
1007
            /* DTS = decompression timestamp */
1008
            /* PTS = presentation timestamp */
1009
            if (pkt->dts == AV_NOPTS_VALUE)
1010
                pkt->dts = st->last_IP_pts;
1011
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1012
            if (pkt->dts == AV_NOPTS_VALUE)
1013
                pkt->dts = st->cur_dts;
1014

    
1015
            /* this is tricky: the dts must be incremented by the duration
1016
            of the frame we are displaying, i.e. the last I- or P-frame */
1017
            if (st->last_IP_duration == 0)
1018
                st->last_IP_duration = pkt->duration;
1019
            if(pkt->dts != AV_NOPTS_VALUE)
1020
                st->cur_dts = pkt->dts + st->last_IP_duration;
1021
            st->last_IP_duration  = pkt->duration;
1022
            st->last_IP_pts= pkt->pts;
1023
            /* cannot compute PTS if not present (we can compute it only
1024
            by knowing the future */
1025
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1026
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1027
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1028
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1029
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1030
                    pkt->pts += pkt->duration;
1031
    //                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);
1032
                }
1033
            }
1034

    
1035
            /* presentation is not delayed : PTS and DTS are the same */
1036
            if(pkt->pts == AV_NOPTS_VALUE)
1037
                pkt->pts = pkt->dts;
1038
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1039
            if(pkt->pts == AV_NOPTS_VALUE)
1040
                pkt->pts = st->cur_dts;
1041
            pkt->dts = pkt->pts;
1042
            if(pkt->pts != AV_NOPTS_VALUE)
1043
                st->cur_dts = pkt->pts + pkt->duration;
1044
        }
1045
    }
1046

    
1047
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1048
        st->pts_buffer[0]= pkt->pts;
1049
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1050
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1051
        if(pkt->dts == AV_NOPTS_VALUE)
1052
            pkt->dts= st->pts_buffer[0];
1053
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1054
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1055
        }
1056
        if(pkt->dts > st->cur_dts)
1057
            st->cur_dts = pkt->dts;
1058
    }
1059

    
1060
//    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);
1061

    
1062
    /* update flags */
1063
    if(is_intra_only(st->codec))
1064
        pkt->flags |= AV_PKT_FLAG_KEY;
1065
    else if (pc) {
1066
        pkt->flags = 0;
1067
        /* keyframe computation */
1068
        if (pc->key_frame == 1)
1069
            pkt->flags |= AV_PKT_FLAG_KEY;
1070
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1071
            pkt->flags |= AV_PKT_FLAG_KEY;
1072
    }
1073
    if (pc)
1074
        pkt->convergence_duration = pc->convergence_duration;
1075
}
1076

    
1077

    
1078
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1079
{
1080
    AVStream *st;
1081
    int len, ret, i;
1082

    
1083
    av_init_packet(pkt);
1084

    
1085
    for(;;) {
1086
        /* select current input stream component */
1087
        st = s->cur_st;
1088
        if (st) {
1089
            if (!st->need_parsing || !st->parser) {
1090
                /* no parsing needed: we just output the packet as is */
1091
                /* raw data support */
1092
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1093
                compute_pkt_fields(s, st, NULL, pkt);
1094
                s->cur_st = NULL;
1095
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1096
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1097
                    ff_reduce_index(s, st->index);
1098
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1099
                }
1100
                break;
1101
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1102
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1103
                                       st->cur_ptr, st->cur_len,
1104
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1105
                                       st->cur_pkt.pos);
1106
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1107
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1108
                /* increment read pointer */
1109
                st->cur_ptr += len;
1110
                st->cur_len -= len;
1111

    
1112
                /* return packet if any */
1113
                if (pkt->size) {
1114
                got_packet:
1115
                    pkt->duration = 0;
1116
                    pkt->stream_index = st->index;
1117
                    pkt->pts = st->parser->pts;
1118
                    pkt->dts = st->parser->dts;
1119
                    pkt->pos = st->parser->pos;
1120
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1121
                        s->cur_st = NULL;
1122
                        pkt->destruct= st->cur_pkt.destruct;
1123
                        st->cur_pkt.destruct= NULL;
1124
                        st->cur_pkt.data    = NULL;
1125
                        assert(st->cur_len == 0);
1126
                    }else{
1127
                    pkt->destruct = NULL;
1128
                    }
1129
                    compute_pkt_fields(s, st, st->parser, pkt);
1130

    
1131
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1132
                        ff_reduce_index(s, st->index);
1133
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1134
                                           0, 0, AVINDEX_KEYFRAME);
1135
                    }
1136

    
1137
                    break;
1138
                }
1139
            } else {
1140
                /* free packet */
1141
                av_free_packet(&st->cur_pkt);
1142
                s->cur_st = NULL;
1143
            }
1144
        } else {
1145
            AVPacket cur_pkt;
1146
            /* read next packet */
1147
            ret = av_read_packet(s, &cur_pkt);
1148
            if (ret < 0) {
1149
                if (ret == AVERROR(EAGAIN))
1150
                    return ret;
1151
                /* return the last frames, if any */
1152
                for(i = 0; i < s->nb_streams; i++) {
1153
                    st = s->streams[i];
1154
                    if (st->parser && st->need_parsing) {
1155
                        av_parser_parse2(st->parser, st->codec,
1156
                                        &pkt->data, &pkt->size,
1157
                                        NULL, 0,
1158
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1159
                                        AV_NOPTS_VALUE);
1160
                        if (pkt->size)
1161
                            goto got_packet;
1162
                    }
1163
                }
1164
                /* no more packets: really terminate parsing */
1165
                return ret;
1166
            }
1167
            st = s->streams[cur_pkt.stream_index];
1168
            st->cur_pkt= cur_pkt;
1169

    
1170
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1171
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1172
               st->cur_pkt.pts < st->cur_pkt.dts){
1173
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1174
                    st->cur_pkt.stream_index,
1175
                    st->cur_pkt.pts,
1176
                    st->cur_pkt.dts,
1177
                    st->cur_pkt.size);
1178
//                av_free_packet(&st->cur_pkt);
1179
//                return -1;
1180
            }
1181

    
1182
            if(s->debug & FF_FDEBUG_TS)
1183
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1184
                    st->cur_pkt.stream_index,
1185
                    st->cur_pkt.pts,
1186
                    st->cur_pkt.dts,
1187
                    st->cur_pkt.size,
1188
                    st->cur_pkt.duration,
1189
                    st->cur_pkt.flags);
1190

    
1191
            s->cur_st = st;
1192
            st->cur_ptr = st->cur_pkt.data;
1193
            st->cur_len = st->cur_pkt.size;
1194
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1195
                st->parser = av_parser_init(st->codec->codec_id);
1196
                if (!st->parser) {
1197
                    /* no parser available: just output the raw packets */
1198
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1199
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1200
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1201
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1202
                    st->parser->flags |= PARSER_FLAG_ONCE;
1203
                }
1204
            }
1205
        }
1206
    }
1207
    if(s->debug & FF_FDEBUG_TS)
1208
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1209
            pkt->stream_index,
1210
            pkt->pts,
1211
            pkt->dts,
1212
            pkt->size,
1213
            pkt->duration,
1214
            pkt->flags);
1215

    
1216
    return 0;
1217
}
1218

    
1219
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1220
{
1221
    AVPacketList *pktl;
1222
    int eof=0;
1223
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1224

    
1225
    for(;;){
1226
        pktl = s->packet_buffer;
1227
        if (pktl) {
1228
            AVPacket *next_pkt= &pktl->pkt;
1229

    
1230
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1231
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1232
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1233
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1234
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1235
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1236
                        next_pkt->pts= pktl->pkt.dts;
1237
                    }
1238
                    pktl= pktl->next;
1239
                }
1240
                pktl = s->packet_buffer;
1241
            }
1242

    
1243
            if(   next_pkt->pts != AV_NOPTS_VALUE
1244
               || next_pkt->dts == AV_NOPTS_VALUE
1245
               || !genpts || eof){
1246
                /* read packet from packet buffer, if there is data */
1247
                *pkt = *next_pkt;
1248
                s->packet_buffer = pktl->next;
1249
                av_free(pktl);
1250
                return 0;
1251
            }
1252
        }
1253
        if(genpts){
1254
            int ret= av_read_frame_internal(s, pkt);
1255
            if(ret<0){
1256
                if(pktl && ret != AVERROR(EAGAIN)){
1257
                    eof=1;
1258
                    continue;
1259
                }else
1260
                    return ret;
1261
            }
1262

    
1263
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1264
                                           &s->packet_buffer_end)) < 0)
1265
                return AVERROR(ENOMEM);
1266
        }else{
1267
            assert(!s->packet_buffer);
1268
            return av_read_frame_internal(s, pkt);
1269
        }
1270
    }
1271
}
1272

    
1273
/* XXX: suppress the packet queue */
1274
static void flush_packet_queue(AVFormatContext *s)
1275
{
1276
    AVPacketList *pktl;
1277

    
1278
    for(;;) {
1279
        pktl = s->packet_buffer;
1280
        if (!pktl)
1281
            break;
1282
        s->packet_buffer = pktl->next;
1283
        av_free_packet(&pktl->pkt);
1284
        av_free(pktl);
1285
    }
1286
    while(s->raw_packet_buffer){
1287
        pktl = s->raw_packet_buffer;
1288
        s->raw_packet_buffer = pktl->next;
1289
        av_free_packet(&pktl->pkt);
1290
        av_free(pktl);
1291
    }
1292
    s->packet_buffer_end=
1293
    s->raw_packet_buffer_end= NULL;
1294
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1295
}
1296

    
1297
/*******************************************************/
1298
/* seek support */
1299

    
1300
int av_find_default_stream_index(AVFormatContext *s)
1301
{
1302
    int first_audio_index = -1;
1303
    int i;
1304
    AVStream *st;
1305

    
1306
    if (s->nb_streams <= 0)
1307
        return -1;
1308
    for(i = 0; i < s->nb_streams; i++) {
1309
        st = s->streams[i];
1310
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1311
            return i;
1312
        }
1313
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1314
            first_audio_index = i;
1315
    }
1316
    return first_audio_index >= 0 ? first_audio_index : 0;
1317
}
1318

    
1319
/**
1320
 * Flush the frame reader.
1321
 */
1322
void ff_read_frame_flush(AVFormatContext *s)
1323
{
1324
    AVStream *st;
1325
    int i, j;
1326

    
1327
    flush_packet_queue(s);
1328

    
1329
    s->cur_st = NULL;
1330

    
1331
    /* for each stream, reset read state */
1332
    for(i = 0; i < s->nb_streams; i++) {
1333
        st = s->streams[i];
1334

    
1335
        if (st->parser) {
1336
            av_parser_close(st->parser);
1337
            st->parser = NULL;
1338
            av_free_packet(&st->cur_pkt);
1339
        }
1340
        st->last_IP_pts = AV_NOPTS_VALUE;
1341
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1342
        st->reference_dts = AV_NOPTS_VALUE;
1343
        /* fail safe */
1344
        st->cur_ptr = NULL;
1345
        st->cur_len = 0;
1346

    
1347
        st->probe_packets = MAX_PROBE_PACKETS;
1348

    
1349
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1350
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1351
    }
1352
}
1353

    
1354
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1355
    int i;
1356

    
1357
    for(i = 0; i < s->nb_streams; i++) {
1358
        AVStream *st = s->streams[i];
1359

    
1360
        st->cur_dts = av_rescale(timestamp,
1361
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1362
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1363
    }
1364
}
1365

    
1366
void ff_reduce_index(AVFormatContext *s, int stream_index)
1367
{
1368
    AVStream *st= s->streams[stream_index];
1369
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1370

    
1371
    if((unsigned)st->nb_index_entries >= max_entries){
1372
        int i;
1373
        for(i=0; 2*i<st->nb_index_entries; i++)
1374
            st->index_entries[i]= st->index_entries[2*i];
1375
        st->nb_index_entries= i;
1376
    }
1377
}
1378

    
1379
int ff_add_index_entry(AVIndexEntry **index_entries,
1380
                       int *nb_index_entries,
1381
                       unsigned int *index_entries_allocated_size,
1382
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1383
{
1384
    AVIndexEntry *entries, *ie;
1385
    int index;
1386

    
1387
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1388
        return -1;
1389

    
1390
    entries = av_fast_realloc(*index_entries,
1391
                              index_entries_allocated_size,
1392
                              (*nb_index_entries + 1) *
1393
                              sizeof(AVIndexEntry));
1394
    if(!entries)
1395
        return -1;
1396

    
1397
    *index_entries= entries;
1398

    
1399
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1400

    
1401
    if(index<0){
1402
        index= (*nb_index_entries)++;
1403
        ie= &entries[index];
1404
        assert(index==0 || ie[-1].timestamp < timestamp);
1405
    }else{
1406
        ie= &entries[index];
1407
        if(ie->timestamp != timestamp){
1408
            if(ie->timestamp <= timestamp)
1409
                return -1;
1410
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1411
            (*nb_index_entries)++;
1412
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1413
            distance= ie->min_distance;
1414
    }
1415

    
1416
    ie->pos = pos;
1417
    ie->timestamp = timestamp;
1418
    ie->min_distance= distance;
1419
    ie->size= size;
1420
    ie->flags = flags;
1421

    
1422
    return index;
1423
}
1424

    
1425
int av_add_index_entry(AVStream *st,
1426
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1427
{
1428
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1429
                              &st->index_entries_allocated_size, pos,
1430
                              timestamp, size, distance, flags);
1431
}
1432

    
1433
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1434
                              int64_t wanted_timestamp, int flags)
1435
{
1436
    int a, b, m;
1437
    int64_t timestamp;
1438

    
1439
    a = - 1;
1440
    b = nb_entries;
1441

    
1442
    //optimize appending index entries at the end
1443
    if(b && entries[b-1].timestamp < wanted_timestamp)
1444
        a= b-1;
1445

    
1446
    while (b - a > 1) {
1447
        m = (a + b) >> 1;
1448
        timestamp = entries[m].timestamp;
1449
        if(timestamp >= wanted_timestamp)
1450
            b = m;
1451
        if(timestamp <= wanted_timestamp)
1452
            a = m;
1453
    }
1454
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1455

    
1456
    if(!(flags & AVSEEK_FLAG_ANY)){
1457
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1458
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1459
        }
1460
    }
1461

    
1462
    if(m == nb_entries)
1463
        return -1;
1464
    return  m;
1465
}
1466

    
1467
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1468
                              int flags)
1469
{
1470
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1471
                                     wanted_timestamp, flags);
1472
}
1473

    
1474
#define DEBUG_SEEK
1475

    
1476
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1477
    AVInputFormat *avif= s->iformat;
1478
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1479
    int64_t ts_min, ts_max, ts;
1480
    int index;
1481
    int64_t ret;
1482
    AVStream *st;
1483

    
1484
    if (stream_index < 0)
1485
        return -1;
1486

    
1487
#ifdef DEBUG_SEEK
1488
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1489
#endif
1490

    
1491
    ts_max=
1492
    ts_min= AV_NOPTS_VALUE;
1493
    pos_limit= -1; //gcc falsely says it may be uninitialized
1494

    
1495
    st= s->streams[stream_index];
1496
    if(st->index_entries){
1497
        AVIndexEntry *e;
1498

    
1499
        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()
1500
        index= FFMAX(index, 0);
1501
        e= &st->index_entries[index];
1502

    
1503
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1504
            pos_min= e->pos;
1505
            ts_min= e->timestamp;
1506
#ifdef DEBUG_SEEK
1507
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1508
                   pos_min,ts_min);
1509
#endif
1510
        }else{
1511
            assert(index==0);
1512
        }
1513

    
1514
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1515
        assert(index < st->nb_index_entries);
1516
        if(index >= 0){
1517
            e= &st->index_entries[index];
1518
            assert(e->timestamp >= target_ts);
1519
            pos_max= e->pos;
1520
            ts_max= e->timestamp;
1521
            pos_limit= pos_max - e->min_distance;
1522
#ifdef DEBUG_SEEK
1523
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1524
                   pos_max,pos_limit, ts_max);
1525
#endif
1526
        }
1527
    }
1528

    
1529
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1530
    if(pos<0)
1531
        return -1;
1532

    
1533
    /* do the seek */
1534
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1535
        return ret;
1536

    
1537
    av_update_cur_dts(s, st, ts);
1538

    
1539
    return 0;
1540
}
1541

    
1542
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 )){
1543
    int64_t pos, ts;
1544
    int64_t start_pos, filesize;
1545
    int no_change;
1546

    
1547
#ifdef DEBUG_SEEK
1548
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1549
#endif
1550

    
1551
    if(ts_min == AV_NOPTS_VALUE){
1552
        pos_min = s->data_offset;
1553
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1554
        if (ts_min == AV_NOPTS_VALUE)
1555
            return -1;
1556
    }
1557

    
1558
    if(ts_max == AV_NOPTS_VALUE){
1559
        int step= 1024;
1560
        filesize = url_fsize(s->pb);
1561
        pos_max = filesize - 1;
1562
        do{
1563
            pos_max -= step;
1564
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1565
            step += step;
1566
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1567
        if (ts_max == AV_NOPTS_VALUE)
1568
            return -1;
1569

    
1570
        for(;;){
1571
            int64_t tmp_pos= pos_max + 1;
1572
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1573
            if(tmp_ts == AV_NOPTS_VALUE)
1574
                break;
1575
            ts_max= tmp_ts;
1576
            pos_max= tmp_pos;
1577
            if(tmp_pos >= filesize)
1578
                break;
1579
        }
1580
        pos_limit= pos_max;
1581
    }
1582

    
1583
    if(ts_min > ts_max){
1584
        return -1;
1585
    }else if(ts_min == ts_max){
1586
        pos_limit= pos_min;
1587
    }
1588

    
1589
    no_change=0;
1590
    while (pos_min < pos_limit) {
1591
#ifdef DEBUG_SEEK
1592
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1593
               pos_min, pos_max,
1594
               ts_min, ts_max);
1595
#endif
1596
        assert(pos_limit <= pos_max);
1597

    
1598
        if(no_change==0){
1599
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1600
            // interpolate position (better than dichotomy)
1601
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1602
                + pos_min - approximate_keyframe_distance;
1603
        }else if(no_change==1){
1604
            // bisection, if interpolation failed to change min or max pos last time
1605
            pos = (pos_min + pos_limit)>>1;
1606
        }else{
1607
            /* linear search if bisection failed, can only happen if there
1608
               are very few or no keyframes between min/max */
1609
            pos=pos_min;
1610
        }
1611
        if(pos <= pos_min)
1612
            pos= pos_min + 1;
1613
        else if(pos > pos_limit)
1614
            pos= pos_limit;
1615
        start_pos= pos;
1616

    
1617
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1618
        if(pos == pos_max)
1619
            no_change++;
1620
        else
1621
            no_change=0;
1622
#ifdef DEBUG_SEEK
1623
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1624
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1625
               start_pos, no_change);
1626
#endif
1627
        if(ts == AV_NOPTS_VALUE){
1628
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1629
            return -1;
1630
        }
1631
        assert(ts != AV_NOPTS_VALUE);
1632
        if (target_ts <= ts) {
1633
            pos_limit = start_pos - 1;
1634
            pos_max = pos;
1635
            ts_max = ts;
1636
        }
1637
        if (target_ts >= ts) {
1638
            pos_min = pos;
1639
            ts_min = ts;
1640
        }
1641
    }
1642

    
1643
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1644
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1645
#ifdef DEBUG_SEEK
1646
    pos_min = pos;
1647
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1648
    pos_min++;
1649
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1650
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1651
           pos, ts_min, target_ts, ts_max);
1652
#endif
1653
    *ts_ret= ts;
1654
    return pos;
1655
}
1656

    
1657
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1658
    int64_t pos_min, pos_max;
1659
#if 0
1660
    AVStream *st;
1661

1662
    if (stream_index < 0)
1663
        return -1;
1664

1665
    st= s->streams[stream_index];
1666
#endif
1667

    
1668
    pos_min = s->data_offset;
1669
    pos_max = url_fsize(s->pb) - 1;
1670

    
1671
    if     (pos < pos_min) pos= pos_min;
1672
    else if(pos > pos_max) pos= pos_max;
1673

    
1674
    url_fseek(s->pb, pos, SEEK_SET);
1675

    
1676
#if 0
1677
    av_update_cur_dts(s, st, ts);
1678
#endif
1679
    return 0;
1680
}
1681

    
1682
static int av_seek_frame_generic(AVFormatContext *s,
1683
                                 int stream_index, int64_t timestamp, int flags)
1684
{
1685
    int index;
1686
    int64_t ret;
1687
    AVStream *st;
1688
    AVIndexEntry *ie;
1689

    
1690
    st = s->streams[stream_index];
1691

    
1692
    index = av_index_search_timestamp(st, timestamp, flags);
1693

    
1694
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1695
        return -1;
1696

    
1697
    if(index < 0 || index==st->nb_index_entries-1){
1698
        int i;
1699
        AVPacket pkt;
1700

    
1701
        if(st->nb_index_entries){
1702
            assert(st->index_entries);
1703
            ie= &st->index_entries[st->nb_index_entries-1];
1704
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1705
                return ret;
1706
            av_update_cur_dts(s, st, ie->timestamp);
1707
        }else{
1708
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1709
                return ret;
1710
        }
1711
        for(i=0;; i++) {
1712
            int ret;
1713
            do{
1714
                ret = av_read_frame(s, &pkt);
1715
            }while(ret == AVERROR(EAGAIN));
1716
            if(ret<0)
1717
                break;
1718
            av_free_packet(&pkt);
1719
            if(stream_index == pkt.stream_index){
1720
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1721
                    break;
1722
            }
1723
        }
1724
        index = av_index_search_timestamp(st, timestamp, flags);
1725
    }
1726
    if (index < 0)
1727
        return -1;
1728

    
1729
    ff_read_frame_flush(s);
1730
    if (s->iformat->read_seek){
1731
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1732
            return 0;
1733
    }
1734
    ie = &st->index_entries[index];
1735
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1736
        return ret;
1737
    av_update_cur_dts(s, st, ie->timestamp);
1738

    
1739
    return 0;
1740
}
1741

    
1742
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1743
{
1744
    int ret;
1745
    AVStream *st;
1746

    
1747
    ff_read_frame_flush(s);
1748

    
1749
    if(flags & AVSEEK_FLAG_BYTE)
1750
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1751

    
1752
    if(stream_index < 0){
1753
        stream_index= av_find_default_stream_index(s);
1754
        if(stream_index < 0)
1755
            return -1;
1756

    
1757
        st= s->streams[stream_index];
1758
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1759
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1760
    }
1761

    
1762
    /* first, we try the format specific seek */
1763
    if (s->iformat->read_seek)
1764
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1765
    else
1766
        ret = -1;
1767
    if (ret >= 0) {
1768
        return 0;
1769
    }
1770

    
1771
    if(s->iformat->read_timestamp)
1772
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1773
    else
1774
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1775
}
1776

    
1777
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1778
{
1779
    if(min_ts > ts || max_ts < ts)
1780
        return -1;
1781

    
1782
    ff_read_frame_flush(s);
1783

    
1784
    if (s->iformat->read_seek2)
1785
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1786

    
1787
    if(s->iformat->read_timestamp){
1788
        //try to seek via read_timestamp()
1789
    }
1790

    
1791
    //Fallback to old API if new is not implemented but old is
1792
    //Note the old has somewat different sematics
1793
    if(s->iformat->read_seek || 1)
1794
        return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1795

    
1796
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1797
}
1798

    
1799
/*******************************************************/
1800

    
1801
/**
1802
 * Return TRUE if the stream has accurate duration in any stream.
1803
 *
1804
 * @return TRUE if the stream has accurate duration for at least one component.
1805
 */
1806
static int av_has_duration(AVFormatContext *ic)
1807
{
1808
    int i;
1809
    AVStream *st;
1810

    
1811
    for(i = 0;i < ic->nb_streams; i++) {
1812
        st = ic->streams[i];
1813
        if (st->duration != AV_NOPTS_VALUE)
1814
            return 1;
1815
    }
1816
    return 0;
1817
}
1818

    
1819
/**
1820
 * Estimate the stream timings from the one of each components.
1821
 *
1822
 * Also computes the global bitrate if possible.
1823
 */
1824
static void av_update_stream_timings(AVFormatContext *ic)
1825
{
1826
    int64_t start_time, start_time1, end_time, end_time1;
1827
    int64_t duration, duration1;
1828
    int i;
1829
    AVStream *st;
1830

    
1831
    start_time = INT64_MAX;
1832
    end_time = INT64_MIN;
1833
    duration = INT64_MIN;
1834
    for(i = 0;i < ic->nb_streams; i++) {
1835
        st = ic->streams[i];
1836
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1837
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1838
            if (start_time1 < start_time)
1839
                start_time = start_time1;
1840
            if (st->duration != AV_NOPTS_VALUE) {
1841
                end_time1 = start_time1
1842
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1843
                if (end_time1 > end_time)
1844
                    end_time = end_time1;
1845
            }
1846
        }
1847
        if (st->duration != AV_NOPTS_VALUE) {
1848
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1849
            if (duration1 > duration)
1850
                duration = duration1;
1851
        }
1852
    }
1853
    if (start_time != INT64_MAX) {
1854
        ic->start_time = start_time;
1855
        if (end_time != INT64_MIN) {
1856
            if (end_time - start_time > duration)
1857
                duration = end_time - start_time;
1858
        }
1859
    }
1860
    if (duration != INT64_MIN) {
1861
        ic->duration = duration;
1862
        if (ic->file_size > 0) {
1863
            /* compute the bitrate */
1864
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1865
                (double)ic->duration;
1866
        }
1867
    }
1868
}
1869

    
1870
static void fill_all_stream_timings(AVFormatContext *ic)
1871
{
1872
    int i;
1873
    AVStream *st;
1874

    
1875
    av_update_stream_timings(ic);
1876
    for(i = 0;i < ic->nb_streams; i++) {
1877
        st = ic->streams[i];
1878
        if (st->start_time == AV_NOPTS_VALUE) {
1879
            if(ic->start_time != AV_NOPTS_VALUE)
1880
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1881
            if(ic->duration != AV_NOPTS_VALUE)
1882
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1883
        }
1884
    }
1885
}
1886

    
1887
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1888
{
1889
    int64_t filesize, duration;
1890
    int bit_rate, i;
1891
    AVStream *st;
1892

    
1893
    /* if bit_rate is already set, we believe it */
1894
    if (ic->bit_rate <= 0) {
1895
        bit_rate = 0;
1896
        for(i=0;i<ic->nb_streams;i++) {
1897
            st = ic->streams[i];
1898
            if (st->codec->bit_rate > 0)
1899
            bit_rate += st->codec->bit_rate;
1900
        }
1901
        ic->bit_rate = bit_rate;
1902
    }
1903

    
1904
    /* if duration is already set, we believe it */
1905
    if (ic->duration == AV_NOPTS_VALUE &&
1906
        ic->bit_rate != 0 &&
1907
        ic->file_size != 0)  {
1908
        filesize = ic->file_size;
1909
        if (filesize > 0) {
1910
            for(i = 0; i < ic->nb_streams; i++) {
1911
                st = ic->streams[i];
1912
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1913
                if (st->duration == AV_NOPTS_VALUE)
1914
                    st->duration = duration;
1915
            }
1916
        }
1917
    }
1918
}
1919

    
1920
#define DURATION_MAX_READ_SIZE 250000
1921
#define DURATION_MAX_RETRY 3
1922

    
1923
/* only usable for MPEG-PS streams */
1924
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1925
{
1926
    AVPacket pkt1, *pkt = &pkt1;
1927
    AVStream *st;
1928
    int read_size, i, ret;
1929
    int64_t end_time;
1930
    int64_t filesize, offset, duration;
1931
    int retry=0;
1932

    
1933
    ic->cur_st = NULL;
1934

    
1935
    /* flush packet queue */
1936
    flush_packet_queue(ic);
1937

    
1938
    for (i=0; i<ic->nb_streams; i++) {
1939
        st = ic->streams[i];
1940
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1941
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1942

    
1943
        if (st->parser) {
1944
            av_parser_close(st->parser);
1945
            st->parser= NULL;
1946
            av_free_packet(&st->cur_pkt);
1947
        }
1948
    }
1949

    
1950
    /* estimate the end time (duration) */
1951
    /* XXX: may need to support wrapping */
1952
    filesize = ic->file_size;
1953
    end_time = AV_NOPTS_VALUE;
1954
    do{
1955
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1956
    if (offset < 0)
1957
        offset = 0;
1958

    
1959
    url_fseek(ic->pb, offset, SEEK_SET);
1960
    read_size = 0;
1961
    for(;;) {
1962
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1963
            break;
1964

    
1965
        do{
1966
            ret = av_read_packet(ic, pkt);
1967
        }while(ret == AVERROR(EAGAIN));
1968
        if (ret != 0)
1969
            break;
1970
        read_size += pkt->size;
1971
        st = ic->streams[pkt->stream_index];
1972
        if (pkt->pts != AV_NOPTS_VALUE &&
1973
            (st->start_time != AV_NOPTS_VALUE ||
1974
             st->first_dts  != AV_NOPTS_VALUE)) {
1975
            duration = end_time = pkt->pts;
1976
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1977
            else                                   duration -= st->first_dts;
1978
            if (duration < 0)
1979
                duration += 1LL<<st->pts_wrap_bits;
1980
            if (duration > 0) {
1981
                if (st->duration == AV_NOPTS_VALUE ||
1982
                    st->duration < duration)
1983
                    st->duration = duration;
1984
            }
1985
        }
1986
        av_free_packet(pkt);
1987
    }
1988
    }while(   end_time==AV_NOPTS_VALUE
1989
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1990
           && ++retry <= DURATION_MAX_RETRY);
1991

    
1992
    fill_all_stream_timings(ic);
1993

    
1994
    url_fseek(ic->pb, old_offset, SEEK_SET);
1995
    for (i=0; i<ic->nb_streams; i++) {
1996
        st= ic->streams[i];
1997
        st->cur_dts= st->first_dts;
1998
        st->last_IP_pts = AV_NOPTS_VALUE;
1999
    }
2000
}
2001

    
2002
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2003
{
2004
    int64_t file_size;
2005

    
2006
    /* get the file size, if possible */
2007
    if (ic->iformat->flags & AVFMT_NOFILE) {
2008
        file_size = 0;
2009
    } else {
2010
        file_size = url_fsize(ic->pb);
2011
        if (file_size < 0)
2012
            file_size = 0;
2013
    }
2014
    ic->file_size = file_size;
2015

    
2016
    if ((!strcmp(ic->iformat->name, "mpeg") ||
2017
         !strcmp(ic->iformat->name, "mpegts")) &&
2018
        file_size && !url_is_streamed(ic->pb)) {
2019
        /* get accurate estimate from the PTSes */
2020
        av_estimate_timings_from_pts(ic, old_offset);
2021
    } else if (av_has_duration(ic)) {
2022
        /* at least one component has timings - we use them for all
2023
           the components */
2024
        fill_all_stream_timings(ic);
2025
    } else {
2026
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2027
        /* less precise: use bitrate info */
2028
        av_estimate_timings_from_bit_rate(ic);
2029
    }
2030
    av_update_stream_timings(ic);
2031

    
2032
#if 0
2033
    {
2034
        int i;
2035
        AVStream *st;
2036
        for(i = 0;i < ic->nb_streams; i++) {
2037
            st = ic->streams[i];
2038
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2039
               i, (double)st->start_time / AV_TIME_BASE,
2040
               (double)st->duration / AV_TIME_BASE);
2041
        }
2042
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2043
               (double)ic->start_time / AV_TIME_BASE,
2044
               (double)ic->duration / AV_TIME_BASE,
2045
               ic->bit_rate / 1000);
2046
    }
2047
#endif
2048
}
2049

    
2050
static int has_codec_parameters(AVCodecContext *enc)
2051
{
2052
    int val;
2053
    switch(enc->codec_type) {
2054
    case AVMEDIA_TYPE_AUDIO:
2055
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2056
        if(!enc->frame_size &&
2057
           (enc->codec_id == CODEC_ID_VORBIS ||
2058
            enc->codec_id == CODEC_ID_AAC ||
2059
            enc->codec_id == CODEC_ID_MP1 ||
2060
            enc->codec_id == CODEC_ID_MP2 ||
2061
            enc->codec_id == CODEC_ID_MP3 ||
2062
            enc->codec_id == CODEC_ID_SPEEX))
2063
            return 0;
2064
        break;
2065
    case AVMEDIA_TYPE_VIDEO:
2066
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2067
        break;
2068
    default:
2069
        val = 1;
2070
        break;
2071
    }
2072
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2073
}
2074

    
2075
static int has_decode_delay_been_guessed(AVStream *st)
2076
{
2077
    return st->codec->codec_id != CODEC_ID_H264 ||
2078
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2079
}
2080

    
2081
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2082
{
2083
    int16_t *samples;
2084
    AVCodec *codec;
2085
    int got_picture, data_size, ret=0;
2086
    AVFrame picture;
2087

    
2088
    if(!st->codec->codec){
2089
        codec = avcodec_find_decoder(st->codec->codec_id);
2090
        if (!codec)
2091
            return -1;
2092
        ret = avcodec_open(st->codec, codec);
2093
        if (ret < 0)
2094
            return ret;
2095
    }
2096

    
2097
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2098
        switch(st->codec->codec_type) {
2099
        case AVMEDIA_TYPE_VIDEO:
2100
            avcodec_get_frame_defaults(&picture);
2101
            ret = avcodec_decode_video2(st->codec, &picture,
2102
                                        &got_picture, avpkt);
2103
            break;
2104
        case AVMEDIA_TYPE_AUDIO:
2105
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2106
            samples = av_malloc(data_size);
2107
            if (!samples)
2108
                goto fail;
2109
            ret = avcodec_decode_audio3(st->codec, samples,
2110
                                        &data_size, avpkt);
2111
            av_free(samples);
2112
            break;
2113
        default:
2114
            break;
2115
        }
2116
    }
2117
 fail:
2118
    return ret;
2119
}
2120

    
2121
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2122
{
2123
    while (tags->id != CODEC_ID_NONE) {
2124
        if (tags->id == id)
2125
            return tags->tag;
2126
        tags++;
2127
    }
2128
    return 0;
2129
}
2130

    
2131
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2132
{
2133
    int i;
2134
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2135
        if(tag == tags[i].tag)
2136
            return tags[i].id;
2137
    }
2138
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2139
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2140
            return tags[i].id;
2141
    }
2142
    return CODEC_ID_NONE;
2143
}
2144

    
2145
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2146
{
2147
    int i;
2148
    for(i=0; tags && tags[i]; i++){
2149
        int tag= ff_codec_get_tag(tags[i], id);
2150
        if(tag) return tag;
2151
    }
2152
    return 0;
2153
}
2154

    
2155
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2156
{
2157
    int i;
2158
    for(i=0; tags && tags[i]; i++){
2159
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2160
        if(id!=CODEC_ID_NONE) return id;
2161
    }
2162
    return CODEC_ID_NONE;
2163
}
2164

    
2165
static void compute_chapters_end(AVFormatContext *s)
2166
{
2167
    unsigned int i;
2168

    
2169
    for (i=0; i+1<s->nb_chapters; i++)
2170
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2171
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2172
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2173
            s->chapters[i]->end = s->chapters[i+1]->start;
2174
        }
2175

    
2176
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2177
        assert(s->start_time != AV_NOPTS_VALUE);
2178
        assert(s->duration > 0);
2179
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2180
                                           AV_TIME_BASE_Q,
2181
                                           s->chapters[i]->time_base);
2182
    }
2183
}
2184

    
2185
static int get_std_framerate(int i){
2186
    if(i<60*12) return i*1001;
2187
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2188
}
2189

    
2190
/*
2191
 * Is the time base unreliable.
2192
 * This is a heuristic to balance between quick acceptance of the values in
2193
 * the headers vs. some extra checks.
2194
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2195
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2196
 * And there are "variable" fps files this needs to detect as well.
2197
 */
2198
static int tb_unreliable(AVCodecContext *c){
2199
    if(   c->time_base.den >= 101L*c->time_base.num
2200
       || c->time_base.den <    5L*c->time_base.num
2201
/*       || c->codec_tag == AV_RL32("DIVX")
2202
       || c->codec_tag == AV_RL32("XVID")*/
2203
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2204
       || c->codec_id == CODEC_ID_H264
2205
       )
2206
        return 1;
2207
    return 0;
2208
}
2209

    
2210
int av_find_stream_info(AVFormatContext *ic)
2211
{
2212
    int i, count, ret, read_size, j;
2213
    AVStream *st;
2214
    AVPacket pkt1, *pkt;
2215
    int64_t old_offset = url_ftell(ic->pb);
2216

    
2217
    for(i=0;i<ic->nb_streams;i++) {
2218
        AVCodec *codec;
2219
        st = ic->streams[i];
2220
        if (st->codec->codec_id == CODEC_ID_AAC) {
2221
            st->codec->sample_rate = 0;
2222
            st->codec->frame_size = 0;
2223
            st->codec->channels = 0;
2224
        }
2225
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2226
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2227
/*            if(!st->time_base.num)
2228
                st->time_base= */
2229
            if(!st->codec->time_base.num)
2230
                st->codec->time_base= st->time_base;
2231
        }
2232
        //only for the split stuff
2233
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2234
            st->parser = av_parser_init(st->codec->codec_id);
2235
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2236
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2237
            }
2238
        }
2239
        assert(!st->codec->codec);
2240
        codec = avcodec_find_decoder(st->codec->codec_id);
2241

    
2242
        /* Force decoding of at least one frame of codec data
2243
         * this makes sure the codec initializes the channel configuration
2244
         * and does not trust the values from the container.
2245
         */
2246
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2247
            st->codec->channels = 0;
2248

    
2249
        /* Ensure that subtitle_header is properly set. */
2250
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2251
            && codec && !st->codec->codec)
2252
            avcodec_open(st->codec, codec);
2253

    
2254
        //try to just open decoders, in case this is enough to get parameters
2255
        if(!has_codec_parameters(st->codec)){
2256
            if (codec && !st->codec->codec)
2257
                avcodec_open(st->codec, codec);
2258
        }
2259
    }
2260

    
2261
    for (i=0; i<ic->nb_streams; i++) {
2262
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2263
    }
2264

    
2265
    count = 0;
2266
    read_size = 0;
2267
    for(;;) {
2268
        if(url_interrupt_cb()){
2269
            ret= AVERROR(EINTR);
2270
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2271
            break;
2272
        }
2273

    
2274
        /* check if one codec still needs to be handled */
2275
        for(i=0;i<ic->nb_streams;i++) {
2276
            st = ic->streams[i];
2277
            if (!has_codec_parameters(st->codec))
2278
                break;
2279
            /* variable fps and no guess at the real fps */
2280
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2281
               && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2282
                break;
2283
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2284
                break;
2285
            if(st->first_dts == AV_NOPTS_VALUE)
2286
                break;
2287
        }
2288
        if (i == ic->nb_streams) {
2289
            /* NOTE: if the format has no header, then we need to read
2290
               some packets to get most of the streams, so we cannot
2291
               stop here */
2292
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2293
                /* if we found the info for all the codecs, we can stop */
2294
                ret = count;
2295
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2296
                break;
2297
            }
2298
        }
2299
        /* we did not get all the codec info, but we read too much data */
2300
        if (read_size >= ic->probesize) {
2301
            ret = count;
2302
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2303
            break;
2304
        }
2305

    
2306
        /* NOTE: a new stream can be added there if no header in file
2307
           (AVFMTCTX_NOHEADER) */
2308
        ret = av_read_frame_internal(ic, &pkt1);
2309
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2310
            /* EOF or error */
2311
            ret = -1; /* we could not have all the codec parameters before EOF */
2312
            for(i=0;i<ic->nb_streams;i++) {
2313
                st = ic->streams[i];
2314
                if (!has_codec_parameters(st->codec)){
2315
                    char buf[256];
2316
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2317
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2318
                } else {
2319
                    ret = 0;
2320
                }
2321
            }
2322
            break;
2323
        }
2324

    
2325
        if (ret == AVERROR(EAGAIN))
2326
            continue;
2327

    
2328
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2329
        if ((ret = av_dup_packet(pkt)) < 0)
2330
            goto find_stream_info_err;
2331

    
2332
        read_size += pkt->size;
2333

    
2334
        st = ic->streams[pkt->stream_index];
2335
        if (st->codec_info_nb_frames>1) {
2336
            if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2337
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2338
                break;
2339
            }
2340
            st->info->codec_info_duration += pkt->duration;
2341
        }
2342
        {
2343
            int64_t last = st->info->last_dts;
2344
            int64_t duration= pkt->dts - last;
2345

    
2346
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2347
                double dur= duration * av_q2d(st->time_base);
2348

    
2349
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2350
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2351
                if (st->info->duration_count < 2)
2352
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2353
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2354
                    int framerate= get_std_framerate(i);
2355
                    int ticks= lrintf(dur*framerate/(1001*12));
2356
                    double error= dur - ticks*1001*12/(double)framerate;
2357
                    st->info->duration_error[i] += error*error;
2358
                }
2359
                st->info->duration_count++;
2360
                // ignore the first 4 values, they might have some random jitter
2361
                if (st->info->duration_count > 3)
2362
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2363
            }
2364
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2365
                st->info->last_dts = pkt->dts;
2366
        }
2367
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2368
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2369
            if(i){
2370
                st->codec->extradata_size= i;
2371
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2372
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2373
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2374
            }
2375
        }
2376

    
2377
        /* if still no information, we try to open the codec and to
2378
           decompress the frame. We try to avoid that in most cases as
2379
           it takes longer and uses more memory. For MPEG-4, we need to
2380
           decompress for QuickTime. */
2381
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2382
            try_decode_frame(st, pkt);
2383

    
2384
        st->codec_info_nb_frames++;
2385
        count++;
2386
    }
2387

    
2388
    // close codecs which were opened in try_decode_frame()
2389
    for(i=0;i<ic->nb_streams;i++) {
2390
        st = ic->streams[i];
2391
        if(st->codec->codec)
2392
            avcodec_close(st->codec);
2393
    }
2394
    for(i=0;i<ic->nb_streams;i++) {
2395
        st = ic->streams[i];
2396
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2397
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2398
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2399
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2400
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2401
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2402
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2403

    
2404
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2405
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2406
            // ipmovie.c produces.
2407
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2408
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2409
            if (st->info->duration_count && !st->r_frame_rate.num
2410
               && tb_unreliable(st->codec) /*&&
2411
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2412
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2413
                int num = 0;
2414
                double best_error= 2*av_q2d(st->time_base);
2415
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2416

    
2417
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2418
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2419
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2420
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2421
                    if(error < best_error){
2422
                        best_error= error;
2423
                        num = get_std_framerate(j);
2424
                    }
2425
                }
2426
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2427
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2428
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2429
            }
2430

    
2431
            if (!st->r_frame_rate.num){
2432
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2433
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2434
                    st->r_frame_rate.num = st->codec->time_base.den;
2435
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2436
                }else{
2437
                    st->r_frame_rate.num = st->time_base.den;
2438
                    st->r_frame_rate.den = st->time_base.num;
2439
                }
2440
            }
2441
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2442
            if(!st->codec->bits_per_coded_sample)
2443
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2444
        }
2445
    }
2446

    
2447
    av_estimate_timings(ic, old_offset);
2448

    
2449
    compute_chapters_end(ic);
2450

    
2451
#if 0
2452
    /* correct DTS for B-frame streams with no timestamps */
2453
    for(i=0;i<ic->nb_streams;i++) {
2454
        st = ic->streams[i];
2455
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2456
            if(b-frames){
2457
                ppktl = &ic->packet_buffer;
2458
                while(ppkt1){
2459
                    if(ppkt1->stream_index != i)
2460
                        continue;
2461
                    if(ppkt1->pkt->dts < 0)
2462
                        break;
2463
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2464
                        break;
2465
                    ppkt1->pkt->dts -= delta;
2466
                    ppkt1= ppkt1->next;
2467
                }
2468
                if(ppkt1)
2469
                    continue;
2470
                st->cur_dts -= delta;
2471
            }
2472
        }
2473
    }
2474
#endif
2475

    
2476
 find_stream_info_err:
2477
    for (i=0; i < ic->nb_streams; i++)
2478
        av_freep(&ic->streams[i]->info);
2479
    return ret;
2480
}
2481

    
2482
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2483
{
2484
    int i, j;
2485

    
2486
    for (i = 0; i < ic->nb_programs; i++)
2487
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2488
            if (ic->programs[i]->stream_index[j] == s)
2489
                return ic->programs[i];
2490
    return NULL;
2491
}
2492

    
2493
int av_find_best_stream(AVFormatContext *ic,
2494
                        enum AVMediaType type,
2495
                        int wanted_stream_nb,
2496
                        int related_stream,
2497
                        AVCodec **decoder_ret,
2498
                        int flags)
2499
{
2500
    int i, nb_streams = ic->nb_streams, stream_number = 0;
2501
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2502
    unsigned *program = NULL;
2503
    AVCodec *decoder = NULL, *best_decoder = NULL;
2504

    
2505
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2506
        AVProgram *p = find_program_from_stream(ic, related_stream);
2507
        if (p) {
2508
            program = p->stream_index;
2509
            nb_streams = p->nb_stream_indexes;
2510
        }
2511
    }
2512
    for (i = 0; i < nb_streams; i++) {
2513
        AVStream *st = ic->streams[program ? program[i] : i];
2514
        AVCodecContext *avctx = st->codec;
2515
        if (avctx->codec_type != type)
2516
            continue;
2517
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2518
            continue;
2519
        if (decoder_ret) {
2520
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2521
            if (!decoder) {
2522
                if (ret < 0)
2523
                    ret = AVERROR_DECODER_NOT_FOUND;
2524
                continue;
2525
            }
2526
        }
2527
        if (best_count >= st->codec_info_nb_frames)
2528
            continue;
2529
        best_count = st->codec_info_nb_frames;
2530
        ret = i;
2531
        best_decoder = decoder;
2532
        if (program && i == nb_streams - 1 && ret < 0) {
2533
            program = NULL;
2534
            nb_streams = ic->nb_streams;
2535
            i = 0; /* no related stream found, try again with everything */
2536
        }
2537
    }
2538
    if (decoder_ret)
2539
        *decoder_ret = best_decoder;
2540
    return ret;
2541
}
2542

    
2543
/*******************************************************/
2544

    
2545
int av_read_play(AVFormatContext *s)
2546
{
2547
    if (s->iformat->read_play)
2548
        return s->iformat->read_play(s);
2549
    if (s->pb)
2550
        return av_url_read_fpause(s->pb, 0);
2551
    return AVERROR(ENOSYS);
2552
}
2553

    
2554
int av_read_pause(AVFormatContext *s)
2555
{
2556
    if (s->iformat->read_pause)
2557
        return s->iformat->read_pause(s);
2558
    if (s->pb)
2559
        return av_url_read_fpause(s->pb, 1);
2560
    return AVERROR(ENOSYS);
2561
}
2562

    
2563
void av_close_input_stream(AVFormatContext *s)
2564
{
2565
    flush_packet_queue(s);
2566
    if (s->iformat->read_close)
2567
        s->iformat->read_close(s);
2568
    avformat_free_context(s);
2569
}
2570

    
2571
void avformat_free_context(AVFormatContext *s)
2572
{
2573
    int i;
2574
    AVStream *st;
2575

    
2576
    for(i=0;i<s->nb_streams;i++) {
2577
        /* free all data in a stream component */
2578
        st = s->streams[i];
2579
        if (st->parser) {
2580
            av_parser_close(st->parser);
2581
            av_free_packet(&st->cur_pkt);
2582
        }
2583
        av_metadata_free(&st->metadata);
2584
        av_free(st->index_entries);
2585
        av_free(st->codec->extradata);
2586
        av_free(st->codec->subtitle_header);
2587
        av_free(st->codec);
2588
#if FF_API_OLD_METADATA
2589
        av_free(st->filename);
2590
#endif
2591
        av_free(st->priv_data);
2592
        av_free(st->info);
2593
        av_free(st);
2594
    }
2595
    for(i=s->nb_programs-1; i>=0; i--) {
2596
#if FF_API_OLD_METADATA
2597
        av_freep(&s->programs[i]->provider_name);
2598
        av_freep(&s->programs[i]->name);
2599
#endif
2600
        av_metadata_free(&s->programs[i]->metadata);
2601
        av_freep(&s->programs[i]->stream_index);
2602
        av_freep(&s->programs[i]);
2603
    }
2604
    av_freep(&s->programs);
2605
    av_freep(&s->priv_data);
2606
    while(s->nb_chapters--) {
2607
#if FF_API_OLD_METADATA
2608
        av_free(s->chapters[s->nb_chapters]->title);
2609
#endif
2610
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2611
        av_free(s->chapters[s->nb_chapters]);
2612
    }
2613
    av_freep(&s->chapters);
2614
    av_metadata_free(&s->metadata);
2615
    av_freep(&s->key);
2616
    av_free(s);
2617
}
2618

    
2619
void av_close_input_file(AVFormatContext *s)
2620
{
2621
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2622
    av_close_input_stream(s);
2623
    if (pb)
2624
        url_fclose(pb);
2625
}
2626

    
2627
AVStream *av_new_stream(AVFormatContext *s, int id)
2628
{
2629
    AVStream *st;
2630
    int i;
2631

    
2632
#if FF_API_MAX_STREAMS
2633
    if (s->nb_streams >= MAX_STREAMS){
2634
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2635
        return NULL;
2636
    }
2637
#else
2638
    AVStream **streams;
2639

    
2640
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2641
        return NULL;
2642
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2643
    if (!streams)
2644
        return NULL;
2645
    s->streams = streams;
2646
#endif
2647

    
2648
    st = av_mallocz(sizeof(AVStream));
2649
    if (!st)
2650
        return NULL;
2651
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2652
        av_free(st);
2653
        return NULL;
2654
    }
2655

    
2656
    st->codec= avcodec_alloc_context();
2657
    if (s->iformat) {
2658
        /* no default bitrate if decoding */
2659
        st->codec->bit_rate = 0;
2660
    }
2661
    st->index = s->nb_streams;
2662
    st->id = id;
2663
    st->start_time = AV_NOPTS_VALUE;
2664
    st->duration = AV_NOPTS_VALUE;
2665
        /* we set the current DTS to 0 so that formats without any timestamps
2666
           but durations get some timestamps, formats with some unknown
2667
           timestamps have their first few packets buffered and the
2668
           timestamps corrected before they are returned to the user */
2669
    st->cur_dts = 0;
2670
    st->first_dts = AV_NOPTS_VALUE;
2671
    st->probe_packets = MAX_PROBE_PACKETS;
2672

    
2673
    /* default pts setting is MPEG-like */
2674
    av_set_pts_info(st, 33, 1, 90000);
2675
    st->last_IP_pts = AV_NOPTS_VALUE;
2676
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2677
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2678
    st->reference_dts = AV_NOPTS_VALUE;
2679

    
2680
    st->sample_aspect_ratio = (AVRational){0,1};
2681

    
2682
    s->streams[s->nb_streams++] = st;
2683
    return st;
2684
}
2685

    
2686
AVProgram *av_new_program(AVFormatContext *ac, int id)
2687
{
2688
    AVProgram *program=NULL;
2689
    int i;
2690

    
2691
#ifdef DEBUG_SI
2692
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2693
#endif
2694

    
2695
    for(i=0; i<ac->nb_programs; i++)
2696
        if(ac->programs[i]->id == id)
2697
            program = ac->programs[i];
2698

    
2699
    if(!program){
2700
        program = av_mallocz(sizeof(AVProgram));
2701
        if (!program)
2702
            return NULL;
2703
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2704
        program->discard = AVDISCARD_NONE;
2705
    }
2706
    program->id = id;
2707

    
2708
    return program;
2709
}
2710

    
2711
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2712
{
2713
    AVChapter *chapter = NULL;
2714
    int i;
2715

    
2716
    for(i=0; i<s->nb_chapters; i++)
2717
        if(s->chapters[i]->id == id)
2718
            chapter = s->chapters[i];
2719

    
2720
    if(!chapter){
2721
        chapter= av_mallocz(sizeof(AVChapter));
2722
        if(!chapter)
2723
            return NULL;
2724
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2725
    }
2726
#if FF_API_OLD_METADATA
2727
    av_free(chapter->title);
2728
#endif
2729
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2730
    chapter->id    = id;
2731
    chapter->time_base= time_base;
2732
    chapter->start = start;
2733
    chapter->end   = end;
2734

    
2735
    return chapter;
2736
}
2737

    
2738
/************************************************************/
2739
/* output media file */
2740

    
2741
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2742
{
2743
    int ret;
2744

    
2745
    if (s->oformat->priv_data_size > 0) {
2746
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2747
        if (!s->priv_data)
2748
            return AVERROR(ENOMEM);
2749
        if (s->oformat->priv_class) {
2750
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2751
            av_opt_set_defaults(s->priv_data);
2752
        }
2753
    } else
2754
        s->priv_data = NULL;
2755

    
2756
    if (s->oformat->set_parameters) {
2757
        ret = s->oformat->set_parameters(s, ap);
2758
        if (ret < 0)
2759
            return ret;
2760
    }
2761
    return 0;
2762
}
2763

    
2764
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2765
{
2766
    const AVCodecTag *avctag;
2767
    int n;
2768
    enum CodecID id = CODEC_ID_NONE;
2769
    unsigned int tag = 0;
2770

    
2771
    /**
2772
     * Check that tag + id is in the table
2773
     * If neither is in the table -> OK
2774
     * If tag is in the table with another id -> FAIL
2775
     * If id is in the table with another tag -> FAIL unless strict < normal
2776
     */
2777
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2778
        avctag = s->oformat->codec_tag[n];
2779
        while (avctag->id != CODEC_ID_NONE) {
2780
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2781
                id = avctag->id;
2782
                if (id == st->codec->codec_id)
2783
                    return 1;
2784
            }
2785
            if (avctag->id == st->codec->codec_id)
2786
                tag = avctag->tag;
2787
            avctag++;
2788
        }
2789
    }
2790
    if (id != CODEC_ID_NONE)
2791
        return 0;
2792
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2793
        return 0;
2794
    return 1;
2795
}
2796

    
2797
int av_write_header(AVFormatContext *s)
2798
{
2799
    int ret, i;
2800
    AVStream *st;
2801

    
2802
    // some sanity checks
2803
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2804
        av_log(s, AV_LOG_ERROR, "no streams\n");
2805
        return AVERROR(EINVAL);
2806
    }
2807

    
2808
    for(i=0;i<s->nb_streams;i++) {
2809
        st = s->streams[i];
2810

    
2811
        switch (st->codec->codec_type) {
2812
        case AVMEDIA_TYPE_AUDIO:
2813
            if(st->codec->sample_rate<=0){
2814
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2815
                return AVERROR(EINVAL);
2816
            }
2817
            if(!st->codec->block_align)
2818
                st->codec->block_align = st->codec->channels *
2819
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2820
            break;
2821
        case AVMEDIA_TYPE_VIDEO:
2822
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2823
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2824
                return AVERROR(EINVAL);
2825
            }
2826
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2827
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2828
                return AVERROR(EINVAL);
2829
            }
2830
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2831
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2832
                return AVERROR(EINVAL);
2833
            }
2834
            break;
2835
        }
2836

    
2837
        if(s->oformat->codec_tag){
2838
            if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2839
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2840
                st->codec->codec_tag= 0;
2841
            }
2842
            if(st->codec->codec_tag){
2843
                if (!validate_codec_tag(s, st)) {
2844
                    char tagbuf[32];
2845
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2846
                    av_log(s, AV_LOG_ERROR,
2847
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2848
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2849
                    return AVERROR_INVALIDDATA;
2850
                }
2851
            }else
2852
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2853
        }
2854

    
2855
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2856
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2857
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2858
    }
2859

    
2860
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2861
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2862
        if (!s->priv_data)
2863
            return AVERROR(ENOMEM);
2864
    }
2865

    
2866
#if FF_API_OLD_METADATA
2867
    ff_metadata_mux_compat(s);
2868
#endif
2869

    
2870
    /* set muxer identification string */
2871
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2872
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2873
    }
2874

    
2875
    if(s->oformat->write_header){
2876
        ret = s->oformat->write_header(s);
2877
        if (ret < 0)
2878
            return ret;
2879
    }
2880

    
2881
    /* init PTS generation */
2882
    for(i=0;i<s->nb_streams;i++) {
2883
        int64_t den = AV_NOPTS_VALUE;
2884
        st = s->streams[i];
2885

    
2886
        switch (st->codec->codec_type) {
2887
        case AVMEDIA_TYPE_AUDIO:
2888
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2889
            break;
2890
        case AVMEDIA_TYPE_VIDEO:
2891
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2892
            break;
2893
        default:
2894
            break;
2895
        }
2896
        if (den != AV_NOPTS_VALUE) {
2897
            if (den <= 0)
2898
                return AVERROR_INVALIDDATA;
2899
            av_frac_init(&st->pts, 0, 0, den);
2900
        }
2901
    }
2902
    return 0;
2903
}
2904

    
2905
//FIXME merge with compute_pkt_fields
2906
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2907
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2908
    int num, den, frame_size, i;
2909

    
2910
//    av_log(s, 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);
2911

    
2912
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2913
        return -1;*/
2914

    
2915
    /* duration field */
2916
    if (pkt->duration == 0) {
2917
        compute_frame_duration(&num, &den, st, NULL, pkt);
2918
        if (den && num) {
2919
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2920
        }
2921
    }
2922

    
2923
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2924
        pkt->pts= pkt->dts;
2925

    
2926
    //XXX/FIXME this is a temporary hack until all encoders output pts
2927
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2928
        pkt->dts=
2929
//        pkt->pts= st->cur_dts;
2930
        pkt->pts= st->pts.val;
2931
    }
2932

    
2933
    //calculate dts from pts
2934
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2935
        st->pts_buffer[0]= pkt->pts;
2936
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2937
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2938
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2939
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2940

    
2941
        pkt->dts= st->pts_buffer[0];
2942
    }
2943

    
2944
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2945
        av_log(s, AV_LOG_ERROR,
2946
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2947
               st->index, st->cur_dts, pkt->dts);
2948
        return -1;
2949
    }
2950
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2951
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2952
        return -1;
2953
    }
2954

    
2955
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2956
    st->cur_dts= pkt->dts;
2957
    st->pts.val= pkt->dts;
2958

    
2959
    /* update pts */
2960
    switch (st->codec->codec_type) {
2961
    case AVMEDIA_TYPE_AUDIO:
2962
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2963

    
2964
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2965
           likely equal to the encoder delay, but it would be better if we
2966
           had the real timestamps from the encoder */
2967
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2968
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2969
        }
2970
        break;
2971
    case AVMEDIA_TYPE_VIDEO:
2972
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2973
        break;
2974
    default:
2975
        break;
2976
    }
2977
    return 0;
2978
}
2979

    
2980
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2981
{
2982
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2983

    
2984
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2985
        return ret;
2986

    
2987
    ret= s->oformat->write_packet(s, pkt);
2988
    if(!ret)
2989
        ret= url_ferror(s->pb);
2990
    return ret;
2991
}
2992

    
2993
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2994
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2995
{
2996
    AVPacketList **next_point, *this_pktl;
2997

    
2998
    this_pktl = av_mallocz(sizeof(AVPacketList));
2999
    this_pktl->pkt= *pkt;
3000
    pkt->destruct= NULL;             // do not free original but only the copy
3001
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3002

    
3003
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3004
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3005
    }else
3006
        next_point = &s->packet_buffer;
3007

    
3008
    if(*next_point){
3009
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3010
            while(!compare(s, &(*next_point)->pkt, pkt)){
3011
                next_point= &(*next_point)->next;
3012
            }
3013
            goto next_non_null;
3014
        }else{
3015
            next_point = &(s->packet_buffer_end->next);
3016
        }
3017
    }
3018
    assert(!*next_point);
3019

    
3020
    s->packet_buffer_end= this_pktl;
3021
next_non_null:
3022

    
3023
    this_pktl->next= *next_point;
3024

    
3025
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3026
    *next_point= this_pktl;
3027
}
3028

    
3029
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3030
{
3031
    AVStream *st = s->streams[ pkt ->stream_index];
3032
    AVStream *st2= s->streams[ next->stream_index];
3033
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3034
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3035
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3036
}
3037

    
3038
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3039
    AVPacketList *pktl;
3040
    int stream_count=0;
3041
    int i;
3042

    
3043
    if(pkt){
3044
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3045
    }
3046

    
3047
    for(i=0; i < s->nb_streams; i++)
3048
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3049

    
3050
    if(stream_count && (s->nb_streams == stream_count || flush)){
3051
        pktl= s->packet_buffer;
3052
        *out= pktl->pkt;
3053

    
3054
        s->packet_buffer= pktl->next;
3055
        if(!s->packet_buffer)
3056
            s->packet_buffer_end= NULL;
3057

    
3058
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3059
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3060
        av_freep(&pktl);
3061
        return 1;
3062
    }else{
3063
        av_init_packet(out);
3064
        return 0;
3065
    }
3066
}
3067

    
3068
/**
3069
 * Interleave an AVPacket correctly so it can be muxed.
3070
 * @param out the interleaved packet will be output here
3071
 * @param in the input packet
3072
 * @param flush 1 if no further packets are available as input and all
3073
 *              remaining packets should be output
3074
 * @return 1 if a packet was output, 0 if no packet could be output,
3075
 *         < 0 if an error occurred
3076
 */
3077
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3078
    if(s->oformat->interleave_packet)
3079
        return s->oformat->interleave_packet(s, out, in, flush);
3080
    else
3081
        return av_interleave_packet_per_dts(s, out, in, flush);
3082
}
3083

    
3084
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3085
    AVStream *st= s->streams[ pkt->stream_index];
3086

    
3087
    //FIXME/XXX/HACK drop zero sized packets
3088
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3089
        return 0;
3090

    
3091
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
3092
    if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3093
        return -1;
3094

    
3095
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3096
        return -1;
3097

    
3098
    for(;;){
3099
        AVPacket opkt;
3100
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3101
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3102
            return ret;
3103

    
3104
        ret= s->oformat->write_packet(s, &opkt);
3105

    
3106
        av_free_packet(&opkt);
3107
        pkt= NULL;
3108

    
3109
        if(ret<0)
3110
            return ret;
3111
        if(url_ferror(s->pb))
3112
            return url_ferror(s->pb);
3113
    }
3114
}
3115

    
3116
int av_write_trailer(AVFormatContext *s)
3117
{
3118
    int ret, i;
3119

    
3120
    for(;;){
3121
        AVPacket pkt;
3122
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3123
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3124
            goto fail;
3125
        if(!ret)
3126
            break;
3127

    
3128
        ret= s->oformat->write_packet(s, &pkt);
3129

    
3130
        av_free_packet(&pkt);
3131

    
3132
        if(ret<0)
3133
            goto fail;
3134
        if(url_ferror(s->pb))
3135
            goto fail;
3136
    }
3137

    
3138
    if(s->oformat->write_trailer)
3139
        ret = s->oformat->write_trailer(s);
3140
fail:
3141
    if(ret == 0)
3142
       ret=url_ferror(s->pb);
3143
    for(i=0;i<s->nb_streams;i++) {
3144
        av_freep(&s->streams[i]->priv_data);
3145
        av_freep(&s->streams[i]->index_entries);
3146
    }
3147
    av_freep(&s->priv_data);
3148
    return ret;
3149
}
3150

    
3151
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3152
{
3153
    int i, j;
3154
    AVProgram *program=NULL;
3155
    void *tmp;
3156

    
3157
    if (idx >= ac->nb_streams) {
3158
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3159
        return;
3160
    }
3161

    
3162
    for(i=0; i<ac->nb_programs; i++){
3163
        if(ac->programs[i]->id != progid)
3164
            continue;
3165
        program = ac->programs[i];
3166
        for(j=0; j<program->nb_stream_indexes; j++)
3167
            if(program->stream_index[j] == idx)
3168
                return;
3169

    
3170
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3171
        if(!tmp)
3172
            return;
3173
        program->stream_index = tmp;
3174
        program->stream_index[program->nb_stream_indexes++] = idx;
3175
        return;
3176
    }
3177
}
3178

    
3179
static void print_fps(double d, const char *postfix){
3180
    uint64_t v= lrintf(d*100);
3181
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3182
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3183
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3184
}
3185

    
3186
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3187
{
3188
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3189
        AVMetadataTag *tag=NULL;
3190

    
3191
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3192
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3193
            if(strcmp("language", tag->key))
3194
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3195
        }
3196
    }
3197
}
3198

    
3199
/* "user interface" functions */
3200
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3201
{
3202
    char buf[256];
3203
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3204
    AVStream *st = ic->streams[i];
3205
    int g = av_gcd(st->time_base.num, st->time_base.den);
3206
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3207
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3208
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3209
    /* the pid is an important information, so we display it */
3210
    /* XXX: add a generic system */
3211
    if (flags & AVFMT_SHOW_IDS)
3212
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3213
    if (lang)
3214
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3215
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3216
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3217
    if (st->sample_aspect_ratio.num && // default
3218
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3219
        AVRational display_aspect_ratio;
3220
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3221
                  st->codec->width*st->sample_aspect_ratio.num,
3222
                  st->codec->height*st->sample_aspect_ratio.den,
3223
                  1024*1024);
3224
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3225
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3226
                 display_aspect_ratio.num, display_aspect_ratio.den);
3227
    }
3228
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3229
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3230
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3231
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3232
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3233
        if(st->time_base.den && st->time_base.num)
3234
            print_fps(1/av_q2d(st->time_base), "tbn");
3235
        if(st->codec->time_base.den && st->codec->time_base.num)
3236
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3237
    }
3238
    av_log(NULL, AV_LOG_INFO, "\n");
3239
    dump_metadata(NULL, st->metadata, "    ");
3240
}
3241

    
3242
void dump_format(AVFormatContext *ic,
3243
                 int index,
3244
                 const char *url,
3245
                 int is_output)
3246
{
3247
    int i;
3248
    uint8_t *printed = av_mallocz(ic->nb_streams);
3249
    if (ic->nb_streams && !printed)
3250
        return;
3251

    
3252
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3253
            is_output ? "Output" : "Input",
3254
            index,
3255
            is_output ? ic->oformat->name : ic->iformat->name,
3256
            is_output ? "to" : "from", url);
3257
    dump_metadata(NULL, ic->metadata, "  ");
3258
    if (!is_output) {
3259
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3260
        if (ic->duration != AV_NOPTS_VALUE) {
3261
            int hours, mins, secs, us;
3262
            secs = ic->duration / AV_TIME_BASE;
3263
            us = ic->duration % AV_TIME_BASE;
3264
            mins = secs / 60;
3265
            secs %= 60;
3266
            hours = mins / 60;
3267
            mins %= 60;
3268
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3269
                   (100 * us) / AV_TIME_BASE);
3270
        } else {
3271
            av_log(NULL, AV_LOG_INFO, "N/A");
3272
        }
3273
        if (ic->start_time != AV_NOPTS_VALUE) {
3274
            int secs, us;
3275
            av_log(NULL, AV_LOG_INFO, ", start: ");
3276
            secs = ic->start_time / AV_TIME_BASE;
3277
            us = abs(ic->start_time % AV_TIME_BASE);
3278
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3279
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3280
        }
3281
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3282
        if (ic->bit_rate) {
3283
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3284
        } else {
3285
            av_log(NULL, AV_LOG_INFO, "N/A");
3286
        }
3287
        av_log(NULL, AV_LOG_INFO, "\n");
3288
    }
3289
    for (i = 0; i < ic->nb_chapters; i++) {
3290
        AVChapter *ch = ic->chapters[i];
3291
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3292
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3293
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3294

    
3295
        dump_metadata(NULL, ch->metadata, "    ");
3296
    }
3297
    if(ic->nb_programs) {
3298
        int j, k, total = 0;
3299
        for(j=0; j<ic->nb_programs; j++) {
3300
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3301
                                                  "name", NULL, 0);
3302
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3303
                   name ? name->value : "");
3304
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3305
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3306
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3307
                printed[ic->programs[j]->stream_index[k]] = 1;
3308
            }
3309
            total += ic->programs[j]->nb_stream_indexes;
3310
        }
3311
        if (total < ic->nb_streams)
3312
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3313
    }
3314
    for(i=0;i<ic->nb_streams;i++)
3315
        if (!printed[i])
3316
            dump_stream_format(ic, i, index, is_output);
3317

    
3318
    av_free(printed);
3319
}
3320

    
3321
#if FF_API_PARSE_FRAME_PARAM
3322
#include "libavcore/parseutils.h"
3323

    
3324
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3325
{
3326
    return av_parse_video_size(width_ptr, height_ptr, str);
3327
}
3328

    
3329
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3330
{
3331
    AVRational frame_rate;
3332
    int ret = av_parse_video_rate(&frame_rate, arg);
3333
    *frame_rate_num= frame_rate.num;
3334
    *frame_rate_den= frame_rate.den;
3335
    return ret;
3336
}
3337
#endif
3338

    
3339
int64_t av_gettime(void)
3340
{
3341
    struct timeval tv;
3342
    gettimeofday(&tv,NULL);
3343
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3344
}
3345

    
3346
uint64_t ff_ntp_time(void)
3347
{
3348
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3349
}
3350

    
3351
int64_t parse_date(const char *datestr, int duration)
3352
{
3353
    const char *p;
3354
    int64_t t;
3355
    struct tm dt;
3356
    int i;
3357
    static const char * const date_fmt[] = {
3358
        "%Y-%m-%d",
3359
        "%Y%m%d",
3360
    };
3361
    static const char * const time_fmt[] = {
3362
        "%H:%M:%S",
3363
        "%H%M%S",
3364
    };
3365
    const char *q;
3366
    int is_utc, len;
3367
    char lastch;
3368
    int negative = 0;
3369

    
3370
#undef time
3371
    time_t now = time(0);
3372

    
3373
    len = strlen(datestr);
3374
    if (len > 0)
3375
        lastch = datestr[len - 1];
3376
    else
3377
        lastch = '\0';
3378
    is_utc = (lastch == 'z' || lastch == 'Z');
3379

    
3380
    memset(&dt, 0, sizeof(dt));
3381

    
3382
    p = datestr;
3383
    q = NULL;
3384
    if (!duration) {
3385
        if (!strncasecmp(datestr, "now", len))
3386
            return (int64_t) now * 1000000;
3387

    
3388
        /* parse the year-month-day part */
3389
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3390
            q = small_strptime(p, date_fmt[i], &dt);
3391
            if (q) {
3392
                break;
3393
            }
3394
        }
3395

    
3396
        /* if the year-month-day part is missing, then take the
3397
         * current year-month-day time */
3398
        if (!q) {
3399
            if (is_utc) {
3400
                dt = *gmtime(&now);
3401
            } else {
3402
                dt = *localtime(&now);
3403
            }
3404
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3405
        } else {
3406
            p = q;
3407
        }
3408

    
3409
        if (*p == 'T' || *p == 't' || *p == ' ')
3410
            p++;
3411

    
3412
        /* parse the hour-minute-second part */
3413
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3414
            q = small_strptime(p, time_fmt[i], &dt);
3415
            if (q) {
3416
                break;
3417
            }
3418
        }
3419
    } else {
3420
        /* parse datestr as a duration */
3421
        if (p[0] == '-') {
3422
            negative = 1;
3423
            ++p;
3424
        }
3425
        /* parse datestr as HH:MM:SS */
3426
        q = small_strptime(p, time_fmt[0], &dt);
3427
        if (!q) {
3428
            /* parse datestr as S+ */
3429
            dt.tm_sec = strtol(p, (char **)&q, 10);
3430
            if (q == p)
3431
                /* the parsing didn't succeed */
3432
                return INT64_MIN;
3433
            dt.tm_min = 0;
3434
            dt.tm_hour = 0;
3435
        }
3436
    }
3437

    
3438
    /* Now we have all the fields that we can get */
3439
    if (!q) {
3440
        return INT64_MIN;
3441
    }
3442

    
3443
    if (duration) {
3444
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3445
    } else {
3446
        dt.tm_isdst = -1;       /* unknown */
3447
        if (is_utc) {
3448
            t = mktimegm(&dt);
3449
        } else {
3450
            t = mktime(&dt);
3451
        }
3452
    }
3453

    
3454
    t *= 1000000;
3455

    
3456
    /* parse the .m... part */
3457
    if (*q == '.') {
3458
        int val, n;
3459
        q++;
3460
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3461
            if (!isdigit(*q))
3462
                break;
3463
            val += n * (*q - '0');
3464
        }
3465
        t += val;
3466
    }
3467
    return negative ? -t : t;
3468
}
3469

    
3470
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3471
{
3472
    const char *p;
3473
    char tag[128], *q;
3474

    
3475
    p = info;
3476
    if (*p == '?')
3477
        p++;
3478
    for(;;) {
3479
        q = tag;
3480
        while (*p != '\0' && *p != '=' && *p != '&') {
3481
            if ((q - tag) < sizeof(tag) - 1)
3482
                *q++ = *p;
3483
            p++;
3484
        }
3485
        *q = '\0';
3486
        q = arg;
3487
        if (*p == '=') {
3488
            p++;
3489
            while (*p != '&' && *p != '\0') {
3490
                if ((q - arg) < arg_size - 1) {
3491
                    if (*p == '+')
3492
                        *q++ = ' ';
3493
                    else
3494
                        *q++ = *p;
3495
                }
3496
                p++;
3497
            }
3498
        }
3499
        *q = '\0';
3500
        if (!strcmp(tag, tag1))
3501
            return 1;
3502
        if (*p != '&')
3503
            break;
3504
        p++;
3505
    }
3506
    return 0;
3507
}
3508

    
3509
int av_get_frame_filename(char *buf, int buf_size,
3510
                          const char *path, int number)
3511
{
3512
    const char *p;
3513
    char *q, buf1[20], c;
3514
    int nd, len, percentd_found;
3515

    
3516
    q = buf;
3517
    p = path;
3518
    percentd_found = 0;
3519
    for(;;) {
3520
        c = *p++;
3521
        if (c == '\0')
3522
            break;
3523
        if (c == '%') {
3524
            do {
3525
                nd = 0;
3526
                while (isdigit(*p)) {
3527
                    nd = nd * 10 + *p++ - '0';
3528
                }
3529
                c = *p++;
3530
            } while (isdigit(c));
3531

    
3532
            switch(c) {
3533
            case '%':
3534
                goto addchar;
3535
            case 'd':
3536
                if (percentd_found)
3537
                    goto fail;
3538
                percentd_found = 1;
3539
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3540
                len = strlen(buf1);
3541
                if ((q - buf + len) > buf_size - 1)
3542
                    goto fail;
3543
                memcpy(q, buf1, len);
3544
                q += len;
3545
                break;
3546
            default:
3547
                goto fail;
3548
            }
3549
        } else {
3550
        addchar:
3551
            if ((q - buf) < buf_size - 1)
3552
                *q++ = c;
3553
        }
3554
    }
3555
    if (!percentd_found)
3556
        goto fail;
3557
    *q = '\0';
3558
    return 0;
3559
 fail:
3560
    *q = '\0';
3561
    return -1;
3562
}
3563

    
3564
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3565
{
3566
    int len, i, j, c;
3567
#undef fprintf
3568
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3569

    
3570
    for(i=0;i<size;i+=16) {
3571
        len = size - i;
3572
        if (len > 16)
3573
            len = 16;
3574
        PRINT("%08x ", i);
3575
        for(j=0;j<16;j++) {
3576
            if (j < len)
3577
                PRINT(" %02x", buf[i+j]);
3578
            else
3579
                PRINT("   ");
3580
        }
3581
        PRINT(" ");
3582
        for(j=0;j<len;j++) {
3583
            c = buf[i+j];
3584
            if (c < ' ' || c > '~')
3585
                c = '.';
3586
            PRINT("%c", c);
3587
        }
3588
        PRINT("\n");
3589
    }
3590
#undef PRINT
3591
}
3592

    
3593
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3594
{
3595
    hex_dump_internal(NULL, f, 0, buf, size);
3596
}
3597

    
3598
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3599
{
3600
    hex_dump_internal(avcl, NULL, level, buf, size);
3601
}
3602

    
3603
 //FIXME needs to know the time_base
3604
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3605
{
3606
#undef fprintf
3607
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3608
    PRINT("stream #%d:\n", pkt->stream_index);
3609
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3610
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3611
    /* DTS is _always_ valid after av_read_frame() */
3612
    PRINT("  dts=");
3613
    if (pkt->dts == AV_NOPTS_VALUE)
3614
        PRINT("N/A");
3615
    else
3616
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3617
    /* PTS may not be known if B-frames are present. */
3618
    PRINT("  pts=");
3619
    if (pkt->pts == AV_NOPTS_VALUE)
3620
        PRINT("N/A");
3621
    else
3622
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3623
    PRINT("\n");
3624
    PRINT("  size=%d\n", pkt->size);
3625
#undef PRINT
3626
    if (dump_payload)
3627
        av_hex_dump(f, pkt->data, pkt->size);
3628
}
3629

    
3630
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3631
{
3632
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3633
}
3634

    
3635
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3636
{
3637
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3638
}
3639

    
3640
#if FF_API_URL_SPLIT
3641
attribute_deprecated
3642
void ff_url_split(char *proto, int proto_size,
3643
                  char *authorization, int authorization_size,
3644
                  char *hostname, int hostname_size,
3645
                  int *port_ptr,
3646
                  char *path, int path_size,
3647
                  const char *url)
3648
{
3649
    av_url_split(proto, proto_size,
3650
                 authorization, authorization_size,
3651
                 hostname, hostname_size,
3652
                 port_ptr,
3653
                 path, path_size,
3654
                 url);
3655
}
3656
#endif
3657

    
3658
void av_url_split(char *proto, int proto_size,
3659
                  char *authorization, int authorization_size,
3660
                  char *hostname, int hostname_size,
3661
                  int *port_ptr,
3662
                  char *path, int path_size,
3663
                  const char *url)
3664
{
3665
    const char *p, *ls, *at, *col, *brk;
3666

    
3667
    if (port_ptr)               *port_ptr = -1;
3668
    if (proto_size > 0)         proto[0] = 0;
3669
    if (authorization_size > 0) authorization[0] = 0;
3670
    if (hostname_size > 0)      hostname[0] = 0;
3671
    if (path_size > 0)          path[0] = 0;
3672

    
3673
    /* parse protocol */
3674
    if ((p = strchr(url, ':'))) {
3675
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3676
        p++; /* skip ':' */
3677
        if (*p == '/') p++;
3678
        if (*p == '/') p++;
3679
    } else {
3680
        /* no protocol means plain filename */
3681
        av_strlcpy(path, url, path_size);
3682
        return;
3683
    }
3684

    
3685
    /* separate path from hostname */
3686
    ls = strchr(p, '/');
3687
    if(!ls)
3688
        ls = strchr(p, '?');
3689
    if(ls)
3690
        av_strlcpy(path, ls, path_size);
3691
    else
3692
        ls = &p[strlen(p)]; // XXX
3693

    
3694
    /* the rest is hostname, use that to parse auth/port */
3695
    if (ls != p) {
3696
        /* authorization (user[:pass]@hostname) */
3697
        if ((at = strchr(p, '@')) && at < ls) {
3698
            av_strlcpy(authorization, p,
3699
                       FFMIN(authorization_size, at + 1 - p));
3700
            p = at + 1; /* skip '@' */
3701
        }
3702

    
3703
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3704
            /* [host]:port */
3705
            av_strlcpy(hostname, p + 1,
3706
                       FFMIN(hostname_size, brk - p));
3707
            if (brk[1] == ':' && port_ptr)
3708
                *port_ptr = atoi(brk + 2);
3709
        } else if ((col = strchr(p, ':')) && col < ls) {
3710
            av_strlcpy(hostname, p,
3711
                       FFMIN(col + 1 - p, hostname_size));
3712
            if (port_ptr) *port_ptr = atoi(col + 1);
3713
        } else
3714
            av_strlcpy(hostname, p,
3715
                       FFMIN(ls + 1 - p, hostname_size));
3716
    }
3717
}
3718

    
3719
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3720
{
3721
    int i;
3722
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3723
                                           '4', '5', '6', '7',
3724
                                           '8', '9', 'A', 'B',
3725
                                           'C', 'D', 'E', 'F' };
3726
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3727
                                           '4', '5', '6', '7',
3728
                                           '8', '9', 'a', 'b',
3729
                                           'c', 'd', 'e', 'f' };
3730
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3731

    
3732
    for(i = 0; i < s; i++) {
3733
        buff[i * 2]     = hex_table[src[i] >> 4];
3734
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3735
    }
3736

    
3737
    return buff;
3738
}
3739

    
3740
int ff_hex_to_data(uint8_t *data, const char *p)
3741
{
3742
    int c, len, v;
3743

    
3744
    len = 0;
3745
    v = 1;
3746
    for (;;) {
3747
        p += strspn(p, SPACE_CHARS);
3748
        if (*p == '\0')
3749
            break;
3750
        c = toupper((unsigned char) *p++);
3751
        if (c >= '0' && c <= '9')
3752
            c = c - '0';
3753
        else if (c >= 'A' && c <= 'F')
3754
            c = c - 'A' + 10;
3755
        else
3756
            break;
3757
        v = (v << 4) | c;
3758
        if (v & 0x100) {
3759
            if (data)
3760
                data[len] = v;
3761
            len++;
3762
            v = 1;
3763
        }
3764
    }
3765
    return len;
3766
}
3767

    
3768
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3769
                     unsigned int pts_num, unsigned int pts_den)
3770
{
3771
    AVRational new_tb;
3772
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3773
        if(new_tb.num != pts_num)
3774
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3775
    }else
3776
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3777

    
3778
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3779
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3780
        return;
3781
    }
3782
    s->time_base = new_tb;
3783
    s->pts_wrap_bits = pts_wrap_bits;
3784
}
3785

    
3786
int ff_url_join(char *str, int size, const char *proto,
3787
                const char *authorization, const char *hostname,
3788
                int port, const char *fmt, ...)
3789
{
3790
#if CONFIG_NETWORK
3791
    struct addrinfo hints, *ai;
3792
#endif
3793

    
3794
    str[0] = '\0';
3795
    if (proto)
3796
        av_strlcatf(str, size, "%s://", proto);
3797
    if (authorization && authorization[0])
3798
        av_strlcatf(str, size, "%s@", authorization);
3799
#if CONFIG_NETWORK && defined(AF_INET6)
3800
    /* Determine if hostname is a numerical IPv6 address,
3801
     * properly escape it within [] in that case. */
3802
    memset(&hints, 0, sizeof(hints));
3803
    hints.ai_flags = AI_NUMERICHOST;
3804
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3805
        if (ai->ai_family == AF_INET6) {
3806
            av_strlcat(str, "[", size);
3807
            av_strlcat(str, hostname, size);
3808
            av_strlcat(str, "]", size);
3809
        } else {
3810
            av_strlcat(str, hostname, size);
3811
        }
3812
        freeaddrinfo(ai);
3813
    } else
3814
#endif
3815
        /* Not an IPv6 address, just output the plain string. */
3816
        av_strlcat(str, hostname, size);
3817

    
3818
    if (port >= 0)
3819
        av_strlcatf(str, size, ":%d", port);
3820
    if (fmt) {
3821
        va_list vl;
3822
        int len = strlen(str);
3823

    
3824
        va_start(vl, fmt);
3825
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3826
        va_end(vl);
3827
    }
3828
    return strlen(str);
3829
}
3830

    
3831
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3832
                     AVFormatContext *src)
3833
{
3834
    AVPacket local_pkt;
3835

    
3836
    local_pkt = *pkt;
3837
    local_pkt.stream_index = dst_stream;
3838
    if (pkt->pts != AV_NOPTS_VALUE)
3839
        local_pkt.pts = av_rescale_q(pkt->pts,
3840
                                     src->streams[pkt->stream_index]->time_base,
3841
                                     dst->streams[dst_stream]->time_base);
3842
    if (pkt->dts != AV_NOPTS_VALUE)
3843
        local_pkt.dts = av_rescale_q(pkt->dts,
3844
                                     src->streams[pkt->stream_index]->time_base,
3845
                                     dst->streams[dst_stream]->time_base);
3846
    return av_write_frame(dst, &local_pkt);
3847
}
3848

    
3849
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3850
                        void *context)
3851
{
3852
    const char *ptr = str;
3853

    
3854
    /* Parse key=value pairs. */
3855
    for (;;) {
3856
        const char *key;
3857
        char *dest = NULL, *dest_end;
3858
        int key_len, dest_len = 0;
3859

    
3860
        /* Skip whitespace and potential commas. */
3861
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3862
            ptr++;
3863
        if (!*ptr)
3864
            break;
3865

    
3866
        key = ptr;
3867

    
3868
        if (!(ptr = strchr(key, '=')))
3869
            break;
3870
        ptr++;
3871
        key_len = ptr - key;
3872

    
3873
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3874
        dest_end = dest + dest_len - 1;
3875

    
3876
        if (*ptr == '\"') {
3877
            ptr++;
3878
            while (*ptr && *ptr != '\"') {
3879
                if (*ptr == '\\') {
3880
                    if (!ptr[1])
3881
                        break;
3882
                    if (dest && dest < dest_end)
3883
                        *dest++ = ptr[1];
3884
                    ptr += 2;
3885
                } else {
3886
                    if (dest && dest < dest_end)
3887
                        *dest++ = *ptr;
3888
                    ptr++;
3889
                }
3890
            }
3891
            if (*ptr == '\"')
3892
                ptr++;
3893
        } else {
3894
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3895
                if (dest && dest < dest_end)
3896
                    *dest++ = *ptr;
3897
        }
3898
        if (dest)
3899
            *dest = 0;
3900
    }
3901
}
3902

    
3903
int ff_find_stream_index(AVFormatContext *s, int id)
3904
{
3905
    int i;
3906
    for (i = 0; i < s->nb_streams; i++) {
3907
        if (s->streams[i]->id == id)
3908
            return i;
3909
    }
3910
    return -1;
3911
}