Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ c70a6a41

History | View | Annotate | Download (123 KB)

1
/*
2
 * various utility functions for use within Libav
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* #define DEBUG */
23

    
24
#include "avformat.h"
25
#include "avio_internal.h"
26
#include "internal.h"
27
#include "libavcodec/internal.h"
28
#include "libavutil/opt.h"
29
#include "metadata.h"
30
#include "id3v2.h"
31
#include "libavutil/avstring.h"
32
#include "riff.h"
33
#include "audiointerleave.h"
34
#include <sys/time.h>
35
#include <time.h>
36
#include <strings.h>
37
#include <stdarg.h>
38
#if CONFIG_NETWORK
39
#include "network.h"
40
#endif
41

    
42
#undef NDEBUG
43
#include <assert.h>
44

    
45
/**
46
 * @file
47
 * various utility functions for use within Libav
48
 */
49

    
50
unsigned avformat_version(void)
51
{
52
    return LIBAVFORMAT_VERSION_INT;
53
}
54

    
55
const char *avformat_configuration(void)
56
{
57
    return LIBAV_CONFIGURATION;
58
}
59

    
60
const char *avformat_license(void)
61
{
62
#define LICENSE_PREFIX "libavformat license: "
63
    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
64
}
65

    
66
/* fraction handling */
67

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

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

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

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

    
127
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
128
{
129
    if(f) return f->next;
130
    else  return first_iformat;
131
}
132

    
133
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
134
{
135
    if(f) return f->next;
136
    else  return first_oformat;
137
}
138

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

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

    
157
int av_match_ext(const char *filename, const char *extensions)
158
{
159
    const char *ext, *p;
160
    char ext1[32], *q;
161

    
162
    if(!filename)
163
        return 0;
164

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

    
184
static int match_format(const char *name, const char *names)
185
{
186
    const char *p;
187
    int len, namelen;
188

    
189
    if (!name || !names)
190
        return 0;
191

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

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

    
210
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
211
                                const char *mime_type)
212
{
213
    AVOutputFormat *fmt = NULL, *fmt_found;
214
    int score_max, score;
215

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

    
245
#if FF_API_GUESS_FORMAT
246
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
247
                             const char *mime_type)
248
{
249
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
250

    
251
    if (fmt) {
252
        AVOutputFormat *stream_fmt;
253
        char stream_format_name[64];
254

    
255
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
256
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
257

    
258
        if (stream_fmt)
259
            fmt = stream_fmt;
260
    }
261

    
262
    return fmt;
263
}
264
#endif
265

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

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

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

    
297
#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
298
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
299
{
300
    av_destruct_packet_nofree(pkt);
301
}
302

    
303
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
304
{
305
    av_destruct_packet(pkt);
306
}
307

    
308
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
309
{
310
    return av_new_packet(pkt, size);
311
}
312

    
313
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
314
{
315
    return av_dup_packet(pkt);
316
}
317

    
318
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
319
{
320
    av_free_packet(pkt);
321
}
322

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

    
330
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
331
{
332
    int ret= av_new_packet(pkt, size);
333

    
334
    if(ret<0)
335
        return ret;
336

    
337
    pkt->pos= avio_tell(s);
338

    
339
    ret= avio_read(s, pkt->data, size);
340
    if(ret<=0)
341
        av_free_packet(pkt);
342
    else
343
        av_shrink_packet(pkt, ret);
344

    
345
    return ret;
346
}
347

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

    
363

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

    
370
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
371
{
372
    AVProbeData lpd = *pd;
373
    AVInputFormat *fmt1 = NULL, *fmt;
374
    int score;
375

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

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

    
405
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
406
    int score=0;
407
    return av_probe_input_format2(pd, is_opened, &score);
408
}
409

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

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

    
442
/************************************************************/
443
/* input media file */
444

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

    
456
    if(!ap){
457
        ap=&default_ap;
458
        memset(ap, 0, sizeof(default_ap));
459
    }
460

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

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

    
486
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
487
    if (ic->pb)
488
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
489

    
490
    if (ic->iformat->read_header) {
491
        err = ic->iformat->read_header(ic, ap);
492
        if (err < 0)
493
            goto fail;
494
    }
495

    
496
    if (pb && !ic->data_offset)
497
        ic->data_offset = avio_tell(ic->pb);
498

    
499
#if FF_API_OLD_METADATA
500
    ff_metadata_demux_compat(ic);
501
#endif
502

    
503
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
504

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

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

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

    
539
    if (!max_probe_size) {
540
        max_probe_size = PROBE_BUF_MAX;
541
    } else if (max_probe_size > PROBE_BUF_MAX) {
542
        max_probe_size = PROBE_BUF_MAX;
543
    } else if (max_probe_size < PROBE_BUF_MIN) {
544
        return AVERROR(EINVAL);
545
    }
546

    
547
    if (offset >= max_probe_size) {
548
        return AVERROR(EINVAL);
549
    }
550

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

    
556
        if (probe_size < offset) {
557
            continue;
558
        }
559

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

    
574
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
575

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

    
586
    if (!*fmt) {
587
        av_free(buf);
588
        return AVERROR_INVALIDDATA;
589
    }
590

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

    
595
    return ret;
596
}
597

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

    
608
    pd->filename = "";
609
    if (filename)
610
        pd->filename = filename;
611
    pd->buf = NULL;
612
    pd->buf_size = 0;
613

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

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

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

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

    
660
}
661

    
662
/*******************************************************/
663

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

    
670
    if (*packet_buffer)
671
        (*plast_pktl)->next = pktl;
672
    else
673
        *packet_buffer = pktl;
674

    
675
    /* add the packet in the buffered packet list */
676
    *plast_pktl = pktl;
677
    pktl->pkt= *pkt;
678
    return &pktl->pkt;
679
}
680

    
681
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
682
{
683
    int ret, i;
684
    AVStream *st;
685

    
686
    for(;;){
687
        AVPacketList *pktl = s->raw_packet_buffer;
688

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

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

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

    
727
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
728
                     !st->probe_packets))
729
            return ret;
730

    
731
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
732
        s->raw_packet_buffer_remaining_size -= pkt->size;
733

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

    
739
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
740
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
741
            pd->buf_size += pkt->size;
742
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
743

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

    
757
/**********************************************************/
758

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

    
766
    if(enc->codec_id == CODEC_ID_VORBIS)
767
        return -1;
768

    
769
    if (enc->frame_size <= 1) {
770
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
771

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

    
788

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

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

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

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

    
859
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
860
        return;
861

    
862
    st->first_dts= dts - st->cur_dts;
863
    st->cur_dts= dts;
864

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

    
872
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
873
            pktl->pkt.dts += st->first_dts;
874

    
875
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
876
            st->start_time= pktl->pkt.pts;
877
    }
878
    if (st->start_time == AV_NOPTS_VALUE)
879
        st->start_time = pts;
