Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ f1ef2cd9

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 "avio_internal.h"
23
#include "internal.h"
24
#include "libavcodec/internal.h"
25
#include "libavutil/opt.h"
26
#include "metadata.h"
27
#include "id3v2.h"
28
#include "libavutil/avstring.h"
29
#include "riff.h"
30
#include "audiointerleave.h"
31
#include <sys/time.h>
32
#include <time.h>
33
#include <strings.h>
34
#include <stdarg.h>
35
#if CONFIG_NETWORK
36
#include "network.h"
37
#endif
38

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

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

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

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

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

    
63
/* fraction handling */
64

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

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

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

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

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

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

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

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

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

    
159
    if(!filename)
160
        return 0;
161

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

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

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

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

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

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

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

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

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

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

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

    
259
    return fmt;
260
}
261
#endif
262

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

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

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

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

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

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

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

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

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

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

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

    
334
    pkt->pos= avio_tell(s);
335

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

    
342
    return ret;
343
}
344

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

    
360

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

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

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

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

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

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

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

    
439
/************************************************************/
440
/* input media file */
441

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

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

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

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

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

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

    
493
    if (pb && !ic->data_offset)
494
        ic->data_offset = avio_tell(ic->pb);
495

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

    
500
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
501

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

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

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

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

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

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

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

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

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

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

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

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

    
592
    return ret;
593
}
594

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

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

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

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

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

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

    
657
}
658

    
659
/*******************************************************/
660

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

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

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

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

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

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

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

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

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

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

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

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

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

    
754
/**********************************************************/
755

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

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

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

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

    
785

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1078

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

    
1084
    av_init_packet(pkt);
1085

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

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

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

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

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

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

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

    
1217
    return 0;
1218
}
1219

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

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

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

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

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

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

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

    
1298
/*******************************************************/
1299
/* seek support */
1300

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

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

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

    
1328
    flush_packet_queue(s);
1329

    
1330
    s->cur_st = NULL;
1331

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

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

    
1348
        st->probe_packets = MAX_PROBE_PACKETS;
1349

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

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

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

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

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

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

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

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

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

    
1398
    *index_entries= entries;
1399

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

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

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

    
1423
    return index;
1424
}
1425

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

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

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

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

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

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

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

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

    
1475
#define DEBUG_SEEK
1476

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

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

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

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

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

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

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

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

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

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

    
1538
    av_update_cur_dts(s, st, ts);
1539

    
1540
    return 0;
1541
}
1542

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1669
    pos_min = s->data_offset;
1670
    pos_max = avio_size(s->pb) - 1;
1671

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

    
1675
    avio_seek(s->pb, pos, SEEK_SET);
1676

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

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

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

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

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

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

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

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

    
1740
    return 0;
1741
}
1742

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

    
1748
    ff_read_frame_flush(s);
1749

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

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

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

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

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

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

    
1783
    ff_read_frame_flush(s);
1784

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

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

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

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

    
1800
/*******************************************************/
1801

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

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

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

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

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

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

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

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

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

    
1921
#define DURATION_MAX_READ_SIZE 250000
1922
#define DURATION_MAX_RETRY 3
1923

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

    
1934
    ic->cur_st = NULL;
1935

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

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

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

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

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

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

    
1993
    fill_all_stream_timings(ic);
1994

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2333
        read_size += pkt->size;
2334

    
2335
        st = ic->streams[pkt->stream_index];
2336
        if (st->codec_info_nb_frames>1) {
2337
            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) {
2338
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2339
                break;
2340
            }
2341
            st->info->codec_info_duration += pkt->duration;
2342
        }
2343
        {
2344
            int64_t last = st->info->last_dts;
2345
            int64_t duration= pkt->dts - last;
2346

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

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

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

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

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

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

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

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

    
2448
    av_estimate_timings(ic, old_offset);
2449

    
2450
    compute_chapters_end(ic);
2451

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

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

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

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

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

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

    
2546
/*******************************************************/
2547

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2711
    return program;
2712
}
2713

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

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

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

    
2738
    return chapter;
2739
}
2740

    
2741
/************************************************************/
2742
/* output media file */
2743

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3026
    this_pktl->next= *next_point;
3027

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3133
        av_free_packet(&pkt);
3134

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3351
    av_free(printed);
3352
}
3353

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3498
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
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", pkt->duration * av_q2d(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", pkt->dts * av_q2d(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", pkt->pts * av_q2d(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
    AVRational tb = { 1, AV_TIME_BASE };
3527
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3528
}
3529

    
3530
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3531
{
3532
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3533
}
3534

    
3535
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3536
{
3537
    AVRational tb = { 1, AV_TIME_BASE };
3538
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3539
}
3540

    
3541
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3542
                      AVStream *st)
