Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 512f973e

History | View | Annotate | Download (125 KB)

1
/*
2
 * various utility functions for use within FFmpeg
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* #define DEBUG */
23

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

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

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

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

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

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

    
66
/* fraction handling */
67

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

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

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

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

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

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

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

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

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

    
162
    if(!filename)
163
        return 0;
164

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

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

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

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

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

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

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

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

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

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

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

    
262
    return fmt;
263
}
264
#endif
265

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

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

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

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

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

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

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

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

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

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

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

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

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

    
345
    return ret;
346
}
347

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

    
363

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

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

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

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

    
406
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
407
{
408
    int score_ret;
409
    AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
410
    if(score_ret > *score_max){
411
        *score_max= score_ret;
412
        return fmt;
413
    }else
414
        return NULL;
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)
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
    int score;
438
    AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
439

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

    
455
/************************************************************/
456
/* input media file */
457

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

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

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

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

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

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

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

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

    
516
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
517

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

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

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

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

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

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

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

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

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

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

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

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

    
608
    return ret;
609
}
610

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

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

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

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

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

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

    
673
}
674

    
675
/*******************************************************/
676

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

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

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

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

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

    
702
        if (pktl) {
703
            *pkt = pktl->pkt;
704
            if(s->streams[pkt->stream_index]->request_probe <= 0){
705
                s->raw_packet_buffer = pktl->next;
706
                s->raw_packet_buffer_remaining_size += pkt->size;
707
                av_free(pktl);
708
                return 0;
709
            }
710
        }
711

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

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

    
736
        if(!pktl && st->request_probe <= 0)
737
            return ret;
738

    
739
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
740
        s->raw_packet_buffer_remaining_size -= pkt->size;
741

    
742
        if(st->request_probe>0){
743
            AVProbeData *pd = &st->probe_data;
744
            int end;
745
            av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
746
            --st->probe_packets;
747

    
748
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
749
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
750
            pd->buf_size += pkt->size;
751
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
752

    
753
            end=    s->raw_packet_buffer_remaining_size <= 0
754
                 || st->probe_packets<=0;
755

    
756
            if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
757
                int score= set_codec_from_probe_data(s, st, pd);
758
                if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
759
                    || end){
760
                    pd->buf_size=0;
761
                    av_freep(&pd->buf);
762
                    st->request_probe= -1;
763
                    if(st->codec->codec_id != CODEC_ID_NONE){
764
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
765
                    }else
766
                        av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
767
                }
768
            }
769
        }
770
    }
771
}
772

    
773
/**********************************************************/
774

    
775
/**
776
 * Get the number of samples of an audio frame. Return -1 on error.
777
 */
778
static int get_audio_frame_size(AVCodecContext *enc, int size)
779
{
780
    int frame_size;
781

    
782
    if(enc->codec_id == CODEC_ID_VORBIS)
783
        return -1;
784

    
785
    if (enc->frame_size <= 1) {
786
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
787

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

    
804

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

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

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

    
869
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
870
                                      int64_t dts, int64_t pts)
871
{
872
    AVStream *st= s->streams[stream_index];
873
    AVPacketList *pktl= s->packet_buffer;
874

    
875
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
876
        return;
877

    
878
    st->first_dts= dts - st->cur_dts;
879
    st->cur_dts= dts;
880

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

    
888
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
889
            pktl->pkt.dts += st->first_dts;
890

    
891
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
892
            st->start_time= pktl->pkt.pts;
893
    }
894
    if (st->start_time == AV_NOPTS_VALUE)
895
        st->start_time = pts;
896
}
897

    
898
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
899
{
900
    AVPacketList *pktl= s->packet_buffer;
901
    int64_t cur_dts= 0;
902

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

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

    
934
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
935
                               AVCodecParserContext *pc, AVPacket *pkt)
936
{
937
    int num, den, presentation_delayed, delay, i;
938
    int64_t offset;
939

    
940
    if (s->flags & AVFMT_FLAG_NOFILLIN)
941
        return;
942

    
943
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
944
        pkt->dts= AV_NOPTS_VALUE;
945

    
946
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
947
        //FIXME Set low_delay = 0 when has_b_frames = 1
948
        st->codec->has_b_frames = 1;
949

    
950
    /* do we have a video B-frame ? */
951
    delay= st->codec->has_b_frames;
952
    presentation_delayed = 0;
953

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

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

    
965
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
966
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
967
        pkt->dts -= 1LL<<st->pts_wrap_bits;
968
    }
969

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

    
978
    if (pkt->duration == 0) {
979
        compute_frame_duration(&num, &den, st, pc, pkt);
980
        if (den && num) {
981
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
982

    
983
            if(pkt->duration != 0 && s->packet_buffer)
984
                update_initial_durations(s, st, pkt);
985
        }
986
    }
987

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

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

    
1018
    /* This may be redundant, but it should not hurt. */
1019
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1020
        presentation_delayed = 1;
1021

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

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

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

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

    
1080
//    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);
1081

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

    
1097

    
1098
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1099
{
1100
    AVStream *st;
1101
    int len, ret, i;
1102

    
1103
    av_init_packet(pkt);
1104

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

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

    
1151
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1152
                        ff_reduce_index(s, st->index);
1153
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1154
                                           0, 0, AVINDEX_KEYFRAME);
1155
                    }
1156

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

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

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

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

    
1236
    return 0;
1237
}
1238

    
1239
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1240
{
1241
    AVPacketList *pktl;
1242
    int eof=0;
1243
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1244

    
1245
    for(;;){
1246
        pktl = s->packet_buffer;
1247
        if (pktl) {
1248
            AVPacket *next_pkt= &pktl->pkt;
1249

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

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

    
1283
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1284
                                           &s->packet_buffer_end)) < 0)
1285
                return AVERROR(ENOMEM);
1286
        }else{
1287
            assert(!s->packet_buffer);
1288
            return av_read_frame_internal(s, pkt);
1289
        }
1290
    }
1291
}
1292

    
1293
/* XXX: suppress the packet queue */
1294
static void flush_packet_queue(AVFormatContext *s)
1295
{
1296
    AVPacketList *pktl;
1297

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

    
1317
/*******************************************************/
1318
/* seek support */
1319

    
1320
int av_find_default_stream_index(AVFormatContext *s)
1321
{
1322
    int first_audio_index = -1;
1323
    int i;
1324
    AVStream *st;
1325

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

    
1339
/**
1340
 * Flush the frame reader.
1341
 */
1342
void ff_read_frame_flush(AVFormatContext *s)
1343
{
1344
    AVStream *st;
1345
    int i, j;
1346

    
1347
    flush_packet_queue(s);
1348

    
1349
    s->cur_st = NULL;
1350

    
1351
    /* for each stream, reset read state */
1352
    for(i = 0; i < s->nb_streams; i++) {
1353
        st = s->streams[i];
1354

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

    
1367
        st->probe_packets = MAX_PROBE_PACKETS;
1368

    
1369
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1370
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1371
    }
1372
}
1373

    
1374
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1375
    int i;
1376

    
1377
    for(i = 0; i < s->nb_streams; i++) {
1378
        AVStream *st = s->streams[i];
1379

    
1380
        st->cur_dts = av_rescale(timestamp,
1381
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1382
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1383
    }
1384
}
1385

    
1386
void ff_reduce_index(AVFormatContext *s, int stream_index)
1387
{
1388
    AVStream *st= s->streams[stream_index];
1389
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1390

    
1391
    if((unsigned)st->nb_index_entries >= max_entries){
1392
        int i;
1393
        for(i=0; 2*i<st->nb_index_entries; i++)
1394
            st->index_entries[i]= st->index_entries[2*i];
1395
        st->nb_index_entries= i;
1396
    }
1397
}
1398

    
1399
int ff_add_index_entry(AVIndexEntry **index_entries,
1400
                       int *nb_index_entries,
1401
                       unsigned int *index_entries_allocated_size,
1402
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1403
{
1404
    AVIndexEntry *entries, *ie;
1405
    int index;
1406

    
1407
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1408
        return -1;
1409

    
1410
    entries = av_fast_realloc(*index_entries,
1411
                              index_entries_allocated_size,
1412
                              (*nb_index_entries + 1) *
1413
                              sizeof(AVIndexEntry));
1414
    if(!entries)
1415
        return -1;
1416

    
1417
    *index_entries= entries;
1418

    
1419
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1420

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

    
1436
    ie->pos = pos;
1437
    ie->timestamp = timestamp;
1438
    ie->min_distance= distance;
1439
    ie->size= size;
1440
    ie->flags = flags;
1441

    
1442
    return index;
1443
}
1444

    
1445
int av_add_index_entry(AVStream *st,
1446
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1447
{
1448
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1449
                              &st->index_entries_allocated_size, pos,
1450
                              timestamp, size, distance, flags);
1451
}
1452

    
1453
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1454
                              int64_t wanted_timestamp, int flags)
1455
{
1456
    int a, b, m;
1457
    int64_t timestamp;
1458

    
1459
    a = - 1;
1460
    b = nb_entries;
1461

    
1462
    //optimize appending index entries at the end
1463
    if(b && entries[b-1].timestamp < wanted_timestamp)
1464
        a= b-1;
1465

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

    
1476
    if(!(flags & AVSEEK_FLAG_ANY)){
1477
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1478
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1479
        }
1480
    }
1481

    
1482
    if(m == nb_entries)
1483
        return -1;
1484
    return  m;
1485
}
1486

    
1487
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1488
                              int flags)