880
}
881

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

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

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

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

    
924
    if (s->flags & AVFMT_FLAG_NOFILLIN)
925
        return;
926

    
927
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
928
        pkt->dts= AV_NOPTS_VALUE;
929

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

    
934
    /* do we have a video B-frame ? */
935
    delay= st->codec->has_b_frames;
936
    presentation_delayed = 0;
937

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

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

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

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

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

    
967
            if(pkt->duration != 0 && s->packet_buffer)
968
                update_initial_durations(s, st, pkt);
969
        }
970
    }
971

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

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

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

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

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

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

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

    
1064
//    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);
1065

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

    
1081

    
1082
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1083
{
1084
    AVStream *st;
1085
    int len, ret, i;
1086

    
1087
    av_init_packet(pkt);
1088

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

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

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

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

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

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

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

    
1220
    return 0;
1221
}
1222

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

    
1229
    for(;;){
1230
        pktl = s->packet_buffer;
1231
        if (pktl) {
1232
            AVPacket *next_pkt= &pktl->pkt;
1233

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

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

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

    
1277
/* XXX: suppress the packet queue */
1278
static void flush_packet_queue(AVFormatContext *s)
1279
{
1280
    AVPacketList *pktl;
1281

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

    
1301
/*******************************************************/
1302
/* seek support */
1303

    
1304
int av_find_default_stream_index(AVFormatContext *s)
1305
{
1306
    int first_audio_index = -1;
1307
    int i;
1308
    AVStream *st;
1309

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

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

    
1331
    flush_packet_queue(s);
1332

    
1333
    s->cur_st = NULL;
1334

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

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

    
1351
        st->probe_packets = MAX_PROBE_PACKETS;
1352

    
1353
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1354
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1355
    }
1356
}
1357

    
1358
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1359
    int i;
1360

    
1361
    for(i = 0; i < s->nb_streams; i++) {
1362
        AVStream *st = s->streams[i];
1363

    
1364
        st->cur_dts = av_rescale(timestamp,
1365
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1366
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1367
    }
1368
}
1369

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

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

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

    
1391
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1392
        return -1;
1393

    
1394
    entries = av_fast_realloc(*index_entries,
1395
                              index_entries_allocated_size,
1396
                              (*nb_index_entries + 1) *
1397
                              sizeof(AVIndexEntry));
1398
    if(!entries)
1399
        return -1;
1400

    
1401
    *index_entries= entries;
1402

    
1403
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1404

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

    
1420
    ie->pos = pos;
1421
    ie->timestamp = timestamp;
1422
    ie->min_distance= distance;
1423
    ie->size= size;
1424
    ie->flags = flags;
1425

    
1426
    return index;
1427
}
1428

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

    
1437
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1438
                              int64_t wanted_timestamp, int flags)
1439
{
1440
    int a, b, m;
1441
    int64_t timestamp;
1442

    
1443
    a = - 1;
1444
    b = nb_entries;
1445

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

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

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

    
1466
    if(m == nb_entries)
1467
        return -1;
1468
    return  m;
1469
}
1470

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

    
1478
#define DEBUG_SEEK
1479

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

    
1488
    if (stream_index < 0)
1489
        return -1;
1490

    
1491
#ifdef DEBUG_SEEK
1492
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1493
#endif
1494

    
1495
    ts_max=
1496
    ts_min= AV_NOPTS_VALUE;
1497
    pos_limit= -1; //gcc falsely says it may be uninitialized
1498

    
1499
    st= s->streams[stream_index];
1500
    if(st->index_entries){
1501
        AVIndexEntry *e;
1502

    
1503
        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()
1504
        index= FFMAX(index, 0);
1505
        e= &st->index_entries[index];
1506

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

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

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

    
1537
    /* do the seek */
1538
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1539
        return ret;
1540

    
1541
    av_update_cur_dts(s, st, ts);
1542

    
1543
    return 0;
1544
}
1545

    
1546
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 )){
1547
    int64_t pos, ts;
1548
    int64_t start_pos, filesize;
1549
    int no_change;
1550

    
1551
#ifdef DEBUG_SEEK
1552
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1553
#endif
1554

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

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

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

    
1587
    if(ts_min > ts_max){
1588
        return -1;
1589
    }else if(ts_min == ts_max){
1590
        pos_limit= pos_min;
1591
    }
1592

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

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

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

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

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

1666
    if (stream_index < 0)
1667
        return -1;
1668

1669
    st= s->streams[stream_index];
1670
#endif
1671

    
1672
    pos_min = s->data_offset;
1673
    pos_max = avio_size(s->pb) - 1;
1674

    
1675
    if     (pos < pos_min) pos= pos_min;
1676
    else if(pos > pos_max) pos= pos_max;
1677

    
1678
    avio_seek(s->pb, pos, SEEK_SET);
1679

    
1680
#if 0
1681
    av_update_cur_dts(s, st, ts);
1682
#endif
1683
    return 0;
1684
}
1685

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

    
1694
    st = s->streams[stream_index];
1695

    
1696
    index = av_index_search_timestamp(st, timestamp, flags);
1697

    
1698
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1699
        return -1;