3543
{
3544
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3545
}
3546

    
3547
#if FF_API_URL_SPLIT
3548
attribute_deprecated
3549
void ff_url_split(char *proto, int proto_size,
3550
                  char *authorization, int authorization_size,
3551
                  char *hostname, int hostname_size,
3552
                  int *port_ptr,
3553
                  char *path, int path_size,
3554
                  const char *url)
3555
{
3556
    av_url_split(proto, proto_size,
3557
                 authorization, authorization_size,
3558
                 hostname, hostname_size,
3559
                 port_ptr,
3560
                 path, path_size,
3561
                 url);
3562
}
3563
#endif
3564

    
3565
void av_url_split(char *proto, int proto_size,
3566
                  char *authorization, int authorization_size,
3567
                  char *hostname, int hostname_size,
3568
                  int *port_ptr,
3569
                  char *path, int path_size,
3570
                  const char *url)
3571
{
3572
    const char *p, *ls, *at, *col, *brk;
3573

    
3574
    if (port_ptr)               *port_ptr = -1;
3575
    if (proto_size > 0)         proto[0] = 0;
3576
    if (authorization_size > 0) authorization[0] = 0;
3577
    if (hostname_size > 0)      hostname[0] = 0;
3578
    if (path_size > 0)          path[0] = 0;
3579

    
3580
    /* parse protocol */
3581
    if ((p = strchr(url, ':'))) {
3582
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3583
        p++; /* skip ':' */
3584
        if (*p == '/') p++;
3585
        if (*p == '/') p++;
3586
    } else {
3587
        /* no protocol means plain filename */
3588
        av_strlcpy(path, url, path_size);
3589
        return;
3590
    }
3591

    
3592
    /* separate path from hostname */
3593
    ls = strchr(p, '/');
3594
    if(!ls)
3595
        ls = strchr(p, '?');
3596
    if(ls)
3597
        av_strlcpy(path, ls, path_size);
3598
    else
3599
        ls = &p[strlen(p)]; // XXX
3600

    
3601
    /* the rest is hostname, use that to parse auth/port */
3602
    if (ls != p) {
3603
        /* authorization (user[:pass]@hostname) */
3604
        if ((at = strchr(p, '@')) && at < ls) {
3605
            av_strlcpy(authorization, p,
3606
                       FFMIN(authorization_size, at + 1 - p));
3607
            p = at + 1; /* skip '@' */
3608
        }
3609

    
3610
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3611
            /* [host]:port */
3612
            av_strlcpy(hostname, p + 1,
3613
                       FFMIN(hostname_size, brk - p));
3614
            if (brk[1] == ':' && port_ptr)
3615
                *port_ptr = atoi(brk + 2);
3616
        } else if ((col = strchr(p, ':')) && col < ls) {
3617
            av_strlcpy(hostname, p,
3618
                       FFMIN(col + 1 - p, hostname_size));
3619
            if (port_ptr) *port_ptr = atoi(col + 1);
3620
        } else
3621
            av_strlcpy(hostname, p,
3622
                       FFMIN(ls + 1 - p, hostname_size));
3623
    }
3624
}
3625

    
3626
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3627
{
3628
    int i;
3629
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3630
                                           '4', '5', '6', '7',
3631
                                           '8', '9', 'A', 'B',
3632
                                           'C', 'D', 'E', 'F' };
3633
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3634
                                           '4', '5', '6', '7',
3635
                                           '8', '9', 'a', 'b',
3636
                                           'c', 'd', 'e', 'f' };
3637
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3638

    
3639
    for(i = 0; i < s; i++) {
3640
        buff[i * 2]     = hex_table[src[i] >> 4];
3641
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3642
    }
3643

    
3644
    return buff;
3645
}
3646

    
3647
int ff_hex_to_data(uint8_t *data, const char *p)
3648
{
3649
    int c, len, v;
3650

    
3651
    len = 0;
3652
    v = 1;
3653
    for (;;) {
3654
        p += strspn(p, SPACE_CHARS);
3655
        if (*p == '\0')
3656
            break;
3657
        c = toupper((unsigned char) *p++);
3658
        if (c >= '0' && c <= '9')
3659
            c = c - '0';
3660
        else if (c >= 'A' && c <= 'F')
3661
            c = c - 'A' + 10;
3662
        else
3663
            break;
3664
        v = (v << 4) | c;
3665
        if (v & 0x100) {
3666
            if (data)
3667
                data[len] = v;
3668
            len++;
3669
            v = 1;
3670
        }
3671
    }
3672
    return len;
3673
}
3674

    
3675
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3676
                     unsigned int pts_num, unsigned int pts_den)