1489
{
1490
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1491
                                     wanted_timestamp, flags);
1492
}
1493

    
1494
#define DEBUG_SEEK
1495

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

    
1504
    if (stream_index < 0)
1505
        return -1;
1506

    
1507
#ifdef DEBUG_SEEK
1508
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1509
#endif
1510

    
1511
    ts_max=
1512
    ts_min= AV_NOPTS_VALUE;
1513
    pos_limit= -1; //gcc falsely says it may be uninitialized
1514

    
1515
    st= s->streams[stream_index];
1516
    if(st->index_entries){
1517
        AVIndexEntry *e;
1518

    
1519
        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()
1520
        index= FFMAX(index, 0);
1521
        e= &st->index_entries[index];
1522

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

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

    
1549
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1550
    if(pos<0)
1551
        return -1;
1552

    
1553
    /* do the seek */
1554
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1555
        return ret;
1556

    
1557
    av_update_cur_dts(s, st, ts);
1558

    
1559
    return 0;
1560
}
1561

    
1562
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 )){
1563
    int64_t pos, ts;
1564
    int64_t start_pos, filesize;
1565
    int no_change;
1566

    
1567
#ifdef DEBUG_SEEK
1568
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1569
#endif
1570

    
1571
    if(ts_min == AV_NOPTS_VALUE){
1572
        pos_min = s->data_offset;
1573
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1574
        if (ts_min == AV_NOPTS_VALUE)
1575
            return -1;
1576
    }
1577

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

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

    
1603
    if(ts_min > ts_max){
1604
        return -1;
1605
    }else if(ts_min == ts_max){
1606
        pos_limit= pos_min;
1607
    }
1608

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

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

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

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

    
1677
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1678
    int64_t pos_min, pos_max;
1679
#if 0
1680
    AVStream *st;
1681

1682
    if (stream_index < 0)
1683
        return -1;
1684

1685
    st= s->streams[stream_index];
1686
#endif
1687

    
1688
    pos_min = s->data_offset;
1689
    pos_max = avio_size(s->pb) - 1;
1690

    
1691
    if     (pos < pos_min) pos= pos_min;
1692
    else if(pos > pos_max) pos= pos_max;
1693

    
1694
    avio_seek(s->pb, pos, SEEK_SET);
1695

    
1696
#if 0
1697
    av_update_cur_dts(s, st, ts);
1698
#endif
1699
    return 0;
1700
}
1701

    
1702
static int av_seek_frame_generic(AVFormatContext *s,
1703
                                 int stream_index, int64_t timestamp, int flags)
