Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ b7effd4e

History | View | Annotate | Download (121 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(AVIOContext *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= avio_read(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(AVIOContext *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 = avio_read(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
                         AVIOContext *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 AVIOContext
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(AVIOContext *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 = avio_read(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
    AVIOContext *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 (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2520
            continue;
2521
        if (decoder_ret) {
2522
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2523
            if (!decoder) {
2524
                if (ret < 0)
2525
                    ret = AVERROR_DECODER_NOT_FOUND;
2526
                continue;
2527
            }
2528
        }
2529
        if (best_count >= st->codec_info_nb_frames)
2530
            continue;
2531
        best_count = st->codec_info_nb_frames;
2532
        ret = program ? program[i] : i;
2533
        best_decoder = decoder;
2534
        if (program && i == nb_streams - 1 && ret < 0) {
2535
            program = NULL;
2536
            nb_streams = ic->nb_streams;
2537
            i = 0; /* no related stream found, try again with everything */
2538
        }
2539
    }
2540
    if (decoder_ret)
2541
        *decoder_ret = best_decoder;
2542
    return ret;
2543
}
2544

    
2545
/*******************************************************/
2546

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

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

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

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

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

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

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

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

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

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

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

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

    
2682
    st->sample_aspect_ratio = (AVRational){0,1};
2683

    
2684
    s->streams[s->nb_streams++] = st;
2685
    return st;
2686
}
2687

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

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

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

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

    
2710
    return program;
2711
}
2712

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

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

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

    
2737
    return chapter;
2738
}
2739

    
2740
/************************************************************/
2741
/* output media file */
2742

    
2743
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2744
{
2745
    int ret;
2746

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

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

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

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

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

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

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

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

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

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

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

    
2868
#if FF_API_OLD_METADATA
2869
    ff_metadata_mux_compat(s);
2870
#endif
2871

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

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

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

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

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

    
2912
//    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);
2913

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

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

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

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

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

    
2943
        pkt->dts= st->pts_buffer[0];
2944
    }
2945

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

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

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

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

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

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

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

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

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

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

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

    
3022
    s->packet_buffer_end= this_pktl;
3023
next_non_null:
3024

    
3025
    this_pktl->next= *next_point;
3026

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

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

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

    
3045
    if(pkt){
3046
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3047
    }
3048

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

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

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

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

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

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

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

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

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

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

    
3106
        ret= s->oformat->write_packet(s, &opkt);
3107

    
3108
        av_free_packet(&opkt);
3109
        pkt= NULL;
3110

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

    
3118
int av_write_trailer(AVFormatContext *s)
3119
{
3120
    int ret, i;
3121

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

    
3130
        ret= s->oformat->write_packet(s, &pkt);
3131

    
3132
        av_free_packet(&pkt);
3133

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

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

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

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

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

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

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

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

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

    
3201
/* "user interface" functions */
3202
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3203
{
3204
    char buf[256];
3205
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3206
    AVStream *st = ic->streams[i];
3207
    int g = av_gcd(st->time_base.num, st->time_base.den);
3208
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3209
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3210
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3211
    /* the pid is an important information, so we display it */
3212
    /* XXX: add a generic system */
3213
    if (flags & AVFMT_SHOW_IDS)
3214
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3215
    if (lang)
3216
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3217
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3218
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3219
    if (st->sample_aspect_ratio.num && // default
3220
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3221
        AVRational display_aspect_ratio;
3222
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3223
                  st->codec->width*st->sample_aspect_ratio.num,
3224
                  st->codec->height*st->sample_aspect_ratio.den,
3225
                  1024*1024);
3226
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3227
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3228
                 display_aspect_ratio.num, display_aspect_ratio.den);
3229
    }
3230
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3231
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3232
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3233
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3234
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3235
        if(st->time_base.den && st->time_base.num)
3236
            print_fps(1/av_q2d(st->time_base), "tbn");
3237
        if(st->codec->time_base.den && st->codec->time_base.num)
3238
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3239
    }
3240
    if (st->disposition & AV_DISPOSITION_DEFAULT)
3241
        av_log(NULL, AV_LOG_INFO, " (default)");
3242
    if (st->disposition & AV_DISPOSITION_DUB)
3243
        av_log(NULL, AV_LOG_INFO, " (dub)");
3244
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
3245
        av_log(NULL, AV_LOG_INFO, " (original)");
3246
    if (st->disposition & AV_DISPOSITION_COMMENT)
3247
        av_log(NULL, AV_LOG_INFO, " (comment)");
3248
    if (st->disposition & AV_DISPOSITION_LYRICS)
3249
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
3250
    if (st->disposition & AV_DISPOSITION_KARAOKE)
3251
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
3252
    if (st->disposition & AV_DISPOSITION_FORCED)
3253
        av_log(NULL, AV_LOG_INFO, " (forced)");
3254
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3255
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3256
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3257
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3258
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3259
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3260
    av_log(NULL, AV_LOG_INFO, "\n");
3261
    dump_metadata(NULL, st->metadata, "    ");
3262
}
3263

    
3264
#if FF_API_DUMP_FORMAT
3265
void dump_format(AVFormatContext *ic,
3266
                 int index,
3267
                 const char *url,
3268
                 int is_output)
3269
{
3270
    av_dump_format(ic, index, url, is_output);
3271
}
3272
#endif
3273

    
3274
void av_dump_format(AVFormatContext *ic,
3275
                    int index,
3276
                    const char *url,
3277
                    int is_output)
3278
{
3279
    int i;
3280
    uint8_t *printed = av_mallocz(ic->nb_streams);
3281
    if (ic->nb_streams && !printed)
3282
        return;
3283

    
3284
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3285
            is_output ? "Output" : "Input",
3286
            index,
3287
            is_output ? ic->oformat->name : ic->iformat->name,
3288
            is_output ? "to" : "from", url);
3289
    dump_metadata(NULL, ic->metadata, "  ");
3290
    if (!is_output) {
3291
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3292
        if (ic->duration != AV_NOPTS_VALUE) {
3293
            int hours, mins, secs, us;
3294
            secs = ic->duration / AV_TIME_BASE;
3295
            us = ic->duration % AV_TIME_BASE;
3296
            mins = secs / 60;
3297
            secs %= 60;
3298
            hours = mins / 60;
3299
            mins %= 60;
3300
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3301
                   (100 * us) / AV_TIME_BASE);
3302
        } else {
3303
            av_log(NULL, AV_LOG_INFO, "N/A");
3304
        }
3305
        if (ic->start_time != AV_NOPTS_VALUE) {
3306
            int secs, us;
3307
            av_log(NULL, AV_LOG_INFO, ", start: ");
3308
            secs = ic->start_time / AV_TIME_BASE;
3309
            us = abs(ic->start_time % AV_TIME_BASE);
3310
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3311
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3312
        }
3313
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3314
        if (ic->bit_rate) {
3315
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3316
        } else {
3317
            av_log(NULL, AV_LOG_INFO, "N/A");
3318
        }
3319
        av_log(NULL, AV_LOG_INFO, "\n");
3320
    }
