Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 96573c0d

History | View | Annotate | Download (124 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 "url.h"
35
#include <sys/time.h>
36
#include <time.h>
37
#include <strings.h>
38
#include <stdarg.h>
39
#if CONFIG_NETWORK
40
#include "network.h"
41
#endif
42

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

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

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

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

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

    
67
/* fraction handling */
68

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

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

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

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

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

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

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

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

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

    
163
    if(!filename)
164
        return 0;
165

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

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

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

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

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

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

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

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

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

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

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

    
263
    return fmt;
264
}
265
#endif
266

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

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

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

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

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

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

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

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

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

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

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

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

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

    
346
    return ret;
347
}
348

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

    
364

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

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

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

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

    
405
    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
406
    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4) {
407
        while ((fmt = av_iformat_next(fmt)))
408
            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
409
                *score_max = AVPROBE_SCORE_MAX/4;
410
                break;
411
            }
412
    }
413

    
414
    return fmt;
415
}
416

    
417
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
418
    int score=0;
419
    return av_probe_input_format2(pd, is_opened, &score);
420
}
421

    
422
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
423
{
424
    static const struct {
425
        const char *name; enum CodecID id; enum AVMediaType type;
426
    } fmt_id_type[] = {
427
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
428
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
429
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
430
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
431
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
432
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
433
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
434
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
435
        { 0 }
436
    };
437
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
438

    
439
    if (fmt) {
440
        int i;
441
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
442
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
443
        for (i = 0; fmt_id_type[i].name; i++) {
444
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
445
                st->codec->codec_id   = fmt_id_type[i].id;
446
                st->codec->codec_type = fmt_id_type[i].type;
447
                break;
448
            }
449
        }
450
    }
451
    return !!fmt;
452
}
453

    
454
/************************************************************/
455
/* input media file */
456

    
457
/**
458
 * Open a media file from an IO stream. 'fmt' must be specified.
459
 */
460
int av_open_input_stream(AVFormatContext **ic_ptr,
461
                         AVIOContext *pb, const char *filename,
462
                         AVInputFormat *fmt, AVFormatParameters *ap)
463
{
464
    int err;
465
    AVFormatContext *ic;
466
    AVFormatParameters default_ap;
467

    
468
    if(!ap){
469
        ap=&default_ap;
470
        memset(ap, 0, sizeof(default_ap));
471
    }
472

    
473
    if(!ap->prealloced_context)
474
        ic = avformat_alloc_context();
475
    else
476
        ic = *ic_ptr;
477
    if (!ic) {
478
        err = AVERROR(ENOMEM);
479
        goto fail;
480
    }
481
    ic->iformat = fmt;
482
    ic->pb = pb;
483
    ic->duration = AV_NOPTS_VALUE;
484
    ic->start_time = AV_NOPTS_VALUE;
485
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
486

    
487
    /* allocate private data */
488
    if (fmt->priv_data_size > 0) {
489
        ic->priv_data = av_mallocz(fmt->priv_data_size);
490
        if (!ic->priv_data) {
491
            err = AVERROR(ENOMEM);
492
            goto fail;
493
        }
494
    } else {
495
        ic->priv_data = NULL;
496
    }
497

    
498
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
499
    if (ic->pb)
500
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
501

    
502
    if (ic->iformat->read_header) {
503
        err = ic->iformat->read_header(ic, ap);
504
        if (err < 0)
505
            goto fail;
506
    }
507

    
508
    if (pb && !ic->data_offset)
509
        ic->data_offset = avio_tell(ic->pb);
510

    
511
#if FF_API_OLD_METADATA
512
    ff_metadata_demux_compat(ic);
513
#endif
514

    
515
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
516

    
517
    *ic_ptr = ic;
518
    return 0;
519
 fail:
520
    if (ic) {
521
        int i;
522
        av_freep(&ic->priv_data);
523
        for(i=0;i<ic->nb_streams;i++) {
524
            AVStream *st = ic->streams[i];
525
            if (st) {
526
                av_free(st->priv_data);
527
                av_free(st->codec->extradata);
528
                av_free(st->codec);
529
                av_free(st->info);
530
            }
531
            av_free(st);
532
        }
533
    }
534
    av_free(ic);
535
    *ic_ptr = NULL;
536
    return err;
537
}
538

    
539
/** size of probe buffer, for guessing file type from file contents */
540
#define PROBE_BUF_MIN 2048
541
#define PROBE_BUF_MAX (1<<20)
542

    
543
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
544
                          const char *filename, void *logctx,
545
                          unsigned int offset, unsigned int max_probe_size)
546
{
547
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
548
    unsigned char *buf = NULL;
549
    int ret = 0, probe_size;
550

    
551
    if (!max_probe_size) {
552
        max_probe_size = PROBE_BUF_MAX;
553
    } else if (max_probe_size > PROBE_BUF_MAX) {
554
        max_probe_size = PROBE_BUF_MAX;
555
    } else if (max_probe_size < PROBE_BUF_MIN) {
556
        return AVERROR(EINVAL);
557
    }
558

    
559
    if (offset >= max_probe_size) {
560
        return AVERROR(EINVAL);
561
    }
562

    
563
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
564
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
565
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
566
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
567

    
568
        if (probe_size < offset) {
569
            continue;
570
        }
571

    
572
        /* read probe data */
573
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
574
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
575
            /* fail if error was not end of file, otherwise, lower score */
576
            if (ret != AVERROR_EOF) {
577
                av_free(buf);
578
                return ret;
579
            }
580
            score = 0;
581
            ret = 0;            /* error was end of file, nothing read */
582
        }
583
        pd.buf_size += ret;
584
        pd.buf = &buf[offset];
585

    
586
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
587

    
588
        /* guess file format */
589
        *fmt = av_probe_input_format2(&pd, 1, &score);
590
        if(*fmt){
591
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
592
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
593
            }else
594
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
595
        }
596
    }
597

    
598
    if (!*fmt) {
599
        av_free(buf);
600
        return AVERROR_INVALIDDATA;
601
    }
602

    
603
    /* rewind. reuse probe buffer to avoid seeking */
604
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
605
        av_free(buf);
606

    
607
    return ret;
608
}
609

    
610
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
611
                       AVInputFormat *fmt,
612
                       int buf_size,
613
                       AVFormatParameters *ap)
614
{
615
    int err;
616
    AVProbeData probe_data, *pd = &probe_data;
617
    AVIOContext *pb = NULL;
618
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
619

    
620
    pd->filename = "";
621
    if (filename)
622
        pd->filename = filename;
623
    pd->buf = NULL;
624
    pd->buf_size = 0;
625

    
626
    if (!fmt) {
627
        /* guess format if no file can be opened */
628
        fmt = av_probe_input_format(pd, 0);
629
    }
630

    
631
    /* Do not open file if the format does not need it. XXX: specific
632
       hack needed to handle RTSP/TCP */
633
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
634
        /* if no file needed do not try to open one */
635
        if ((err=avio_open(&pb, filename, AVIO_RDONLY)) < 0) {
636
            goto fail;
637
        }
638
        if (buf_size > 0) {
639
            ffio_set_buf_size(pb, buf_size);
640
        }
641
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
642
            goto fail;
643
        }
644
    }
645

    
646
    /* if still no format found, error */
647
    if (!fmt) {
648
        err = AVERROR_INVALIDDATA;
649
        goto fail;
650
    }
651

    
652
    /* check filename in case an image number is expected */
653
    if (fmt->flags & AVFMT_NEEDNUMBER) {
654
        if (!av_filename_number_test(filename)) {
655
            err = AVERROR_NUMEXPECTED;
656
            goto fail;
657
        }
658
    }
659
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
660
    if (err)
661
        goto fail;
662
    return 0;
663
 fail:
664
    av_freep(&pd->buf);
665
    if (pb)
666
        avio_close(pb);
667
    if (ap && ap->prealloced_context)
668
        av_free(*ic_ptr);
669
    *ic_ptr = NULL;
670
    return err;
671

    
672
}
673

    
674
/*******************************************************/
675

    
676
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
677
                               AVPacketList **plast_pktl){
678
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
679
    if (!pktl)
680
        return NULL;
681

    
682
    if (*packet_buffer)
683
        (*plast_pktl)->next = pktl;
684
    else
685
        *packet_buffer = pktl;
686

    
687
    /* add the packet in the buffered packet list */
688
    *plast_pktl = pktl;
689
    pktl->pkt= *pkt;
690
    return &pktl->pkt;
691
}
692

    
693
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
694
{
695
    int ret, i;
696
    AVStream *st;
697

    
698
    for(;;){
699
        AVPacketList *pktl = s->raw_packet_buffer;
700

    
701
        if (pktl) {
702
            *pkt = pktl->pkt;
703
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
704
               !s->streams[pkt->stream_index]->probe_packets ||
705
               s->raw_packet_buffer_remaining_size < pkt->size){
706
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
707
                av_freep(&pd->buf);
708
                pd->buf_size = 0;
709
                s->raw_packet_buffer = pktl->next;
710
                s->raw_packet_buffer_remaining_size += pkt->size;
711
                av_free(pktl);
712
                return 0;
713
            }
714
        }
715

    
716
        av_init_packet(pkt);
717
        ret= s->iformat->read_packet(s, pkt);
718
        if (ret < 0) {
719
            if (!pktl || ret == AVERROR(EAGAIN))
720
                return ret;
721
            for (i = 0; i < s->nb_streams; i++)
722
                s->streams[i]->probe_packets = 0;
723
            continue;
724
        }
725
        st= s->streams[pkt->stream_index];
726

    
727
        switch(st->codec->codec_type){
728
        case AVMEDIA_TYPE_VIDEO:
729
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
730
            break;
731
        case AVMEDIA_TYPE_AUDIO:
732
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
733
            break;
734
        case AVMEDIA_TYPE_SUBTITLE:
735
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
736
            break;
737
        }
738

    
739
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
740
                     !st->probe_packets))
741
            return ret;
742

    
743
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
744
        s->raw_packet_buffer_remaining_size -= pkt->size;
745

    
746
        if(st->codec->codec_id == CODEC_ID_PROBE){
747
            AVProbeData *pd = &st->probe_data;
748
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
749
            --st->probe_packets;
750

    
751
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
752
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
753
            pd->buf_size += pkt->size;
754
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
755

    
756
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
757
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
758
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
759
                if(st->codec->codec_id != CODEC_ID_PROBE){
760
                    pd->buf_size=0;
761
                    av_freep(&pd->buf);
762
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
763
                }
764
            }
765
        }
766
    }
767
}
768

    
769
/**********************************************************/
770

    
771
/**
772
 * Get the number of samples of an audio frame. Return -1 on error.
773
 */
774
static int get_audio_frame_size(AVCodecContext *enc, int size)
775
{
776
    int frame_size;
777

    
778
    if(enc->codec_id == CODEC_ID_VORBIS)
779
        return -1;
780

    
781
    if (enc->frame_size <= 1) {
782
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
783

    
784
        if (bits_per_sample) {
785
            if (enc->channels == 0)
786
                return -1;
787
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
788
        } else {
789
            /* used for example by ADPCM codecs */
790
            if (enc->bit_rate == 0)
791
                return -1;
792
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
793
        }
794
    } else {
795
        frame_size = enc->frame_size;
796
    }
797
    return frame_size;
798
}
799

    
800

    
801
/**
802
 * Return the frame duration in seconds. Return 0 if not available.
803
 */
804
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
805
                                   AVCodecParserContext *pc, AVPacket *pkt)
806
{
807
    int frame_size;
808

    
809
    *pnum = 0;
810
    *pden = 0;
811
    switch(st->codec->codec_type) {
812
    case AVMEDIA_TYPE_VIDEO:
813
        if(st->time_base.num*1000LL > st->time_base.den){
814
            *pnum = st->time_base.num;
815
            *pden = st->time_base.den;
816
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
817
            *pnum = st->codec->time_base.num;
818
            *pden = st->codec->time_base.den;
819
            if (pc && pc->repeat_pict) {
820
                *pnum = (*pnum) * (1 + pc->repeat_pict);
821
            }
822
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
823
            //Thus if we have no parser in such case leave duration undefined.
824
            if(st->codec->ticks_per_frame>1 && !pc){
825
                *pnum = *pden = 0;
826
            }
827
        }
828
        break;
829
    case AVMEDIA_TYPE_AUDIO:
830
        frame_size = get_audio_frame_size(st->codec, pkt->size);
831
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
832
            break;
833
        *pnum = frame_size;
834
        *pden = st->codec->sample_rate;
835
        break;
836
    default:
837
        break;
838
    }
839
}
840

    
841
static int is_intra_only(AVCodecContext *enc){
842
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
843
        return 1;
844
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
845
        switch(enc->codec_id){
846
        case CODEC_ID_MJPEG:
847
        case CODEC_ID_MJPEGB:
848
        case CODEC_ID_LJPEG:
849
        case CODEC_ID_RAWVIDEO:
850
        case CODEC_ID_DVVIDEO:
851
        case CODEC_ID_HUFFYUV:
852
        case CODEC_ID_FFVHUFF:
853
        case CODEC_ID_ASV1:
854
        case CODEC_ID_ASV2:
855
        case CODEC_ID_VCR1:
856
        case CODEC_ID_DNXHD:
857
        case CODEC_ID_JPEG2000:
858
            return 1;
859
        default: break;
860
        }
861
    }