1700

    
1701
    if(index < 0 || index==st->nb_index_entries-1){
1702
        int i;
1703
        AVPacket pkt;
1704

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

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

    
1743
    return 0;
1744
}
1745

    
1746
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1747
{
1748
    int ret;
1749
    AVStream *st;
1750

    
1751
    ff_read_frame_flush(s);
1752

    
1753
    if(flags & AVSEEK_FLAG_BYTE)
1754
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1755

    
1756
    if(stream_index < 0){
1757
        stream_index= av_find_default_stream_index(s);
1758
        if(stream_index < 0)
1759
            return -1;
1760

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

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

    
1775
    if(s->iformat->read_timestamp)
1776
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1777
    else
1778
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1779
}
1780

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

    
1786
    ff_read_frame_flush(s);
1787

    
1788
    if (s->iformat->read_seek2)
1789
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1790

    
1791
    if(s->iformat->read_timestamp){
1792
        //try to seek via read_timestamp()
1793
    }
1794

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

    
1800
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1801
}
1802

    
1803
/*******************************************************/
1804

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

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

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

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

    
1874
static void fill_all_stream_timings(AVFormatContext *ic)
1875
{
1876
    int i;
1877
    AVStream *st;
1878

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

    
1891
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1892
{
1893
    int64_t filesize, duration;
1894
    int bit_rate, i;
1895
    AVStream *st;
1896

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

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

    
1924
#define DURATION_MAX_READ_SIZE 250000
1925
#define DURATION_MAX_RETRY 3
1926

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

    
1937
    ic->cur_st = NULL;
1938

    
1939
    /* flush packet queue */
1940
    flush_packet_queue(ic);
1941

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

    
1947
        if (st->parser) {
1948
            av_parser_close(st->parser);
1949
            st->parser= NULL;
1950
            av_free_packet(&st->cur_pkt);
1951
        }
1952
    }
1953

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

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

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

    
1996
    fill_all_stream_timings(ic);
1997

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

    
2006
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2007
{
2008
    int64_t file_size;
2009

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

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

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

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

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

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

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

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

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

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

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

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

    
2169
static void compute_chapters_end(AVFormatContext *s)
2170
{
2171
    unsigned int i;
2172

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

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

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

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

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

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

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

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

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

    
2265
    for (i=0; i<ic->nb_streams; i++) {
2266
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2267
    }
2268

    
2269
    count = 0;
2270
    read_size = 0;
2271
    for(;;) {
2272
        if(url_interrupt_cb()){
2273
            ret= AVERROR_EXIT;
2274
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2275
            break;
2276
        }
2277

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

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

    
2329
        if (ret == AVERROR(EAGAIN))
2330
            continue;
2331

    
2332
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2333
        if ((ret = av_dup_packet(pkt)) < 0)
2334
            goto find_stream_info_err;
2335

    
2336
        read_size += pkt->size;
2337

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

    
2350
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2351
                double dur= duration * av_q2d(st->time_base);
2352

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

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

    
2388
        st->codec_info_nb_frames++;
2389
        count++;
2390
    }
2391

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

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

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

    
2435
            if (!st->r_frame_rate.num){
2436
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2437
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2438
                    st->r_frame_rate.num = st->codec->time_base.den;
2439
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2440
                }else{
2441
                    st->r_frame_rate.num = st->time_base.den;
2442
                    st->r_frame_rate.den = st->time_base.num;
2443
                }
2444
            }
2445
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2446
            if(!st->codec->bits_per_coded_sample)
2447
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2448
            // set stream disposition based on audio service type
2449
            switch (st->codec->audio_service_type) {
2450
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2451
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2452
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2453
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2454
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2455
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2456
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2457
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2458
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2459
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2460
            }
2461
        }
2462
    }
2463

    
2464
    av_estimate_timings(ic, old_offset);
2465

    
2466
    compute_chapters_end(ic);
2467

    
2468
#if 0
2469
    /* correct DTS for B-frame streams with no timestamps */
2470
    for(i=0;i<ic->nb_streams;i++) {
2471
        st = ic->streams[i];
2472
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2473
            if(b-frames){
2474
                ppktl = &ic->packet_buffer;
2475
                while(ppkt1){
2476
                    if(ppkt1->stream_index != i)
2477
                        continue;
2478
                    if(ppkt1->pkt->dts < 0)
2479
                        break;
2480
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2481
                        break;
2482
                    ppkt1->pkt->dts -= delta;
2483
                    ppkt1= ppkt1->next;
2484
                }
2485
                if(ppkt1)
2486
                    continue;
2487
                st->cur_dts -= delta;
2488
            }
2489
        }
2490
    }
2491
#endif
2492

    
2493
 find_stream_info_err:
2494
    for (i=0; i < ic->nb_streams; i++)
2495
        av_freep(&ic->streams[i]->info);
2496
    return ret;
2497
}
2498

    
2499
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2500
{
2501
    int i, j;
2502

    
2503
    for (i = 0; i < ic->nb_programs; i++)
2504
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2505
            if (ic->programs[i]->stream_index[j] == s)
2506
                return ic->programs[i];
2507
    return NULL;
2508
}
2509

    
2510
int av_find_best_stream(AVFormatContext *ic,
2511
                        enum AVMediaType type,
2512
                        int wanted_stream_nb,
2513
                        int related_stream,
2514
                        AVCodec **decoder_ret,
2515
                        int flags)
2516
{
2517
    int i, nb_streams = ic->nb_streams, stream_number = 0;
2518
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2519
    unsigned *program = NULL;
2520
    AVCodec *decoder = NULL, *best_decoder = NULL;
2521

    
2522
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2523
        AVProgram *p = find_program_from_stream(ic, related_stream);
2524
        if (p) {
2525
            program = p->stream_index;
2526
            nb_streams = p->nb_stream_indexes;
2527
        }
2528
    }
2529
    for (i = 0; i < nb_streams; i++) {
2530
        AVStream *st = ic->streams[program ? program[i] : i];
2531
        AVCodecContext *avctx = st->codec;
2532
        if (avctx->codec_type != type)
2533
            continue;
2534
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2535
            continue;
2536
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2537
            continue;
2538
        if (decoder_ret) {
2539
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2540
            if (!decoder) {
2541
                if (ret < 0)
2542
                    ret = AVERROR_DECODER_NOT_FOUND;
2543
                continue;
2544
            }
2545
        }
2546
        if (best_count >= st->codec_info_nb_frames)
2547
            continue;
2548
        best_count = st->codec_info_nb_frames;
2549
        ret = program ? program[i] : i;
2550
        best_decoder = decoder;
2551
        if (program && i == nb_streams - 1 && ret < 0) {
2552
            program = NULL;
2553
            nb_streams = ic->nb_streams;
2554
            i = 0; /* no related stream found, try again with everything */
2555
        }
2556
    }
2557
    if (decoder_ret)
2558
        *decoder_ret = best_decoder;
2559
    return ret;