1704
{
1705
    int index;
1706
    int64_t ret;
1707
    AVStream *st;
1708
    AVIndexEntry *ie;
1709

    
1710
    st = s->streams[stream_index];
1711

    
1712
    index = av_index_search_timestamp(st, timestamp, flags);
1713

    
1714
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1715
        return -1;
1716

    
1717
    if(index < 0 || index==st->nb_index_entries-1){
1718
        int i;
1719
        AVPacket pkt;
1720

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

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

    
1759
    return 0;
1760
}
1761

    
1762
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1763
{
1764
    int ret;
1765
    AVStream *st;
1766

    
1767
    ff_read_frame_flush(s);
1768

    
1769
    if(flags & AVSEEK_FLAG_BYTE)
1770
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1771

    
1772
    if(stream_index < 0){
1773
        stream_index= av_find_default_stream_index(s);
1774
        if(stream_index < 0)
1775
            return -1;
1776

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

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

    
1791
    if(s->iformat->read_timestamp)
1792
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1793
    else
1794
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1795
}
1796

    
1797
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1798
{
1799
    if(min_ts > ts || max_ts < ts)
1800
        return -1;
1801

    
1802
    ff_read_frame_flush(s);
1803

    
1804
    if (s->iformat->read_seek2)
1805
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1806

    
1807
    if(s->iformat->read_timestamp){
1808
        //try to seek via read_timestamp()
1809
    }
1810

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

    
1816
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1817
}
1818

    
1819
/*******************************************************/
1820

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

    
1831
    for(i = 0;i < ic->nb_streams; i++) {
1832
        st = ic->streams[i];
1833
        if (st->duration != AV_NOPTS_VALUE)
1834
            return 1;
1835
    }
1836
    return 0;
1837
}
1838

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

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

    
1890
static void fill_all_stream_timings(AVFormatContext *ic)
1891
{
1892
    int i;
1893
    AVStream *st;
1894

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

    
1907
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1908
{
1909
    int64_t filesize, duration;
1910
    int bit_rate, i;
1911
    AVStream *st;
1912

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

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

    
1940
#define DURATION_MAX_READ_SIZE 250000
1941
#define DURATION_MAX_RETRY 3
1942

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

    
1953
    ic->cur_st = NULL;
1954

    
1955
    /* flush packet queue */
1956
    flush_packet_queue(ic);
1957

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

    
1963
        if (st->parser) {
1964
            av_parser_close(st->parser);
1965
            st->parser= NULL;
1966
            av_free_packet(&st->cur_pkt);
1967
        }
1968
    }
1969

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

    
1979
    avio_seek(ic->pb, offset, SEEK_SET);
1980
    read_size = 0;
1981
    for(;;) {
1982
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1983
            break;
1984

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

    
2012
    fill_all_stream_timings(ic);
2013

    
2014
    avio_seek(ic->pb, old_offset, SEEK_SET);
2015
    for (i=0; i<ic->nb_streams; i++) {
2016
        st= ic->streams[i];
2017
        st->cur_dts= st->first_dts;
2018
        st->last_IP_pts = AV_NOPTS_VALUE;
2019
        st->reference_dts = AV_NOPTS_VALUE;
2020
    }
2021
}
2022

    
2023
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2024
{
2025
    int64_t file_size;
2026

    
2027
    /* get the file size, if possible */
2028
    if (ic->iformat->flags & AVFMT_NOFILE) {
2029
        file_size = 0;
2030
    } else {
2031
        file_size = avio_size(ic->pb);
2032
        if (file_size < 0)
2033
            file_size = 0;
2034
    }
2035
    ic->file_size = file_size;
2036

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

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

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

    
2096
static int has_decode_delay_been_guessed(AVStream *st)
2097
{
2098
    return st->codec->codec_id != CODEC_ID_H264 ||
2099
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2100
}
2101

    
2102
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2103
{
2104
    int16_t *samples;
2105
    AVCodec *codec;
2106
    int got_picture, data_size, ret=0;
2107
    AVFrame picture;
2108

    
2109
    if(!st->codec->codec){
2110
        codec = avcodec_find_decoder(st->codec->codec_id);
2111
        if (!codec)
2112
            return -1;
2113
        ret = avcodec_open(st->codec, codec);
2114
        if (ret < 0)
2115
            return ret;
2116
    }
2117

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

    
2142
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2143
{
2144
    while (tags->id != CODEC_ID_NONE) {
2145
        if (tags->id == id)
2146
            return tags->tag;
2147
        tags++;
2148
    }
2149
    return 0;
2150
}
2151

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

    
2166
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2167
{
2168
    int i;
2169
    for(i=0; tags && tags[i]; i++){
2170
        int tag= ff_codec_get_tag(tags[i], id);
2171
        if(tag) return tag;
2172
    }
2173
    return 0;
2174
}
2175

    
2176
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2177
{
2178
    int i;
2179
    for(i=0; tags && tags[i]; i++){
2180
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2181
        if(id!=CODEC_ID_NONE) return id;
2182
    }
2183
    return CODEC_ID_NONE;
2184
}
2185

    
2186
static void compute_chapters_end(AVFormatContext *s)
2187
{
2188
    unsigned int i, j;
2189
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2190

    
2191
    for (i = 0; i < s->nb_chapters; i++)
2192
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2193
            AVChapter *ch = s->chapters[i];
2194
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2195
                                     : INT64_MAX;
2196

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

    
2207
static int get_std_framerate(int i){
2208
    if(i<60*12) return i*1001;
2209
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2210
}
2211

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

    
2232
int av_find_stream_info(AVFormatContext *ic)
2233
{
2234
    int i, count, ret, read_size, j;
2235
    AVStream *st;
2236
    AVPacket pkt1, *pkt;
2237
    int64_t old_offset = avio_tell(ic->pb);
2238

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

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

    
2271
        /* Ensure that subtitle_header is properly set. */
2272
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2273
            && codec && !st->codec->codec)
2274
            avcodec_open(st->codec, codec);
2275

    
2276
        //try to just open decoders, in case this is enough to get parameters
2277
        if(!has_codec_parameters(st->codec)){
2278
            if (codec && !st->codec->codec)
2279
                avcodec_open(st->codec, codec);
2280
        }
2281
    }
2282

    
2283
    for (i=0; i<ic->nb_streams; i++) {
2284
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2285
    }
2286

    
2287
    count = 0;
2288
    read_size = 0;
2289
    for(;;) {
2290
        if(url_interrupt_cb()){
2291
            ret= AVERROR_EXIT;
2292
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2293
            break;
2294
        }
2295

    
2296
        /* check if one codec still needs to be handled */
2297
        for(i=0;i<ic->nb_streams;i++) {
2298
            int fps_analyze_framecount = 20;
2299

    
2300
            st = ic->streams[i];
2301
            if (!has_codec_parameters(st->codec))
2302
                break;
2303
            /* if the timebase is coarse (like the usual millisecond precision
2304
               of mkv), we need to analyze more frames to reliably arrive at
2305
               the correct fps */
2306
            if (av_q2d(st->time_base) > 0.0005)
2307
                fps_analyze_framecount *= 2;
2308
            /* variable fps and no guess at the real fps */
2309
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2310
               && st->info->duration_count < fps_analyze_framecount
2311
               && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2312
                break;
2313
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2314
                break;
2315
            if(st->first_dts == AV_NOPTS_VALUE)
2316
                break;
2317
        }
2318
        if (i == ic->nb_streams) {
2319
            /* NOTE: if the format has no header, then we need to read
2320
               some packets to get most of the streams, so we cannot
2321
               stop here */
2322
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2323
                /* if we found the info for all the codecs, we can stop */
2324
                ret = count;
2325
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2326
                break;
2327
            }
2328
        }
2329
        /* we did not get all the codec info, but we read too much data */
2330
        if (read_size >= ic->probesize) {
2331
            ret = count;
2332
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2333
            break;
2334
        }
2335

    
2336
        /* NOTE: a new stream can be added there if no header in file
2337
           (AVFMTCTX_NOHEADER) */
2338
        ret = av_read_frame_internal(ic, &pkt1);
2339
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2340
            /* EOF or error */
2341
            ret = -1; /* we could not have all the codec parameters before EOF */
2342
            for(i=0;i<ic->nb_streams;i++) {
2343
                st = ic->streams[i];
2344
                if (!has_codec_parameters(st->codec)){
2345
                    char buf[256];
2346
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2347
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2348
                } else {
2349
                    ret = 0;
2350
                }
2351
            }
2352
            break;
2353
        }
2354

    
2355
        if (ret == AVERROR(EAGAIN))
2356
            continue;
2357

    
2358
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2359
        if ((ret = av_dup_packet(pkt)) < 0)
2360
            goto find_stream_info_err;
2361

    
2362
        read_size += pkt->size;
2363

    
2364
        st = ic->streams[pkt->stream_index];
2365
        if (st->codec_info_nb_frames>1) {
2366
            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) {
2367
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2368
                break;
2369
            }
2370
            st->info->codec_info_duration += pkt->duration;
2371
        }
2372
        {
2373
            int64_t last = st->info->last_dts;
2374
            int64_t duration= pkt->dts - last;
2375

    
2376
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2377
                double dur= duration * av_q2d(st->time_base);
2378

    
2379
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2380
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2381
                if (st->info->duration_count < 2)
2382
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2383
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2384
                    int framerate= get_std_framerate(i);
2385
                    int ticks= lrintf(dur*framerate/(1001*12));
2386
                    double error= dur - ticks*1001*12/(double)framerate;
2387
                    st->info->duration_error[i] += error*error;
2388
                }
2389
                st->info->duration_count++;
2390
                // ignore the first 4 values, they might have some random jitter
2391
                if (st->info->duration_count > 3)
2392
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2393
            }
2394
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2395
                st->info->last_dts = pkt->dts;
2396
        }
2397
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2398
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2399
            if(i){
2400
                st->codec->extradata_size= i;
2401
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2402
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2403
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2404
            }
2405
        }
2406

    
2407
        /* if still no information, we try to open the codec and to
2408
           decompress the frame. We try to avoid that in most cases as
2409
           it takes longer and uses more memory. For MPEG-4, we need to
2410
           decompress for QuickTime. */
2411
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2412
            try_decode_frame(st, pkt);
2413

    
2414
        st->codec_info_nb_frames++;
2415
        count++;
2416
    }
2417

    
2418
    // close codecs which were opened in try_decode_frame()
2419
    for(i=0;i<ic->nb_streams;i++) {
2420
        st = ic->streams[i];
2421
        if(st->codec->codec)
2422
            avcodec_close(st->codec);
2423
    }
2424
    for(i=0;i<ic->nb_streams;i++) {
2425
        st = ic->streams[i];
2426
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2427
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2428
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2429
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2430
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2431
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2432
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2433

    
2434
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2435
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2436
            // ipmovie.c produces.
2437
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2438
                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);
2439
            if (st->info->duration_count && !st->r_frame_rate.num
2440
               && tb_unreliable(st->codec) /*&&
2441
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2442
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2443
                int num = 0;
2444
                double best_error= 2*av_q2d(st->time_base);
2445
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2446

    
2447
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2448
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2449
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2450
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2451
                    if(error < best_error){
2452
                        best_error= error;
2453
                        num = get_std_framerate(j);
2454
                    }
2455
                }
2456
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2457
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2458
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2459
            }
2460

    
2461
            if (!st->r_frame_rate.num){
2462
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2463
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2464
                    st->r_frame_rate.num = st->codec->time_base.den;
2465
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2466
                }else{
2467
                    st->r_frame_rate.num = st->time_base.den;
2468
                    st->r_frame_rate.den = st->time_base.num;
2469
                }
2470
            }
2471
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2472
            if(!st->codec->bits_per_coded_sample)
2473
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2474
            // set stream disposition based on audio service type
2475
            switch (st->codec->audio_service_type) {
2476
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2477
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2478
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2479
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2480
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2481
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2482
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2483
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2484
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2485
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2486
            }
2487
        }
2488
    }
2489

    
2490
    av_estimate_timings(ic, old_offset);
2491

    
2492
    compute_chapters_end(ic);
2493

    
2494
#if 0
2495
    /* correct DTS for B-frame streams with no timestamps */
2496
    for(i=0;i<ic->nb_streams;i++) {
2497
        st = ic->streams[i];
2498
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2499
            if(b-frames){
2500
                ppktl = &ic->packet_buffer;
2501
                while(ppkt1){
2502
                    if(ppkt1->stream_index != i)
2503
                        continue;
2504
                    if(ppkt1->pkt->dts < 0)
2505
                        break;
2506
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2507
                        break;
2508
                    ppkt1->pkt->dts -= delta;
2509
                    ppkt1= ppkt1->next;
2510
                }
2511
                if(ppkt1)
2512
                    continue;
2513
                st->cur_dts -= delta;
2514
            }
2515
        }
2516
    }