862
    return 0;
863
}
864

    
865
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
866
                                      int64_t dts, int64_t pts)
867
{
868
    AVStream *st= s->streams[stream_index];
869
    AVPacketList *pktl= s->packet_buffer;
870

    
871
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
872
        return;
873

    
874
    st->first_dts= dts - st->cur_dts;
875
    st->cur_dts= dts;
876

    
877
    for(; pktl; pktl= pktl->next){
878
        if(pktl->pkt.stream_index != stream_index)
879
            continue;
880
        //FIXME think more about this check
881
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
882
            pktl->pkt.pts += st->first_dts;
883

    
884
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
885
            pktl->pkt.dts += st->first_dts;
886

    
887
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
888
            st->start_time= pktl->pkt.pts;
889
    }
890
    if (st->start_time == AV_NOPTS_VALUE)
891
        st->start_time = pts;
892
}
893

    
894
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
895
{
896
    AVPacketList *pktl= s->packet_buffer;
897
    int64_t cur_dts= 0;
898

    
899
    if(st->first_dts != AV_NOPTS_VALUE){
900
        cur_dts= st->first_dts;
901
        for(; pktl; pktl= pktl->next){
902
            if(pktl->pkt.stream_index == pkt->stream_index){
903
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
904
                    break;
905
                cur_dts -= pkt->duration;
906
            }
907
        }
908
        pktl= s->packet_buffer;
909
        st->first_dts = cur_dts;
910
    }else if(st->cur_dts)
911
        return;
912

    
913
    for(; pktl; pktl= pktl->next){
914
        if(pktl->pkt.stream_index != pkt->stream_index)
915
            continue;
916
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
917
           && !pktl->pkt.duration){
918
            pktl->pkt.dts= cur_dts;
919
            if(!st->codec->has_b_frames)
920
                pktl->pkt.pts= cur_dts;
921
            cur_dts += pkt->duration;
922
            pktl->pkt.duration= pkt->duration;
923
        }else
924
            break;
925
    }
926
    if(st->first_dts == AV_NOPTS_VALUE)
927
        st->cur_dts= cur_dts;
928
}
929

    
930
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
931
                               AVCodecParserContext *pc, AVPacket *pkt)
932
{
933
    int num, den, presentation_delayed, delay, i;
934
    int64_t offset;
935

    
936
    if (s->flags & AVFMT_FLAG_NOFILLIN)
937
        return;
938

    
939
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
940
        pkt->dts= AV_NOPTS_VALUE;
941

    
942
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
943
        //FIXME Set low_delay = 0 when has_b_frames = 1
944
        st->codec->has_b_frames = 1;
945

    
946
    /* do we have a video B-frame ? */
947
    delay= st->codec->has_b_frames;
948
    presentation_delayed = 0;
949

    
950
    // ignore delay caused by frame threading so that the mpeg2-without-dts
951
    // warning will not trigger
952
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
953
        delay -= st->codec->thread_count-1;
954

    
955
    /* XXX: need has_b_frame, but cannot get it if the codec is
956
        not initialized */
957
    if (delay &&
958
        pc && pc->pict_type != FF_B_TYPE)
959
        presentation_delayed = 1;
960

    
961
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
962
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
963
        pkt->dts -= 1LL<<st->pts_wrap_bits;
964
    }
965

    
966
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
967
    // we take the conservative approach and discard both
968
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
969
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
970
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
971
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
972
    }
973

    
974
    if (pkt->duration == 0) {
975
        compute_frame_duration(&num, &den, st, pc, pkt);
976
        if (den && num) {
977
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
978

    
979
            if(pkt->duration != 0 && s->packet_buffer)
980
                update_initial_durations(s, st, pkt);
981
        }
982
    }
983

    
984
    /* correct timestamps with byte offset if demuxers only have timestamps
985
       on packet boundaries */
986
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
987
        /* this will estimate bitrate based on this frame's duration and size */
988
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
989
        if(pkt->pts != AV_NOPTS_VALUE)
990
            pkt->pts += offset;
991
        if(pkt->dts != AV_NOPTS_VALUE)
992
            pkt->dts += offset;
993
    }
994

    
995
    if (pc && pc->dts_sync_point >= 0) {
996
        // we have synchronization info from the parser
997
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
998
        if (den > 0) {
999
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1000
            if (pkt->dts != AV_NOPTS_VALUE) {
1001
                // got DTS from the stream, update reference timestamp
1002
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1003
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1004
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
1005
                // compute DTS based on reference timestamp
1006
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1007
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1008
            }
1009
            if (pc->dts_sync_point > 0)
1010
                st->reference_dts = pkt->dts; // new reference
1011
        }
1012
    }
1013

    
1014
    /* This may be redundant, but it should not hurt. */
1015
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1016
        presentation_delayed = 1;
1017

    
1018
//    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);
1019
    /* interpolate PTS and DTS if they are not present */
1020
    //We skip H264 currently because delay and has_b_frames are not reliably set
1021
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1022
        if (presentation_delayed) {
1023
            /* DTS = decompression timestamp */
1024
            /* PTS = presentation timestamp */
1025
            if (pkt->dts == AV_NOPTS_VALUE)
1026
                pkt->dts = st->last_IP_pts;
1027
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1028
            if (pkt->dts == AV_NOPTS_VALUE)
1029
                pkt->dts = st->cur_dts;
1030

    
1031
            /* this is tricky: the dts must be incremented by the duration
1032
            of the frame we are displaying, i.e. the last I- or P-frame */
1033
            if (st->last_IP_duration == 0)
1034
                st->last_IP_duration = pkt->duration;
1035
            if(pkt->dts != AV_NOPTS_VALUE)
1036
                st->cur_dts = pkt->dts + st->last_IP_duration;
1037
            st->last_IP_duration  = pkt->duration;
1038
            st->last_IP_pts= pkt->pts;
1039
            /* cannot compute PTS if not present (we can compute it only
1040
            by knowing the future */
1041
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1042
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1043
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1044
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1045
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1046
                    pkt->pts += pkt->duration;
1047
    //                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);
1048
                }
1049
            }
1050

    
1051
            /* presentation is not delayed : PTS and DTS are the same */
1052
            if(pkt->pts == AV_NOPTS_VALUE)
1053
                pkt->pts = pkt->dts;
1054
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1055
            if(pkt->pts == AV_NOPTS_VALUE)
1056
                pkt->pts = st->cur_dts;
1057
            pkt->dts = pkt->pts;
1058
            if(pkt->pts != AV_NOPTS_VALUE)
1059
                st->cur_dts = pkt->pts + pkt->duration;
1060
        }
1061
    }
1062

    
1063
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1064
        st->pts_buffer[0]= pkt->pts;
1065
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1066
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1067
        if(pkt->dts == AV_NOPTS_VALUE)
1068
            pkt->dts= st->pts_buffer[0];
1069
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1070
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1071
        }
1072
        if(pkt->dts > st->cur_dts)
1073
            st->cur_dts = pkt->dts;
1074
    }
1075

    
1076
//    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);
1077

    
1078
    /* update flags */
1079
    if(is_intra_only(st->codec))
1080
        pkt->flags |= AV_PKT_FLAG_KEY;
1081
    else if (pc) {
1082
        pkt->flags = 0;
1083
        /* keyframe computation */
1084
        if (pc->key_frame == 1)
1085
            pkt->flags |= AV_PKT_FLAG_KEY;
1086
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1087
            pkt->flags |= AV_PKT_FLAG_KEY;
1088
    }
1089
    if (pc)
1090
        pkt->convergence_duration = pc->convergence_duration;
1091
}
1092

    
1093

    
1094
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1095
{
1096
    AVStream *st;
1097
    int len, ret, i;
1098

    
1099
    av_init_packet(pkt);
1100

    
1101
    for(;;) {
1102
        /* select current input stream component */
1103
        st = s->cur_st;
1104
        if (st) {
1105
            if (!st->need_parsing || !st->parser) {
1106
                /* no parsing needed: we just output the packet as is */
1107
                /* raw data support */
1108
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1109
                compute_pkt_fields(s, st, NULL, pkt);
1110
                s->cur_st = NULL;
1111
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1112
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1113
                    ff_reduce_index(s, st->index);
1114
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1115
                }
1116
                break;
1117
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1118
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1119
                                       st->cur_ptr, st->cur_len,
1120
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1121
                                       st->cur_pkt.pos);
1122
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1123
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1124
                /* increment read pointer */
1125
                st->cur_ptr += len;
1126
                st->cur_len -= len;
1127

    
1128
                /* return packet if any */
1129
                if (pkt->size) {
1130
                got_packet:
1131
                    pkt->duration = 0;
1132
                    pkt->stream_index = st->index;
1133
                    pkt->pts = st->parser->pts;
1134
                    pkt->dts = st->parser->dts;
1135
                    pkt->pos = st->parser->pos;
1136
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1137
                        s->cur_st = NULL;
1138
                        pkt->destruct= st->cur_pkt.destruct;
1139
                        st->cur_pkt.destruct= NULL;
1140
                        st->cur_pkt.data    = NULL;
1141
                        assert(st->cur_len == 0);
1142
                    }else{
1143
                    pkt->destruct = NULL;
1144
                    }
1145
                    compute_pkt_fields(s, st, st->parser, pkt);
1146

    
1147
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1148
                        ff_reduce_index(s, st->index);
1149
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1150
                                           0, 0, AVINDEX_KEYFRAME);
1151
                    }
1152

    
1153
                    break;
1154
                }
1155
            } else {
1156
                /* free packet */
1157
                av_free_packet(&st->cur_pkt);
1158
                s->cur_st = NULL;
1159
            }
1160
        } else {
1161
            AVPacket cur_pkt;
1162
            /* read next packet */
1163
            ret = av_read_packet(s, &cur_pkt);
1164
            if (ret < 0) {
1165
                if (ret == AVERROR(EAGAIN))
1166
                    return ret;
1167
                /* return the last frames, if any */
1168
                for(i = 0; i < s->nb_streams; i++) {
1169
                    st = s->streams[i];
1170
                    if (st->parser && st->need_parsing) {
1171
                        av_parser_parse2(st->parser, st->codec,
1172
                                        &pkt->data, &pkt->size,
1173
                                        NULL, 0,
1174
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1175
                                        AV_NOPTS_VALUE);
1176
                        if (pkt->size)
1177
                            goto got_packet;
1178
                    }
1179
                }
1180
                /* no more packets: really terminate parsing */
1181
                return ret;
1182
            }
1183
            st = s->streams[cur_pkt.stream_index];
1184
            st->cur_pkt= cur_pkt;
1185

    
1186
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1187
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1188
               st->cur_pkt.pts < st->cur_pkt.dts){
1189
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1190
                    st->cur_pkt.stream_index,
1191
                    st->cur_pkt.pts,
1192
                    st->cur_pkt.dts,
1193
                    st->cur_pkt.size);
1194
//                av_free_packet(&st->cur_pkt);
1195
//                return -1;
1196
            }
1197

    
1198
            if(s->debug & FF_FDEBUG_TS)
1199
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1200
                    st->cur_pkt.stream_index,
1201
                    st->cur_pkt.pts,
1202
                    st->cur_pkt.dts,
1203
                    st->cur_pkt.size,
1204
                    st->cur_pkt.duration,
1205
                    st->cur_pkt.flags);
1206

    
1207
            s->cur_st = st;
1208
            st->cur_ptr = st->cur_pkt.data;
1209
            st->cur_len = st->cur_pkt.size;
1210
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1211
                st->parser = av_parser_init(st->codec->codec_id);
1212
                if (!st->parser) {
1213
                    /* no parser available: just output the raw packets */
1214
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1215
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1216
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1217
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1218
                    st->parser->flags |= PARSER_FLAG_ONCE;
1219
                }
1220
            }
1221
        }
1222
    }
1223
    if(s->debug & FF_FDEBUG_TS)
1224
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1225
            pkt->stream_index,
1226
            pkt->pts,
1227
            pkt->dts,
1228
            pkt->size,
1229
            pkt->duration,
1230
            pkt->flags);
1231

    
1232
    return 0;