2560
}
2561

    
2562
/*******************************************************/
2563

    
2564
int av_read_play(AVFormatContext *s)
2565
{
2566
    if (s->iformat->read_play)
2567
        return s->iformat->read_play(s);
2568
    if (s->pb)
2569
        return ffio_read_pause(s->pb, 0);
2570
    return AVERROR(ENOSYS);
2571
}
2572

    
2573
int av_read_pause(AVFormatContext *s)
2574
{
2575
    if (s->iformat->read_pause)
2576
        return s->iformat->read_pause(s);
2577
    if (s->pb)
2578
        return ffio_read_pause(s->pb, 1);
2579
    return AVERROR(ENOSYS);
2580
}
2581

    
2582
void av_close_input_stream(AVFormatContext *s)
2583
{
2584
    flush_packet_queue(s);
2585
    if (s->iformat->read_close)
2586
        s->iformat->read_close(s);
2587
    avformat_free_context(s);
2588
}
2589

    
2590
void avformat_free_context(AVFormatContext *s)
2591
{
2592
    int i;
2593
    AVStream *st;
2594

    
2595
    for(i=0;i<s->nb_streams;i++) {
2596
        /* free all data in a stream component */
2597
        st = s->streams[i];
2598
        if (st->parser) {
2599
            av_parser_close(st->parser);
2600
            av_free_packet(&st->cur_pkt);
2601
        }
2602
        av_metadata_free(&st->metadata);
2603
        av_free(st->index_entries);
2604
        av_free(st->codec->extradata);
2605
        av_free(st->codec->subtitle_header);
2606
        av_free(st->codec);
2607
#if FF_API_OLD_METADATA
2608
        av_free(st->filename);
2609
#endif
2610
        av_free(st->priv_data);
2611
        av_free(st->info);
2612
        av_free(st);
2613
    }
2614
    for(i=s->nb_programs-1; i>=0; i--) {
2615
#if FF_API_OLD_METADATA
2616
        av_freep(&s->programs[i]->provider_name);
2617
        av_freep(&s->programs[i]->name);
2618
#endif
2619
        av_metadata_free(&s->programs[i]->metadata);
2620
        av_freep(&s->programs[i]->stream_index);
2621
        av_freep(&s->programs[i]);
2622
    }
2623
    av_freep(&s->programs);
2624
    av_freep(&s->priv_data);
2625
    while(s->nb_chapters--) {
2626
#if FF_API_OLD_METADATA
2627
        av_free(s->chapters[s->nb_chapters]->title);
2628
#endif
2629
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2630
        av_free(s->chapters[s->nb_chapters]);
2631
    }
2632
    av_freep(&s->chapters);
2633
    av_metadata_free(&s->metadata);
2634
    av_freep(&s->key);
2635
    av_free(s);
2636
}
2637

    
2638
void av_close_input_file(AVFormatContext *s)
2639
{
2640
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2641
    av_close_input_stream(s);
2642
    if (pb)
2643
        avio_close(pb);
2644
}
2645

    
2646
AVStream *av_new_stream(AVFormatContext *s, int id)
2647
{
2648
    AVStream *st;
2649
    int i;
2650

    
2651
#if FF_API_MAX_STREAMS
2652
    if (s->nb_streams >= MAX_STREAMS){
2653
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2654
        return NULL;
2655
    }
2656
#else
2657
    AVStream **streams;
2658

    
2659
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2660
        return NULL;
2661
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2662
    if (!streams)
2663
        return NULL;
2664
    s->streams = streams;
2665
#endif
2666

    
2667
    st = av_mallocz(sizeof(AVStream));
2668
    if (!st)
2669
        return NULL;
2670
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2671
        av_free(st);
2672
        return NULL;
2673
    }
2674

    
2675
    st->codec= avcodec_alloc_context();
2676
    if (s->iformat) {
2677
        /* no default bitrate if decoding */
2678
        st->codec->bit_rate = 0;
2679
    }
2680
    st->index = s->nb_streams;
2681
    st->id = id;
2682
    st->start_time = AV_NOPTS_VALUE;
2683
    st->duration = AV_NOPTS_VALUE;
2684
        /* we set the current DTS to 0 so that formats without any timestamps
2685
           but durations get some timestamps, formats with some unknown
2686
           timestamps have their first few packets buffered and the
2687
           timestamps corrected before they are returned to the user */
2688
    st->cur_dts = 0;
2689
    st->first_dts = AV_NOPTS_VALUE;
2690
    st->probe_packets = MAX_PROBE_PACKETS;
2691

    
2692
    /* default pts setting is MPEG-like */
2693
    av_set_pts_info(st, 33, 1, 90000);
2694
    st->last_IP_pts = AV_NOPTS_VALUE;
2695
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2696
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2697
    st->reference_dts = AV_NOPTS_VALUE;
2698

    
2699
    st->sample_aspect_ratio = (AVRational){0,1};
2700

    
2701
    s->streams[s->nb_streams++] = st;
2702
    return st;
2703
}
2704

    
2705
AVProgram *av_new_program(AVFormatContext *ac, int id)
2706
{
2707
    AVProgram *program=NULL;
2708
    int i;
2709

    
2710
#ifdef DEBUG_SI
2711
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2712
#endif
2713

    
2714
    for(i=0; i<ac->nb_programs; i++)
2715
        if(ac->programs[i]->id == id)
2716
            program = ac->programs[i];
2717

    
2718
    if(!program){
2719
        program = av_mallocz(sizeof(AVProgram));
2720
        if (!program)
2721
            return NULL;
2722
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2723
        program->discard = AVDISCARD_NONE;
2724
    }
2725
    program->id = id;
2726

    
2727
    return program;
2728
}
2729

    
2730
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2731
{
2732
    AVChapter *chapter = NULL;
2733
    int i;
2734

    
2735
    for(i=0; i<s->nb_chapters; i++)
2736
        if(s->chapters[i]->id == id)
2737
            chapter = s->chapters[i];
2738

    
2739
    if(!chapter){
2740
        chapter= av_mallocz(sizeof(AVChapter));
2741
        if(!chapter)
2742
            return NULL;
2743
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2744
    }
2745
#if FF_API_OLD_METADATA
2746
    av_free(chapter->title);
2747
#endif
2748
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2749
    chapter->id    = id;
2750
    chapter->time_base= time_base;
2751
    chapter->start = start;
2752
    chapter->end   = end;
2753

    
2754
    return chapter;
2755
}
2756

    
2757
/************************************************************/
2758
/* output media file */
2759

    
2760
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2761
{
2762
    int ret;
2763

    
2764
    if (s->oformat->priv_data_size > 0) {
2765
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2766
        if (!s->priv_data)
2767
            return AVERROR(ENOMEM);
2768
        if (s->oformat->priv_class) {
2769
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2770
            av_opt_set_defaults(s->priv_data);
2771
        }
2772
    } else
2773
        s->priv_data = NULL;
2774

    
2775
    if (s->oformat->set_parameters) {
2776
        ret = s->oformat->set_parameters(s, ap);
2777
        if (ret < 0)
2778
            return ret;
2779
    }
2780
    return 0;
2781
}
2782

    
2783
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2784
{
2785
    const AVCodecTag *avctag;
2786
    int n;
2787
    enum CodecID id = CODEC_ID_NONE;
2788
    unsigned int tag = 0;
2789

    
2790
    /**
2791
     * Check that tag + id is in the table
2792
     * If neither is in the table -> OK
2793
     * If tag is in the table with another id -> FAIL
2794
     * If id is in the table with another tag -> FAIL unless strict < normal
2795
     */
2796
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2797
        avctag = s->oformat->codec_tag[n];
2798
        while (avctag->id != CODEC_ID_NONE) {
2799
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2800
                id = avctag->id;
2801
                if (id == st->codec->codec_id)
2802
                    return 1;
2803
            }
2804
            if (avctag->id == st->codec->codec_id)
2805
                tag = avctag->tag;
2806
            avctag++;
2807
        }
2808
    }
2809
    if (id != CODEC_ID_NONE)
2810
        return 0;
2811
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2812
        return 0;
2813
    return 1;
2814
}
2815

    
2816
int av_write_header(AVFormatContext *s)
2817
{
2818
    int ret, i;
2819
    AVStream *st;
2820

    
2821
    // some sanity checks
2822
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2823
        av_log(s, AV_LOG_ERROR, "no streams\n");
2824
        return AVERROR(EINVAL);
2825
    }