2517
#endif
2518

    
2519
 find_stream_info_err:
2520
    for (i=0; i < ic->nb_streams; i++)
2521
        av_freep(&ic->streams[i]->info);
2522
    return ret;
2523
}
2524

    
2525
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2526
{
2527
    int i, j;
2528

    
2529
    for (i = 0; i < ic->nb_programs; i++)
2530
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2531
            if (ic->programs[i]->stream_index[j] == s)
2532
                return ic->programs[i];
2533
    return NULL;
2534
}
2535

    
2536
int av_find_best_stream(AVFormatContext *ic,
2537
                        enum AVMediaType type,
2538
                        int wanted_stream_nb,
2539
                        int related_stream,
2540
                        AVCodec **decoder_ret,
2541
                        int flags)
2542
{
2543
    int i, nb_streams = ic->nb_streams;
2544
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2545
    unsigned *program = NULL;
2546
    AVCodec *decoder = NULL, *best_decoder = NULL;
2547

    
2548
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2549
        AVProgram *p = find_program_from_stream(ic, related_stream);
2550
        if (p) {
2551
            program = p->stream_index;
2552
            nb_streams = p->nb_stream_indexes;
2553
        }
2554
    }
2555
    for (i = 0; i < nb_streams; i++) {
2556
        int real_stream_index = program ? program[i] : i;
2557
        AVStream *st = ic->streams[real_stream_index];
2558
        AVCodecContext *avctx = st->codec;
2559
        if (avctx->codec_type != type)
2560
            continue;
2561
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2562
            continue;
2563
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2564
            continue;
2565
        if (decoder_ret) {
2566
            decoder = avcodec_find_decoder(st->codec->codec_id);
2567
            if (!decoder) {
2568
                if (ret < 0)
2569
                    ret = AVERROR_DECODER_NOT_FOUND;
2570
                continue;
2571
            }
2572
        }
2573
        if (best_count >= st->codec_info_nb_frames)
2574
            continue;
2575
        best_count = st->codec_info_nb_frames;
2576
        ret = real_stream_index;
2577
        best_decoder = decoder;
2578
        if (program && i == nb_streams - 1 && ret < 0) {
2579
            program = NULL;
2580
            nb_streams = ic->nb_streams;
2581
            i = 0; /* no related stream found, try again with everything */
2582
        }
2583
    }
2584
    if (decoder_ret)
2585
        *decoder_ret = best_decoder;
2586
    return ret;
2587
}
2588

    
2589
/*******************************************************/
2590

    
2591
int av_read_play(AVFormatContext *s)
2592
{
2593
    if (s->iformat->read_play)
2594
        return s->iformat->read_play(s);
2595
    if (s->pb)
2596
        return ffio_read_pause(s->pb, 0);
2597
    return AVERROR(ENOSYS);
2598
}
2599

    
2600
int av_read_pause(AVFormatContext *s)
2601
{
2602
    if (s->iformat->read_pause)
2603
        return s->iformat->read_pause(s);
2604
    if (s->pb)
2605
        return ffio_read_pause(s->pb, 1);
2606
    return AVERROR(ENOSYS);
2607
}
2608

    
2609
void av_close_input_stream(AVFormatContext *s)
2610
{
2611
    flush_packet_queue(s);
2612
    if (s->iformat->read_close)
2613
        s->iformat->read_close(s);
2614
    avformat_free_context(s);
2615
}
2616

    
2617
void avformat_free_context(AVFormatContext *s)
2618
{
2619
    int i;
2620
    AVStream *st;
2621

    
2622
    for(i=0;i<s->nb_streams;i++) {
2623
        /* free all data in a stream component */
2624
        st = s->streams[i];
2625
        if (st->parser) {
2626
            av_parser_close(st->parser);
2627
            av_free_packet(&st->cur_pkt);
2628
        }
2629
        av_metadata_free(&st->metadata);
2630
        av_free(st->index_entries);
2631
        av_free(st->codec->extradata);
2632
        av_free(st->codec->subtitle_header);
2633
        av_free(st->codec);
2634
#if FF_API_OLD_METADATA
2635
        av_free(st->filename);
2636
#endif
2637
        av_free(st->priv_data);
2638
        av_free(st->info);
2639
        av_free(st);
2640
    }
2641
    for(i=s->nb_programs-1; i>=0; i--) {
2642
#if FF_API_OLD_METADATA
2643
        av_freep(&s->programs[i]->provider_name);
2644
        av_freep(&s->programs[i]->name);
2645
#endif
2646
        av_metadata_free(&s->programs[i]->metadata);
2647
        av_freep(&s->programs[i]->stream_index);
2648
        av_freep(&s->programs[i]);
2649
    }
2650
    av_freep(&s->programs);
2651
    av_freep(&s->priv_data);
2652
    while(s->nb_chapters--) {
2653
#if FF_API_OLD_METADATA
2654
        av_free(s->chapters[s->nb_chapters]->title);
2655
#endif
2656
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2657
        av_free(s->chapters[s->nb_chapters]);
2658
    }
2659
    av_freep(&s->chapters);
2660
    av_metadata_free(&s->metadata);
2661
    av_freep(&s->key);
2662
    av_free(s);
2663
}
2664

    
2665
void av_close_input_file(AVFormatContext *s)
2666
{
2667
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2668
    av_close_input_stream(s);
2669
    if (pb)
2670
        avio_close(pb);
2671
}
2672

    
2673
AVStream *av_new_stream(AVFormatContext *s, int id)
2674
{
2675
    AVStream *st;
2676
    int i;
2677

    
2678
#if FF_API_MAX_STREAMS
2679
    if (s->nb_streams >= MAX_STREAMS){
2680
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2681
        return NULL;
2682
    }
2683
#else
2684
    AVStream **streams;
2685

    
2686
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2687
        return NULL;
2688
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2689
    if (!streams)
2690
        return NULL;
2691
    s->streams = streams;
2692
#endif
2693

    
2694
    st = av_mallocz(sizeof(AVStream));
2695
    if (!st)
2696
        return NULL;
2697
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2698
        av_free(st);
2699
        return NULL;
2700
    }
2701

    
2702
    st->codec= avcodec_alloc_context();
2703
    if (s->iformat) {
2704
        /* no default bitrate if decoding */
2705
        st->codec->bit_rate = 0;
2706
    }
2707
    st->index = s->nb_streams;
2708
    st->id = id;
2709
    st->start_time = AV_NOPTS_VALUE;
2710
    st->duration = AV_NOPTS_VALUE;
2711
        /* we set the current DTS to 0 so that formats without any timestamps
2712
           but durations get some timestamps, formats with some unknown
2713
           timestamps have their first few packets buffered and the
2714
           timestamps corrected before they are returned to the user */
2715
    st->cur_dts = 0;
2716
    st->first_dts = AV_NOPTS_VALUE;
2717
    st->probe_packets = MAX_PROBE_PACKETS;
2718

    
2719
    /* default pts setting is MPEG-like */
2720
    av_set_pts_info(st, 33, 1, 90000);
2721
    st->last_IP_pts = AV_NOPTS_VALUE;
2722
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2723
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2724
    st->reference_dts = AV_NOPTS_VALUE;
2725

    
2726
    st->sample_aspect_ratio = (AVRational){0,1};
2727

    
2728
    s->streams[s->nb_streams++] = st;
2729
    return st;