3321
    for (i = 0; i < ic->nb_chapters; i++) {
3322
        AVChapter *ch = ic->chapters[i];
3323
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3324
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3325
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3326

    
3327
        dump_metadata(NULL, ch->metadata, "    ");
3328
    }
3329
    if(ic->nb_programs) {
3330
        int j, k, total = 0;
3331
        for(j=0; j<ic->nb_programs; j++) {
3332
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3333
                                                  "name", NULL, 0);
3334
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3335
                   name ? name->value : "");
3336
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3337
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3338
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3339
                printed[ic->programs[j]->stream_index[k]] = 1;
3340
            }
3341
            total += ic->programs[j]->nb_stream_indexes;
3342
        }
3343
        if (total < ic->nb_streams)
3344
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3345
    }
3346
    for(i=0;i<ic->nb_streams;i++)
3347
        if (!printed[i])
3348
            dump_stream_format(ic, i, index, is_output);
3349

    
3350
    av_free(printed);
3351
}
3352

    
3353
#if FF_API_PARSE_FRAME_PARAM
3354
#include "libavutil/parseutils.h"
3355

    
3356
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3357
{
3358
    return av_parse_video_size(width_ptr, height_ptr, str);
3359
}
3360

    
3361
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3362
{
3363
    AVRational frame_rate;
3364
    int ret = av_parse_video_rate(&frame_rate, arg);
3365
    *frame_rate_num= frame_rate.num;
3366
    *frame_rate_den= frame_rate.den;
3367
    return ret;
3368
}
3369
#endif
3370

    
3371
int64_t av_gettime(void)
3372
{
3373
    struct timeval tv;
3374
    gettimeofday(&tv,NULL);
3375
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3376
}
3377

    
3378
uint64_t ff_ntp_time(void)
3379
{
3380
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3381
}
3382

    
3383
#if FF_API_PARSE_DATE
3384
#include "libavutil/parseutils.h"
3385

    
3386
int64_t parse_date(const char *timestr, int duration)
3387
{
3388
    int64_t timeval;
3389
    av_parse_time(&timeval, timestr, duration);
3390
    return timeval;
3391
}
3392
#endif
3393

    
3394
#if FF_API_FIND_INFO_TAG
3395
#include "libavutil/parseutils.h"
3396

    
3397
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3398
{
3399
    return av_find_info_tag(arg, arg_size, tag1, info);
3400
}
3401
#endif
3402

    
3403
int av_get_frame_filename(char *buf, int buf_size,
3404
                          const char *path, int number)