2826

    
2827
    for(i=0;i<s->nb_streams;i++) {
2828
        st = s->streams[i];
2829

    
2830
        switch (st->codec->codec_type) {
2831
        case AVMEDIA_TYPE_AUDIO:
2832
            if(st->codec->sample_rate<=0){
2833
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2834
                return AVERROR(EINVAL);
2835
            }
2836
            if(!st->codec->block_align)
2837
                st->codec->block_align = st->codec->channels *
2838
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2839
            break;
2840
        case AVMEDIA_TYPE_VIDEO:
2841
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2842
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2843
                return AVERROR(EINVAL);
2844
            }
2845
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2846
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2847
                return AVERROR(EINVAL);
2848
            }
2849
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2850
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2851
                return AVERROR(EINVAL);
2852
            }
2853
            break;
2854
        }
2855

    
2856
        if(s->oformat->codec_tag){
2857
            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)){
2858
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2859
                st->codec->codec_tag= 0;
2860
            }
2861
            if(st->codec->codec_tag){
2862
                if (!validate_codec_tag(s, st)) {
2863
                    char tagbuf[32];
2864
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2865
                    av_log(s, AV_LOG_ERROR,
2866
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2867
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2868
                    return AVERROR_INVALIDDATA;
2869
                }
2870
            }else
2871
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2872
        }
2873

    
2874
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2875
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2876
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2877
    }
2878

    
2879
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2880
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2881
        if (!s->priv_data)
2882
            return AVERROR(ENOMEM);
2883
    }
2884

    
2885
#if FF_API_OLD_METADATA
2886
    ff_metadata_mux_compat(s);
2887
#endif
2888

    
2889
    /* set muxer identification string */
2890
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2891
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2892
    }
2893

    
2894
    if(s->oformat->write_header){
2895
        ret = s->oformat->write_header(s);
2896
        if (ret < 0)
2897
            return ret;
2898
    }
2899

    
2900
    /* init PTS generation */
2901
    for(i=0;i<s->nb_streams;i++) {
2902
        int64_t den = AV_NOPTS_VALUE;
2903
        st = s->streams[i];
2904

    
2905
        switch (st->codec->codec_type) {
2906
        case AVMEDIA_TYPE_AUDIO:
2907
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2908
            break;
2909
        case AVMEDIA_TYPE_VIDEO:
2910
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2911
            break;
2912
        default:
2913
            break;
2914
        }
2915
        if (den != AV_NOPTS_VALUE) {
2916
            if (den <= 0)
2917
                return AVERROR_INVALIDDATA;
2918
            av_frac_init(&st->pts, 0, 0, den);
2919
        }
2920
    }
2921
    return 0;
2922
}
2923

    
2924
//FIXME merge with compute_pkt_fields
2925
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2926
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2927
    int num, den, frame_size, i;
2928

    
2929
    av_dlog(s, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2930
            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2931

    
2932
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2933
        return -1;*/
2934

    
2935
    /* duration field */
2936
    if (pkt->duration == 0) {
2937
        compute_frame_duration(&num, &den, st, NULL, pkt);
2938
        if (den && num) {
2939
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2940
        }
2941
    }
2942

    
2943
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2944
        pkt->pts= pkt->dts;
2945

    
2946
    //XXX/FIXME this is a temporary hack until all encoders output pts
2947
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2948
        pkt->dts=
2949
//        pkt->pts= st->cur_dts;
2950
        pkt->pts= st->pts.val;
2951
    }
2952

    
2953
    //calculate dts from pts
2954
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2955
        st->pts_buffer[0]= pkt->pts;
2956
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2957
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2958
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2959
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2960

    
2961
        pkt->dts= st->pts_buffer[0];
2962
    }
2963

    
2964
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2965
        av_log(s, AV_LOG_ERROR,
2966
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2967
               st->index, st->cur_dts, pkt->dts);
2968
        return -1;
2969
    }
2970
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2971
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2972
        return -1;
2973
    }
2974

    
2975
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2976
    st->cur_dts= pkt->dts;
2977
    st->pts.val= pkt->dts;
2978

    
2979
    /* update pts */
2980
    switch (st->codec->codec_type) {
2981
    case AVMEDIA_TYPE_AUDIO:
2982
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2983

    
2984
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2985
           likely equal to the encoder delay, but it would be better if we
2986
           had the real timestamps from the encoder */
2987
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2988
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2989
        }
2990
        break;
2991
    case AVMEDIA_TYPE_VIDEO:
2992
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2993
        break;
2994
    default:
2995
        break;
2996
    }
2997
    return 0;
2998
}
2999

    
3000
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3001
{
3002
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3003

    
3004
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3005
        return ret;
3006

    
3007
    ret= s->oformat->write_packet(s, pkt);
3008
    return ret;
3009
}
3010

    
3011
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3012
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3013
{
3014
    AVPacketList **next_point, *this_pktl;
3015

    
3016
    this_pktl = av_mallocz(sizeof(AVPacketList));
3017
    this_pktl->pkt= *pkt;
3018
    pkt->destruct= NULL;             // do not free original but only the copy
3019
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3020

    
3021
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3022
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3023
    }else
3024
        next_point = &s->packet_buffer;
3025

    
3026
    if(*next_point){
3027
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3028
            while(!compare(s, &(*next_point)->pkt, pkt)){
3029
                next_point= &(*next_point)->next;
3030
            }
3031
            goto next_non_null;
3032
        }else{
3033
            next_point = &(s->packet_buffer_end->next);
3034
        }
3035
    }
3036
    assert(!*next_point);
3037

    
3038
    s->packet_buffer_end= this_pktl;
3039
next_non_null:
3040

    
3041
    this_pktl->next= *next_point;
3042

    
3043
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3044
    *next_point= this_pktl;
3045
}
3046

    
3047
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3048
{
3049
    AVStream *st = s->streams[ pkt ->stream_index];
3050
    AVStream *st2= s->streams[ next->stream_index];
3051
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3052
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3053
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3054
}
3055

    
3056
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3057
    AVPacketList *pktl;
3058
    int stream_count=0;
3059
    int i;
3060

    
3061
    if(pkt){
3062
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3063
    }
3064

    
3065
    for(i=0; i < s->nb_streams; i++)
3066
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3067

    
3068
    if(stream_count && (s->nb_streams == stream_count || flush)){
3069
        pktl= s->packet_buffer;
3070
        *out= pktl->pkt;
3071

    
3072
        s->packet_buffer= pktl->next;
3073
        if(!s->packet_buffer)
3074
            s->packet_buffer_end= NULL;
3075

    
3076
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3077
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3078
        av_freep(&pktl);
3079
        return 1;
3080
    }else{
3081
        av_init_packet(out);
3082
        return 0;
3083
    }
3084
}
3085

    
3086
/**
3087
 * Interleave an AVPacket correctly so it can be muxed.
3088
 * @param out the interleaved packet will be output here
3089
 * @param in the input packet
3090
 * @param flush 1 if no further packets are available as input and all
3091
 *              remaining packets should be output
3092
 * @return 1 if a packet was output, 0 if no packet could be output,
3093
 *         < 0 if an error occurred
3094
 */