2730
}
2731

    
2732
AVProgram *av_new_program(AVFormatContext *ac, int id)
2733
{
2734
    AVProgram *program=NULL;
2735
    int i;
2736

    
2737
#ifdef DEBUG_SI
2738
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2739
#endif
2740

    
2741
    for(i=0; i<ac->nb_programs; i++)
2742
        if(ac->programs[i]->id == id)
2743
            program = ac->programs[i];
2744

    
2745
    if(!program){
2746
        program = av_mallocz(sizeof(AVProgram));
2747
        if (!program)
2748
            return NULL;
2749
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2750
        program->discard = AVDISCARD_NONE;
2751
    }
2752
    program->id = id;
2753

    
2754
    return program;
2755
}
2756

    
2757
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2758
{
2759
    AVChapter *chapter = NULL;
2760
    int i;
2761

    
2762
    for(i=0; i<s->nb_chapters; i++)
2763
        if(s->chapters[i]->id == id)
2764
            chapter = s->chapters[i];
2765

    
2766
    if(!chapter){
2767
        chapter= av_mallocz(sizeof(AVChapter));
2768
        if(!chapter)
2769
            return NULL;
2770
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2771
    }
2772
#if FF_API_OLD_METADATA
2773
    av_free(chapter->title);
2774
#endif
2775
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2776
    chapter->id    = id;
2777
    chapter->time_base= time_base;
2778
    chapter->start = start;
2779
    chapter->end   = end;
2780

    
2781
    return chapter;
2782
}
2783

    
2784
/************************************************************/
2785
/* output media file */
2786

    
2787
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2788
{
2789
    int ret;
2790

    
2791
    if (s->oformat->priv_data_size > 0) {
2792
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2793
        if (!s->priv_data)
2794
            return AVERROR(ENOMEM);
2795
        if (s->oformat->priv_class) {
2796
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2797
            av_opt_set_defaults(s->priv_data);
2798
        }
2799
    } else
2800
        s->priv_data = NULL;
2801

    
2802
    if (s->oformat->set_parameters) {
2803
        ret = s->oformat->set_parameters(s, ap);
2804
        if (ret < 0)
2805
            return ret;
2806
    }
2807
    return 0;
2808
}
2809

    
2810
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2811
{
2812
    const AVCodecTag *avctag;
2813
    int n;
2814
    enum CodecID id = CODEC_ID_NONE;
2815
    unsigned int tag = 0;
2816

    
2817
    /**
2818
     * Check that tag + id is in the table
2819
     * If neither is in the table -> OK
2820
     * If tag is in the table with another id -> FAIL
2821
     * If id is in the table with another tag -> FAIL unless strict < normal
2822
     */
2823
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2824
        avctag = s->oformat->codec_tag[n];
2825
        while (avctag->id != CODEC_ID_NONE) {
2826
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2827
                id = avctag->id;
2828
                if (id == st->codec->codec_id)
2829
                    return 1;
2830
            }
2831
            if (avctag->id == st->codec->codec_id)
2832
                tag = avctag->tag;
2833
            avctag++;
2834
        }
2835
    }
2836
    if (id != CODEC_ID_NONE)
2837
        return 0;
2838
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2839
        return 0;
2840
    return 1;
2841
}
2842

    
2843
int av_write_header(AVFormatContext *s)
2844
{
2845
    int ret, i;
2846
    AVStream *st;
2847

    
2848
    // some sanity checks
2849
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2850
        av_log(s, AV_LOG_ERROR, "no streams\n");
2851
        return AVERROR(EINVAL);
2852
    }
2853

    
2854
    for(i=0;i<s->nb_streams;i++) {
2855
        st = s->streams[i];
2856

    
2857
        switch (st->codec->codec_type) {
2858
        case AVMEDIA_TYPE_AUDIO:
2859
            if(st->codec->sample_rate<=0){
2860
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2861
                return AVERROR(EINVAL);
2862
            }
2863
            if(!st->codec->block_align)
2864
                st->codec->block_align = st->codec->channels *
2865
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2866
            break;
2867
        case AVMEDIA_TYPE_VIDEO:
2868
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2869
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2870
                return AVERROR(EINVAL);
2871
            }
2872
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2873
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2874
                return AVERROR(EINVAL);
2875
            }
2876
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2877
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2878
                return AVERROR(EINVAL);
2879
            }
2880
            break;
2881
        }
2882

    
2883
        if(s->oformat->codec_tag){
2884
            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)){
2885
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2886
                st->codec->codec_tag= 0;
2887
            }
2888
            if(st->codec->codec_tag){
2889
                if (!validate_codec_tag(s, st)) {
2890
                    char tagbuf[32];
2891
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2892
                    av_log(s, AV_LOG_ERROR,
2893
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2894
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2895
                    return AVERROR_INVALIDDATA;
2896
                }
2897
            }else
2898
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2899
        }
2900

    
2901
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2902
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2903
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2904
    }
2905

    
2906
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2907
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2908
        if (!s->priv_data)
2909
            return AVERROR(ENOMEM);
2910
    }
2911

    
2912
#if FF_API_OLD_METADATA
2913
    ff_metadata_mux_compat(s);
2914
#endif
2915

    
2916
    /* set muxer identification string */
2917
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2918
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2919
    }
2920

    
2921
    if(s->oformat->write_header){
2922
        ret = s->oformat->write_header(s);
2923
        if (ret < 0)
2924
            return ret;
2925
    }
2926

    
2927
    /* init PTS generation */
2928
    for(i=0;i<s->nb_streams;i++) {
2929
        int64_t den = AV_NOPTS_VALUE;
2930
        st = s->streams[i];
2931

    
2932
        switch (st->codec->codec_type) {
2933
        case AVMEDIA_TYPE_AUDIO:
2934
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2935
            break;
2936
        case AVMEDIA_TYPE_VIDEO:
2937
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2938
            break;
2939
        default:
2940
            break;
2941
        }
2942
        if (den != AV_NOPTS_VALUE) {
2943
            if (den <= 0)
2944
                return AVERROR_INVALIDDATA;
2945
            av_frac_init(&st->pts, 0, 0, den);
2946
        }
2947
    }
2948
    return 0;
2949
}
2950

    
2951
//FIXME merge with compute_pkt_fields
2952
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2953
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2954
    int num, den, frame_size, i;
2955

    
2956
    av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2957
            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2958

    
2959
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2960
        return AVERROR(EINVAL);*/
2961

    
2962
    /* duration field */
2963
    if (pkt->duration == 0) {
2964
        compute_frame_duration(&num, &den, st, NULL, pkt);
2965
        if (den && num) {
2966
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2967
        }
2968
    }
2969

    
2970
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2971
        pkt->pts= pkt->dts;
2972

    
2973
    //XXX/FIXME this is a temporary hack until all encoders output pts
2974
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2975
        pkt->dts=
2976
//        pkt->pts= st->cur_dts;
2977
        pkt->pts= st->pts.val;
2978
    }
2979

    
2980
    //calculate dts from pts
2981
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2982
        st->pts_buffer[0]= pkt->pts;
2983
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2984
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2985
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2986
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2987

    
2988
        pkt->dts= st->pts_buffer[0];
2989
    }
2990

    
2991
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2992
        av_log(s, AV_LOG_ERROR,
2993
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2994
               st->index, st->cur_dts, pkt->dts);
2995
        return AVERROR(EINVAL);
2996
    }
2997
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2998
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2999
        return AVERROR(EINVAL);
3000
    }
3001

    
3002
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3003
    st->cur_dts= pkt->dts;
3004
    st->pts.val= pkt->dts;
3005

    
3006
    /* update pts */
3007
    switch (st->codec->codec_type) {
3008
    case AVMEDIA_TYPE_AUDIO:
3009
        frame_size = get_audio_frame_size(st->codec, pkt->size);
3010

    
3011
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
3012
           likely equal to the encoder delay, but it would be better if we
3013
           had the real timestamps from the encoder */
3014
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3015
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3016
        }
3017
        break;
3018
    case AVMEDIA_TYPE_VIDEO:
3019
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3020
        break;
3021
    default:
3022
        break;
3023
    }
3024
    return 0;
3025
}
3026

    
3027
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3028
{
3029
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3030

    
3031
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3032
        return ret;
3033

    
3034
    ret= s->oformat->write_packet(s, pkt);
3035
    if(!ret)
3036
        ret= url_ferror(s->pb);
3037
    return ret;
3038
}
3039

    
3040
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3041
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3042
{
3043
    AVPacketList **next_point, *this_pktl;
3044

    
3045
    this_pktl = av_mallocz(sizeof(AVPacketList));
3046
    this_pktl->pkt= *pkt;
3047
    pkt->destruct= NULL;             // do not free original but only the copy
3048
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3049

    
3050
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3051
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3052
    }else