3677
{
3678
    AVRational new_tb;
3679
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3680
        if(new_tb.num != pts_num)
3681
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3682
    }else
3683
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3684

    
3685
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3686
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3687
        return;
3688
    }
3689
    s->time_base = new_tb;
3690
    s->pts_wrap_bits = pts_wrap_bits;
3691
}
3692

    
3693
int ff_url_join(char *str, int size, const char *proto,
3694
                const char *authorization, const char *hostname,
3695
                int port, const char *fmt, ...)
3696
{
3697
#if CONFIG_NETWORK
3698
    struct addrinfo hints, *ai;
3699
#endif
3700

    
3701
    str[0] = '\0';
3702
    if (proto)
3703
        av_strlcatf(str, size, "%s://", proto);
3704
    if (authorization && authorization[0])
3705
        av_strlcatf(str, size, "%s@", authorization);
3706
#if CONFIG_NETWORK && defined(AF_INET6)
3707
    /* Determine if hostname is a numerical IPv6 address,
3708
     * properly escape it within [] in that case. */
3709
    memset(&hints, 0, sizeof(hints));
3710
    hints.ai_flags = AI_NUMERICHOST;
3711
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3712
        if (ai->ai_family == AF_INET6) {
3713
            av_strlcat(str, "[", size);
3714
            av_strlcat(str, hostname, size);
3715
            av_strlcat(str, "]", size);
3716
        } else {
3717
            av_strlcat(str, hostname, size);
3718
        }
3719
        freeaddrinfo(ai);
3720
    } else
3721
#endif
3722
        /* Not an IPv6 address, just output the plain string. */
3723
        av_strlcat(str, hostname, size);
3724

    
3725
    if (port >= 0)
3726
        av_strlcatf(str, size, ":%d", port);
3727
    if (fmt) {
3728
        va_list vl;
3729
        int len = strlen(str);
3730

    
3731
        va_start(vl, fmt);
3732
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3733
        va_end(vl);
3734
    }
3735
    return strlen(str);
3736
}
3737

    
3738
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3739
                     AVFormatContext *src)
3740
{
3741
    AVPacket local_pkt;
3742

    
3743
    local_pkt = *pkt;
3744
    local_pkt.stream_index = dst_stream;
3745
    if (pkt->pts != AV_NOPTS_VALUE)
3746
        local_pkt.pts = av_rescale_q(pkt->pts,
3747
                                     src->streams[pkt->stream_index]->time_base,
3748
                                     dst->streams[dst_stream]->time_base);
3749
    if (pkt->dts != AV_NOPTS_VALUE)
3750
        local_pkt.dts = av_rescale_q(pkt->dts,
3751
                                     src->streams[pkt->stream_index]->time_base,
3752
                                     dst->streams[dst_stream]->time_base);
3753
    return av_write_frame(dst, &local_pkt);
3754
}
3755

    
3756
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3757
                        void *context)
3758
{
3759
    const char *ptr = str;
3760

    
3761
    /* Parse key=value pairs. */
3762
    for (;;) {
3763
        const char *key;
3764
        char *dest = NULL, *dest_end;
3765
        int key_len, dest_len = 0;
3766

    
3767
        /* Skip whitespace and potential commas. */
3768
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3769
            ptr++;
3770
        if (!*ptr)
3771
            break;
3772

    
3773
        key = ptr;
3774

    
3775
        if (!(ptr = strchr(key, '=')))
3776
            break;
3777
        ptr++;
3778
        key_len = ptr - key;
3779

    
3780
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3781
        dest_end = dest + dest_len - 1;
3782

    
3783
        if (*ptr == '\"') {
3784
            ptr++;
3785
            while (*ptr && *ptr != '\"') {
3786
                if (*ptr == '\\') {
3787
                    if (!ptr[1])
3788
                        break;
3789
                    if (dest && dest < dest_end)
3790
                        *dest++ = ptr[1];
3791
                    ptr += 2;
3792
                } else {
3793
                    if (dest && dest < dest_end)
3794
                        *dest++ = *ptr;
3795
                    ptr++;
3796
                }
3797
            }
3798
            if (*ptr == '\"')
3799
                ptr++;
3800
        } else {
3801
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3802
                if (dest && dest < dest_end)
3803
                    *dest++ = *ptr;
3804
        }
3805
        if (dest)
3806
            *dest = 0;
3807
    }
3808
}
3809

    
3810
int ff_find_stream_index(AVFormatContext *s, int id)
3811
{
3812
    int i;
3813
    for (i = 0; i < s->nb_streams; i++) {
3814
        if (s->streams[i]->id == id)
3815
            return i;
3816
    }
3817
    return -1;
3818
}