3405
{
3406
    const char *p;
3407
    char *q, buf1[20], c;
3408
    int nd, len, percentd_found;
3409

    
3410
    q = buf;
3411
    p = path;
3412
    percentd_found = 0;
3413
    for(;;) {
3414
        c = *p++;
3415
        if (c == '\0')
3416
            break;
3417
        if (c == '%') {
3418
            do {
3419
                nd = 0;
3420
                while (isdigit(*p)) {
3421
                    nd = nd * 10 + *p++ - '0';
3422
                }
3423
                c = *p++;
3424
            } while (isdigit(c));
3425

    
3426
            switch(c) {
3427
            case '%':
3428
                goto addchar;
3429
            case 'd':
3430
                if (percentd_found)
3431
                    goto fail;
3432
                percentd_found = 1;
3433
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3434
                len = strlen(buf1);
3435
                if ((q - buf + len) > buf_size - 1)
3436
                    goto fail;
3437
                memcpy(q, buf1, len);
3438
                q += len;
3439
                break;
3440
            default:
3441
                goto fail;
3442
            }
3443
        } else {
3444
        addchar:
3445
            if ((q - buf) < buf_size - 1)
3446
                *q++ = c;
3447
        }
3448
    }
3449
    if (!percentd_found)
3450
        goto fail;
3451
    *q = '\0';
3452
    return 0;
3453
 fail:
3454
    *q = '\0';
3455
    return -1;
3456
}
3457

    
3458
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3459
{
3460
    int len, i, j, c;
3461
#undef fprintf
3462
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3463

    
3464
    for(i=0;i<size;i+=16) {
3465
        len = size - i;
3466
        if (len > 16)
3467
            len = 16;
3468
        PRINT("%08x ", i);
3469
        for(j=0;j<16;j++) {
3470
            if (j < len)
3471
                PRINT(" %02x", buf[i+j]);
3472
            else
3473
                PRINT("   ");
3474
        }
3475
        PRINT(" ");
3476
        for(j=0;j<len;j++) {
3477
            c = buf[i+j];
3478
            if (c < ' ' || c > '~')
3479
                c = '.';
3480
            PRINT("%c", c);
3481
        }
3482
        PRINT("\n");
3483
    }
3484
#undef PRINT
3485
}
3486

    
3487
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3488
{
3489
    hex_dump_internal(NULL, f, 0, buf, size);
3490
}
3491

    
3492
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3493
{
3494
    hex_dump_internal(avcl, NULL, level, buf, size);
3495
}
3496

    
3497
 //FIXME needs to know the time_base
3498
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3499
{
3500
#undef fprintf
3501
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3502
    PRINT("stream #%d:\n", pkt->stream_index);
3503
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3504
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3505
    /* DTS is _always_ valid after av_read_frame() */
3506
    PRINT("  dts=");
3507
    if (pkt->dts == AV_NOPTS_VALUE)
3508
        PRINT("N/A");
3509
    else
3510
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3511
    /* PTS may not be known if B-frames are present. */
3512
    PRINT("  pts=");
3513
    if (pkt->pts == AV_NOPTS_VALUE)
3514
        PRINT("N/A");
3515
    else
3516
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3517
    PRINT("\n");
3518
    PRINT("  size=%d\n", pkt->size);
3519
#undef PRINT
3520
    if (dump_payload)
3521
        av_hex_dump(f, pkt->data, pkt->size);
3522
}
3523

    
3524
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3525
{
3526
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3527
}
3528

    
3529
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3530
{
3531
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3532
}
3533

    
3534
#if FF_API_URL_SPLIT
3535
attribute_deprecated
3536
void ff_url_split(char *proto, int proto_size,
3537
                  char *authorization, int authorization_size,
3538
                  char *hostname, int hostname_size,
3539
                  int *port_ptr,
3540
                  char *path, int path_size,
3541
                  const char *url)