3053
        next_point = &s->packet_buffer;
3054

    
3055
    if(*next_point){
3056
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3057
            while(!compare(s, &(*next_point)->pkt, pkt)){
3058
                next_point= &(*next_point)->next;
3059
            }
3060
            goto next_non_null;
3061
        }else{
3062
            next_point = &(s->packet_buffer_end->next);
3063
        }
3064
    }
3065
    assert(!*next_point);
3066

    
3067
    s->packet_buffer_end= this_pktl;
3068
next_non_null:
3069

    
3070
    this_pktl->next= *next_point;
3071

    
3072
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3073
    *next_point= this_pktl;
3074
}
3075

    
3076
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3077
{
3078
    AVStream *st = s->streams[ pkt ->stream_index];
3079
    AVStream *st2= s->streams[ next->stream_index];
3080
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3081
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3082
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3083
}
3084

    
3085
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3086
    AVPacketList *pktl;
3087
    int stream_count=0;
3088
    int i;
3089

    
3090
    if(pkt){
3091
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3092
    }
3093

    
3094
    for(i=0; i < s->nb_streams; i++)
3095
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3096

    
3097
    if(stream_count && (s->nb_streams == stream_count || flush)){
3098
        pktl= s->packet_buffer;
3099
        *out= pktl->pkt;
3100

    
3101
        s->packet_buffer= pktl->next;
3102
        if(!s->packet_buffer)
3103
            s->packet_buffer_end= NULL;
3104

    
3105
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3106
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3107
        av_freep(&pktl);
3108
        return 1;
3109
    }else{
3110
        av_init_packet(out);
3111
        return 0;
3112
    }
3113
}
3114

    
3115
/**
3116
 * Interleave an AVPacket correctly so it can be muxed.
3117
 * @param out the interleaved packet will be output here
3118
 * @param in the input packet
3119
 * @param flush 1 if no further packets are available as input and all
3120
 *              remaining packets should be output
3121
 * @return 1 if a packet was output, 0 if no packet could be output,
3122
 *         < 0 if an error occurred
3123
 */
3124
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3125
    if(s->oformat->interleave_packet)
3126
        return s->oformat->interleave_packet(s, out, in, flush);
3127
    else
3128
        return av_interleave_packet_per_dts(s, out, in, flush);
3129
}
3130

    
3131
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3132
    AVStream *st= s->streams[ pkt->stream_index];
3133
    int ret;
3134

    
3135
    //FIXME/XXX/HACK drop zero sized packets
3136
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3137
        return 0;
3138

    
3139
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3140
            pkt->size, pkt->dts, pkt->pts);
3141
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3142
        return ret;
3143

    
3144
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3145
        return AVERROR(EINVAL);
3146

    
3147
    for(;;){
3148
        AVPacket opkt;
3149
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3150
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3151
            return ret;
3152

    
3153
        ret= s->oformat->write_packet(s, &opkt);
3154

    
3155
        av_free_packet(&opkt);
3156
        pkt= NULL;
3157

    
3158
        if(ret<0)
3159
            return ret;
3160
        if(url_ferror(s->pb))
3161
            return url_ferror(s->pb);
3162
    }
3163
}
3164

    
3165
int av_write_trailer(AVFormatContext *s)
3166
{
3167
    int ret, i;
3168

    
3169
    for(;;){
3170
        AVPacket pkt;
3171
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3172
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3173
            goto fail;
3174
        if(!ret)
3175
            break;
3176

    
3177
        ret= s->oformat->write_packet(s, &pkt);
3178

    
3179
        av_free_packet(&pkt);
3180

    
3181
        if(ret<0)
3182
            goto fail;
3183
        if(url_ferror(s->pb))
3184
            goto fail;
3185
    }
3186

    
3187
    if(s->oformat->write_trailer)
3188
        ret = s->oformat->write_trailer(s);
3189
fail:
3190
    if(ret == 0)
3191
       ret=url_ferror(s->pb);
3192
    for(i=0;i<s->nb_streams;i++) {
3193
        av_freep(&s->streams[i]->priv_data);
3194
        av_freep(&s->streams[i]->index_entries);
3195
    }
3196
    av_freep(&s->priv_data);
3197
    return ret;
3198
}
3199

    
3200
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3201
{
3202
    int i, j;
3203
    AVProgram *program=NULL;
3204
    void *tmp;
3205

    
3206
    if (idx >= ac->nb_streams) {
3207
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3208
        return;
3209
    }
3210

    
3211
    for(i=0; i<ac->nb_programs; i++){
3212
        if(ac->programs[i]->id != progid)
3213
            continue;
3214
        program = ac->programs[i];
3215
        for(j=0; j<program->nb_stream_indexes; j++)
3216
            if(program->stream_index[j] == idx)
3217
                return;
3218

    
3219
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3220
        if(!tmp)
3221
            return;
3222
        program->stream_index = tmp;
3223
        program->stream_index[program->nb_stream_indexes++] = idx;
3224
        return;
3225
    }
3226
}
3227

    
3228
static void print_fps(double d, const char *postfix){
3229
    uint64_t v= lrintf(d*100);
3230
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3231
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3232
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3233
}
3234

    
3235
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3236
{
3237
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3238
        AVMetadataTag *tag=NULL;
3239

    
3240
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3241
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3242
            if(strcmp("language", tag->key))
3243
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3244
        }
3245
    }
3246
}
3247

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

    
3311
#if FF_API_DUMP_FORMAT
3312
void dump_format(AVFormatContext *ic,
3313
                 int index,
3314
                 const char *url,
3315
                 int is_output)
3316
{
3317
    av_dump_format(ic, index, url, is_output);
3318
}
3319
#endif
3320

    
3321
void av_dump_format(AVFormatContext *ic,
3322
                    int index,
3323
                    const char *url,
3324
                    int is_output)
3325
{
3326
    int i;
3327
    uint8_t *printed = av_mallocz(ic->nb_streams);
3328
    if (ic->nb_streams && !printed)
3329
        return;
3330

    
3331
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3332
            is_output ? "Output" : "Input",
3333
            index,
3334
            is_output ? ic->oformat->name : ic->iformat->name,
3335
            is_output ? "to" : "from", url);
3336
    dump_metadata(NULL, ic->metadata, "  ");
3337
    if (!is_output) {
3338
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3339
        if (ic->duration != AV_NOPTS_VALUE) {
3340
            int hours, mins, secs, us;
3341
            secs = ic->duration / AV_TIME_BASE;
3342
            us = ic->duration % AV_TIME_BASE;
3343
            mins = secs / 60;
3344
            secs %= 60;
3345
            hours = mins / 60;
3346
            mins %= 60;
3347
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3348
                   (100 * us) / AV_TIME_BASE);
3349
        } else {
3350
            av_log(NULL, AV_LOG_INFO, "N/A");
3351
        }
3352
        if (ic->start_time != AV_NOPTS_VALUE) {
3353
            int secs, us;
3354
            av_log(NULL, AV_LOG_INFO, ", start: ");
3355
            secs = ic->start_time / AV_TIME_BASE;
3356
            us = abs(ic->start_time % AV_TIME_BASE);
3357
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3358
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3359
        }
3360
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3361
        if (ic->bit_rate) {
3362
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3363
        } else {
3364
            av_log(NULL, AV_LOG_INFO, "N/A");
3365
        }
3366
        av_log(NULL, AV_LOG_INFO, "\n");
3367
    }
3368
    for (i = 0; i < ic->nb_chapters; i++) {
3369
        AVChapter *ch = ic->chapters[i];
3370
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3371
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3372
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3373

    
3374
        dump_metadata(NULL, ch->metadata, "    ");
3375
    }
3376
    if(ic->nb_programs) {
3377
        int j, k, total = 0;
3378
        for(j=0; j<ic->nb_programs; j++) {
3379
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3380
                                                  "name", NULL, 0);
3381
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3382
                   name ? name->value : "");
3383
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3384
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3385
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3386
                printed[ic->programs[j]->stream_index[k]] = 1;
3387
            }
3388
            total += ic->programs[j]->nb_stream_indexes;
3389
        }