1233
}
1234

    
1235
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1236
{
1237
    AVPacketList *pktl;
1238
    int eof=0;
1239
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1240

    
1241
    for(;;){
1242
        pktl = s->packet_buffer;
1243
        if (pktl) {
1244
            AVPacket *next_pkt= &pktl->pkt;
1245

    
1246
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1247
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1248
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1249
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1250
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1251
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1252
                        next_pkt->pts= pktl->pkt.dts;
1253
                    }
1254
                    pktl= pktl->next;
1255
                }
1256
                pktl = s->packet_buffer;
1257
            }
1258

    
1259
            if(   next_pkt->pts != AV_NOPTS_VALUE
1260
               || next_pkt->dts == AV_NOPTS_VALUE
1261
               || !genpts || eof){
1262
                /* read packet from packet buffer, if there is data */
1263
                *pkt = *next_pkt;
1264
                s->packet_buffer = pktl->next;
1265
                av_free(pktl);
1266
                return 0;
1267
            }
1268
        }
1269
        if(genpts){
1270
            int ret= av_read_frame_internal(s, pkt);
1271
            if(ret<0){
1272
                if(pktl && ret != AVERROR(EAGAIN)){
1273
                    eof=1;
1274
                    continue;
1275
                }else
1276
                    return ret;
1277
            }
1278

    
1279
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1280
                                           &s->packet_buffer_end)) < 0)
1281
                return AVERROR(ENOMEM);
1282
        }else{
1283
            assert(!s->packet_buffer);
1284
            return av_read_frame_internal(s, pkt);
1285
        }
1286
    }
1287
}
1288

    
1289
/* XXX: suppress the packet queue */
1290
static void flush_packet_queue(AVFormatContext *s)
1291
{
1292
    AVPacketList *pktl;
1293

    
1294
    for(;;) {
1295
        pktl = s->packet_buffer;
1296
        if (!pktl)
1297
            break;
1298
        s->packet_buffer = pktl->next;
1299
        av_free_packet(&pktl->pkt);
1300
        av_free(pktl);
1301
    }
1302
    while(s->raw_packet_buffer){
1303
        pktl = s->raw_packet_buffer;
1304
        s->raw_packet_buffer = pktl->next;
1305
        av_free_packet(&pktl->pkt);
1306
        av_free(pktl);
1307
    }
1308
    s->packet_buffer_end=
1309
    s->raw_packet_buffer_end= NULL;
1310
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1311
}
1312

    
1313
/*******************************************************/
1314
/* seek support */
1315

    
1316
int av_find_default_stream_index(AVFormatContext *s)
1317
{
1318
    int first_audio_index = -1;
1319
    int i;
1320
    AVStream *st;
1321

    
1322
    if (s->nb_streams <= 0)
1323
        return -1;
1324
    for(i = 0; i < s->nb_streams; i++) {
1325
        st = s->streams[i];
1326
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1327
            return i;
1328
        }
1329
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1330
            first_audio_index = i;
1331
    }
1332
    return first_audio_index >= 0 ? first_audio_index : 0;
1333
}
1334

    
1335
/**
1336
 * Flush the frame reader.
1337
 */
1338
void ff_read_frame_flush(AVFormatContext *s)
1339
{
1340
    AVStream *st;
1341
    int i, j;
1342

    
1343
    flush_packet_queue(s);
1344

    
1345
    s->cur_st = NULL;
1346

    
1347
    /* for each stream, reset read state */
1348
    for(i = 0; i < s->nb_streams; i++) {
1349
        st = s->streams[i];
1350

    
1351
        if (st->parser) {
1352
            av_parser_close(st->parser);
1353
            st->parser = NULL;
1354
            av_free_packet(&st->cur_pkt);
1355
        }
1356
        st->last_IP_pts = AV_NOPTS_VALUE;
1357
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1358
        st->reference_dts = AV_NOPTS_VALUE;
1359
        /* fail safe */
1360
        st->cur_ptr = NULL;
1361
        st->cur_len = 0;
1362

    
1363
        st->probe_packets = MAX_PROBE_PACKETS;
1364

    
1365
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1366
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1367
    }
1368
}
1369

    
1370
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1371
    int i;
1372

    
1373
    for(i = 0; i < s->nb_streams; i++) {
1374
        AVStream *st = s->streams[i];
1375

    
1376
        st->cur_dts = av_rescale(timestamp,
1377
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1378
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1379
    }
1380
}
1381

    
1382
void ff_reduce_index(AVFormatContext *s, int stream_index)
1383
{
1384
    AVStream *st= s->streams[stream_index];
1385
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1386

    
1387
    if((unsigned)st->nb_index_entries >= max_entries){
1388
        int i;
1389
        for(i=0; 2*i<st->nb_index_entries; i++)
1390
            st->index_entries[i]= st->index_entries[2*i];
1391
        st->nb_index_entries= i;
1392
    }
1393
}
1394

    
1395
int ff_add_index_entry(AVIndexEntry **index_entries,
1396
                       int *nb_index_entries,
1397
                       unsigned int *index_entries_allocated_size,
1398
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1399
{
1400
    AVIndexEntry *entries, *ie;
1401
    int index;
1402

    
1403
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1404
        return -1;
1405

    
1406
    entries = av_fast_realloc(*index_entries,
1407
                              index_entries_allocated_size,
1408
                              (*nb_index_entries + 1) *
1409
                              sizeof(AVIndexEntry));
1410
    if(!entries)
1411
        return -1;
1412

    
1413
    *index_entries= entries;
1414

    
1415
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1416

    
1417
    if(index<0){
1418
        index= (*nb_index_entries)++;
1419
        ie= &entries[index];
1420
        assert(index==0 || ie[-1].timestamp < timestamp);
1421
    }else{
1422
        ie= &entries[index];
1423
        if(ie->timestamp != timestamp){
1424
            if(ie->timestamp <= timestamp)
1425
                return -1;
1426
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1427
            (*nb_index_entries)++;
1428
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1429
            distance= ie->min_distance;
1430
    }
1431

    
1432
    ie->pos = pos;
1433
    ie->timestamp = timestamp;
1434
    ie->min_distance= distance;
1435
    ie->size= size;
1436
    ie->flags = flags;
1437

    
1438
    return index;
1439
}
1440

    
1441
int av_add_index_entry(AVStream *st,
1442
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1443
{
1444
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1445
                              &st->index_entries_allocated_size, pos,
1446
                              timestamp, size, distance, flags);
1447
}
1448

    
1449
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1450
                              int64_t wanted_timestamp, int flags)
1451
{
1452
    int a, b, m;
1453
    int64_t timestamp;
1454

    
1455
    a = - 1;
1456
    b = nb_entries;
1457

    
1458
    //optimize appending index entries at the end
1459
    if(b && entries[b-1].timestamp < wanted_timestamp)
1460
        a= b-1;
1461

    
1462
    while (b - a > 1) {
1463
        m = (a + b) >> 1;
1464
        timestamp = entries[m].timestamp;
1465
        if(timestamp >= wanted_timestamp)
1466
            b = m;
1467
        if(timestamp <= wanted_timestamp)
1468
            a = m;
1469
    }
1470
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1471

    
1472
    if(!(flags & AVSEEK_FLAG_ANY)){
1473
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1474
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1475
        }
1476
    }
1477

    
1478
    if(m == nb_entries)
1479
        return -1;
1480
    return  m;
1481
}
1482

    
1483
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1484
                              int flags)
1485
{
1486
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1487
                                     wanted_timestamp, flags);
1488
}
1489

    
1490
#define DEBUG_SEEK
1491

    
1492
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1493
    AVInputFormat *avif= s->iformat;
1494
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1495
    int64_t ts_min, ts_max, ts;
1496
    int index;
1497
    int64_t ret;
1498
    AVStream *st;
1499

    
1500
    if (stream_index < 0)
1501
        return -1;
1502

    
1503
#ifdef DEBUG_SEEK
1504
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1505
#endif
1506

    
1507
    ts_max=
1508
    ts_min= AV_NOPTS_VALUE;
1509
    pos_limit= -1; //gcc falsely says it may be uninitialized
1510

    
1511
    st= s->streams[stream_index];
1512
    if(st->index_entries){
1513
        AVIndexEntry *e;
1514

    
1515
        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()
1516
        index= FFMAX(index, 0);
1517
        e= &st->index_entries[index];
1518

    
1519
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1520
            pos_min= e->pos;
1521
            ts_min= e->timestamp;
1522
#ifdef DEBUG_SEEK
1523
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1524
                   pos_min,ts_min);
1525
#endif
1526
        }else{
1527
            assert(index==0);
1528
        }
1529

    
1530
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1531
        assert(index < st->nb_index_entries);
1532
        if(index >= 0){
1533
            e= &st->index_entries[index];
1534
            assert(e->timestamp >= target_ts);
1535
            pos_max= e->pos;
1536
            ts_max= e->timestamp;
1537
            pos_limit= pos_max - e->min_distance;
1538
#ifdef DEBUG_SEEK
1539
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1540
                   pos_max,pos_limit, ts_max);
1541
#endif
1542
        }
1543
    }
1544

    
1545
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1546
    if(pos<0)
1547
        return -1;
1548

    
1549
    /* do the seek */
1550
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1551
        return ret;
1552

    
1553
    av_update_cur_dts(s, st, ts);
1554

    
1555
    return 0;
1556
}
1557

    
1558
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 )){
1559
    int64_t pos, ts;
1560
    int64_t start_pos, filesize;
1561
    int no_change;
1562

    
1563
#ifdef DEBUG_SEEK
1564
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1565
#endif
1566

    
1567
    if(ts_min == AV_NOPTS_VALUE){
1568
        pos_min = s->data_offset;
1569
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1570
        if (ts_min == AV_NOPTS_VALUE)
1571
            return -1;
1572
    }
1573

    
1574
    if(ts_max == AV_NOPTS_VALUE){
1575
        int step= 1024;
1576
        filesize = avio_size(s->pb);
1577
        pos_max = filesize - 1;
1578
        do{
1579
            pos_max -= step;
1580
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1581
            step += step;
1582
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1583
        if (ts_max == AV_NOPTS_VALUE)
1584
            return -1;
1585

    
1586
        for(;;){
1587
            int64_t tmp_pos= pos_max + 1;
1588
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1589
            if(tmp_ts == AV_NOPTS_VALUE)
1590
                break;
1591
            ts_max= tmp_ts;
1592
            pos_max= tmp_pos;
1593
            if(tmp_pos >= filesize)
1594
                break;
1595
        }
1596
        pos_limit= pos_max;
1597
    }
1598

    
1599
    if(ts_min > ts_max){
1600
        return -1;
1601
    }else if(ts_min == ts_max){
1602
        pos_limit= pos_min;
1603
    }
1604

    
1605
    no_change=0;
1606
    while (pos_min < pos_limit) {
1607
#ifdef DEBUG_SEEK
1608
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1609
               pos_min, pos_max,
1610
               ts_min, ts_max);
1611
#endif
1612
        assert(pos_limit <= pos_max);
1613

    
1614
        if(no_change==0){
1615
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1616
            // interpolate position (better than dichotomy)
1617
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1618
                + pos_min - approximate_keyframe_distance;
1619
        }else if(no_change==1){
1620
            // bisection, if interpolation failed to change min or max pos last time
1621
            pos = (pos_min + pos_limit)>>1;
1622
        }else{
1623
            /* linear search if bisection failed, can only happen if there
1624
               are very few or no keyframes between min/max */
1625
            pos=pos_min;
1626
        }
1627
        if(pos <= pos_min)
1628
            pos= pos_min + 1;
1629
        else if(pos > pos_limit)
1630
            pos= pos_limit;
1631
        start_pos= pos;
1632

    
1633
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1634
        if(pos == pos_max)
1635
            no_change++;
1636
        else
1637
            no_change=0;
1638
#ifdef DEBUG_SEEK
1639
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1640
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1641
               start_pos, no_change);
1642
#endif
1643
        if(ts == AV_NOPTS_VALUE){
1644
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1645
            return -1;
1646
        }
1647
        assert(ts != AV_NOPTS_VALUE);
1648
        if (target_ts <= ts) {
1649
            pos_limit = start_pos - 1;
1650
            pos_max = pos;
1651
            ts_max = ts;
1652
        }
1653
        if (target_ts >= ts) {
1654
            pos_min = pos;
1655
            ts_min = ts;
1656
        }
1657
    }
1658

    
1659
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1660
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1661
#ifdef DEBUG_SEEK
1662
    pos_min = pos;
1663
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1664
    pos_min++;
1665
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1666
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1667
           pos, ts_min, target_ts, ts_max);
1668
#endif
1669
    *ts_ret= ts;
1670
    return pos;
1671
}
1672

    
1673
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1674
    int64_t pos_min, pos_max;
1675
#if 0
1676
    AVStream *st;
1677

1678
    if (stream_index < 0)
1679
        return -1;
1680