3542
{
3543
    av_url_split(proto, proto_size,
3544
                 authorization, authorization_size,
3545
                 hostname, hostname_size,
3546
                 port_ptr,
3547
                 path, path_size,
3548
                 url);
3549
}
3550
#endif
3551

    
3552
void av_url_split(char *proto, int proto_size,
3553
                  char *authorization, int authorization_size,
3554
                  char *hostname, int hostname_size,
3555
                  int *port_ptr,
3556
                  char *path, int path_size,
3557
                  const char *url)
3558
{
3559
    const char *p, *ls, *at, *col, *brk;
3560

    
3561
    if (port_ptr)               *port_ptr = -1;
3562
    if (proto_size > 0)         proto[0] = 0;
3563
    if (authorization_size > 0) authorization[0] = 0;
3564
    if (hostname_size > 0)      hostname[0] = 0;
3565
    if (path_size > 0)          path[0] = 0;
3566

    
3567
    /* parse protocol */
3568
    if ((p = strchr(url, ':'))) {
3569
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3570
        p++; /* skip ':' */
3571
        if (*p == '/') p++;
3572
        if (*p == '/') p++;
3573
    } else {
3574
        /* no protocol means plain filename */
3575
        av_strlcpy(path, url, path_size);
3576
        return;
3577
    }
3578

    
3579
    /* separate path from hostname */
3580
    ls = strchr(p, '/');
3581
    if(!ls)
3582
        ls = strchr(p, '?');
3583
    if(ls)
3584
        av_strlcpy(path, ls, path_size);
3585
    else
3586
        ls = &p[strlen(p)]; // XXX
3587

    
3588
    /* the rest is hostname, use that to parse auth/port */
3589
    if (ls != p) {
3590
        /* authorization (user[:pass]@hostname) */
3591
        if ((at = strchr(p, '@')) && at < ls) {
3592
            av_strlcpy(authorization, p,
3593
                       FFMIN(authorization_size, at + 1 - p));
3594
            p = at + 1; /* skip '@' */
3595
        }
3596

    
3597
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3598
            /* [host]:port */
3599
            av_strlcpy(hostname, p + 1,
3600
                       FFMIN(hostname_size, brk - p));
3601
            if (brk[1] == ':' && port_ptr)
3602
                *port_ptr = atoi(brk + 2);
3603
        } else if ((col = strchr(p, ':')) && col < ls) {
3604
            av_strlcpy(hostname, p,
3605
                       FFMIN(col + 1 - p, hostname_size));
3606
            if (port_ptr) *port_ptr = atoi(col + 1);
3607
        } else
3608
            av_strlcpy(hostname, p,
3609
                       FFMIN(ls + 1 - p, hostname_size));
3610
    }
3611
}
3612

    
3613
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3614
{
3615
    int i;
3616
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3617
                                           '4', '5', '6', '7',
3618
                                           '8', '9', 'A', 'B',
3619
                                           'C', 'D', 'E', 'F' };
3620
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3621
                                           '4', '5', '6', '7',
3622
                                           '8', '9', 'a', 'b',
3623
                                           'c', 'd', 'e', 'f' };
3624
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3625

    
3626
    for(i = 0; i < s; i++) {
3627
        buff[i * 2]     = hex_table[src[i] >> 4];
3628
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3629
    }
3630

    
3631
    return buff;
3632
}
3633

    
3634
int ff_hex_to_data(uint8_t *data, const char *p)
3635
{
3636
    int c, len, v;
3637

    
3638
    len = 0;
3639
    v = 1;
3640
    for (;;) {
3641
        p += strspn(p, SPACE_CHARS);
3642
        if (*p == '\0')
3643
            break;
3644
        c = toupper((unsigned char) *p++);
3645
        if (c >= '0' && c <= '9')
3646
            c = c - '0';
3647
        else if (c >= 'A' && c <= 'F')
3648
            c = c - 'A' + 10;
3649
        else
3650
            break;
3651
        v = (v << 4) | c;
3652
        if (v & 0x100) {
3653
            if (data)
3654
                data[len] = v;
3655
            len++;
3656
            v = 1;
3657
        }
3658
    }
3659
    return len;
3660
}
3661

    
3662
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3663
                     unsigned int pts_num, unsigned int pts_den)
3664
{
3665
    AVRational new_tb;
3666
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3667
        if(new_tb.num != pts_num)
3668
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3669
    }else
3670
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3671

    
3672
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3673
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3674
        return;