3390
        if (total < ic->nb_streams)
3391
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3392
    }
3393
    for(i=0;i<ic->nb_streams;i++)
3394
        if (!printed[i])
3395
            dump_stream_format(ic, i, index, is_output);
3396

    
3397
    av_free(printed);
3398
}
3399

    
3400
#if FF_API_PARSE_FRAME_PARAM
3401
#include "libavutil/parseutils.h"
3402

    
3403
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3404
{
3405
    return av_parse_video_size(width_ptr, height_ptr, str);
3406
}
3407

    
3408
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3409
{
3410
    AVRational frame_rate;
3411
    int ret = av_parse_video_rate(&frame_rate, arg);
3412
    *frame_rate_num= frame_rate.num;
3413
    *frame_rate_den= frame_rate.den;
3414
    return ret;
3415
}
3416
#endif
3417

    
3418
int64_t av_gettime(void)
3419
{
3420
    struct timeval tv;
3421
    gettimeofday(&tv,NULL);
3422
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3423
}
3424

    
3425
uint64_t ff_ntp_time(void)
3426
{
3427
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3428
}
3429

    
3430
#if FF_API_PARSE_DATE
3431
#include "libavutil/parseutils.h"
3432

    
3433
int64_t parse_date(const char *timestr, int duration)
3434
{
3435
    int64_t timeval;
3436
    av_parse_time(&timeval, timestr, duration);
3437
    return timeval;
3438
}
3439
#endif
3440

    
3441
#if FF_API_FIND_INFO_TAG
3442
#include "libavutil/parseutils.h"
3443

    
3444
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3445
{
3446
    return av_find_info_tag(arg, arg_size, tag1, info);
3447
}
3448
#endif
3449

    
3450
int av_get_frame_filename(char *buf, int buf_size,
3451
                          const char *path, int number)
3452
{
3453
    const char *p;
3454
    char *q, buf1[20], c;
3455
    int nd, len, percentd_found;
3456

    
3457
    q = buf;
3458
    p = path;
3459
    percentd_found = 0;
3460
    for(;;) {
3461
        c = *p++;
3462
        if (c == '\0')
3463
            break;
3464
        if (c == '%') {
3465
            do {
3466
                nd = 0;
3467
                while (isdigit(*p)) {
3468
                    nd = nd * 10 + *p++ - '0';
3469
                }
3470
                c = *p++;
3471
            } while (isdigit(c));
3472

    
3473
            switch(c) {
3474
            case '%':
3475
                goto addchar;
3476
            case 'd':
3477
                if (percentd_found)
3478
                    goto fail;
3479
                percentd_found = 1;
3480
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3481
                len = strlen(buf1);
3482
                if ((q - buf + len) > buf_size - 1)
3483
                    goto fail;
3484
                memcpy(q, buf1, len);
3485
                q += len;
3486
                break;
3487
            default:
3488
                goto fail;
3489
            }
3490
        } else {
3491
        addchar:
3492
            if ((q - buf) < buf_size - 1)
3493
                *q++ = c;
3494
        }
3495
    }
3496
    if (!percentd_found)
3497
        goto fail;
3498
    *q = '\0';
3499
    return 0;
3500
 fail:
3501
    *q = '\0';
3502
    return -1;
3503
}
3504

    
3505
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3506
{
3507
    int len, i, j, c;
3508
#undef fprintf
3509
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3510

    
3511
    for(i=0;i<size;i+=16) {
3512
        len = size - i;
3513
        if (len > 16)
3514
            len = 16;
3515
        PRINT("%08x ", i);
3516
        for(j=0;j<16;j++) {
3517
            if (j < len)
3518
                PRINT(" %02x", buf[i+j]);
3519
            else
3520
                PRINT("   ");
3521
        }
3522
        PRINT(" ");
3523
        for(j=0;j<len;j++) {
3524
            c = buf[i+j];
3525
            if (c < ' ' || c > '~')
3526
                c = '.';
3527
            PRINT("%c", c);
3528
        }
3529
        PRINT("\n");
3530
    }
3531
#undef PRINT
3532
}
3533

    
3534
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3535
{
3536
    hex_dump_internal(NULL, f, 0, buf, size);
3537
}
3538

    
3539
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3540
{
3541
    hex_dump_internal(avcl, NULL, level, buf, size);
3542
}
3543

    
3544
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3545
{
3546
#undef fprintf
3547
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3548
    PRINT("stream #%d:\n", pkt->stream_index);
3549
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3550
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3551
    /* DTS is _always_ valid after av_read_frame() */
3552
    PRINT("  dts=");
3553
    if (pkt->dts == AV_NOPTS_VALUE)
3554
        PRINT("N/A");
3555
    else
3556
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3557
    /* PTS may not be known if B-frames are present. */
3558
    PRINT("  pts=");
3559
    if (pkt->pts == AV_NOPTS_VALUE)
3560
        PRINT("N/A");
3561
    else
3562
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3563
    PRINT("\n");
3564
    PRINT("  size=%d\n", pkt->size);
3565
#undef PRINT
3566
    if (dump_payload)
3567
        av_hex_dump(f, pkt->data, pkt->size);
3568
}
3569

    
3570
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3571
{
3572
    AVRational tb = { 1, AV_TIME_BASE };
3573
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3574
}
3575

    
3576
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3577
{
3578
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3579
}
3580

    
3581
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3582
{
3583
    AVRational tb = { 1, AV_TIME_BASE };
3584
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3585
}
3586

    
3587
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3588
                      AVStream *st)
3589
{
3590
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3591
}
3592

    
3593
#if FF_API_URL_SPLIT
3594
attribute_deprecated
3595
void ff_url_split(char *proto, int proto_size,
3596
                  char *authorization, int authorization_size,
3597
                  char *hostname, int hostname_size,
3598
                  int *port_ptr,
3599
                  char *path, int path_size,
3600
                  const char *url)
3601
{
3602
    av_url_split(proto, proto_size,
3603
                 authorization, authorization_size,
3604
                 hostname, hostname_size,
3605
                 port_ptr,
3606
                 path, path_size,
3607
                 url);
3608
}
3609
#endif
3610

    
3611
void av_url_split(char *proto, int proto_size,
3612
                  char *authorization, int authorization_size,
3613
                  char *hostname, int hostname_size,
3614
                  int *port_ptr,
3615
                  char *path, int path_size,
3616
                  const char *url)
3617
{
3618
    const char *p, *ls, *at, *col, *brk;
3619

    
3620
    if (port_ptr)               *port_ptr = -1;
3621
    if (proto_size > 0)         proto[0] = 0;
3622
    if (authorization_size > 0) authorization[0] = 0;
3623
    if (hostname_size > 0)      hostname[0] = 0;
3624
    if (path_size > 0)          path[0] = 0;
3625

    
3626
    /* parse protocol */
3627
    if ((p = strchr(url, ':'))) {
3628
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3629
        p++; /* skip ':' */
3630
        if (*p == '/') p++;
3631
        if (*p == '/') p++;
3632
    } else {
3633
        /* no protocol means plain filename */
3634
        av_strlcpy(path, url, path_size);
3635
        return;
3636
    }
3637

    
3638
    /* separate path from hostname */
3639
    ls = strchr(p, '/');
3640
    if(!ls)
3641
        ls = strchr(p, '?');
3642
    if(ls)
3643
        av_strlcpy(path, ls, path_size);
3644
    else
3645
        ls = &p[strlen(p)]; // XXX
3646

    
3647
    /* the rest is hostname, use that to parse auth/port */
3648
    if (ls != p) {
3649
        /* authorization (user[:pass]@hostname) */
3650
        if ((at = strchr(p, '@')) && at < ls) {
3651
            av_strlcpy(authorization, p,
3652
                       FFMIN(authorization_size, at + 1 - p));
3653
            p = at + 1; /* skip '@' */
3654
        }
3655

    
3656
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3657
            /* [host]:port */
3658
            av_strlcpy(hostname, p + 1,
3659
                       FFMIN(hostname_size, brk - p));
3660
            if (brk[1] == ':' && port_ptr)
3661
                *port_ptr = atoi(brk + 2);
3662
        } else if ((col = strchr(p, ':')) && col < ls) {
3663
            av_strlcpy(hostname, p,
3664
                       FFMIN(col + 1 - p, hostname_size));
3665
            if (port_ptr) *port_ptr = atoi(col + 1);
3666
        } else
3667
            av_strlcpy(hostname, p,
3668
                       FFMIN(ls + 1 - p, hostname_size));
3669
    }