1681
    st= s->streams[stream_index];
1682
#endif
1683

    
1684
    pos_min = s->data_offset;
1685
    pos_max = avio_size(s->pb) - 1;
1686

    
1687
    if     (pos < pos_min) pos= pos_min;
1688
    else if(pos > pos_max) pos= pos_max;
1689

    
1690
    avio_seek(s->pb, pos, SEEK_SET);
1691

    
1692
#if 0
1693
    av_update_cur_dts(s, st, ts);
1694
#endif
1695
    return 0;
1696
}
1697

    
1698
static int av_seek_frame_generic(AVFormatContext *s,
1699
                                 int stream_index, int64_t timestamp, int flags)
1700
{
1701
    int index;
1702
    int64_t ret;
1703
    AVStream *st;
1704
    AVIndexEntry *ie;
1705

    
1706
    st = s->streams[stream_index];
1707

    
1708
    index = av_index_search_timestamp(st, timestamp, flags);
1709

    
1710
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1711
        return -1;
1712

    
1713
    if(index < 0 || index==st->nb_index_entries-1){
1714
        int i;
1715
        AVPacket pkt;
1716

    
1717
        if(st->nb_index_entries){
1718
            assert(st->index_entries);
1719
            ie= &st->index_entries[st->nb_index_entries-1];
1720
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1721
                return ret;
1722
            av_update_cur_dts(s, st, ie->timestamp);
1723
        }else{
1724
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1725
                return ret;
1726
        }
1727
        for(i=0;; i++) {
1728
            int ret;
1729
            do{
1730
                ret = av_read_frame(s, &pkt);
1731
            }while(ret == AVERROR(EAGAIN));
1732
            if(ret<0)
1733
                break;
1734
            av_free_packet(&pkt);
1735
            if(stream_index == pkt.stream_index){
1736
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1737
                    break;
1738
            }
1739
        }
1740
        index = av_index_search_timestamp(st, timestamp, flags);
1741
    }
1742
    if (index < 0)
1743
        return -1;
1744

    
1745
    ff_read_frame_flush(s);
1746
    if (s->iformat->read_seek){
1747
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1748
            return 0;
1749
    }
1750
    ie = &st->index_entries[index];
1751
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1752
        return ret;
1753
    av_update_cur_dts(s, st, ie->timestamp);
1754

    
1755
    return 0;
1756
}
1757

    
1758
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1759
{
1760
    int ret;
1761
    AVStream *st;
1762

    
1763
    ff_read_frame_flush(s);
1764

    
1765
    if(flags & AVSEEK_FLAG_BYTE)
1766
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1767

    
1768
    if(stream_index < 0){
1769
        stream_index= av_find_default_stream_index(s);
1770
        if(stream_index < 0)
1771
            return -1;
1772

    
1773
        st= s->streams[stream_index];
1774
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1775
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1776
    }
1777

    
1778
    /* first, we try the format specific seek */
1779
    if (s->iformat->read_seek)
1780
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1781
    else
1782
        ret = -1;
1783
    if (ret >= 0) {
1784
        return 0;
1785
    }
1786

    
1787
    if(s->iformat->read_timestamp)
1788
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1789
    else
1790
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1791
}
1792

    
1793
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1794
{
1795
    if(min_ts > ts || max_ts < ts)
1796
        return -1;
1797

    
1798
    ff_read_frame_flush(s);
1799

    
1800
    if (s->iformat->read_seek2)
1801
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1802

    
1803
    if(s->iformat->read_timestamp){
1804
        //try to seek via read_timestamp()
1805
    }
1806

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

    
1812
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1813
}
1814

    
1815
/*******************************************************/
1816

    
1817
/**
1818
 * Return TRUE if the stream has accurate duration in any stream.
1819
 *
1820
 * @return TRUE if the stream has accurate duration for at least one component.
1821
 */
1822
static int av_has_duration(AVFormatContext *ic)
1823
{
1824
    int i;
1825
    AVStream *st;
1826

    
1827
    for(i = 0;i < ic->nb_streams; i++) {
1828
        st = ic->streams[i];
1829
        if (st->duration != AV_NOPTS_VALUE)
1830
            return 1;
1831
    }
1832
    return 0;
1833
}
1834

    
1835
/**
1836
 * Estimate the stream timings from the one of each components.
1837
 *
1838
 * Also computes the global bitrate if possible.
1839
 */
1840
static void av_update_stream_timings(AVFormatContext *ic)
1841
{
1842
    int64_t start_time, start_time1, end_time, end_time1;
1843
    int64_t duration, duration1;
1844
    int i;
1845
    AVStream *st;
1846

    
1847
    start_time = INT64_MAX;
1848
    end_time = INT64_MIN;
1849
    duration = INT64_MIN;
1850
    for(i = 0;i < ic->nb_streams; i++) {
1851
        st = ic->streams[i];
1852
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1853
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1854
            if (start_time1 < start_time)
1855
                start_time = start_time1;
1856
            if (st->duration != AV_NOPTS_VALUE) {
1857
                end_time1 = start_time1
1858
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1859
                if (end_time1 > end_time)
1860
                    end_time = end_time1;
1861
            }
1862
        }
1863
        if (st->duration != AV_NOPTS_VALUE) {
1864
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1865
            if (duration1 > duration)
1866
                duration = duration1;
1867
        }
1868
    }
1869
    if (start_time != INT64_MAX) {
1870
        ic->start_time = start_time;
1871
        if (end_time != INT64_MIN) {
1872
            if (end_time - start_time > duration)
1873
                duration = end_time - start_time;
1874
        }
1875
    }
1876
    if (duration != INT64_MIN) {
1877
        ic->duration = duration;
1878
        if (ic->file_size > 0) {
1879
            /* compute the bitrate */
1880
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1881
                (double)ic->duration;
1882
        }
1883
    }
1884
}
1885

    
1886
static void fill_all_stream_timings(AVFormatContext *ic)
1887
{
1888
    int i;
1889
    AVStream *st;
1890

    
1891
    av_update_stream_timings(ic);
1892
    for(i = 0;i < ic->nb_streams; i++) {
1893
        st = ic->streams[i];
1894
        if (st->start_time == AV_NOPTS_VALUE) {
1895
            if(ic->start_time != AV_NOPTS_VALUE)
1896
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1897
            if(ic->duration != AV_NOPTS_VALUE)
1898
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1899
        }
1900
    }
1901
}
1902

    
1903
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1904
{
1905
    int64_t filesize, duration;
1906
    int bit_rate, i;
1907
    AVStream *st;
1908

    
1909
    /* if bit_rate is already set, we believe it */
1910
    if (ic->bit_rate <= 0) {
1911
        bit_rate = 0;
1912
        for(i=0;i<ic->nb_streams;i++) {
1913
            st = ic->streams[i];
1914
            if (st->codec->bit_rate > 0)
1915
            bit_rate += st->codec->bit_rate;
1916
        }
1917
        ic->bit_rate = bit_rate;
1918
    }
1919

    
1920
    /* if duration is already set, we believe it */
1921
    if (ic->duration == AV_NOPTS_VALUE &&
1922
        ic->bit_rate != 0 &&
1923
        ic->file_size != 0)  {
1924
        filesize = ic->file_size;
1925
        if (filesize > 0) {
1926
            for(i = 0; i < ic->nb_streams; i++) {
1927
                st = ic->streams[i];
1928
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1929
                if (st->duration == AV_NOPTS_VALUE)
1930
                    st->duration = duration;
1931
            }
1932
        }
1933
    }
1934
}
1935

    
1936
#define DURATION_MAX_READ_SIZE 250000
1937
#define DURATION_MAX_RETRY 3
1938

    
1939
/* only usable for MPEG-PS streams */
1940
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1941
{
1942
    AVPacket pkt1, *pkt = &pkt1;
1943
    AVStream *st;
1944
    int read_size, i, ret;
1945
    int64_t end_time;
1946
    int64_t filesize, offset, duration;
1947
    int retry=0;
1948

    
1949
    ic->cur_st = NULL;
1950

    
1951
    /* flush packet queue */
1952
    flush_packet_queue(ic);
1953

    
1954
    for (i=0; i<ic->nb_streams; i++) {
1955
        st = ic->streams[i];
1956
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1957
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1958

    
1959
        if (st->parser) {
1960
            av_parser_close(st->parser);
1961
            st->parser= NULL;
1962
            av_free_packet(&st->cur_pkt);
1963
        }
1964
    }
1965

    
1966
    /* estimate the end time (duration) */
1967
    /* XXX: may need to support wrapping */
1968
    filesize = ic->file_size;
1969
    end_time = AV_NOPTS_VALUE;
1970
    do{
1971
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1972
    if (offset < 0)
1973
        offset = 0;
1974

    
1975
    avio_seek(ic->pb, offset, SEEK_SET);
1976
    read_size = 0;
1977
    for(;;) {
1978
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1979
            break;
1980

    
1981
        do{
1982
            ret = av_read_packet(ic, pkt);
1983
        }while(ret == AVERROR(EAGAIN));
1984
        if (ret != 0)
1985
            break;
1986
        read_size += pkt->size;
1987
        st = ic->streams[pkt->stream_index];
1988
        if (pkt->pts != AV_NOPTS_VALUE &&
1989
            (st->start_time != AV_NOPTS_VALUE ||
1990
             st->first_dts  != AV_NOPTS_VALUE)) {
1991
            duration = end_time = pkt->pts;
1992
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1993
            else                                   duration -= st->first_dts;
1994
            if (duration < 0)
1995
                duration += 1LL<<st->pts_wrap_bits;
1996
            if (duration > 0) {
1997
                if (st->duration == AV_NOPTS_VALUE ||
1998
                    st->duration < duration)
1999
                    st->duration = duration;
2000
            }
2001
        }
2002
        av_free_packet(pkt);
2003
    }
2004
    }while(   end_time==AV_NOPTS_VALUE
2005
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
2006
           && ++retry <= DURATION_MAX_RETRY);
2007

    
2008
    fill_all_stream_timings(ic);
2009

    
2010
    avio_seek(ic->pb, old_offset, SEEK_SET);
2011
    for (i=0; i<ic->nb_streams; i++) {
2012
        st= ic->streams[i];
2013
        st->cur_dts= st->first_dts;
2014
        st->last_IP_pts = AV_NOPTS_VALUE;
2015
    }
2016
}
2017

    
2018
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2019
{
2020
    int64_t file_size;
2021

    
2022
    /* get the file size, if possible */
2023
    if (ic->iformat->flags & AVFMT_NOFILE) {
2024
        file_size = 0;
2025
    } else {
2026
        file_size = avio_size(ic->pb);
2027
        if (file_size < 0)
2028
            file_size = 0;
2029
    }
2030
    ic->file_size = file_size;
2031

    
2032
    if ((!strcmp(ic->iformat->name, "mpeg") ||
2033
         !strcmp(ic->iformat->name, "mpegts")) &&
2034
        file_size && ic->pb->seekable) {
2035
        /* get accurate estimate from the PTSes */
2036
        av_estimate_timings_from_pts(ic, old_offset);
2037
    } else if (av_has_duration(ic)) {
2038
        /* at least one component has timings - we use them for all
2039
           the components */
2040
        fill_all_stream_timings(ic);
2041
    } else {
2042
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2043
        /* less precise: use bitrate info */
2044
        av_estimate_timings_from_bit_rate(ic);
2045
    }
2046
    av_update_stream_timings(ic);
2047

    
2048
#if 0
2049
    {
2050
        int i;
2051
        AVStream *st;
2052
        for(i = 0;i < ic->nb_streams; i++) {
2053
            st = ic->streams[i];
2054
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2055
               i, (double)st->start_time / AV_TIME_BASE,
2056
               (double)st->duration / AV_TIME_BASE);
2057
        }
2058
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2059
               (double)ic->start_time / AV_TIME_BASE,
2060
               (double)ic->duration / AV_TIME_BASE,
2061
               ic->bit_rate / 1000);
2062
    }