3095
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3096
    if(s->oformat->interleave_packet)
3097
        return s->oformat->interleave_packet(s, out, in, flush);
3098
    else
3099
        return av_interleave_packet_per_dts(s, out, in, flush);
3100
}
3101

    
3102
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3103
    AVStream *st= s->streams[ pkt->stream_index];
3104
    int ret;
3105

    
3106
    //FIXME/XXX/HACK drop zero sized packets
3107
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3108
        return 0;
3109

    
3110
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3111
            pkt->size, pkt->dts, pkt->pts);
3112
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3113
        return ret;
3114

    
3115
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3116
        return AVERROR(EINVAL);
3117

    
3118
    for(;;){
3119
        AVPacket opkt;
3120
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3121
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3122
            return ret;
3123

    
3124
        ret= s->oformat->write_packet(s, &opkt);
3125

    
3126
        av_free_packet(&opkt);
3127
        pkt= NULL;
3128

    
3129
        if(ret<0)
3130
            return ret;
3131
    }
3132
}
3133

    
3134
int av_write_trailer(AVFormatContext *s)
3135
{
3136
    int ret, i;
3137

    
3138
    for(;;){
3139
        AVPacket pkt;
3140
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3141
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3142
            goto fail;
3143
        if(!ret)
3144
            break;
3145

    
3146
        ret= s->oformat->write_packet(s, &pkt);
3147

    
3148
        av_free_packet(&pkt);
3149

    
3150
        if(ret<0)
3151
            goto fail;
3152
    }
3153

    
3154
    if(s->oformat->write_trailer)
3155
        ret = s->oformat->write_trailer(s);
3156
fail:
3157
    for(i=0;i<s->nb_streams;i++) {
3158
        av_freep(&s->streams[i]->priv_data);
3159
        av_freep(&s->streams[i]->index_entries);
3160
    }
3161
    av_freep(&s->priv_data);
3162
    return ret;
3163
}
3164

    
3165
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3166
{
3167
    int i, j;
3168
    AVProgram *program=NULL;
3169
    void *tmp;
3170

    
3171
    if (idx >= ac->nb_streams) {
3172
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3173
        return;
3174
    }
3175

    
3176
    for(i=0; i<ac->nb_programs; i++){
3177
        if(ac->programs[i]->id != progid)
3178
            continue;
3179
        program = ac->programs[i];
3180
        for(j=0; j<program->nb_stream_indexes; j++)
3181
            if(program->stream_index[j] == idx)
3182
                return;
3183

    
3184
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3185
        if(!tmp)
3186
            return;
3187
        program->stream_index = tmp;
3188
        program->stream_index[program->nb_stream_indexes++] = idx;
3189
        return;
3190
    }
3191
}
3192

    
3193
static void print_fps(double d, const char *postfix){
3194
    uint64_t v= lrintf(d*100);
3195
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3196
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3197
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3198
}
3199

    
3200
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3201
{
3202
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3203
        AVMetadataTag *tag=NULL;
3204

    
3205
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3206
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3207
            if(strcmp("language", tag->key))
3208
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3209
        }
3210
    }
3211
}
3212

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

    
3276
#if FF_API_DUMP_FORMAT
3277
void dump_format(AVFormatContext *ic,
3278
                 int index,
3279
                 const char *url,
3280
                 int is_output)
3281
{
3282
    av_dump_format(ic, index, url, is_output);
3283
}
3284
#endif
3285

    
3286
void av_dump_format(AVFormatContext *ic,
3287
                    int index,
3288
                    const char *url,
3289
                    int is_output)
3290
{
3291
    int i;
3292
    uint8_t *printed = av_mallocz(ic->nb_streams);
3293
    if (ic->nb_streams && !printed)
3294
        return;
3295

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

    
3339
        dump_metadata(NULL, ch->metadata, "    ");
3340
    }
3341
    if(ic->nb_programs) {
3342
        int j, k, total = 0;
3343
        for(j=0; j<ic->nb_programs; j++) {
3344
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3345
                                                  "name", NULL, 0);
3346
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3347
                   name ? name->value : "");
3348
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3349
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3350
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3351
                printed[ic->programs[j]->stream_index[k]] = 1;
3352
            }
3353
            total += ic->programs[j]->nb_stream_indexes;
3354
        }
3355
        if (total < ic->nb_streams)
3356
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3357
    }
3358
    for(i=0;i<ic->nb_streams;i++)
3359
        if (!printed[i])
3360
            dump_stream_format(ic, i, index, is_output);
3361

    
3362
    av_free(printed);
3363
}
3364

    
3365
#if FF_API_PARSE_FRAME_PARAM
3366
#include "libavutil/parseutils.h"
3367

    
3368
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3369
{
3370
    return av_parse_video_size(width_ptr, height_ptr, str);
3371
}
3372

    
3373
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3374
{
3375
    AVRational frame_rate;
3376
    int ret = av_parse_video_rate(&frame_rate, arg);
3377
    *frame_rate_num= frame_rate.num;
3378
    *frame_rate_den= frame_rate.den;
3379
    return ret;
3380
}
3381
#endif
3382

    
3383
int64_t av_gettime(void)
3384
{
3385
    struct timeval tv;
3386
    gettimeofday(&tv,NULL);
3387
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3388
}
3389

    
3390
uint64_t ff_ntp_time(void)
3391
{
3392
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3393
}
3394

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

    
3398
int64_t parse_date(const char *timestr, int duration)
3399
{
3400
    int64_t timeval;
3401
    av_parse_time(&timeval, timestr, duration);
3402
    return timeval;
3403
}
3404
#endif
3405

    
3406
#if FF_API_FIND_INFO_TAG
3407
#include "libavutil/parseutils.h"
3408

    
3409
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3410
{
3411
    return av_find_info_tag(arg, arg_size, tag1, info);
3412
}
3413
#endif
3414

    
3415
int av_get_frame_filename(char *buf, int buf_size,
3416
                          const char *path, int number)