3670
}
3671

    
3672
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3673
{
3674
    int i;
3675
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3676
                                           '4', '5', '6', '7',
3677
                                           '8', '9', 'A', 'B',
3678
                                           'C', 'D', 'E', 'F' };
3679
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3680
                                           '4', '5', '6', '7',
3681
                                           '8', '9', 'a', 'b',
3682
                                           'c', 'd', 'e', 'f' };
3683
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3684

    
3685
    for(i = 0; i < s; i++) {
3686
        buff[i * 2]     = hex_table[src[i] >> 4];
3687
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3688
    }
3689

    
3690
    return buff;
3691
}
3692

    
3693
int ff_hex_to_data(uint8_t *data, const char *p)
3694
{
3695
    int c, len, v;
3696

    
3697
    len = 0;
3698
    v = 1;
3699
    for (;;) {
3700
        p += strspn(p, SPACE_CHARS);
3701
        if (*p == '\0')
3702
            break;
3703
        c = toupper((unsigned char) *p++);
3704
        if (c >= '0' && c <= '9')
3705
            c = c - '0';
3706
        else if (c >= 'A' && c <= 'F')
3707
            c = c - 'A' + 10;
3708
        else
3709
            break;
3710
        v = (v << 4) | c;
3711
        if (v & 0x100) {
3712
            if (data)
3713
                data[len] = v;
3714
            len++;
3715
            v = 1;
3716
        }
3717
    }
3718
    return len;
3719
}
3720

    
3721
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3722
                     unsigned int pts_num, unsigned int pts_den)
3723
{
3724
    AVRational new_tb;
3725
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3726
        if(new_tb.num != pts_num)
3727
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3728
    }else
3729
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3730

    
3731
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3732
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3733
        return;
3734
    }
3735
    s->time_base = new_tb;
3736
    s->pts_wrap_bits = pts_wrap_bits;
3737
}
3738

    
3739
int ff_url_join(char *str, int size, const char *proto,
3740
                const char *authorization, const char *hostname,
3741
                int port, const char *fmt, ...)
3742
{
3743
#if CONFIG_NETWORK
3744
    struct addrinfo hints, *ai;
3745
#endif
3746

    
3747
    str[0] = '\0';
3748
    if (proto)
3749
        av_strlcatf(str, size, "%s://", proto);
3750
    if (authorization && authorization[0])
3751
        av_strlcatf(str, size, "%s@", authorization);
3752
#if CONFIG_NETWORK && defined(AF_INET6)
3753
    /* Determine if hostname is a numerical IPv6 address,
3754
     * properly escape it within [] in that case. */
3755
    memset(&hints, 0, sizeof(hints));
3756
    hints.ai_flags = AI_NUMERICHOST;
3757
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3758
        if (ai->ai_family == AF_INET6) {
3759
            av_strlcat(str, "[", size);
3760
            av_strlcat(str, hostname, size);
3761
            av_strlcat(str, "]", size);
3762
        } else {
3763
            av_strlcat(str, hostname, size);
3764
        }
3765
        freeaddrinfo(ai);
3766
    } else
3767
#endif
3768
        /* Not an IPv6 address, just output the plain string. */
3769
        av_strlcat(str, hostname, size);
3770

    
3771
    if (port >= 0)
3772
        av_strlcatf(str, size, ":%d", port);
3773
    if (fmt) {
3774
        va_list vl;
3775
        int len = strlen(str);
3776

    
3777
        va_start(vl, fmt);
3778
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3779
        va_end(vl);
3780
    }
3781
    return strlen(str);
3782
}
3783

    
3784
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3785
                     AVFormatContext *src)
3786
{
3787
    AVPacket local_pkt;
3788

    
3789
    local_pkt = *pkt;
3790
    local_pkt.stream_index = dst_stream;
3791
    if (pkt->pts != AV_NOPTS_VALUE)
3792
        local_pkt.pts = av_rescale_q(pkt->pts,
3793
                                     src->streams[pkt->stream_index]->time_base,
3794
                                     dst->streams[dst_stream]->time_base);
3795
    if (pkt->dts != AV_NOPTS_VALUE)
3796
        local_pkt.dts = av_rescale_q(pkt->dts,
3797
                                     src->streams[pkt->stream_index]->time_base,
3798
                                     dst->streams[dst_stream]->time_base);
3799
    return av_write_frame(dst, &local_pkt);
3800
}
3801

    
3802
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3803
                        void *context)
3804
{
3805
    const char *ptr = str;
3806

    
3807
    /* Parse key=value pairs. */
3808
    for (;;) {
3809
        const char *key;
3810
        char *dest = NULL, *dest_end;
3811
        int key_len, dest_len = 0;
3812

    
3813
        /* Skip whitespace and potential commas. */
3814
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3815
            ptr++;
3816
        if (!*ptr)
3817
            break;
3818

    
3819
        key = ptr;
3820

    
3821
        if (!(ptr = strchr(key, '=')))
3822
            break;
3823
        ptr++;
3824
        key_len = ptr - key;
3825

    
3826
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3827
        dest_end = dest + dest_len - 1;
3828

    
3829
        if (*ptr == '\"') {
3830
            ptr++;
3831
            while (*ptr && *ptr != '\"') {
3832
                if (*ptr == '\\') {
3833
                    if (!ptr[1])
3834
                        break;
3835
                    if (dest && dest < dest_end)
3836
                        *dest++ = ptr[1];
3837
                    ptr += 2;
3838
                } else {
3839
                    if (dest && dest < dest_end)
3840
                        *dest++ = *ptr;
3841
                    ptr++;
3842
                }
3843
            }
3844
            if (*ptr == '\"')
3845
                ptr++;
3846
        } else {
3847
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3848
                if (dest && dest < dest_end)
3849
                    *dest++ = *ptr;
3850
        }
3851
        if (dest)
3852
            *dest = 0;
3853
    }
3854
}
3855

    
3856
int ff_find_stream_index(AVFormatContext *s, int id)
3857
{
3858
    int i;
3859
    for (i = 0; i < s->nb_streams; i++) {
3860
        if (s->streams[i]->id == id)
3861
            return i;
3862
    }
3863
    return -1;
3864
}
3865

    
3866
void ff_make_absolute_url(char *buf, int size, const char *base,
3867
                          const char *rel)
3868
{
3869
    char *sep;
3870
    /* Absolute path, relative to the current server */
3871
    if (base && strstr(base, "://") && rel[0] == '/') {
3872
        if (base != buf)
3873
            av_strlcpy(buf, base, size);
3874
        sep = strstr(buf, "://");
3875
        if (sep) {
3876
            sep += 3;
3877
            sep = strchr(sep, '/');
3878
            if (sep)
3879
                *sep = '\0';
3880
        }
3881
        av_strlcat(buf, rel, size);
3882
        return;
3883
    }
3884
    /* If rel actually is an absolute url, just copy it */
3885
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3886
        av_strlcpy(buf, rel, size);
3887
        return;
3888
    }
3889
    if (base != buf)
3890
        av_strlcpy(buf, base, size);
3891
    /* Remove the file name from the base url */
3892
    sep = strrchr(buf, '/');
3893
    if (sep)
3894
        sep[1] = '\0';
3895
    else
3896
        buf[0] = '\0';
3897
    while (av_strstart(rel, "../", NULL) && sep) {
3898
        /* Remove the path delimiter at the end */
3899
        sep[0] = '\0';
3900
        sep = strrchr(buf, '/');
3901
        /* If the next directory name to pop off is "..", break here */
3902
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3903
            /* Readd the slash we just removed */
3904
            av_strlcat(buf, "/", size);
3905
            break;
3906
        }
3907
        /* Cut off the directory name */
3908
        if (sep)
3909
            sep[1] = '\0';
3910
        else
3911
            buf[0] = '\0';
3912
        rel += 3;
3913
    }
3914
    av_strlcat(buf, rel, size);
3915
}