2063
#endif
2064
}
2065

    
2066
static int has_codec_parameters(AVCodecContext *enc)
2067
{
2068
    int val;
2069
    switch(enc->codec_type) {
2070
    case AVMEDIA_TYPE_AUDIO:
2071
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2072
        if(!enc->frame_size &&
2073
           (enc->codec_id == CODEC_ID_VORBIS ||
2074
            enc->codec_id == CODEC_ID_AAC ||
2075
            enc->codec_id == CODEC_ID_MP1 ||
2076
            enc->codec_id == CODEC_ID_MP2 ||
2077
            enc->codec_id == CODEC_ID_MP3 ||
2078
            enc->codec_id == CODEC_ID_SPEEX))
2079
            return 0;
2080
        break;
2081
    case AVMEDIA_TYPE_VIDEO:
2082
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2083
        break;
2084
    default:
2085
        val = 1;
2086
        break;
2087
    }
2088
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2089
}
2090

    
2091
static int has_decode_delay_been_guessed(AVStream *st)
2092
{
2093
    return st->codec->codec_id != CODEC_ID_H264 ||
2094
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2095
}
2096

    
2097
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2098
{
2099
    int16_t *samples;
2100
    AVCodec *codec;
2101
    int got_picture, data_size, ret=0;
2102
    AVFrame picture;
2103

    
2104
    if(!st->codec->codec){
2105
        codec = avcodec_find_decoder(st->codec->codec_id);
2106
        if (!codec)
2107
            return -1;
2108
        ret = avcodec_open(st->codec, codec);
2109
        if (ret < 0)
2110
            return ret;
2111
    }
2112

    
2113
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2114
        switch(st->codec->codec_type) {
2115
        case AVMEDIA_TYPE_VIDEO:
2116
            avcodec_get_frame_defaults(&picture);
2117
            ret = avcodec_decode_video2(st->codec, &picture,
2118
                                        &got_picture, avpkt);
2119
            break;
2120
        case AVMEDIA_TYPE_AUDIO:
2121
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2122
            samples = av_malloc(data_size);
2123
            if (!samples)
2124
                goto fail;
2125
            ret = avcodec_decode_audio3(st->codec, samples,
2126
                                        &data_size, avpkt);
2127
            av_free(samples);
2128
            break;
2129
        default:
2130
            break;
2131
        }
2132
    }
2133
 fail:
2134
    return ret;
2135
}
2136

    
2137
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2138
{
2139
    while (tags->id != CODEC_ID_NONE) {
2140
        if (tags->id == id)
2141
            return tags->tag;
2142
        tags++;
2143
    }
2144
    return 0;
2145
}
2146

    
2147
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2148
{
2149
    int i;
2150
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2151
        if(tag == tags[i].tag)
2152
            return tags[i].id;
2153
    }
2154
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2155
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2156
            return tags[i].id;
2157
    }
2158
    return CODEC_ID_NONE;
2159
}
2160

    
2161
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2162
{
2163
    int i;
2164
    for(i=0; tags && tags[i]; i++){
2165
        int tag= ff_codec_get_tag(tags[i], id);
2166
        if(tag) return tag;
2167
    }
2168
    return 0;
2169
}
2170

    
2171
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2172
{
2173
    int i;
2174
    for(i=0; tags && tags[i]; i++){
2175
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2176
        if(id!=CODEC_ID_NONE) return id;
2177
    }
2178
    return CODEC_ID_NONE;
2179
}
2180

    
2181
static void compute_chapters_end(AVFormatContext *s)
2182
{
2183
    unsigned int i, j;
2184
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2185

    
2186
    for (i = 0; i < s->nb_chapters; i++)
2187
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2188
            AVChapter *ch = s->chapters[i];
2189
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2190
                                     : INT64_MAX;
2191

    
2192
            for (j = 0; j < s->nb_chapters; j++) {
2193
                AVChapter *ch1 = s->chapters[j];
2194
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2195
                if (j != i && next_start > ch->start && next_start < end)
2196
                    end = next_start;
2197
            }
2198
            ch->end = (end == INT64_MAX) ? ch->start : end;
2199
        }
2200
}
2201

    
2202
static int get_std_framerate(int i){
2203
    if(i<60*12) return i*1001;
2204
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2205
}
2206

    
2207
/*
2208
 * Is the time base unreliable.
2209
 * This is a heuristic to balance between quick acceptance of the values in
2210
 * the headers vs. some extra checks.
2211
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2212
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2213
 * And there are "variable" fps files this needs to detect as well.
2214
 */
2215
static int tb_unreliable(AVCodecContext *c){
2216
    if(   c->time_base.den >= 101L*c->time_base.num
2217
       || c->time_base.den <    5L*c->time_base.num
2218
/*       || c->codec_tag == AV_RL32("DIVX")
2219
       || c->codec_tag == AV_RL32("XVID")*/
2220
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2221
       || c->codec_id == CODEC_ID_H264
2222
       )
2223
        return 1;
2224
    return 0;
2225
}
2226

    
2227
int av_find_stream_info(AVFormatContext *ic)
2228
{
2229
    int i, count, ret, read_size, j;
2230
    AVStream *st;
2231
    AVPacket pkt1, *pkt;
2232
    int64_t old_offset = avio_tell(ic->pb);
2233

    
2234
    for(i=0;i<ic->nb_streams;i++) {
2235
        AVCodec *codec;
2236
        st = ic->streams[i];
2237
        if (st->codec->codec_id == CODEC_ID_AAC) {
2238
            st->codec->sample_rate = 0;
2239
            st->codec->frame_size = 0;
2240
            st->codec->channels = 0;
2241
        }
2242
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2243
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2244
/*            if(!st->time_base.num)
2245
                st->time_base= */
2246
            if(!st->codec->time_base.num)
2247
                st->codec->time_base= st->time_base;
2248
        }
2249
        //only for the split stuff
2250
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2251
            st->parser = av_parser_init(st->codec->codec_id);
2252
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2253
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2254
            }
2255
        }
2256
        assert(!st->codec->codec);
2257
        codec = avcodec_find_decoder(st->codec->codec_id);
2258

    
2259
        /* Force decoding of at least one frame of codec data
2260
         * this makes sure the codec initializes the channel configuration
2261
         * and does not trust the values from the container.
2262
         */
2263
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2264
            st->codec->channels = 0;
2265

    
2266
        /* Ensure that subtitle_header is properly set. */
2267
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2268
            && codec && !st->codec->codec)
2269
            avcodec_open(st->codec, codec);
2270

    
2271
        //try to just open decoders, in case this is enough to get parameters
2272
        if(!has_codec_parameters(st->codec)){
2273
            if (codec && !st->codec->codec)
2274
                avcodec_open(st->codec, codec);
2275
        }
2276
    }
2277

    
2278
    for (i=0; i<ic->nb_streams; i++) {
2279
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2280
    }
2281

    
2282
    count = 0;
2283
    read_size = 0;
2284
    for(;;) {
2285
        if(url_interrupt_cb()){
2286
            ret= AVERROR_EXIT;
2287
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2288
            break;
2289
        }
2290

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

    
2323
        /* NOTE: a new stream can be added there if no header in file
2324
           (AVFMTCTX_NOHEADER) */
2325
        ret = av_read_frame_internal(ic, &pkt1);
2326
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2327
            /* EOF or error */
2328
            ret = -1; /* we could not have all the codec parameters before EOF */
2329
            for(i=0;i<ic->nb_streams;i++) {
2330
                st = ic->streams[i];
2331
                if (!has_codec_parameters(st->codec)){
2332
                    char buf[256];
2333
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2334
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2335
                } else {
2336
                    ret = 0;
2337
                }
2338
            }
2339
            break;
2340
        }
2341

    
2342
        if (ret == AVERROR(EAGAIN))
2343
            continue;
2344

    
2345
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2346
        if ((ret = av_dup_packet(pkt)) < 0)
2347
            goto find_stream_info_err;
2348

    
2349
        read_size += pkt->size;
2350

    
2351
        st = ic->streams[pkt->stream_index];
2352
        if (st->codec_info_nb_frames>1) {
2353
            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) {
2354
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2355
                break;
2356
            }
2357
            st->info->codec_info_duration += pkt->duration;
2358
        }
2359
        {
2360
            int64_t last = st->info->last_dts;
2361
            int64_t duration= pkt->dts - last;
2362

    
2363
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2364
                double dur= duration * av_q2d(st->time_base);
2365

    
2366
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2367
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2368
                if (st->info->duration_count < 2)
2369
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2370
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2371
                    int framerate= get_std_framerate(i);
2372
                    int ticks= lrintf(dur*framerate/(1001*12));
2373
                    double error= dur - ticks*1001*12/(double)framerate;
2374
                    st->info->duration_error[i] += error*error;
2375
                }
2376
                st->info->duration_count++;
2377
                // ignore the first 4 values, they might have some random jitter
2378
                if (st->info->duration_count > 3)
2379
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2380
            }
2381
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2382
                st->info->last_dts = pkt->dts;
2383
        }
2384
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2385
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2386
            if(i){
2387
                st->codec->extradata_size= i;
2388
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2389
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2390
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2391
            }
2392
        }
2393

    
2394
        /* if still no information, we try to open the codec and to
2395
           decompress the frame. We try to avoid that in most cases as
2396
           it takes longer and uses more memory. For MPEG-4, we need to
2397
           decompress for QuickTime. */
2398
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2399
            try_decode_frame(st, pkt);
2400

    
2401
        st->codec_info_nb_frames++;
2402
        count++;
2403
    }
2404

    
2405
    // close codecs which were opened in try_decode_frame()
2406
    for(i=0;i<ic->nb_streams;i++) {
2407
        st = ic->streams[i];
2408
        if(st->codec->codec)
2409
            avcodec_close(st->codec);
2410
    }
2411
    for(i=0;i<ic->nb_streams;i++) {
2412
        st = ic->streams[i];
2413
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2414
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2415
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2416
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2417
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2418
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2419
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2420

    
2421
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2422
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2423
            // ipmovie.c produces.
2424
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2425
                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);
2426
            if (st->info->duration_count && !st->r_frame_rate.num
2427
               && tb_unreliable(st->codec) /*&&
2428
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2429
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2430
                int num = 0;
2431
                double best_error= 2*av_q2d(st->time_base);
2432
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2433

    
2434
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2435
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2436
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2437
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2438
                    if(error < best_error){
2439
                        best_error= error;
2440
                        num = get_std_framerate(j);
2441
                    }
2442
                }
2443
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2444
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2445
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2446
            }
2447

    
2448
            if (!st->r_frame_rate.num){
2449
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2450
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2451
                    st->r_frame_rate.num = st->codec->time_base.den;
2452
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2453
                }else{
2454
                    st->r_frame_rate.num = st->time_base.den;
2455
                    st->r_frame_rate.den = st->time_base.num;
2456
                }
2457
            }
2458
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2459
            if(!st->codec->bits_per_coded_sample)
2460
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2461
            // set stream disposition based on audio service type
2462
            switch (st->codec->audio_service_type) {
2463
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2464
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2465
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2466
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2467
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2468
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2469
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2470
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2471
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2472
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2473
            }
2474
        }
2475
    }
2476

    
2477
    av_estimate_timings(ic, old_offset);
2478

    
2479
    compute_chapters_end(ic);
2480

    
2481
#if 0
2482
    /* correct DTS for B-frame streams with no timestamps */
2483
    for(i=0;i<ic->nb_streams;i++) {
2484
        st = ic->streams[i];
2485
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2486
            if(b-frames){
2487
                ppktl = &ic->packet_buffer;
2488
                while(ppkt1){
2489
                    if(ppkt1->stream_index != i)
2490
                        continue;
2491
                    if(ppkt1->pkt->dts < 0)
2492
                        break;
2493
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2494
                        break;
2495
                    ppkt1->pkt->dts -= delta;
2496
                    ppkt1= ppkt1->next;
2497
                }
2498
                if(ppkt1)
2499
                    continue;
2500
                st->cur_dts -= delta;
2501
            }
2502
        }
2503
    }
2504
#endif
2505

    
2506
 find_stream_info_err:
2507
    for (i=0; i < ic->nb_streams; i++)
2508
        av_freep(&ic->streams[i]->info);
2509
    return ret;
2510
}
2511

    
2512
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2513
{
2514
    int i, j;
2515

    
2516
    for (i = 0; i < ic->nb_programs; i++)
2517
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2518
            if (ic->programs[i]->stream_index[j] == s)
2519
                return ic->programs[i];
2520
    return NULL;
2521
}
2522

    
2523
int av_find_best_stream(AVFormatContext *ic,
2524
                        enum AVMediaType type,
2525
                        int wanted_stream_nb,
2526
                        int related_stream,
2527
                        AVCodec **decoder_ret,
2528
                        int flags)
2529
{
2530
    int i, nb_streams = ic->nb_streams, stream_number = 0;
2531
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2532
    unsigned *program = NULL;
2533
    AVCodec *decoder = NULL, *best_decoder = NULL;
2534

    
2535
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2536
        AVProgram *p = find_program_from_stream(ic, related_stream);
2537
        if (p) {
2538
            program = p->stream_index;
2539
            nb_streams = p->nb_stream_indexes;
2540
        }
2541
    }