3417
{
3418
    const char *p;
3419
    char *q, buf1[20], c;
3420
    int nd, len, percentd_found;
3421

    
3422
    q = buf;
3423
    p = path;
3424
    percentd_found = 0;
3425
    for(;;) {
3426
        c = *p++;
3427
        if (c == '\0')
3428
            break;
3429
        if (c == '%') {
3430
            do {
3431
                nd = 0;
3432
                while (isdigit(*p)) {
3433
                    nd = nd * 10 + *p++ - '0';
3434
                }
3435
                c = *p++;
3436
            } while (isdigit(c));
3437

    
3438
            switch(c) {
3439
            case '%':
3440
                goto addchar;
3441
            case 'd':
3442
                if (percentd_found)
3443
                    goto fail;
3444
                percentd_found = 1;
3445
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3446
                len = strlen(buf1);
3447
                if ((q - buf + len) > buf_size - 1)
3448
                    goto fail;
3449
                memcpy(q, buf1, len);
3450
                q += len;
3451
                break;
3452
            default:
3453
                goto fail;
3454
            }
3455
        } else {
3456
        addchar:
3457
            if ((q - buf) < buf_size - 1)
3458
                *q++ = c;
3459
        }
3460
    }
3461
    if (!percentd_found)
3462
        goto fail;
3463
    *q = '\0';
3464
    return 0;
3465
 fail:
3466
    *q = '\0';
3467
    return -1;
3468
}
3469

    
3470
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3471
{
3472
    int len, i, j, c;
3473
#undef fprintf
3474
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3475

    
3476
    for(i=0;i<size;i+=16) {
3477
        len = size - i;
3478
        if (len > 16)
3479
            len = 16;
3480
        PRINT("%08x ", i);
3481
        for(j=0;j<16;j++) {
3482
            if (j < len)
3483
                PRINT(" %02x", buf[i+j]);
3484
            else
3485
                PRINT("   ");
3486
        }
3487
        PRINT(" ");
3488
        for(j=0;j<len;j++) {
3489
            c = buf[i+j];
3490
            if (c < ' ' || c > '~')
3491
                c = '.';
3492
            PRINT("%c", c);
3493
        }
3494
        PRINT("\n");
3495
    }
3496
#undef PRINT
3497
}
3498

    
3499
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3500
{
3501
    hex_dump_internal(NULL, f, 0, buf, size);
3502
}
3503

    
3504
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3505
{
3506
    hex_dump_internal(avcl, NULL, level, buf, size);
3507
}
3508

    
3509
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3510
{
3511
#undef fprintf
3512
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3513
    PRINT("stream #%d:\n", pkt->stream_index);
3514
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3515
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3516
    /* DTS is _always_ valid after av_read_frame() */
3517
    PRINT("  dts=");
3518
    if (pkt->dts == AV_NOPTS_VALUE)
3519
        PRINT("N/A");
3520
    else
3521
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3522
    /* PTS may not be known if B-frames are present. */
3523
    PRINT("  pts=");
3524
    if (pkt->pts == AV_NOPTS_VALUE)
3525
        PRINT("N/A");
3526
    else
3527
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3528
    PRINT("\n");
3529
    PRINT("  size=%d\n", pkt->size);
3530
#undef PRINT
3531
    if (dump_payload)
3532
        av_hex_dump(f, pkt->data, pkt->size);
3533
}
3534

    
3535
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3536
{
3537
    AVRational tb = { 1, AV_TIME_BASE };
3538
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3539
}
3540

    
3541
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3542
{
3543
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3544
}
3545

    
3546
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3547
{
3548
    AVRational tb = { 1, AV_TIME_BASE };
3549
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3550
}
3551

    
3552
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3553
                      AVStream *st)
3554
{
3555
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3556
}
3557

    
3558
#if FF_API_URL_SPLIT
3559
attribute_deprecated
3560
void ff_url_split(char *proto, int proto_size,
3561
                  char *authorization, int authorization_size,
3562
                  char *hostname, int hostname_size,
3563
                  int *port_ptr,
3564
                  char *path, int path_size,
3565
                  const char *url)
3566
{
3567
    av_url_split(proto, proto_size,
3568
                 authorization, authorization_size,
3569
                 hostname, hostname_size,
3570
                 port_ptr,
3571
                 path, path_size,
3572
                 url);
3573
}
3574
#endif
3575

    
3576
void av_url_split(char *proto, int proto_size,
3577
                  char *authorization, int authorization_size,
3578
                  char *hostname, int hostname_size,
3579
                  int *port_ptr,
3580
                  char *path, int path_size,
3581
                  const char *url)
3582
{
3583
    const char *p, *ls, *at, *col, *brk;
3584

    
3585
    if (port_ptr)               *port_ptr = -1;
3586
    if (proto_size > 0)         proto[0] = 0;
3587
    if (authorization_size > 0) authorization[0] = 0;
3588
    if (hostname_size > 0)      hostname[0] = 0;
3589
    if (path_size > 0)          path[0] = 0;
3590

    
3591
    /* parse protocol */
3592
    if ((p = strchr(url, ':'))) {
3593
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3594
        p++; /* skip ':' */
3595
        if (*p == '/') p++;
3596
        if (*p == '/') p++;
3597
    } else {
3598
        /* no protocol means plain filename */
3599
        av_strlcpy(path, url, path_size);
3600
        return;
3601
    }
3602

    
3603
    /* separate path from hostname */
3604
    ls = strchr(p, '/');
3605
    if(!ls)
3606
        ls = strchr(p, '?');
3607
    if(ls)
3608
        av_strlcpy(path, ls, path_size);
3609
    else
3610
        ls = &p[strlen(p)]; // XXX
3611

    
3612
    /* the rest is hostname, use that to parse auth/port */
3613
    if (ls != p) {
3614
        /* authorization (user[:pass]@hostname) */
3615
        if ((at = strchr(p, '@')) && at < ls) {
3616
            av_strlcpy(authorization, p,
3617
                       FFMIN(authorization_size, at + 1 - p));
3618
            p = at + 1; /* skip '@' */
3619
        }
3620

    
3621
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3622
            /* [host]:port */
3623
            av_strlcpy(hostname, p + 1,
3624
                       FFMIN(hostname_size, brk - p));
3625
            if (brk[1] == ':' && port_ptr)
3626
                *port_ptr = atoi(brk + 2);
3627
        } else if ((col = strchr(p, ':')) && col < ls) {
3628
            av_strlcpy(hostname, p,
3629
                       FFMIN(col + 1 - p, hostname_size));
3630
            if (port_ptr) *port_ptr = atoi(col + 1);
3631
        } else
3632
            av_strlcpy(hostname, p,
3633
                       FFMIN(ls + 1 - p, hostname_size));
3634
    }
3635
}
3636

    
3637
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3638
{
3639
    int i;
3640
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3641
                                           '4', '5', '6', '7',
3642
                                           '8', '9', 'A', 'B',
3643
                                           'C', 'D', 'E', 'F' };
3644
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3645
                                           '4', '5', '6', '7',
3646
                                           '8', '9', 'a', 'b',
3647
                                           'c', 'd', 'e', 'f' };
3648
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3649

    
3650
    for(i = 0; i < s; i++) {
3651
        buff[i * 2]     = hex_table[src[i] >> 4];
3652
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3653
    }
3654

    
3655
    return buff;