3675
    }
3676
    s->time_base = new_tb;
3677
    s->pts_wrap_bits = pts_wrap_bits;
3678
}
3679

    
3680
int ff_url_join(char *str, int size, const char *proto,
3681
                const char *authorization, const char *hostname,
3682
                int port, const char *fmt, ...)
3683
{
3684
#if CONFIG_NETWORK
3685
    struct addrinfo hints, *ai;
3686
#endif
3687

    
3688
    str[0] = '\0';
3689
    if (proto)
3690
        av_strlcatf(str, size, "%s://", proto);
3691
    if (authorization && authorization[0])
3692
        av_strlcatf(str, size, "%s@", authorization);
3693
#if CONFIG_NETWORK && defined(AF_INET6)
3694
    /* Determine if hostname is a numerical IPv6 address,
3695
     * properly escape it within [] in that case. */
3696
    memset(&hints, 0, sizeof(hints));
3697
    hints.ai_flags = AI_NUMERICHOST;
3698
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3699
        if (ai->ai_family == AF_INET6) {
3700
            av_strlcat(str, "[", size);
3701
            av_strlcat(str, hostname, size);
3702
            av_strlcat(str, "]", size);
3703
        } else {
3704
            av_strlcat(str, hostname, size);
3705
        }
3706
        freeaddrinfo(ai);
3707
    } else
3708
#endif
3709
        /* Not an IPv6 address, just output the plain string. */
3710
        av_strlcat(str, hostname, size);
3711

    
3712
    if (port >= 0)
3713
        av_strlcatf(str, size, ":%d", port);
3714
    if (fmt) {
3715
        va_list vl;
3716
        int len = strlen(str);
3717

    
3718
        va_start(vl, fmt);
3719
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3720
        va_end(vl);
3721
    }
3722
    return strlen(str);
3723
}
3724

    
3725
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3726
                     AVFormatContext *src)
3727
{
3728
    AVPacket local_pkt;
3729

    
3730
    local_pkt = *pkt;
3731
    local_pkt.stream_index = dst_stream;
3732
    if (pkt->pts != AV_NOPTS_VALUE)
3733
        local_pkt.pts = av_rescale_q(pkt->pts,
3734
                                     src->streams[pkt->stream_index]->time_base,
3735
                                     dst->streams[dst_stream]->time_base);
3736
    if (pkt->dts != AV_NOPTS_VALUE)
3737
        local_pkt.dts = av_rescale_q(pkt->dts,
3738
                                     src->streams[pkt->stream_index]->time_base,
3739
                                     dst->streams[dst_stream]->time_base);
3740
    return av_write_frame(dst, &local_pkt);
3741
}
3742

    
3743
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3744
                        void *context)
3745
{
3746
    const char *ptr = str;
3747

    
3748
    /* Parse key=value pairs. */
3749
    for (;;) {
3750
        const char *key;
3751
        char *dest = NULL, *dest_end;
3752
        int key_len, dest_len = 0;
3753

    
3754
        /* Skip whitespace and potential commas. */
3755
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3756
            ptr++;
3757
        if (!*ptr)
3758
            break;
3759

    
3760
        key = ptr;
3761

    
3762
        if (!(ptr = strchr(key, '=')))
3763
            break;
3764
        ptr++;
3765
        key_len = ptr - key;
3766

    
3767
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3768
        dest_end = dest + dest_len - 1;
3769

    
3770
        if (*ptr == '\"') {
3771
            ptr++;
3772
            while (*ptr && *ptr != '\"') {
3773
                if (*ptr == '\\') {
3774
                    if (!ptr[1])
3775
                        break;
3776
                    if (dest && dest < dest_end)
3777
                        *dest++ = ptr[1];
3778
                    ptr += 2;
3779
                } else {
3780
                    if (dest && dest < dest_end)
3781
                        *dest++ = *ptr;
3782
                    ptr++;
3783
                }
3784
            }
3785
            if (*ptr == '\"')
3786
                ptr++;
3787
        } else {
3788
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3789
                if (dest && dest < dest_end)
3790
                    *dest++ = *ptr;
3791
        }
3792
        if (dest)
3793
            *dest = 0;
3794
    }
3795
}
3796

    
3797
int ff_find_stream_index(AVFormatContext *s, int id)
3798
{
3799
    int i;
3800
    for (i = 0; i < s->nb_streams; i++) {
3801
        if (s->streams[i]->id == id)
3802
            return i;
3803
    }
3804
    return -1;
3805
}