2542
    for (i = 0; i < nb_streams; i++) {
2543
        AVStream *st = ic->streams[program ? program[i] : i];
2544
        AVCodecContext *avctx = st->codec;
2545
        if (avctx->codec_type != type)
2546
            continue;
2547
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2548
            continue;
2549
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2550
            continue;
2551
        if (decoder_ret) {
2552
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2553
            if (!decoder) {
2554
                if (ret < 0)
2555
                    ret = AVERROR_DECODER_NOT_FOUND;
2556
                continue;
2557
            }
2558
        }
2559
        if (best_count >= st->codec_info_nb_frames)
2560
            continue;
2561
        best_count = st->codec_info_nb_frames;
2562
        ret = program ? program[i] : i;
2563
        best_decoder = decoder;
2564
        if (program && i == nb_streams - 1 && ret < 0) {
2565
            program = NULL;
2566
            nb_streams = ic->nb_streams;
2567
            i = 0; /* no related stream found, try again with everything */
2568
        }
2569
    }
2570
    if (decoder_ret)
2571
        *decoder_ret = best_decoder;
2572
    return ret;
2573
}
2574

    
2575
/*******************************************************/
2576

    
2577
int av_read_play(AVFormatContext *s)
2578
{
2579
    if (s->iformat->read_play)
2580
        return s->iformat->read_play(s);
2581
    if (s->pb)
2582
        return avio_pause(s->pb, 0);
2583
    return AVERROR(ENOSYS);
2584
}
2585

    
2586
int av_read_pause(AVFormatContext *s)
2587
{
2588
    if (s->iformat->read_pause)
2589
        return s->iformat->read_pause(s);
2590
    if (s->pb)
2591
        return avio_pause(s->pb, 1);
2592
    return AVERROR(ENOSYS);
2593
}
2594

    
2595
void av_close_input_stream(AVFormatContext *s)
2596
{
2597
    flush_packet_queue(s);
2598
    if (s->iformat->read_close)
2599
        s->iformat->read_close(s);
2600
    avformat_free_context(s);
2601
}
2602

    
2603
void avformat_free_context(AVFormatContext *s)
2604
{
2605
    int i;
2606
    AVStream *st;
2607

    
2608
    for(i=0;i<s->nb_streams;i++) {
2609
        /* free all data in a stream component */
2610
        st = s->streams[i];
2611
        if (st->parser) {
2612
            av_parser_close(st->parser);
2613
            av_free_packet(&st->cur_pkt);
2614
        }
2615
        av_metadata_free(&st->metadata);
2616
        av_free(st->index_entries);
2617
        av_free(st->codec->extradata);
2618
        av_free(st->codec->subtitle_header);
2619
        av_free(st->codec);
2620
#if FF_API_OLD_METADATA
2621
        av_free(st->filename);
2622
#endif
2623
        av_free(st->priv_data);
2624
        av_free(st->info);
2625
        av_free(st);
2626
    }
2627
    for(i=s->nb_programs-1; i>=0; i--) {
2628
#if FF_API_OLD_METADATA
2629
        av_freep(&s->programs[i]->provider_name);
2630
        av_freep(&s->programs[i]->name);
2631
#endif
2632
        av_metadata_free(&s->programs[i]->metadata);
2633
        av_freep(&s->programs[i]->stream_index);
2634
        av_freep(&s->programs[i]);
2635
    }
2636
    av_freep(&s->programs);
2637
    av_freep(&s->priv_data);
2638
    while(s->nb_chapters--) {
2639
#if FF_API_OLD_METADATA
2640
        av_free(s->chapters[s->nb_chapters]->title);
2641
#endif
2642
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2643
        av_free(s->chapters[s->nb_chapters]);
2644
    }
2645
    av_freep(&s->chapters);
2646
    av_metadata_free(&s->metadata);
2647
    av_freep(&s->key);
2648
    av_free(s);
2649
}
2650

    
2651
void av_close_input_file(AVFormatContext *s)
2652
{
2653
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2654
    av_close_input_stream(s);
2655
    if (pb)
2656
        avio_close(pb);
2657
}
2658

    
2659
AVStream *av_new_stream(AVFormatContext *s, int id)
2660
{
2661
    AVStream *st;
2662
    int i;
2663

    
2664
#if FF_API_MAX_STREAMS
2665
    if (s->nb_streams >= MAX_STREAMS){
2666
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2667
        return NULL;
2668
    }
2669
#else
2670
    AVStream **streams;
2671

    
2672
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2673
        return NULL;
2674
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2675
    if (!streams)
2676
        return NULL;
2677
    s->streams = streams;
2678
#endif
2679

    
2680
    st = av_mallocz(sizeof(AVStream));
2681
    if (!st)
2682
        return NULL;
2683
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2684
        av_free(st);
2685
        return NULL;
2686
    }
2687

    
2688
    st->codec= avcodec_alloc_context();
2689
    if (s->iformat) {
2690
        /* no default bitrate if decoding */
2691
        st->codec->bit_rate = 0;
2692
    }
2693
    st->index = s->nb_streams;
2694
    st->id = id;
2695
    st->start_time = AV_NOPTS_VALUE;
2696
    st->duration = AV_NOPTS_VALUE;
2697
        /* we set the current DTS to 0 so that formats without any timestamps
2698
           but durations get some timestamps, formats with some unknown
2699
           timestamps have their first few packets buffered and the
2700
           timestamps corrected before they are returned to the user */
2701
    st->cur_dts = 0;
2702
    st->first_dts = AV_NOPTS_VALUE;
2703
    st->probe_packets = MAX_PROBE_PACKETS;
2704

    
2705
    /* default pts setting is MPEG-like */
2706
    av_set_pts_info(st, 33, 1, 90000);
2707
    st->last_IP_pts = AV_NOPTS_VALUE;
2708
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2709
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2710
    st->reference_dts = AV_NOPTS_VALUE;
2711

    
2712
    st->sample_aspect_ratio = (AVRational){0,1};
2713

    
2714
    s->streams[s->nb_streams++] = st;
2715
    return st;
2716
}
2717

    
2718
AVProgram *av_new_program(AVFormatContext *ac, int id)
2719
{
2720
    AVProgram *program=NULL;
2721
    int i;
2722

    
2723
#ifdef DEBUG_SI
2724
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2725
#endif
2726

    
2727
    for(i=0; i<ac->nb_programs; i++)
2728
        if(ac->programs[i]->id == id)
2729
            program = ac->programs[i];
2730

    
2731
    if(!program){
2732
        program = av_mallocz(sizeof(AVProgram));
2733
        if (!program)
2734
            return NULL;
2735
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2736
        program->discard = AVDISCARD_NONE;
2737
    }
2738
    program->id = id;
2739

    
2740
    return program;
2741
}
2742

    
2743
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2744
{
2745
    AVChapter *chapter = NULL;
2746
    int i;
2747

    
2748
    for(i=0; i<s->nb_chapters; i++)
2749
        if(s->chapters[i]->id == id)
2750
            chapter = s->chapters[i];
2751

    
2752
    if(!chapter){
2753
        chapter= av_mallocz(sizeof(AVChapter));
2754
        if(!chapter)
2755
            return NULL;
2756
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2757
    }
2758
#if FF_API_OLD_METADATA
2759
    av_free(chapter->title);
2760
#endif
2761
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2762
    chapter->id    = id;
2763
    chapter->time_base= time_base;
2764
    chapter->start = start;
2765
    chapter->end   = end;
2766

    
2767
    return chapter;
2768
}
2769

    
2770
/************************************************************/
2771
/* output media file */
2772

    
2773
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2774
{
2775
    int ret;
2776

    
2777
    if (s->oformat->priv_data_size > 0) {
2778
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2779
        if (!s->priv_data)
2780
            return AVERROR(ENOMEM);
2781
        if (s->oformat->priv_class) {
2782
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2783
            av_opt_set_defaults(s->priv_data);
2784
        }
2785
    } else
2786
        s->priv_data = NULL;
2787

    
2788
    if (s->oformat->set_parameters) {
2789
        ret = s->oformat->set_parameters(s, ap);
2790
        if (ret < 0)
2791
            return ret;
2792
    }
2793
    return 0;
2794
}
2795

    
2796
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2797
{
2798
    const AVCodecTag *avctag;
2799
    int n;
2800
    enum CodecID id = CODEC_ID_NONE;
2801
    unsigned int tag = 0;
2802

    
2803
    /**
2804
     * Check that tag + id is in the table
2805
     * If neither is in the table -> OK
2806
     * If tag is in the table with another id -> FAIL
2807
     * If id is in the table with another tag -> FAIL unless strict < normal
2808
     */
2809
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2810
        avctag = s->oformat->codec_tag[n];
2811
        while (avctag->id != CODEC_ID_NONE) {
2812
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2813
                id = avctag->id;
2814
                if (id == st->codec->codec_id)
2815
                    return 1;
2816
            }
2817
            if (avctag->id == st->codec->codec_id)
2818
                tag = avctag->tag;
2819
            avctag++;
2820
        }
2821
    }
2822
    if (id != CODEC_ID_NONE)
2823
        return 0;
2824
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2825
        return 0;
2826
    return 1;
2827
}
2828

    
2829
int av_write_header(AVFormatContext *s)
2830
{
2831
    int ret, i;
2832
    AVStream *st;
2833

    
2834
    // some sanity checks
2835
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2836
        av_log(s, AV_LOG_ERROR, "no streams\n");
2837
        return AVERROR(EINVAL);
2838
    }
2839

    
2840
    for(i=0;i<s->nb_streams;i++) {
2841
        st = s->streams[i];
2842

    
2843
        switch (st->codec->codec_type) {
2844
        case AVMEDIA_TYPE_AUDIO:
2845
            if(st->codec->sample_rate<=0){
2846
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2847
                return AVERROR(EINVAL);
2848
            }
2849
            if(!st->codec->block_align)
2850
                st->codec->block_align = st->codec->channels *
2851
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2852
            break;
2853
        case AVMEDIA_TYPE_VIDEO:
2854
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2855
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2856
                return AVERROR(EINVAL);
2857
            }
2858
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2859
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2860
                return AVERROR(EINVAL);
2861
            }
2862
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2863
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2864
                return AVERROR(EINVAL);
2865
            }
2866
            break;
2867
        }
2868

    
2869
        if(s->oformat->codec_tag){
2870
            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)){
2871
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2872
                st->codec->codec_tag= 0;
2873
            }
2874
            if(st->codec->codec_tag){
2875
                if (!validate_codec_tag(s, st)) {
2876
                    char tagbuf[32];
2877
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2878
                    av_log(s, AV_LOG_ERROR,
2879
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2880
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2881
                    return AVERROR_INVALIDDATA;
2882
                }
2883
            }else
2884
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2885
        }
2886

    
2887
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2888
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2889
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2890
    }
2891

    
2892
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2893
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2894
        if (!s->priv_data)
2895
            return AVERROR(ENOMEM);
2896
    }
2897

    
2898
#if FF_API_OLD_METADATA
2899
    ff_metadata_mux_compat(s);
2900
#endif
2901

    
2902
    /* set muxer identification string */
2903
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2904
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2905
    }
2906

    
2907
    if(s->oformat->write_header){
2908
        ret = s->oformat->write_header(s);
2909
        if (ret < 0)
2910
            return ret;
2911
    }
2912

    
2913
    /* init PTS generation */
2914
    for(i=0;i<s->nb_streams;i++) {
2915
        int64_t den = AV_NOPTS_VALUE;
2916
        st = s->streams[i];
2917

    
2918
        switch (st->codec->codec_type) {
2919
        case AVMEDIA_TYPE_AUDIO:
2920
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2921
            break;
2922
        case AVMEDIA_TYPE_VIDEO:
2923
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2924
            break;
2925
        default:
2926
            break;
2927
        }
2928
        if (den != AV_NOPTS_VALUE) {
2929
            if (den <= 0)
2930
                return AVERROR_INVALIDDATA;
2931
            av_frac_init(&st->pts, 0, 0, den);
2932
        }
2933
    }
2934
    return 0;
2935
}
2936

    
2937
//FIXME merge with compute_pkt_fields
2938
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2939
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2940
    int num, den, frame_size, i;
2941

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

    
2945
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2946
        return -1;*/
2947

    
2948
    /* duration field */
2949
    if (pkt->duration == 0) {
2950
        compute_frame_duration(&num, &den, st, NULL, pkt);
2951
        if (den && num) {
2952
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2953
        }
2954
    }
2955

    
2956
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2957
        pkt->pts= pkt->dts;
2958

    
2959
    //XXX/FIXME this is a temporary hack until all encoders output pts
2960
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2961
        pkt->dts=
2962
//        pkt->pts= st->cur_dts;
2963
        pkt->pts= st->pts.val;
2964
    }
2965

    
2966
    //calculate dts from pts
2967
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2968
        st->pts_buffer[0]= pkt->pts;
2969
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2970
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2971
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2972
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2973

    
2974
        pkt->dts= st->pts_buffer[0];
2975
    }
2976

    
2977
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2978
        av_log(s, AV_LOG_ERROR,
2979
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2980
               st->index, st->cur_dts, pkt->dts);
2981
        return -1;