3656
}
3657

    
3658
int ff_hex_to_data(uint8_t *data, const char *p)
3659
{
3660
    int c, len, v;
3661

    
3662
    len = 0;
3663
    v = 1;
3664
    for (;;) {
3665
        p += strspn(p, SPACE_CHARS);
3666
        if (*p == '\0')
3667
            break;
3668
        c = toupper((unsigned char) *p++);
3669
        if (c >= '0' && c <= '9')
3670
            c = c - '0';
3671
        else if (c >= 'A' && c <= 'F')
3672
            c = c - 'A' + 10;
3673
        else
3674
            break;
3675
        v = (v << 4) | c;
3676
        if (v & 0x100) {
3677
            if (data)
3678
                data[len] = v;
3679
            len++;
3680
            v = 1;
3681
        }
3682
    }
3683
    return len;
3684
}
3685

    
3686
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3687
                     unsigned int pts_num, unsigned int pts_den)
3688
{
3689
    AVRational new_tb;
3690
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3691
        if(new_tb.num != pts_num)
3692
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3693
    }else
3694
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3695

    
3696
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3697
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3698
        return;
3699
    }
3700
    s->time_base = new_tb;
3701
    s->pts_wrap_bits = pts_wrap_bits;
3702
}
3703

    
3704
int ff_url_join(char *str, int size, const char *proto,
3705
                const char *authorization, const char *hostname,
3706
                int port, const char *fmt, ...)
3707
{
3708
#if CONFIG_NETWORK
3709
    struct addrinfo hints, *ai;
3710
#endif
3711

    
3712
    str[0] = '\0';
3713
    if (proto)
3714
        av_strlcatf(str, size, "%s://", proto);
3715
    if (authorization && authorization[0])
3716
        av_strlcatf(str, size, "%s@", authorization);
3717
#if CONFIG_NETWORK && defined(AF_INET6)
3718
    /* Determine if hostname is a numerical IPv6 address,
3719
     * properly escape it within [] in that case. */
3720
    memset(&hints, 0, sizeof(hints));
3721
    hints.ai_flags = AI_NUMERICHOST;
3722
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3723
        if (ai->ai_family == AF_INET6) {
3724
            av_strlcat(str, "[", size);
3725
            av_strlcat(str, hostname, size);
3726
            av_strlcat(str, "]", size);
3727
        } else {
3728
            av_strlcat(str, hostname, size);
3729
        }
3730
        freeaddrinfo(ai);
3731
    } else
3732
#endif
3733
        /* Not an IPv6 address, just output the plain string. */
3734
        av_strlcat(str, hostname, size);
3735

    
3736
    if (port >= 0)
3737
        av_strlcatf(str, size, ":%d", port);
3738
    if (fmt) {
3739
        va_list vl;
3740
        int len = strlen(str);
3741

    
3742
        va_start(vl, fmt);
3743
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3744
        va_end(vl);
3745
    }
3746
    return strlen(str);
3747
}
3748

    
3749
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3750
                     AVFormatContext *src)
3751
{
3752
    AVPacket local_pkt;
3753

    
3754
    local_pkt = *pkt;
3755
    local_pkt.stream_index = dst_stream;
3756
    if (pkt->pts != AV_NOPTS_VALUE)
3757
        local_pkt.pts = av_rescale_q(pkt->pts,
3758
                                     src->streams[pkt->stream_index]->time_base,
3759
                                     dst->streams[dst_stream]->time_base);
3760
    if (pkt->dts != AV_NOPTS_VALUE)
3761
        local_pkt.dts = av_rescale_q(pkt->dts,
3762
                                     src->streams[pkt->stream_index]->time_base,
3763
                                     dst->streams[dst_stream]->time_base);
3764
    return av_write_frame(dst, &local_pkt);
3765
}
3766

    
3767
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3768
                        void *context)
3769
{
3770
    const char *ptr = str;
3771

    
3772
    /* Parse key=value pairs. */
3773
    for (;;) {
3774
        const char *key;
3775
        char *dest = NULL, *dest_end;
3776
        int key_len, dest_len = 0;
3777

    
3778
        /* Skip whitespace and potential commas. */
3779
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3780
            ptr++;
3781
        if (!*ptr)
3782
            break;
3783

    
3784
        key = ptr;
3785

    
3786
        if (!(ptr = strchr(key, '=')))
3787
            break;
3788
        ptr++;
3789
        key_len = ptr - key;
3790

    
3791
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3792
        dest_end = dest + dest_len - 1;
3793

    
3794
        if (*ptr == '\"') {
3795
            ptr++;
3796
            while (*ptr && *ptr != '\"') {
3797
                if (*ptr == '\\') {
3798
                    if (!ptr[1])
3799
                        break;
3800
                    if (dest && dest < dest_end)
3801
                        *dest++ = ptr[1];
3802
                    ptr += 2;
3803
                } else {
3804
                    if (dest && dest < dest_end)
3805
                        *dest++ = *ptr;
3806
                    ptr++;
3807
                }
3808
            }
3809
            if (*ptr == '\"')
3810
                ptr++;
3811
        } else {
3812
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3813
                if (dest && dest < dest_end)
3814
                    *dest++ = *ptr;
3815
        }
3816
        if (dest)
3817
            *dest = 0;
3818
    }
3819
}
3820

    
3821
int ff_find_stream_index(AVFormatContext *s, int id)
3822
{
3823
    int i;
3824
    for (i = 0; i < s->nb_streams; i++) {
3825
        if (s->streams[i]->id == id)
3826
            return i;
3827
    }
3828
    return -1;
3829
}
3830

    
3831
void ff_make_absolute_url(char *buf, int size, const char *base,
3832
                          const char *rel)
3833
{
3834
    char *sep;
3835
    /* Absolute path, relative to the current server */
3836
    if (base && strstr(base, "://") && rel[0] == '/') {
3837
        if (base != buf)
3838
            av_strlcpy(buf, base, size);
3839
        sep = strstr(buf, "://");
3840
        if (sep) {
3841
            sep += 3;
3842
            sep = strchr(sep, '/');
3843
            if (sep)
3844
                *sep = '\0';
3845
        }
3846
        av_strlcat(buf, rel, size);
3847
        return;
3848
    }
3849
    /* If rel actually is an absolute url, just copy it */
3850
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3851
        av_strlcpy(buf, rel, size);
3852
        return;
3853
    }
3854
    if (base != buf)
3855
        av_strlcpy(buf, base, size);
3856
    /* Remove the file name from the base url */
3857
    sep = strrchr(buf, '/');
3858
    if (sep)
3859
        sep[1] = '\0';
3860
    else
3861
        buf[0] = '\0';
3862
    while (av_strstart(rel, "../", NULL) && sep) {
3863
        /* Remove the path delimiter at the end */
3864
        sep[0] = '\0';
3865
        sep = strrchr(buf, '/');
3866
        /* If the next directory name to pop off is "..", break here */
3867
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3868
            /* Readd the slash we just removed */
3869
            av_strlcat(buf, "/", size);
3870
            break;
3871
        }
3872
        /* Cut off the directory name */
3873
        if (sep)
3874
            sep[1] = '\0';
3875
        else
3876
            buf[0] = '\0';
3877
        rel += 3;
3878
    }
3879
    av_strlcat(buf, rel, size);
3880
}