2982
    }
2983
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2984
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2985
        return -1;
2986
    }
2987

    
2988
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2989
    st->cur_dts= pkt->dts;
2990
    st->pts.val= pkt->dts;
2991

    
2992
    /* update pts */
2993
    switch (st->codec->codec_type) {
2994
    case AVMEDIA_TYPE_AUDIO:
2995
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2996

    
2997
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2998
           likely equal to the encoder delay, but it would be better if we
2999
           had the real timestamps from the encoder */
3000
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3001
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3002
        }
3003
        break;
3004
    case AVMEDIA_TYPE_VIDEO:
3005
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3006
        break;
3007
    default:
3008
        break;
3009
    }
3010
    return 0;
3011
}
3012

    
3013
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3014
{
3015
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3016

    
3017
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3018
        return ret;
3019

    
3020
    ret= s->oformat->write_packet(s, pkt);
3021
    return ret;
3022
}
3023

    
3024
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3025
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3026
{
3027
    AVPacketList **next_point, *this_pktl;
3028

    
3029
    this_pktl = av_mallocz(sizeof(AVPacketList));
3030
    this_pktl->pkt= *pkt;
3031
    pkt->destruct= NULL;             // do not free original but only the copy
3032
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3033

    
3034
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3035
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3036
    }else
3037
        next_point = &s->packet_buffer;
3038

    
3039
    if(*next_point){
3040
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3041
            while(!compare(s, &(*next_point)->pkt, pkt)){
3042
                next_point= &(*next_point)->next;
3043
            }
3044
            goto next_non_null;
3045
        }else{
3046
            next_point = &(s->packet_buffer_end->next);
3047
        }
3048
    }
3049
    assert(!*next_point);
3050

    
3051
    s->packet_buffer_end= this_pktl;
3052
next_non_null:
3053

    
3054
    this_pktl->next= *next_point;
3055

    
3056
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3057
    *next_point= this_pktl;
3058
}
3059

    
3060
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3061
{
3062
    AVStream *st = s->streams[ pkt ->stream_index];
3063
    AVStream *st2= s->streams[ next->stream_index];
3064
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3065
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3066
    int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
3067
    if (dts1 == next->dts)
3068
        return pkt->stream_index < next->stream_index;
3069
    return dts1 < next->dts;
3070
}
3071

    
3072
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3073
    AVPacketList *pktl;
3074
    int stream_count=0;
3075
    int i;
3076

    
3077
    if(pkt){
3078
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3079
    }
3080

    
3081
    for(i=0; i < s->nb_streams; i++)
3082
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3083

    
3084
    if(stream_count && (s->nb_streams == stream_count || flush)){
3085
        pktl= s->packet_buffer;
3086
        *out= pktl->pkt;
3087

    
3088
        s->packet_buffer= pktl->next;
3089
        if(!s->packet_buffer)
3090
            s->packet_buffer_end= NULL;
3091

    
3092
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3093
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3094
        av_freep(&pktl);
3095
        return 1;
3096
    }else{
3097
        av_init_packet(out);
3098
        return 0;
3099
    }
3100
}
3101

    
3102
/**
3103
 * Interleave an AVPacket correctly so it can be muxed.
3104
 * @param out the interleaved packet will be output here
3105
 * @param in the input packet
3106
 * @param flush 1 if no further packets are available as input and all
3107
 *              remaining packets should be output
3108
 * @return 1 if a packet was output, 0 if no packet could be output,
3109
 *         < 0 if an error occurred
3110
 */
3111
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3112
    if(s->oformat->interleave_packet)
3113
        return s->oformat->interleave_packet(s, out, in, flush);
3114
    else
3115
        return av_interleave_packet_per_dts(s, out, in, flush);
3116
}
3117

    
3118
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3119
    AVStream *st= s->streams[ pkt->stream_index];
3120
    int ret;
3121

    
3122
    //FIXME/XXX/HACK drop zero sized packets
3123
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3124
        return 0;
3125

    
3126
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3127
            pkt->size, pkt->dts, pkt->pts);
3128
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3129
        return ret;
3130

    
3131
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3132
        return AVERROR(EINVAL);
3133

    
3134
    for(;;){
3135
        AVPacket opkt;
3136
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3137
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3138
            return ret;
3139

    
3140
        ret= s->oformat->write_packet(s, &opkt);
3141

    
3142
        av_free_packet(&opkt);
3143
        pkt= NULL;
3144

    
3145
        if(ret<0)
3146
            return ret;
3147
    }
3148
}
3149

    
3150
int av_write_trailer(AVFormatContext *s)
3151
{
3152
    int ret, i;
3153

    
3154
    for(;;){
3155
        AVPacket pkt;
3156
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3157
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3158
            goto fail;
3159
        if(!ret)
3160
            break;
3161

    
3162
        ret= s->oformat->write_packet(s, &pkt);
3163

    
3164
        av_free_packet(&pkt);
3165

    
3166
        if(ret<0)
3167
            goto fail;
3168
    }
3169

    
3170
    if(s->oformat->write_trailer)
3171
        ret = s->oformat->write_trailer(s);
3172
fail:
3173
    for(i=0;i<s->nb_streams;i++) {
3174
        av_freep(&s->streams[i]->priv_data);
3175
        av_freep(&s->streams[i]->index_entries);
3176
    }
3177
    av_freep(&s->priv_data);
3178
    return ret;
3179
}
3180

    
3181
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3182
{
3183
    int i, j;
3184
    AVProgram *program=NULL;
3185
    void *tmp;
3186

    
3187
    if (idx >= ac->nb_streams) {
3188
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3189
        return;
3190
    }
3191

    
3192
    for(i=0; i<ac->nb_programs; i++){
3193
        if(ac->programs[i]->id != progid)
3194
            continue;
3195
        program = ac->programs[i];
3196
        for(j=0; j<program->nb_stream_indexes; j++)
3197
            if(program->stream_index[j] == idx)
3198
                return;
3199

    
3200
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3201
        if(!tmp)
3202
            return;
3203
        program->stream_index = tmp;
3204
        program->stream_index[program->nb_stream_indexes++] = idx;
3205
        return;
3206
    }
3207
}
3208

    
3209
static void print_fps(double d, const char *postfix){
3210
    uint64_t v= lrintf(d*100);
3211
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3212
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3213
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3214
}
3215

    
3216
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3217
{
3218
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3219
        AVMetadataTag *tag=NULL;
3220

    
3221
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3222
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3223
            if(strcmp("language", tag->key))
3224
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3225
        }
3226
    }
3227
}
3228

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

    
3292
#if FF_API_DUMP_FORMAT
3293
void dump_format(AVFormatContext *ic,
3294
                 int index,
3295
                 const char *url,
3296
                 int is_output)
3297
{
3298
    av_dump_format(ic, index, url, is_output);
3299
}
3300
#endif
3301

    
3302
void av_dump_format(AVFormatContext *ic,
3303
                    int index,
3304
                    const char *url,
3305
                    int is_output)
3306
{
3307
    int i;
3308
    uint8_t *printed = av_mallocz(ic->nb_streams);
3309
    if (ic->nb_streams && !printed)
3310
        return;
3311

    
3312
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3313
            is_output ? "Output" : "Input",
3314
            index,
3315
            is_output ? ic->oformat->name : ic->iformat->name,
3316
            is_output ? "to" : "from", url);
3317
    dump_metadata(NULL, ic->metadata, "  ");
3318
    if (!is_output) {
3319
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3320
        if (ic->duration != AV_NOPTS_VALUE) {
3321
            int hours, mins, secs, us;
3322
            secs = ic->duration / AV_TIME_BASE;
3323
            us = ic->duration % AV_TIME_BASE;
3324
            mins = secs / 60;
3325
            secs %= 60;
3326
            hours = mins / 60;
3327
            mins %= 60;
3328
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3329
                   (100 * us) / AV_TIME_BASE);
3330
        } else {
3331
            av_log(NULL, AV_LOG_INFO, "N/A");
3332
        }
3333
        if (ic->start_time != AV_NOPTS_VALUE) {
3334
            int secs, us;
3335
            av_log(NULL, AV_LOG_INFO, ", start: ");
3336
            secs = ic->start_time / AV_TIME_BASE;
3337
            us = abs(ic->start_time % AV_TIME_BASE);
3338
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3339
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3340
        }
3341
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3342
        if (ic->bit_rate) {
3343
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3344
        } else {
3345
            av_log(NULL, AV_LOG_INFO, "N/A");
3346
        }
3347
        av_log(NULL, AV_LOG_INFO, "\n");
3348
    }
3349
    for (i = 0; i < ic->nb_chapters; i++) {
3350
        AVChapter *ch = ic->chapters[i];
3351
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3352
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3353
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3354

    
3355
        dump_metadata(NULL, ch->metadata, "    ");
3356
    }
3357
    if(ic->nb_programs) {
3358
        int j, k, total = 0;
3359
        for(j=0; j<ic->nb_programs; j++) {
3360
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3361
                                                  "name", NULL, 0);
3362
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3363
                   name ? name->value : "");
3364
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3365
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3366
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3367
                printed[ic->programs[j]->stream_index[k]] = 1;
3368
            }
3369
            total += ic->programs[j]->nb_stream_indexes;
3370
        }
3371
        if (total < ic->nb_streams)
3372
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3373
    }
3374
    for(i=0;i<ic->nb_streams;i++)
3375
        if (!printed[i])
3376
            dump_stream_format(ic, i, index, is_output);
3377

    
3378
    av_free(printed);
3379
}
3380

    
3381
#if FF_API_PARSE_FRAME_PARAM
3382
#include "libavutil/parseutils.h"
3383

    
3384
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3385
{
3386
    return av_parse_video_size(width_ptr, height_ptr, str);
3387
}
3388

    
3389
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3390
{
3391
    AVRational frame_rate;
3392
    int ret = av_parse_video_rate(&frame_rate, arg);
3393
    *frame_rate_num= frame_rate.num;
3394
    *frame_rate_den= frame_rate.den;
3395
    return ret;
3396
}
3397
#endif
3398

    
3399
int64_t av_gettime(void)
3400
{
3401
    struct timeval tv;
3402
    gettimeofday(&tv,NULL);
3403
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3404
}
3405

    
3406
uint64_t ff_ntp_time(void)
3407
{
3408
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3409
}
3410

    
3411
#if FF_API_PARSE_DATE
3412
#include "libavutil/parseutils.h"
3413

    
3414
int64_t parse_date(const char *timestr, int duration)
3415
{
3416
    int64_t timeval;
3417
    av_parse_time(&timeval, timestr, duration);
3418
    return timeval;
3419
}
3420
#endif
3421

    
3422
#if FF_API_FIND_INFO_TAG
3423
#include "libavutil/parseutils.h"
3424

    
3425
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3426
{
3427
    return av_find_info_tag(arg, arg_size, tag1, info);
3428
}
3429
#endif
3430

    
3431
int av_get_frame_filename(char *buf, int buf_size,
3432
                          const char *path, int number)
3433
{
3434
    const char *p;
3435
    char *q, buf1[20], c;
3436
    int nd, len, percentd_found;
3437

    
3438
    q = buf;
3439
    p = path;
3440
    percentd_found = 0;
3441
    for(;;) {
3442
        c = *p++;
3443
        if (c == '\0')
3444
            break;
3445
        if (c == '%') {
3446
            do {
3447
                nd = 0;
3448
                while (isdigit(*p)) {
3449
                    nd = nd * 10 + *p++ - '0';
3450
                }
3451
                c = *p++;
3452
            } while (isdigit(c));
3453

    
3454
            switch(c) {
3455
            case '%':
3456
                goto addchar;
3457
            case 'd':
3458
                if (percentd_found)
3459
                    goto fail;
3460
                percentd_found = 1;
3461
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3462
                len = strlen(buf1);
3463
                if ((q - buf + len) > buf_size - 1)
3464
                    goto fail;
3465
                memcpy(q, buf1, len);
3466
                q += len;
3467
                break;
3468
            default:
3469
                goto fail;
3470
            }
3471
        } else {
3472
        addchar:
3473
            if ((q - buf) < buf_size - 1)
3474
                *q++ = c;
3475
        }
3476
    }
3477
    if (!percentd_found)
3478
        goto fail;
3479
    *q = '\0';
3480
    return 0;
3481
 fail:
3482
    *q = '\0';
3483
    return -1;
3484
}
3485

    
3486
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3487
{
3488
    int len, i, j, c;
3489
#undef fprintf
3490
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3491

    
3492
    for(i=0;i<size;i+=16) {
3493
        len = size - i;
3494
        if (len > 16)
3495
            len = 16;
3496
        PRINT("%08x ", i);
3497
        for(j=0;j<16;j++) {
3498
            if (j < len)
3499
                PRINT(" %02x", buf[i+j]);
3500
            else
3501
                PRINT("   ");
3502
        }
3503
        PRINT(" ");
3504
        for(j=0;j<len;j++) {
3505
            c = buf[i+j];
3506
            if (c < ' ' || c > '~')
3507
                c = '.';
3508
            PRINT("%c", c);
3509
        }
3510
        PRINT("\n");
3511
    }
3512
#undef PRINT
3513
}
3514

    
3515
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3516
{
3517
    hex_dump_internal(NULL, f, 0, buf, size);
3518
}
3519

    
3520
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3521
{
3522
    hex_dump_internal(avcl, NULL, level, buf, size);
3523
}
3524

    
3525
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3526
{
3527
#undef fprintf
3528
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3529
    PRINT("stream #%d:\n", pkt->stream_index);
3530
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3531
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3532
    /* DTS is _always_ valid after av_read_frame() */
3533
    PRINT("  dts=");
3534
    if (pkt->dts == AV_NOPTS_VALUE)
3535
        PRINT("N/A");
3536
    else
3537
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3538
    /* PTS may not be known if B-frames are present. */
3539
    PRINT("  pts=");
3540
    if (pkt->pts == AV_NOPTS_VALUE)
3541
        PRINT("N/A");
3542
    else
3543
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3544
    PRINT("\n");
3545
    PRINT("  size=%d\n", pkt->size);
3546
#undef PRINT
3547
    if (dump_payload)
3548
        av_hex_dump(f, pkt->data, pkt->size);
3549
}
3550

    
3551
#if FF_API_PKT_DUMP
3552
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3553
{
3554
    AVRational tb = { 1, AV_TIME_BASE };
3555
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3556
}
3557
#endif
3558

    
3559
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3560
{
3561
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3562
}
3563

    
3564
#if FF_API_PKT_DUMP
3565
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3566
{
3567
    AVRational tb = { 1, AV_TIME_BASE };
3568
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3569
}
3570
#endif
3571

    
3572
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3573
                      AVStream *st)
3574
{
3575
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3576
}
3577

    
3578
#if FF_API_URL_SPLIT
3579
attribute_deprecated
3580
void ff_url_split(char *proto, int proto_size,
3581
                  char *authorization, int authorization_size,
3582
                  char *hostname, int hostname_size,
3583
                  int *port_ptr,
3584
                  char *path, int path_size,
3585
                  const char *url)
3586
{
3587
    av_url_split(proto, proto_size,
3588
                 authorization, authorization_size,
3589
                 hostname, hostname_size,
3590
                 port_ptr,
3591
                 path, path_size,
3592
                 url);
3593
}
3594
#endif
3595

    
3596
void av_url_split(char *proto, int proto_size,
3597
                  char *authorization, int authorization_size,
3598
                  char *hostname, int hostname_size,
3599
                  int *port_ptr,
3600
                  char *path, int path_size,
3601
                  const char *url)
3602
{
3603
    const char *p, *ls, *at, *col, *brk;
3604

    
3605
    if (port_ptr)               *port_ptr = -1;
3606
    if (proto_size > 0)         proto[0] = 0;
3607
    if (authorization_size > 0) authorization[0] = 0;
3608
    if (hostname_size > 0)      hostname[0] = 0;
3609
    if (path_size > 0)          path[0] = 0;
3610

    
3611
    /* parse protocol */
3612
    if ((p = strchr(url, ':'))) {
3613
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3614
        p++; /* skip ':' */
3615
        if (*p == '/') p++;
3616
        if (*p == '/') p++;
3617
    } else {
3618
        /* no protocol means plain filename */
3619
        av_strlcpy(path, url, path_size);
3620
        return;
3621
    }
3622

    
3623
    /* separate path from hostname */
3624
    ls = strchr(p, '/');
3625
    if(!ls)
3626
        ls = strchr(p, '?');
3627
    if(ls)
3628
        av_strlcpy(path, ls, path_size);
3629
    else
3630
        ls = &p[strlen(p)]; // XXX
3631

    
3632
    /* the rest is hostname, use that to parse auth/port */
3633
    if (ls != p) {
3634
        /* authorization (user[:pass]@hostname) */
3635
        if ((at = strchr(p, '@')) && at < ls) {
3636
            av_strlcpy(authorization, p,
3637
                       FFMIN(authorization_size, at + 1 - p));
3638
            p = at + 1; /* skip '@' */
3639
        }
3640

    
3641
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3642
            /* [host]:port */
3643
            av_strlcpy(hostname, p + 1,
3644
                       FFMIN(hostname_size, brk - p));
3645
            if (brk[1] == ':' && port_ptr)
3646
                *port_ptr = atoi(brk + 2);
3647
        } else if ((col = strchr(p, ':')) && col < ls) {
3648
            av_strlcpy(hostname, p,
3649
                       FFMIN(col + 1 - p, hostname_size));
3650
            if (port_ptr) *port_ptr = atoi(col + 1);
3651
        } else
3652
            av_strlcpy(hostname, p,
3653
                       FFMIN(ls + 1 - p, hostname_size));
3654
    }
3655
}
3656

    
3657
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3658
{
3659
    int i;
3660
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3661
                                           '4', '5', '6', '7',
3662
                                           '8', '9', 'A', 'B',
3663
                                           'C', 'D', 'E', 'F' };
3664
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3665
                                           '4', '5', '6', '7',
3666
                                           '8', '9', 'a', 'b',
3667
                                           'c', 'd', 'e', 'f' };
3668
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3669

    
3670
    for(i = 0; i < s; i++) {
3671
        buff[i * 2]     = hex_table[src[i] >> 4];
3672
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3673
    }
3674

    
3675
    return buff;
3676
}
3677

    
3678
int ff_hex_to_data(uint8_t *data, const char *p)
3679
{
3680
    int c, len, v;
3681

    
3682
    len = 0;
3683
    v = 1;
3684
    for (;;) {
3685
        p += strspn(p, SPACE_CHARS);
3686
        if (*p == '\0')
3687
            break;
3688
        c = toupper((unsigned char) *p++);
3689
        if (c >= '0' && c <= '9')
3690
            c = c - '0';
3691
        else if (c >= 'A' && c <= 'F')
3692
            c = c - 'A' + 10;
3693
        else
3694
            break;
3695
        v = (v << 4) | c;
3696
        if (v & 0x100) {
3697
            if (data)
3698
                data[len] = v;
3699
            len++;
3700
            v = 1;
3701
        }
3702
    }
3703
    return len;
3704
}
3705

    
3706
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3707
                     unsigned int pts_num, unsigned int pts_den)
3708
{
3709
    AVRational new_tb;
3710
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3711
        if(new_tb.num != pts_num)
3712
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3713
    }else
3714
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3715

    
3716
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3717
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3718
        return;
3719
    }
3720
    s->time_base = new_tb;
3721
    s->pts_wrap_bits = pts_wrap_bits;
3722
}
3723

    
3724
int ff_url_join(char *str, int size, const char *proto,
3725
                const char *authorization, const char *hostname,
3726
                int port, const char *fmt, ...)
3727
{
3728
#if CONFIG_NETWORK
3729
    struct addrinfo hints, *ai;
3730
#endif
3731

    
3732
    str[0] = '\0';
3733
    if (proto)
3734
        av_strlcatf(str, size, "%s://", proto);
3735
    if (authorization && authorization[0])
3736
        av_strlcatf(str, size, "%s@", authorization);
3737
#if CONFIG_NETWORK && defined(AF_INET6)
3738
    /* Determine if hostname is a numerical IPv6 address,
3739
     * properly escape it within [] in that case. */
3740
    memset(&hints, 0, sizeof(hints));
3741
    hints.ai_flags = AI_NUMERICHOST;
3742
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3743
        if (ai->ai_family == AF_INET6) {
3744
            av_strlcat(str, "[", size);
3745
            av_strlcat(str, hostname, size);
3746
            av_strlcat(str, "]", size);
3747
        } else {
3748
            av_strlcat(str, hostname, size);
3749
        }
3750
        freeaddrinfo(ai);
3751
    } else
3752
#endif
3753
        /* Not an IPv6 address, just output the plain string. */
3754
        av_strlcat(str, hostname, size);
3755

    
3756
    if (port >= 0)
3757
        av_strlcatf(str, size, ":%d", port);
3758
    if (fmt) {
3759
        va_list vl;
3760
        int len = strlen(str);
3761

    
3762
        va_start(vl, fmt);
3763
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3764
        va_end(vl);
3765
    }
3766
    return strlen(str);
3767
}
3768

    
3769
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3770
                     AVFormatContext *src)
3771
{
3772
    AVPacket local_pkt;
3773

    
3774
    local_pkt = *pkt;
3775
    local_pkt.stream_index = dst_stream;
3776
    if (pkt->pts != AV_NOPTS_VALUE)
3777
        local_pkt.pts = av_rescale_q(pkt->pts,
3778
                                     src->streams[pkt->stream_index]->time_base,
3779
                                     dst->streams[dst_stream]->time_base);
3780
    if (pkt->dts != AV_NOPTS_VALUE)
3781
        local_pkt.dts = av_rescale_q(pkt->dts,
3782
                                     src->streams[pkt->stream_index]->time_base,
3783
                                     dst->streams[dst_stream]->time_base);
3784
    return av_write_frame(dst, &local_pkt);
3785
}
3786

    
3787
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3788
                        void *context)
3789
{
3790
    const char *ptr = str;
3791

    
3792
    /* Parse key=value pairs. */
3793
    for (;;) {
3794
        const char *key;
3795
        char *dest = NULL, *dest_end;
3796
        int key_len, dest_len = 0;
3797

    
3798
        /* Skip whitespace and potential commas. */
3799
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3800
            ptr++;
3801
        if (!*ptr)
3802
            break;
3803

    
3804
        key = ptr;
3805

    
3806
        if (!(ptr = strchr(key, '=')))
3807
            break;
3808
        ptr++;
3809
        key_len = ptr - key;
3810

    
3811
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3812
        dest_end = dest + dest_len - 1;
3813

    
3814
        if (*ptr == '\"') {
3815
            ptr++;
3816
            while (*ptr && *ptr != '\"') {
3817
                if (*ptr == '\\') {
3818
                    if (!ptr[1])
3819
                        break;
3820
                    if (dest && dest < dest_end)
3821
                        *dest++ = ptr[1];
3822
                    ptr += 2;
3823
                } else {
3824
                    if (dest && dest < dest_end)
3825
                        *dest++ = *ptr;
3826
                    ptr++;
3827
                }
3828
            }
3829
            if (*ptr == '\"')
3830
                ptr++;
3831
        } else {
3832
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3833
                if (dest && dest < dest_end)
3834
                    *dest++ = *ptr;
3835
        }
3836
        if (dest)
3837
            *dest = 0;
3838
    }
3839
}
3840

    
3841
int ff_find_stream_index(AVFormatContext *s, int id)
3842
{
3843
    int i;
3844
    for (i = 0; i < s->nb_streams; i++) {
3845
        if (s->streams[i]->id == id)
3846
            return i;
3847
    }
3848
    return -1;
3849
}
3850

    
3851
void ff_make_absolute_url(char *buf, int size, const char *base,
3852
                          const char *rel)
3853
{
3854
    char *sep;
3855
    /* Absolute path, relative to the current server */
3856
    if (base && strstr(base, "://") && rel[0] == '/') {
3857
        if (base != buf)
3858
            av_strlcpy(buf, base, size);
3859
        sep = strstr(buf, "://");
3860
        if (sep) {
3861
            sep += 3;
3862
            sep = strchr(sep, '/');
3863
            if (sep)
3864
                *sep = '\0';
3865
        }
3866
        av_strlcat(buf, rel, size);
3867
        return;
3868
    }
3869
    /* If rel actually is an absolute url, just copy it */
3870
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3871
        av_strlcpy(buf, rel, size);
3872
        return;
3873
    }
3874
    if (base != buf)
3875
        av_strlcpy(buf, base, size);
3876
    /* Remove the file name from the base url */
3877
    sep = strrchr(buf, '/');
3878
    if (sep)
3879
        sep[1] = '\0';
3880
    else
3881
        buf[0] = '\0';
3882
    while (av_strstart(rel, "../", NULL) && sep) {
3883
        /* Remove the path delimiter at the end */
3884
        sep[0] = '\0';
3885
        sep = strrchr(buf, '/');
3886
        /* If the next directory name to pop off is "..", break here */
3887
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3888
            /* Readd the slash we just removed */
3889
            av_strlcat(buf, "/", size);
3890
            break;
3891
        }
3892
        /* Cut off the directory name */
3893
        if (sep)
3894
            sep[1] = '\0';
3895
        else
3896
            buf[0] = '\0';
3897
        rel += 3;
3898
    }
3899
    av_strlcat(buf, rel, size);
3900
}