Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 7820147e

History | View | Annotate | Download (122 KB)

1
/*
2
 * various utility functions for use within FFmpeg
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#include "avformat.h"
22
#include "internal.h"
23
#include "libavcodec/internal.h"
24
#include "libavutil/opt.h"
25
#include "metadata.h"
26
#include "id3v2.h"
27
#include "libavutil/avstring.h"
28
#include "riff.h"
29
#include "audiointerleave.h"
30
#include <sys/time.h>
31
#include <time.h>
32
#include <strings.h>
33
#include <stdarg.h>
34
#if CONFIG_NETWORK
35
#include "network.h"
36
#endif
37

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

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

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

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

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

    
62
/* fraction handling */
63

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

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

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

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

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

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

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

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

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

    
158
    if(!filename)
159
        return 0;
160

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

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

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

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

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

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

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

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

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

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

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

    
258
    return fmt;
259
}
260
#endif
261

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

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

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

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

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

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

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

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

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

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

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

    
333
    pkt->pos= url_ftell(s);
334

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

    
341
    return ret;
342
}
343

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

    
359

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

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

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

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

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

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

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

    
438
/************************************************************/
439
/* input media file */
440

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

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

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

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

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

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

    
492
    if (pb && !ic->data_offset)
493
        ic->data_offset = url_ftell(ic->pb);
494

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

    
499
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
500

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

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

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

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

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

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

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

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

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

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

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

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

    
591
    return ret;
592
}
593

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

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

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

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

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

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

    
656
}
657

    
658
/*******************************************************/
659

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

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

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

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

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

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

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

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

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

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

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

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

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

    
753
/**********************************************************/
754

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

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

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

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

    
784

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
930
    /* do we have a video B-frame ? */
931
    delay= st->codec->has_b_frames;
932
    presentation_delayed = 0;
933
    /* XXX: need has_b_frame, but cannot get it if the codec is
934
        not initialized */
935
    if (delay &&
936
        pc && pc->pict_type != FF_B_TYPE)
937
        presentation_delayed = 1;
938

    
939
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
940
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
941
        pkt->dts -= 1LL<<st->pts_wrap_bits;
942
    }
943

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

    
952
    if (pkt->duration == 0) {
953
        compute_frame_duration(&num, &den, st, pc, pkt);
954
        if (den && num) {
955
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
956

    
957
            if(pkt->duration != 0 && s->packet_buffer)
958
                update_initial_durations(s, st, pkt);
959
        }
960
    }
961

    
962
    /* correct timestamps with byte offset if demuxers only have timestamps
963
       on packet boundaries */
964
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
965
        /* this will estimate bitrate based on this frame's duration and size */
966
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
967
        if(pkt->pts != AV_NOPTS_VALUE)
968
            pkt->pts += offset;
969
        if(pkt->dts != AV_NOPTS_VALUE)
970
            pkt->dts += offset;
971
    }
972

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

    
992
    /* This may be redundant, but it should not hurt. */
993
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
994
        presentation_delayed = 1;
995

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

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

    
1029
            /* presentation is not delayed : PTS and DTS are the same */
1030
            if(pkt->pts == AV_NOPTS_VALUE)
1031
                pkt->pts = pkt->dts;
1032
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1033
            if(pkt->pts == AV_NOPTS_VALUE)
1034
                pkt->pts = st->cur_dts;
1035
            pkt->dts = pkt->pts;
1036
            if(pkt->pts != AV_NOPTS_VALUE)
1037
                st->cur_dts = pkt->pts + pkt->duration;
1038
        }
1039
    }
1040

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

    
1054
//    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);
1055

    
1056
    /* update flags */
1057
    if(is_intra_only(st->codec))
1058
        pkt->flags |= AV_PKT_FLAG_KEY;
1059
    else if (pc) {
1060
        pkt->flags = 0;
1061
        /* keyframe computation */
1062
        if (pc->key_frame == 1)
1063
            pkt->flags |= AV_PKT_FLAG_KEY;
1064
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1065
            pkt->flags |= AV_PKT_FLAG_KEY;
1066
    }
1067
    if (pc)
1068
        pkt->convergence_duration = pc->convergence_duration;
1069
}
1070

    
1071

    
1072
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1073
{
1074
    AVStream *st;
1075
    int len, ret, i;
1076

    
1077
    av_init_packet(pkt);
1078

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

    
1106
                /* return packet if any */
1107
                if (pkt->size) {
1108
                got_packet:
1109
                    pkt->duration = 0;
1110
                    pkt->stream_index = st->index;
1111
                    pkt->pts = st->parser->pts;
1112
                    pkt->dts = st->parser->dts;
1113
                    pkt->pos = st->parser->pos;
1114
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1115
                        s->cur_st = NULL;
1116
                        pkt->destruct= st->cur_pkt.destruct;
1117
                        st->cur_pkt.destruct= NULL;
1118
                        st->cur_pkt.data    = NULL;
1119
                        assert(st->cur_len == 0);
1120
                    }else{
1121
                    pkt->destruct = NULL;
1122
                    }
1123
                    compute_pkt_fields(s, st, st->parser, pkt);
1124

    
1125
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1126
                        ff_reduce_index(s, st->index);
1127
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1128
                                           0, 0, AVINDEX_KEYFRAME);
1129
                    }
1130

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

    
1164
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1165
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1166
               st->cur_pkt.pts < st->cur_pkt.dts){
1167
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1168
                    st->cur_pkt.stream_index,
1169
                    st->cur_pkt.pts,
1170
                    st->cur_pkt.dts,
1171
                    st->cur_pkt.size);
1172
//                av_free_packet(&st->cur_pkt);
1173
//                return -1;
1174
            }
1175

    
1176
            if(s->debug & FF_FDEBUG_TS)
1177
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1178
                    st->cur_pkt.stream_index,
1179
                    st->cur_pkt.pts,
1180
                    st->cur_pkt.dts,
1181
                    st->cur_pkt.size,
1182
                    st->cur_pkt.duration,
1183
                    st->cur_pkt.flags);
1184

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

    
1210
    return 0;
1211
}
1212

    
1213
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1214
{
1215
    AVPacketList *pktl;
1216
    int eof=0;
1217
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1218

    
1219
    for(;;){
1220
        pktl = s->packet_buffer;
1221
        if (pktl) {
1222
            AVPacket *next_pkt= &pktl->pkt;
1223

    
1224
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1225
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1226
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1227
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1228
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1229
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1230
                        next_pkt->pts= pktl->pkt.dts;
1231
                    }
1232
                    pktl= pktl->next;
1233
                }
1234
                pktl = s->packet_buffer;
1235
            }
1236

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

    
1257
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1258
                                           &s->packet_buffer_end)) < 0)
1259
                return AVERROR(ENOMEM);
1260
        }else{
1261
            assert(!s->packet_buffer);
1262
            return av_read_frame_internal(s, pkt);
1263
        }
1264
    }
1265
}
1266

    
1267
/* XXX: suppress the packet queue */
1268
static void flush_packet_queue(AVFormatContext *s)
1269
{
1270
    AVPacketList *pktl;
1271

    
1272
    for(;;) {
1273
        pktl = s->packet_buffer;
1274
        if (!pktl)
1275
            break;
1276
        s->packet_buffer = pktl->next;
1277
        av_free_packet(&pktl->pkt);
1278
        av_free(pktl);
1279
    }
1280
    while(s->raw_packet_buffer){
1281
        pktl = s->raw_packet_buffer;
1282
        s->raw_packet_buffer = pktl->next;
1283
        av_free_packet(&pktl->pkt);
1284
        av_free(pktl);
1285
    }
1286
    s->packet_buffer_end=
1287
    s->raw_packet_buffer_end= NULL;
1288
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1289
}
1290

    
1291
/*******************************************************/
1292
/* seek support */
1293

    
1294
int av_find_default_stream_index(AVFormatContext *s)
1295
{
1296
    int first_audio_index = -1;
1297
    int i;
1298
    AVStream *st;
1299

    
1300
    if (s->nb_streams <= 0)
1301
        return -1;
1302
    for(i = 0; i < s->nb_streams; i++) {
1303
        st = s->streams[i];
1304
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1305
            return i;
1306
        }
1307
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1308
            first_audio_index = i;
1309
    }
1310
    return first_audio_index >= 0 ? first_audio_index : 0;
1311
}
1312

    
1313
/**
1314
 * Flush the frame reader.
1315
 */
1316
void ff_read_frame_flush(AVFormatContext *s)
1317
{
1318
    AVStream *st;
1319
    int i, j;
1320

    
1321
    flush_packet_queue(s);
1322

    
1323
    s->cur_st = NULL;
1324

    
1325
    /* for each stream, reset read state */
1326
    for(i = 0; i < s->nb_streams; i++) {
1327
        st = s->streams[i];
1328

    
1329
        if (st->parser) {
1330
            av_parser_close(st->parser);
1331
            st->parser = NULL;
1332
            av_free_packet(&st->cur_pkt);
1333
        }
1334
        st->last_IP_pts = AV_NOPTS_VALUE;
1335
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1336
        st->reference_dts = AV_NOPTS_VALUE;
1337
        /* fail safe */
1338
        st->cur_ptr = NULL;
1339
        st->cur_len = 0;
1340

    
1341
        st->probe_packets = MAX_PROBE_PACKETS;
1342

    
1343
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1344
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1345
    }
1346
}
1347

    
1348
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1349
    int i;
1350

    
1351
    for(i = 0; i < s->nb_streams; i++) {
1352
        AVStream *st = s->streams[i];
1353

    
1354
        st->cur_dts = av_rescale(timestamp,
1355
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1356
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1357
    }
1358
}
1359

    
1360
void ff_reduce_index(AVFormatContext *s, int stream_index)
1361
{
1362
    AVStream *st= s->streams[stream_index];
1363
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1364

    
1365
    if((unsigned)st->nb_index_entries >= max_entries){
1366
        int i;
1367
        for(i=0; 2*i<st->nb_index_entries; i++)
1368
            st->index_entries[i]= st->index_entries[2*i];
1369
        st->nb_index_entries= i;
1370
    }
1371
}
1372

    
1373
int av_add_index_entry(AVStream *st,
1374
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1375
{
1376
    AVIndexEntry *entries, *ie;
1377
    int index;
1378

    
1379
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1380
        return -1;
1381

    
1382
    entries = av_fast_realloc(st->index_entries,
1383
                              &st->index_entries_allocated_size,
1384
                              (st->nb_index_entries + 1) *
1385
                              sizeof(AVIndexEntry));
1386
    if(!entries)
1387
        return -1;
1388

    
1389
    st->index_entries= entries;
1390

    
1391
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1392

    
1393
    if(index<0){
1394
        index= st->nb_index_entries++;
1395
        ie= &entries[index];
1396
        assert(index==0 || ie[-1].timestamp < timestamp);
1397
    }else{
1398
        ie= &entries[index];
1399
        if(ie->timestamp != timestamp){
1400
            if(ie->timestamp <= timestamp)
1401
                return -1;
1402
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1403
            st->nb_index_entries++;
1404
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1405
            distance= ie->min_distance;
1406
    }
1407

    
1408
    ie->pos = pos;
1409
    ie->timestamp = timestamp;
1410
    ie->min_distance= distance;
1411
    ie->size= size;
1412
    ie->flags = flags;
1413

    
1414
    return index;
1415
}
1416

    
1417
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1418
                              int flags)
1419
{
1420
    AVIndexEntry *entries= st->index_entries;
1421
    int nb_entries= st->nb_index_entries;
1422
    int a, b, m;
1423
    int64_t timestamp;
1424

    
1425
    a = - 1;
1426
    b = nb_entries;
1427

    
1428
    //optimize appending index entries at the end
1429
    if(b && entries[b-1].timestamp < wanted_timestamp)
1430
        a= b-1;
1431

    
1432
    while (b - a > 1) {
1433
        m = (a + b) >> 1;
1434
        timestamp = entries[m].timestamp;
1435
        if(timestamp >= wanted_timestamp)
1436
            b = m;
1437
        if(timestamp <= wanted_timestamp)
1438
            a = m;
1439
    }
1440
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1441

    
1442
    if(!(flags & AVSEEK_FLAG_ANY)){
1443
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1444
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1445
        }
1446
    }
1447

    
1448
    if(m == nb_entries)
1449
        return -1;
1450
    return  m;
1451
}
1452

    
1453
#define DEBUG_SEEK
1454

    
1455
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1456
    AVInputFormat *avif= s->iformat;
1457
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1458
    int64_t ts_min, ts_max, ts;
1459
    int index;
1460
    int64_t ret;
1461
    AVStream *st;
1462

    
1463
    if (stream_index < 0)
1464
        return -1;
1465

    
1466
#ifdef DEBUG_SEEK
1467
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1468
#endif
1469

    
1470
    ts_max=
1471
    ts_min= AV_NOPTS_VALUE;
1472
    pos_limit= -1; //gcc falsely says it may be uninitialized
1473

    
1474
    st= s->streams[stream_index];
1475
    if(st->index_entries){
1476
        AVIndexEntry *e;
1477

    
1478
        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()
1479
        index= FFMAX(index, 0);
1480
        e= &st->index_entries[index];
1481

    
1482
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1483
            pos_min= e->pos;
1484
            ts_min= e->timestamp;
1485
#ifdef DEBUG_SEEK
1486
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1487
                   pos_min,ts_min);
1488
#endif
1489
        }else{
1490
            assert(index==0);
1491
        }
1492

    
1493
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1494
        assert(index < st->nb_index_entries);
1495
        if(index >= 0){
1496
            e= &st->index_entries[index];
1497
            assert(e->timestamp >= target_ts);
1498
            pos_max= e->pos;
1499
            ts_max= e->timestamp;
1500
            pos_limit= pos_max - e->min_distance;
1501
#ifdef DEBUG_SEEK
1502
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1503
                   pos_max,pos_limit, ts_max);
1504
#endif
1505
        }
1506
    }
1507

    
1508
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1509
    if(pos<0)
1510
        return -1;
1511

    
1512
    /* do the seek */
1513
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1514
        return ret;
1515

    
1516
    av_update_cur_dts(s, st, ts);
1517

    
1518
    return 0;
1519
}
1520

    
1521
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 )){
1522
    int64_t pos, ts;
1523
    int64_t start_pos, filesize;
1524
    int no_change;
1525

    
1526
#ifdef DEBUG_SEEK
1527
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1528
#endif
1529

    
1530
    if(ts_min == AV_NOPTS_VALUE){
1531
        pos_min = s->data_offset;
1532
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1533
        if (ts_min == AV_NOPTS_VALUE)
1534
            return -1;
1535
    }
1536

    
1537
    if(ts_max == AV_NOPTS_VALUE){
1538
        int step= 1024;
1539
        filesize = url_fsize(s->pb);
1540
        pos_max = filesize - 1;
1541
        do{
1542
            pos_max -= step;
1543
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1544
            step += step;
1545
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1546
        if (ts_max == AV_NOPTS_VALUE)
1547
            return -1;
1548

    
1549
        for(;;){
1550
            int64_t tmp_pos= pos_max + 1;
1551
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1552
            if(tmp_ts == AV_NOPTS_VALUE)
1553
                break;
1554
            ts_max= tmp_ts;
1555
            pos_max= tmp_pos;
1556
            if(tmp_pos >= filesize)
1557
                break;
1558
        }
1559
        pos_limit= pos_max;
1560
    }
1561

    
1562
    if(ts_min > ts_max){
1563
        return -1;
1564
    }else if(ts_min == ts_max){
1565
        pos_limit= pos_min;
1566
    }
1567

    
1568
    no_change=0;
1569
    while (pos_min < pos_limit) {
1570
#ifdef DEBUG_SEEK
1571
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1572
               pos_min, pos_max,
1573
               ts_min, ts_max);
1574
#endif
1575
        assert(pos_limit <= pos_max);
1576

    
1577
        if(no_change==0){
1578
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1579
            // interpolate position (better than dichotomy)
1580
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1581
                + pos_min - approximate_keyframe_distance;
1582
        }else if(no_change==1){
1583
            // bisection, if interpolation failed to change min or max pos last time
1584
            pos = (pos_min + pos_limit)>>1;
1585
        }else{
1586
            /* linear search if bisection failed, can only happen if there
1587
               are very few or no keyframes between min/max */
1588
            pos=pos_min;
1589
        }
1590
        if(pos <= pos_min)
1591
            pos= pos_min + 1;
1592
        else if(pos > pos_limit)
1593
            pos= pos_limit;
1594
        start_pos= pos;
1595

    
1596
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1597
        if(pos == pos_max)
1598
            no_change++;
1599
        else
1600
            no_change=0;
1601
#ifdef DEBUG_SEEK
1602
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1603
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1604
               start_pos, no_change);
1605
#endif
1606
        if(ts == AV_NOPTS_VALUE){
1607
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1608
            return -1;
1609
        }
1610
        assert(ts != AV_NOPTS_VALUE);
1611
        if (target_ts <= ts) {
1612
            pos_limit = start_pos - 1;
1613
            pos_max = pos;
1614
            ts_max = ts;
1615
        }
1616
        if (target_ts >= ts) {
1617
            pos_min = pos;
1618
            ts_min = ts;
1619
        }
1620
    }
1621

    
1622
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1623
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1624
#ifdef DEBUG_SEEK
1625
    pos_min = pos;
1626
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1627
    pos_min++;
1628
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1629
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1630
           pos, ts_min, target_ts, ts_max);
1631
#endif
1632
    *ts_ret= ts;
1633
    return pos;
1634
}
1635

    
1636
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1637
    int64_t pos_min, pos_max;
1638
#if 0
1639
    AVStream *st;
1640

1641
    if (stream_index < 0)
1642
        return -1;
1643

1644
    st= s->streams[stream_index];
1645
#endif
1646

    
1647
    pos_min = s->data_offset;
1648
    pos_max = url_fsize(s->pb) - 1;
1649

    
1650
    if     (pos < pos_min) pos= pos_min;
1651
    else if(pos > pos_max) pos= pos_max;
1652

    
1653
    url_fseek(s->pb, pos, SEEK_SET);
1654

    
1655
#if 0
1656
    av_update_cur_dts(s, st, ts);
1657
#endif
1658
    return 0;
1659
}
1660

    
1661
static int av_seek_frame_generic(AVFormatContext *s,
1662
                                 int stream_index, int64_t timestamp, int flags)
1663
{
1664
    int index;
1665
    int64_t ret;
1666
    AVStream *st;
1667
    AVIndexEntry *ie;
1668

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

    
1671
    index = av_index_search_timestamp(st, timestamp, flags);
1672

    
1673
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1674
        return -1;
1675

    
1676
    if(index < 0 || index==st->nb_index_entries-1){
1677
        int i;
1678
        AVPacket pkt;
1679

    
1680
        if(st->nb_index_entries){
1681
            assert(st->index_entries);
1682
            ie= &st->index_entries[st->nb_index_entries-1];
1683
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1684
                return ret;
1685
            av_update_cur_dts(s, st, ie->timestamp);
1686
        }else{
1687
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1688
                return ret;
1689
        }
1690
        for(i=0;; i++) {
1691
            int ret;
1692
            do{
1693
                ret = av_read_frame(s, &pkt);
1694
            }while(ret == AVERROR(EAGAIN));
1695
            if(ret<0)
1696
                break;
1697
            av_free_packet(&pkt);
1698
            if(stream_index == pkt.stream_index){
1699
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1700
                    break;
1701
            }
1702
        }
1703
        index = av_index_search_timestamp(st, timestamp, flags);
1704
    }
1705
    if (index < 0)
1706
        return -1;
1707

    
1708
    ff_read_frame_flush(s);
1709
    if (s->iformat->read_seek){
1710
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1711
            return 0;
1712
    }
1713
    ie = &st->index_entries[index];
1714
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1715
        return ret;
1716
    av_update_cur_dts(s, st, ie->timestamp);
1717

    
1718
    return 0;
1719
}
1720

    
1721
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1722
{
1723
    int ret;
1724
    AVStream *st;
1725

    
1726
    ff_read_frame_flush(s);
1727

    
1728
    if(flags & AVSEEK_FLAG_BYTE)
1729
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1730

    
1731
    if(stream_index < 0){
1732
        stream_index= av_find_default_stream_index(s);
1733
        if(stream_index < 0)
1734
            return -1;
1735

    
1736
        st= s->streams[stream_index];
1737
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1738
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1739
    }
1740

    
1741
    /* first, we try the format specific seek */
1742
    if (s->iformat->read_seek)
1743
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1744
    else
1745
        ret = -1;
1746
    if (ret >= 0) {
1747
        return 0;
1748
    }
1749

    
1750
    if(s->iformat->read_timestamp)
1751
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1752
    else
1753
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1754
}
1755

    
1756
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1757
{
1758
    if(min_ts > ts || max_ts < ts)
1759
        return -1;
1760

    
1761
    ff_read_frame_flush(s);
1762

    
1763
    if (s->iformat->read_seek2)
1764
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1765

    
1766
    if(s->iformat->read_timestamp){
1767
        //try to seek via read_timestamp()
1768
    }
1769

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

    
1775
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1776
}
1777

    
1778
/*******************************************************/
1779

    
1780
/**
1781
 * Return TRUE if the stream has accurate duration in any stream.
1782
 *
1783
 * @return TRUE if the stream has accurate duration for at least one component.
1784
 */
1785
static int av_has_duration(AVFormatContext *ic)
1786
{
1787
    int i;
1788
    AVStream *st;
1789

    
1790
    for(i = 0;i < ic->nb_streams; i++) {
1791
        st = ic->streams[i];
1792
        if (st->duration != AV_NOPTS_VALUE)
1793
            return 1;
1794
    }
1795
    return 0;
1796
}
1797

    
1798
/**
1799
 * Estimate the stream timings from the one of each components.
1800
 *
1801
 * Also computes the global bitrate if possible.
1802
 */
1803
static void av_update_stream_timings(AVFormatContext *ic)
1804
{
1805
    int64_t start_time, start_time1, end_time, end_time1;
1806
    int64_t duration, duration1;
1807
    int i;
1808
    AVStream *st;
1809

    
1810
    start_time = INT64_MAX;
1811
    end_time = INT64_MIN;
1812
    duration = INT64_MIN;
1813
    for(i = 0;i < ic->nb_streams; i++) {
1814
        st = ic->streams[i];
1815
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1816
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1817
            if (start_time1 < start_time)
1818
                start_time = start_time1;
1819
            if (st->duration != AV_NOPTS_VALUE) {
1820
                end_time1 = start_time1
1821
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1822
                if (end_time1 > end_time)
1823
                    end_time = end_time1;
1824
            }
1825
        }
1826
        if (st->duration != AV_NOPTS_VALUE) {
1827
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1828
            if (duration1 > duration)
1829
                duration = duration1;
1830
        }
1831
    }
1832
    if (start_time != INT64_MAX) {
1833
        ic->start_time = start_time;
1834
        if (end_time != INT64_MIN) {
1835
            if (end_time - start_time > duration)
1836
                duration = end_time - start_time;
1837
        }
1838
    }
1839
    if (duration != INT64_MIN) {
1840
        ic->duration = duration;
1841
        if (ic->file_size > 0) {
1842
            /* compute the bitrate */
1843
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1844
                (double)ic->duration;
1845
        }
1846
    }
1847
}
1848

    
1849
static void fill_all_stream_timings(AVFormatContext *ic)
1850
{
1851
    int i;
1852
    AVStream *st;
1853

    
1854
    av_update_stream_timings(ic);
1855
    for(i = 0;i < ic->nb_streams; i++) {
1856
        st = ic->streams[i];
1857
        if (st->start_time == AV_NOPTS_VALUE) {
1858
            if(ic->start_time != AV_NOPTS_VALUE)
1859
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1860
            if(ic->duration != AV_NOPTS_VALUE)
1861
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1862
        }
1863
    }
1864
}
1865

    
1866
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1867
{
1868
    int64_t filesize, duration;
1869
    int bit_rate, i;
1870
    AVStream *st;
1871

    
1872
    /* if bit_rate is already set, we believe it */
1873
    if (ic->bit_rate <= 0) {
1874
        bit_rate = 0;
1875
        for(i=0;i<ic->nb_streams;i++) {
1876
            st = ic->streams[i];
1877
            if (st->codec->bit_rate > 0)
1878
            bit_rate += st->codec->bit_rate;
1879
        }
1880
        ic->bit_rate = bit_rate;
1881
    }
1882

    
1883
    /* if duration is already set, we believe it */
1884
    if (ic->duration == AV_NOPTS_VALUE &&
1885
        ic->bit_rate != 0 &&
1886
        ic->file_size != 0)  {
1887
        filesize = ic->file_size;
1888
        if (filesize > 0) {
1889
            for(i = 0; i < ic->nb_streams; i++) {
1890
                st = ic->streams[i];
1891
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1892
                if (st->duration == AV_NOPTS_VALUE)
1893
                    st->duration = duration;
1894
            }
1895
        }
1896
    }
1897
}
1898

    
1899
#define DURATION_MAX_READ_SIZE 250000
1900
#define DURATION_MAX_RETRY 3
1901

    
1902
/* only usable for MPEG-PS streams */
1903
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1904
{
1905
    AVPacket pkt1, *pkt = &pkt1;
1906
    AVStream *st;
1907
    int read_size, i, ret;
1908
    int64_t end_time;
1909
    int64_t filesize, offset, duration;
1910
    int retry=0;
1911

    
1912
    ic->cur_st = NULL;
1913

    
1914
    /* flush packet queue */
1915
    flush_packet_queue(ic);
1916

    
1917
    for (i=0; i<ic->nb_streams; i++) {
1918
        st = ic->streams[i];
1919
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1920
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1921

    
1922
        if (st->parser) {
1923
            av_parser_close(st->parser);
1924
            st->parser= NULL;
1925
            av_free_packet(&st->cur_pkt);
1926
        }
1927
    }
1928

    
1929
    /* estimate the end time (duration) */
1930
    /* XXX: may need to support wrapping */
1931
    filesize = ic->file_size;
1932
    end_time = AV_NOPTS_VALUE;
1933
    do{
1934
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1935
    if (offset < 0)
1936
        offset = 0;
1937

    
1938
    url_fseek(ic->pb, offset, SEEK_SET);
1939
    read_size = 0;
1940
    for(;;) {
1941
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1942
            break;
1943

    
1944
        do{
1945
            ret = av_read_packet(ic, pkt);
1946
        }while(ret == AVERROR(EAGAIN));
1947
        if (ret != 0)
1948
            break;
1949
        read_size += pkt->size;
1950
        st = ic->streams[pkt->stream_index];
1951
        if (pkt->pts != AV_NOPTS_VALUE &&
1952
            (st->start_time != AV_NOPTS_VALUE ||
1953
             st->first_dts  != AV_NOPTS_VALUE)) {
1954
            duration = end_time = pkt->pts;
1955
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1956
            else                                   duration -= st->first_dts;
1957
            if (duration < 0)
1958
                duration += 1LL<<st->pts_wrap_bits;
1959
            if (duration > 0) {
1960
                if (st->duration == AV_NOPTS_VALUE ||
1961
                    st->duration < duration)
1962
                    st->duration = duration;
1963
            }
1964
        }
1965
        av_free_packet(pkt);
1966
    }
1967
    }while(   end_time==AV_NOPTS_VALUE
1968
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1969
           && ++retry <= DURATION_MAX_RETRY);
1970

    
1971
    fill_all_stream_timings(ic);
1972

    
1973
    url_fseek(ic->pb, old_offset, SEEK_SET);
1974
    for (i=0; i<ic->nb_streams; i++) {
1975
        st= ic->streams[i];
1976
        st->cur_dts= st->first_dts;
1977
        st->last_IP_pts = AV_NOPTS_VALUE;
1978
    }
1979
}
1980

    
1981
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1982
{
1983
    int64_t file_size;
1984

    
1985
    /* get the file size, if possible */
1986
    if (ic->iformat->flags & AVFMT_NOFILE) {
1987
        file_size = 0;
1988
    } else {
1989
        file_size = url_fsize(ic->pb);
1990
        if (file_size < 0)
1991
            file_size = 0;
1992
    }
1993
    ic->file_size = file_size;
1994

    
1995
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1996
         !strcmp(ic->iformat->name, "mpegts")) &&
1997
        file_size && !url_is_streamed(ic->pb)) {
1998
        /* get accurate estimate from the PTSes */
1999
        av_estimate_timings_from_pts(ic, old_offset);
2000
    } else if (av_has_duration(ic)) {
2001
        /* at least one component has timings - we use them for all
2002
           the components */
2003
        fill_all_stream_timings(ic);
2004
    } else {
2005
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2006
        /* less precise: use bitrate info */
2007
        av_estimate_timings_from_bit_rate(ic);
2008
    }
2009
    av_update_stream_timings(ic);
2010

    
2011
#if 0
2012
    {
2013
        int i;
2014
        AVStream *st;
2015
        for(i = 0;i < ic->nb_streams; i++) {
2016
            st = ic->streams[i];
2017
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2018
               i, (double)st->start_time / AV_TIME_BASE,
2019
               (double)st->duration / AV_TIME_BASE);
2020
        }
2021
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2022
               (double)ic->start_time / AV_TIME_BASE,
2023
               (double)ic->duration / AV_TIME_BASE,
2024
               ic->bit_rate / 1000);
2025
    }
2026
#endif
2027
}
2028

    
2029
static int has_codec_parameters(AVCodecContext *enc)
2030
{
2031
    int val;
2032
    switch(enc->codec_type) {
2033
    case AVMEDIA_TYPE_AUDIO:
2034
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2035
        if(!enc->frame_size &&
2036
           (enc->codec_id == CODEC_ID_VORBIS ||
2037
            enc->codec_id == CODEC_ID_AAC ||
2038
            enc->codec_id == CODEC_ID_MP1 ||
2039
            enc->codec_id == CODEC_ID_MP2 ||
2040
            enc->codec_id == CODEC_ID_MP3 ||
2041
            enc->codec_id == CODEC_ID_SPEEX))
2042
            return 0;
2043
        break;
2044
    case AVMEDIA_TYPE_VIDEO:
2045
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2046
        break;
2047
    default:
2048
        val = 1;
2049
        break;
2050
    }
2051
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2052
}
2053

    
2054
static int has_decode_delay_been_guessed(AVStream *st)
2055
{
2056
    return st->codec->codec_id != CODEC_ID_H264 ||
2057
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2058
}
2059

    
2060
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2061
{
2062
    int16_t *samples;
2063
    AVCodec *codec;
2064
    int got_picture, data_size, ret=0;
2065
    AVFrame picture;
2066

    
2067
    if(!st->codec->codec){
2068
        codec = avcodec_find_decoder(st->codec->codec_id);
2069
        if (!codec)
2070
            return -1;
2071
        ret = avcodec_open(st->codec, codec);
2072
        if (ret < 0)
2073
            return ret;
2074
    }
2075

    
2076
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2077
        switch(st->codec->codec_type) {
2078
        case AVMEDIA_TYPE_VIDEO:
2079
            avcodec_get_frame_defaults(&picture);
2080
            ret = avcodec_decode_video2(st->codec, &picture,
2081
                                        &got_picture, avpkt);
2082
            break;
2083
        case AVMEDIA_TYPE_AUDIO:
2084
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2085
            samples = av_malloc(data_size);
2086
            if (!samples)
2087
                goto fail;
2088
            ret = avcodec_decode_audio3(st->codec, samples,
2089
                                        &data_size, avpkt);
2090
            av_free(samples);
2091
            break;
2092
        default:
2093
            break;
2094
        }
2095
    }
2096
 fail:
2097
    return ret;
2098
}
2099

    
2100
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2101
{
2102
    while (tags->id != CODEC_ID_NONE) {
2103
        if (tags->id == id)
2104
            return tags->tag;
2105
        tags++;
2106
    }
2107
    return 0;
2108
}
2109

    
2110
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2111
{
2112
    int i;
2113
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2114
        if(tag == tags[i].tag)
2115
            return tags[i].id;
2116
    }
2117
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2118
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2119
            return tags[i].id;
2120
    }
2121
    return CODEC_ID_NONE;
2122
}
2123

    
2124
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2125
{
2126
    int i;
2127
    for(i=0; tags && tags[i]; i++){
2128
        int tag= ff_codec_get_tag(tags[i], id);
2129
        if(tag) return tag;
2130
    }
2131
    return 0;
2132
}
2133

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

    
2144
static void compute_chapters_end(AVFormatContext *s)
2145
{
2146
    unsigned int i;
2147

    
2148
    for (i=0; i+1<s->nb_chapters; i++)
2149
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2150
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2151
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2152
            s->chapters[i]->end = s->chapters[i+1]->start;
2153
        }
2154

    
2155
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2156
        assert(s->start_time != AV_NOPTS_VALUE);
2157
        assert(s->duration > 0);
2158
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2159
                                           AV_TIME_BASE_Q,
2160
                                           s->chapters[i]->time_base);
2161
    }
2162
}
2163

    
2164
static int get_std_framerate(int i){
2165
    if(i<60*12) return i*1001;
2166
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2167
}
2168

    
2169
/*
2170
 * Is the time base unreliable.
2171
 * This is a heuristic to balance between quick acceptance of the values in
2172
 * the headers vs. some extra checks.
2173
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2174
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2175
 * And there are "variable" fps files this needs to detect as well.
2176
 */
2177
static int tb_unreliable(AVCodecContext *c){
2178
    if(   c->time_base.den >= 101L*c->time_base.num
2179
       || c->time_base.den <    5L*c->time_base.num
2180
/*       || c->codec_tag == AV_RL32("DIVX")
2181
       || c->codec_tag == AV_RL32("XVID")*/
2182
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2183
       || c->codec_id == CODEC_ID_H264
2184
       )
2185
        return 1;
2186
    return 0;
2187
}
2188

    
2189
int av_find_stream_info(AVFormatContext *ic)
2190
{
2191
    int i, count, ret, read_size, j;
2192
    AVStream *st;
2193
    AVPacket pkt1, *pkt;
2194
    int64_t old_offset = url_ftell(ic->pb);
2195

    
2196
    for(i=0;i<ic->nb_streams;i++) {
2197
        AVCodec *codec;
2198
        st = ic->streams[i];
2199
        if (st->codec->codec_id == CODEC_ID_AAC) {
2200
            st->codec->sample_rate = 0;
2201
            st->codec->frame_size = 0;
2202
            st->codec->channels = 0;
2203
        }
2204
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2205
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2206
/*            if(!st->time_base.num)
2207
                st->time_base= */
2208
            if(!st->codec->time_base.num)
2209
                st->codec->time_base= st->time_base;
2210
        }
2211
        //only for the split stuff
2212
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2213
            st->parser = av_parser_init(st->codec->codec_id);
2214
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2215
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2216
            }
2217
        }
2218
        assert(!st->codec->codec);
2219
        codec = avcodec_find_decoder(st->codec->codec_id);
2220

    
2221
        /* Force decoding of at least one frame of codec data
2222
         * this makes sure the codec initializes the channel configuration
2223
         * and does not trust the values from the container.
2224
         */
2225
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2226
            st->codec->channels = 0;
2227

    
2228
        /* Ensure that subtitle_header is properly set. */
2229
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2230
            && codec && !st->codec->codec)
2231
            avcodec_open(st->codec, codec);
2232

    
2233
        //try to just open decoders, in case this is enough to get parameters
2234
        if(!has_codec_parameters(st->codec)){
2235
            if (codec && !st->codec->codec)
2236
                avcodec_open(st->codec, codec);
2237
        }
2238
    }
2239

    
2240
    for (i=0; i<ic->nb_streams; i++) {
2241
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2242
    }
2243

    
2244
    count = 0;
2245
    read_size = 0;
2246
    for(;;) {
2247
        if(url_interrupt_cb()){
2248
            ret= AVERROR(EINTR);
2249
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2250
            break;
2251
        }
2252

    
2253
        /* check if one codec still needs to be handled */
2254
        for(i=0;i<ic->nb_streams;i++) {
2255
            st = ic->streams[i];
2256
            if (!has_codec_parameters(st->codec))
2257
                break;
2258
            /* variable fps and no guess at the real fps */
2259
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2260
               && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2261
                break;
2262
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2263
                break;
2264
            if(st->first_dts == AV_NOPTS_VALUE)
2265
                break;
2266
        }
2267
        if (i == ic->nb_streams) {
2268
            /* NOTE: if the format has no header, then we need to read
2269
               some packets to get most of the streams, so we cannot
2270
               stop here */
2271
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2272
                /* if we found the info for all the codecs, we can stop */
2273
                ret = count;
2274
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2275
                break;
2276
            }
2277
        }
2278
        /* we did not get all the codec info, but we read too much data */
2279
        if (read_size >= ic->probesize) {
2280
            ret = count;
2281
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2282
            break;
2283
        }
2284

    
2285
        /* NOTE: a new stream can be added there if no header in file
2286
           (AVFMTCTX_NOHEADER) */
2287
        ret = av_read_frame_internal(ic, &pkt1);
2288
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2289
            /* EOF or error */
2290
            ret = -1; /* we could not have all the codec parameters before EOF */
2291
            for(i=0;i<ic->nb_streams;i++) {
2292
                st = ic->streams[i];
2293
                if (!has_codec_parameters(st->codec)){
2294
                    char buf[256];
2295
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2296
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2297
                } else {
2298
                    ret = 0;
2299
                }
2300
            }
2301
            break;
2302
        }
2303

    
2304
        if (ret == AVERROR(EAGAIN))
2305
            continue;
2306

    
2307
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2308
        if ((ret = av_dup_packet(pkt)) < 0)
2309
            goto find_stream_info_err;
2310

    
2311
        read_size += pkt->size;
2312

    
2313
        st = ic->streams[pkt->stream_index];
2314
        if (st->codec_info_nb_frames>1) {
2315
            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) {
2316
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2317
                break;
2318
            }
2319
            st->info->codec_info_duration += pkt->duration;
2320
        }
2321
        {
2322
            int64_t last = st->info->last_dts;
2323
            int64_t duration= pkt->dts - last;
2324

    
2325
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2326
                double dur= duration * av_q2d(st->time_base);
2327

    
2328
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2329
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2330
                if (st->info->duration_count < 2)
2331
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2332
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2333
                    int framerate= get_std_framerate(i);
2334
                    int ticks= lrintf(dur*framerate/(1001*12));
2335
                    double error= dur - ticks*1001*12/(double)framerate;
2336
                    st->info->duration_error[i] += error*error;
2337
                }
2338
                st->info->duration_count++;
2339
                // ignore the first 4 values, they might have some random jitter
2340
                if (st->info->duration_count > 3)
2341
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2342
            }
2343
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2344
                st->info->last_dts = pkt->dts;
2345
        }
2346
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2347
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2348
            if(i){
2349
                st->codec->extradata_size= i;
2350
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2351
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2352
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2353
            }
2354
        }
2355

    
2356
        /* if still no information, we try to open the codec and to
2357
           decompress the frame. We try to avoid that in most cases as
2358
           it takes longer and uses more memory. For MPEG-4, we need to
2359
           decompress for QuickTime. */
2360
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2361
            try_decode_frame(st, pkt);
2362

    
2363
        st->codec_info_nb_frames++;
2364
        count++;
2365
    }
2366

    
2367
    // close codecs which were opened in try_decode_frame()
2368
    for(i=0;i<ic->nb_streams;i++) {
2369
        st = ic->streams[i];
2370
        if(st->codec->codec)
2371
            avcodec_close(st->codec);
2372
    }
2373
    for(i=0;i<ic->nb_streams;i++) {
2374
        st = ic->streams[i];
2375
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2376
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2377
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2378
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2379
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2380
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2381
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2382

    
2383
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2384
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2385
            // ipmovie.c produces.
2386
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2387
                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);
2388
            if (st->info->duration_count && !st->r_frame_rate.num
2389
               && tb_unreliable(st->codec) /*&&
2390
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2391
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2392
                int num = 0;
2393
                double best_error= 2*av_q2d(st->time_base);
2394
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2395

    
2396
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2397
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2398
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2399
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2400
                    if(error < best_error){
2401
                        best_error= error;
2402
                        num = get_std_framerate(j);
2403
                    }
2404
                }
2405
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2406
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2407
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2408
            }
2409

    
2410
            if (!st->r_frame_rate.num){
2411
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2412
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2413
                    st->r_frame_rate.num = st->codec->time_base.den;
2414
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2415
                }else{
2416
                    st->r_frame_rate.num = st->time_base.den;
2417
                    st->r_frame_rate.den = st->time_base.num;
2418
                }
2419
            }
2420
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2421
            if(!st->codec->bits_per_coded_sample)
2422
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2423
        }
2424
    }
2425

    
2426
    av_estimate_timings(ic, old_offset);
2427

    
2428
    compute_chapters_end(ic);
2429

    
2430
#if 0
2431
    /* correct DTS for B-frame streams with no timestamps */
2432
    for(i=0;i<ic->nb_streams;i++) {
2433
        st = ic->streams[i];
2434
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2435
            if(b-frames){
2436
                ppktl = &ic->packet_buffer;
2437
                while(ppkt1){
2438
                    if(ppkt1->stream_index != i)
2439
                        continue;
2440
                    if(ppkt1->pkt->dts < 0)
2441
                        break;
2442
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2443
                        break;
2444
                    ppkt1->pkt->dts -= delta;
2445
                    ppkt1= ppkt1->next;
2446
                }
2447
                if(ppkt1)
2448
                    continue;
2449
                st->cur_dts -= delta;
2450
            }
2451
        }
2452
    }
2453
#endif
2454

    
2455
 find_stream_info_err:
2456
    for (i=0; i < ic->nb_streams; i++)
2457
        av_freep(&ic->streams[i]->info);
2458
    return ret;
2459
}
2460

    
2461
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2462
{
2463
    int i, j;
2464

    
2465
    for (i = 0; i < ic->nb_programs; i++)
2466
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2467
            if (ic->programs[i]->stream_index[j] == s)
2468
                return ic->programs[i];
2469
    return NULL;
2470
}
2471

    
2472
int av_find_best_stream(AVFormatContext *ic,
2473
                        enum AVMediaType type,
2474
                        int wanted_stream_nb,
2475
                        int related_stream,
2476
                        AVCodec **decoder_ret,
2477
                        int flags)
2478
{
2479
    int i, nb_streams = ic->nb_streams, stream_number = 0;
2480
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2481
    unsigned *program = NULL;
2482
    AVCodec *decoder = NULL, *best_decoder = NULL;
2483

    
2484
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2485
        AVProgram *p = find_program_from_stream(ic, related_stream);
2486
        if (p) {
2487
            program = p->stream_index;
2488
            nb_streams = p->nb_stream_indexes;
2489
        }
2490
    }
2491
    for (i = 0; i < nb_streams; i++) {
2492
        AVStream *st = ic->streams[program ? program[i] : i];
2493
        AVCodecContext *avctx = st->codec;
2494
        if (avctx->codec_type != type)
2495
            continue;
2496
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2497
            continue;
2498
        if (decoder_ret) {
2499
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2500
            if (!decoder) {
2501
                if (ret < 0)
2502
                    ret = AVERROR_DECODER_NOT_FOUND;
2503
                continue;
2504
            }
2505
        }
2506
        if (best_count >= st->codec_info_nb_frames)
2507
            continue;
2508
        best_count = st->codec_info_nb_frames;
2509
        ret = i;
2510
        best_decoder = decoder;
2511
        if (program && i == nb_streams - 1 && ret < 0) {
2512
            program = NULL;
2513
            nb_streams = ic->nb_streams;
2514
            i = 0; /* no related stream found, try again with everything */
2515
        }
2516
    }
2517
    if (decoder_ret)
2518
        *decoder_ret = best_decoder;
2519
    return ret;
2520
}
2521

    
2522
/*******************************************************/
2523

    
2524
int av_read_play(AVFormatContext *s)
2525
{
2526
    if (s->iformat->read_play)
2527
        return s->iformat->read_play(s);
2528
    if (s->pb)
2529
        return av_url_read_fpause(s->pb, 0);
2530
    return AVERROR(ENOSYS);
2531
}
2532

    
2533
int av_read_pause(AVFormatContext *s)
2534
{
2535
    if (s->iformat->read_pause)
2536
        return s->iformat->read_pause(s);
2537
    if (s->pb)
2538
        return av_url_read_fpause(s->pb, 1);
2539
    return AVERROR(ENOSYS);
2540
}
2541

    
2542
void av_close_input_stream(AVFormatContext *s)
2543
{
2544
    int i;
2545
    AVStream *st;
2546

    
2547
    flush_packet_queue(s);
2548
    if (s->iformat->read_close)
2549
        s->iformat->read_close(s);
2550
    for(i=0;i<s->nb_streams;i++) {
2551
        /* free all data in a stream component */
2552
        st = s->streams[i];
2553
        if (st->parser) {
2554
            av_parser_close(st->parser);
2555
            av_free_packet(&st->cur_pkt);
2556
        }
2557
        av_metadata_free(&st->metadata);
2558
        av_free(st->index_entries);
2559
        av_free(st->codec->extradata);
2560
        av_free(st->codec->subtitle_header);
2561
        av_free(st->codec);
2562
#if FF_API_OLD_METADATA
2563
        av_free(st->filename);
2564
#endif
2565
        av_free(st->priv_data);
2566
        av_free(st->info);
2567
        av_free(st);
2568
    }
2569
    for(i=s->nb_programs-1; i>=0; i--) {
2570
#if FF_API_OLD_METADATA
2571
        av_freep(&s->programs[i]->provider_name);
2572
        av_freep(&s->programs[i]->name);
2573
#endif
2574
        av_metadata_free(&s->programs[i]->metadata);
2575
        av_freep(&s->programs[i]->stream_index);
2576
        av_freep(&s->programs[i]);
2577
    }
2578
    av_freep(&s->programs);
2579
    av_freep(&s->priv_data);
2580
    while(s->nb_chapters--) {
2581
#if FF_API_OLD_METADATA
2582
        av_free(s->chapters[s->nb_chapters]->title);
2583
#endif
2584
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2585
        av_free(s->chapters[s->nb_chapters]);
2586
    }
2587
    av_freep(&s->chapters);
2588
    av_metadata_free(&s->metadata);
2589
    av_freep(&s->key);
2590
    av_free(s);
2591
}
2592

    
2593
void av_close_input_file(AVFormatContext *s)
2594
{
2595
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2596
    av_close_input_stream(s);
2597
    if (pb)
2598
        url_fclose(pb);
2599
}
2600

    
2601
AVStream *av_new_stream(AVFormatContext *s, int id)
2602
{
2603
    AVStream *st;
2604
    int i;
2605

    
2606
#if FF_API_MAX_STREAMS
2607
    if (s->nb_streams >= MAX_STREAMS){
2608
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2609
        return NULL;
2610
    }
2611
#else
2612
    AVStream **streams;
2613

    
2614
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2615
        return NULL;
2616
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2617
    if (!streams)
2618
        return NULL;
2619
    s->streams = streams;
2620
#endif
2621

    
2622
    st = av_mallocz(sizeof(AVStream));
2623
    if (!st)
2624
        return NULL;
2625
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2626
        av_free(st);
2627
        return NULL;
2628
    }
2629

    
2630
    st->codec= avcodec_alloc_context();
2631
    if (s->iformat) {
2632
        /* no default bitrate if decoding */
2633
        st->codec->bit_rate = 0;
2634
    }
2635
    st->index = s->nb_streams;
2636
    st->id = id;
2637
    st->start_time = AV_NOPTS_VALUE;
2638
    st->duration = AV_NOPTS_VALUE;
2639
        /* we set the current DTS to 0 so that formats without any timestamps
2640
           but durations get some timestamps, formats with some unknown
2641
           timestamps have their first few packets buffered and the
2642
           timestamps corrected before they are returned to the user */
2643
    st->cur_dts = 0;
2644
    st->first_dts = AV_NOPTS_VALUE;
2645
    st->probe_packets = MAX_PROBE_PACKETS;
2646

    
2647
    /* default pts setting is MPEG-like */
2648
    av_set_pts_info(st, 33, 1, 90000);
2649
    st->last_IP_pts = AV_NOPTS_VALUE;
2650
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2651
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2652
    st->reference_dts = AV_NOPTS_VALUE;
2653

    
2654
    st->sample_aspect_ratio = (AVRational){0,1};
2655

    
2656
    s->streams[s->nb_streams++] = st;
2657
    return st;
2658
}
2659

    
2660
AVProgram *av_new_program(AVFormatContext *ac, int id)
2661
{
2662
    AVProgram *program=NULL;
2663
    int i;
2664

    
2665
#ifdef DEBUG_SI
2666
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2667
#endif
2668

    
2669
    for(i=0; i<ac->nb_programs; i++)
2670
        if(ac->programs[i]->id == id)
2671
            program = ac->programs[i];
2672

    
2673
    if(!program){
2674
        program = av_mallocz(sizeof(AVProgram));
2675
        if (!program)
2676
            return NULL;
2677
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2678
        program->discard = AVDISCARD_NONE;
2679
    }
2680
    program->id = id;
2681

    
2682
    return program;
2683
}
2684

    
2685
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2686
{
2687
    AVChapter *chapter = NULL;
2688
    int i;
2689

    
2690
    for(i=0; i<s->nb_chapters; i++)
2691
        if(s->chapters[i]->id == id)
2692
            chapter = s->chapters[i];
2693

    
2694
    if(!chapter){
2695
        chapter= av_mallocz(sizeof(AVChapter));
2696
        if(!chapter)
2697
            return NULL;
2698
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2699
    }
2700
#if FF_API_OLD_METADATA
2701
    av_free(chapter->title);
2702
#endif
2703
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2704
    chapter->id    = id;
2705
    chapter->time_base= time_base;
2706
    chapter->start = start;
2707
    chapter->end   = end;
2708

    
2709
    return chapter;
2710
}
2711

    
2712
/************************************************************/
2713
/* output media file */
2714

    
2715
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2716
{
2717
    int ret;
2718

    
2719
    if (s->oformat->priv_data_size > 0) {
2720
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2721
        if (!s->priv_data)
2722
            return AVERROR(ENOMEM);
2723
        if (s->oformat->priv_class) {
2724
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2725
            av_opt_set_defaults(s->priv_data);
2726
        }
2727
    } else
2728
        s->priv_data = NULL;
2729

    
2730
    if (s->oformat->set_parameters) {
2731
        ret = s->oformat->set_parameters(s, ap);
2732
        if (ret < 0)
2733
            return ret;
2734
    }
2735
    return 0;
2736
}
2737

    
2738
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2739
{
2740
    const AVCodecTag *avctag;
2741
    int n;
2742
    enum CodecID id = CODEC_ID_NONE;
2743
    unsigned int tag = 0;
2744

    
2745
    /**
2746
     * Check that tag + id is in the table
2747
     * If neither is in the table -> OK
2748
     * If tag is in the table with another id -> FAIL
2749
     * If id is in the table with another tag -> FAIL unless strict < normal
2750
     */
2751
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2752
        avctag = s->oformat->codec_tag[n];
2753
        while (avctag->id != CODEC_ID_NONE) {
2754
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2755
                id = avctag->id;
2756
                if (id == st->codec->codec_id)
2757
                    return 1;
2758
            }
2759
            if (avctag->id == st->codec->codec_id)
2760
                tag = avctag->tag;
2761
            avctag++;
2762
        }
2763
    }
2764
    if (id != CODEC_ID_NONE)
2765
        return 0;
2766
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2767
        return 0;
2768
    return 1;
2769
}
2770

    
2771
int av_write_header(AVFormatContext *s)
2772
{
2773
    int ret, i;
2774
    AVStream *st;
2775

    
2776
    // some sanity checks
2777
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2778
        av_log(s, AV_LOG_ERROR, "no streams\n");
2779
        return AVERROR(EINVAL);
2780
    }
2781

    
2782
    for(i=0;i<s->nb_streams;i++) {
2783
        st = s->streams[i];
2784

    
2785
        switch (st->codec->codec_type) {
2786
        case AVMEDIA_TYPE_AUDIO:
2787
            if(st->codec->sample_rate<=0){
2788
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2789
                return AVERROR(EINVAL);
2790
            }
2791
            if(!st->codec->block_align)
2792
                st->codec->block_align = st->codec->channels *
2793
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2794
            break;
2795
        case AVMEDIA_TYPE_VIDEO:
2796
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2797
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2798
                return AVERROR(EINVAL);
2799
            }
2800
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2801
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2802
                return AVERROR(EINVAL);
2803
            }
2804
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2805
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2806
                return AVERROR(EINVAL);
2807
            }
2808
            break;
2809
        }
2810

    
2811
        if(s->oformat->codec_tag){
2812
            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)){
2813
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2814
                st->codec->codec_tag= 0;
2815
            }
2816
            if(st->codec->codec_tag){
2817
                if (!validate_codec_tag(s, st)) {
2818
                    char tagbuf[32];
2819
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2820
                    av_log(s, AV_LOG_ERROR,
2821
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2822
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2823
                    return AVERROR_INVALIDDATA;
2824
                }
2825
            }else
2826
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2827
        }
2828

    
2829
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2830
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2831
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2832
    }
2833

    
2834
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2835
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2836
        if (!s->priv_data)
2837
            return AVERROR(ENOMEM);
2838
    }
2839

    
2840
#if FF_API_OLD_METADATA
2841
    ff_metadata_mux_compat(s);
2842
#endif
2843

    
2844
    /* set muxer identification string */
2845
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2846
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2847
    }
2848

    
2849
    if(s->oformat->write_header){
2850
        ret = s->oformat->write_header(s);
2851
        if (ret < 0)
2852
            return ret;
2853
    }
2854

    
2855
    /* init PTS generation */
2856
    for(i=0;i<s->nb_streams;i++) {
2857
        int64_t den = AV_NOPTS_VALUE;
2858
        st = s->streams[i];
2859

    
2860
        switch (st->codec->codec_type) {
2861
        case AVMEDIA_TYPE_AUDIO:
2862
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2863
            break;
2864
        case AVMEDIA_TYPE_VIDEO:
2865
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2866
            break;
2867
        default:
2868
            break;
2869
        }
2870
        if (den != AV_NOPTS_VALUE) {
2871
            if (den <= 0)
2872
                return AVERROR_INVALIDDATA;
2873
            av_frac_init(&st->pts, 0, 0, den);
2874
        }
2875
    }
2876
    return 0;
2877
}
2878

    
2879
//FIXME merge with compute_pkt_fields
2880
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2881
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2882
    int num, den, frame_size, i;
2883

    
2884
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2885

    
2886
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2887
        return -1;*/
2888

    
2889
    /* duration field */
2890
    if (pkt->duration == 0) {
2891
        compute_frame_duration(&num, &den, st, NULL, pkt);
2892
        if (den && num) {
2893
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2894
        }
2895
    }
2896

    
2897
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2898
        pkt->pts= pkt->dts;
2899

    
2900
    //XXX/FIXME this is a temporary hack until all encoders output pts
2901
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2902
        pkt->dts=
2903
//        pkt->pts= st->cur_dts;
2904
        pkt->pts= st->pts.val;
2905
    }
2906

    
2907
    //calculate dts from pts
2908
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2909
        st->pts_buffer[0]= pkt->pts;
2910
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2911
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2912
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2913
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2914

    
2915
        pkt->dts= st->pts_buffer[0];
2916
    }
2917

    
2918
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2919
        av_log(s, AV_LOG_ERROR,
2920
               "Non monotone timestamps in stream number %d: st->cur_dts:%"PRId64" >= pkt->dts:%"PRId64"\n",
2921
               st->index, st->cur_dts, pkt->dts);
2922
        return -1;
2923
    }
2924
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2925
        av_log(s, AV_LOG_ERROR,
2926
               "pts < dts in stream number %d\n: pkt->pts:%"PRId64" < pkt->dts:%"PRId64"\n",
2927
               st->index, pkt->pts, pkt->dts);
2928
        return -1;
2929
    }
2930

    
2931
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2932
    st->cur_dts= pkt->dts;
2933
    st->pts.val= pkt->dts;
2934

    
2935
    /* update pts */
2936
    switch (st->codec->codec_type) {
2937
    case AVMEDIA_TYPE_AUDIO:
2938
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2939

    
2940
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2941
           likely equal to the encoder delay, but it would be better if we
2942
           had the real timestamps from the encoder */
2943
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2944
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2945
        }
2946
        break;
2947
    case AVMEDIA_TYPE_VIDEO:
2948
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2949
        break;
2950
    default:
2951
        break;
2952
    }
2953
    return 0;
2954
}
2955

    
2956
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2957
{
2958
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2959

    
2960
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2961
        return ret;
2962

    
2963
    ret= s->oformat->write_packet(s, pkt);
2964
    if(!ret)
2965
        ret= url_ferror(s->pb);
2966
    return ret;
2967
}
2968

    
2969
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2970
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2971
{
2972
    AVPacketList **next_point, *this_pktl;
2973

    
2974
    this_pktl = av_mallocz(sizeof(AVPacketList));
2975
    this_pktl->pkt= *pkt;
2976
    pkt->destruct= NULL;             // do not free original but only the copy
2977
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2978

    
2979
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2980
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2981
    }else
2982
        next_point = &s->packet_buffer;
2983

    
2984
    if(*next_point){
2985
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2986
            while(!compare(s, &(*next_point)->pkt, pkt)){
2987
                next_point= &(*next_point)->next;
2988
            }
2989
            goto next_non_null;
2990
        }else{
2991
            next_point = &(s->packet_buffer_end->next);
2992
        }
2993
    }
2994
    assert(!*next_point);
2995

    
2996
    s->packet_buffer_end= this_pktl;
2997
next_non_null:
2998

    
2999
    this_pktl->next= *next_point;
3000

    
3001
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3002
    *next_point= this_pktl;
3003
}
3004

    
3005
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3006
{
3007
    AVStream *st = s->streams[ pkt ->stream_index];
3008
    AVStream *st2= s->streams[ next->stream_index];
3009
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3010
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3011
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3012
}
3013

    
3014
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3015
    AVPacketList *pktl;
3016
    int stream_count=0;
3017
    int i;
3018

    
3019
    if(pkt){
3020
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3021
    }
3022

    
3023
    for(i=0; i < s->nb_streams; i++)
3024
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3025

    
3026
    if(stream_count && (s->nb_streams == stream_count || flush)){
3027
        pktl= s->packet_buffer;
3028
        *out= pktl->pkt;
3029

    
3030
        s->packet_buffer= pktl->next;
3031
        if(!s->packet_buffer)
3032
            s->packet_buffer_end= NULL;
3033

    
3034
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3035
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3036
        av_freep(&pktl);
3037
        return 1;
3038
    }else{
3039
        av_init_packet(out);
3040
        return 0;
3041
    }
3042
}
3043

    
3044
/**
3045
 * Interleave an AVPacket correctly so it can be muxed.
3046
 * @param out the interleaved packet will be output here
3047
 * @param in the input packet
3048
 * @param flush 1 if no further packets are available as input and all
3049
 *              remaining packets should be output
3050
 * @return 1 if a packet was output, 0 if no packet could be output,
3051
 *         < 0 if an error occurred
3052
 */
3053
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3054
    if(s->oformat->interleave_packet)
3055
        return s->oformat->interleave_packet(s, out, in, flush);
3056
    else
3057
        return av_interleave_packet_per_dts(s, out, in, flush);
3058
}
3059

    
3060
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3061
    AVStream *st= s->streams[ pkt->stream_index];
3062

    
3063
    //FIXME/XXX/HACK drop zero sized packets
3064
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3065
        return 0;
3066

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

    
3071
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3072
        return -1;
3073

    
3074
    for(;;){
3075
        AVPacket opkt;
3076
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3077
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3078
            return ret;
3079

    
3080
        ret= s->oformat->write_packet(s, &opkt);
3081

    
3082
        av_free_packet(&opkt);
3083
        pkt= NULL;
3084

    
3085
        if(ret<0)
3086
            return ret;
3087
        if(url_ferror(s->pb))
3088
            return url_ferror(s->pb);
3089
    }
3090
}
3091

    
3092
int av_write_trailer(AVFormatContext *s)
3093
{
3094
    int ret, i;
3095

    
3096
    for(;;){
3097
        AVPacket pkt;
3098
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3099
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3100
            goto fail;
3101
        if(!ret)
3102
            break;
3103

    
3104
        ret= s->oformat->write_packet(s, &pkt);
3105

    
3106
        av_free_packet(&pkt);
3107

    
3108
        if(ret<0)
3109
            goto fail;
3110
        if(url_ferror(s->pb))
3111
            goto fail;
3112
    }
3113

    
3114
    if(s->oformat->write_trailer)
3115
        ret = s->oformat->write_trailer(s);
3116
fail:
3117
    if(ret == 0)
3118
       ret=url_ferror(s->pb);
3119
    for(i=0;i<s->nb_streams;i++) {
3120
        av_freep(&s->streams[i]->priv_data);
3121
        av_freep(&s->streams[i]->index_entries);
3122
    }
3123
    av_freep(&s->priv_data);
3124
    return ret;
3125
}
3126

    
3127
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3128
{
3129
    int i, j;
3130
    AVProgram *program=NULL;
3131
    void *tmp;
3132

    
3133
    if (idx >= ac->nb_streams) {
3134
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3135
        return;
3136
    }
3137

    
3138
    for(i=0; i<ac->nb_programs; i++){
3139
        if(ac->programs[i]->id != progid)
3140
            continue;
3141
        program = ac->programs[i];
3142
        for(j=0; j<program->nb_stream_indexes; j++)
3143
            if(program->stream_index[j] == idx)
3144
                return;
3145

    
3146
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3147
        if(!tmp)
3148
            return;
3149
        program->stream_index = tmp;
3150
        program->stream_index[program->nb_stream_indexes++] = idx;
3151
        return;
3152
    }
3153
}
3154

    
3155
static void print_fps(double d, const char *postfix){
3156
    uint64_t v= lrintf(d*100);
3157
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3158
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3159
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3160
}
3161

    
3162
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3163
{
3164
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3165
        AVMetadataTag *tag=NULL;
3166

    
3167
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3168
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3169
            if(strcmp("language", tag->key))
3170
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3171
        }
3172
    }
3173
}
3174

    
3175
/* "user interface" functions */
3176
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3177
{
3178
    char buf[256];
3179
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3180
    AVStream *st = ic->streams[i];
3181
    int g = av_gcd(st->time_base.num, st->time_base.den);
3182
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3183
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3184
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3185
    /* the pid is an important information, so we display it */
3186
    /* XXX: add a generic system */
3187
    if (flags & AVFMT_SHOW_IDS)
3188
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3189
    if (lang)
3190
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3191
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3192
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3193
    if (st->sample_aspect_ratio.num && // default
3194
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3195
        AVRational display_aspect_ratio;
3196
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3197
                  st->codec->width*st->sample_aspect_ratio.num,
3198
                  st->codec->height*st->sample_aspect_ratio.den,
3199
                  1024*1024);
3200
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3201
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3202
                 display_aspect_ratio.num, display_aspect_ratio.den);
3203
    }
3204
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3205
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3206
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3207
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3208
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3209
        if(st->time_base.den && st->time_base.num)
3210
            print_fps(1/av_q2d(st->time_base), "tbn");
3211
        if(st->codec->time_base.den && st->codec->time_base.num)
3212
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3213
    }
3214
    av_log(NULL, AV_LOG_INFO, "\n");
3215
    dump_metadata(NULL, st->metadata, "    ");
3216
}
3217

    
3218
void dump_format(AVFormatContext *ic,
3219
                 int index,
3220
                 const char *url,
3221
                 int is_output)
3222
{
3223
    int i;
3224
    uint8_t *printed = av_mallocz(ic->nb_streams);
3225
    if (ic->nb_streams && !printed)
3226
        return;
3227

    
3228
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3229
            is_output ? "Output" : "Input",
3230
            index,
3231
            is_output ? ic->oformat->name : ic->iformat->name,
3232
            is_output ? "to" : "from", url);
3233
    dump_metadata(NULL, ic->metadata, "  ");
3234
    if (!is_output) {
3235
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3236
        if (ic->duration != AV_NOPTS_VALUE) {
3237
            int hours, mins, secs, us;
3238
            secs = ic->duration / AV_TIME_BASE;
3239
            us = ic->duration % AV_TIME_BASE;
3240
            mins = secs / 60;
3241
            secs %= 60;
3242
            hours = mins / 60;
3243
            mins %= 60;
3244
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3245
                   (100 * us) / AV_TIME_BASE);
3246
        } else {
3247
            av_log(NULL, AV_LOG_INFO, "N/A");
3248
        }
3249
        if (ic->start_time != AV_NOPTS_VALUE) {
3250
            int secs, us;
3251
            av_log(NULL, AV_LOG_INFO, ", start: ");
3252
            secs = ic->start_time / AV_TIME_BASE;
3253
            us = abs(ic->start_time % AV_TIME_BASE);
3254
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3255
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3256
        }
3257
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3258
        if (ic->bit_rate) {
3259
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3260
        } else {
3261
            av_log(NULL, AV_LOG_INFO, "N/A");
3262
        }
3263
        av_log(NULL, AV_LOG_INFO, "\n");
3264
    }
3265
    for (i = 0; i < ic->nb_chapters; i++) {
3266
        AVChapter *ch = ic->chapters[i];
3267
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3268
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3269
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3270

    
3271
        dump_metadata(NULL, ch->metadata, "    ");
3272
    }
3273
    if(ic->nb_programs) {
3274
        int j, k, total = 0;
3275
        for(j=0; j<ic->nb_programs; j++) {
3276
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3277
                                                  "name", NULL, 0);
3278
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3279
                   name ? name->value : "");
3280
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3281
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3282
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3283
                printed[ic->programs[j]->stream_index[k]] = 1;
3284
            }
3285
            total += ic->programs[j]->nb_stream_indexes;
3286
        }
3287
        if (total < ic->nb_streams)
3288
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3289
    }
3290
    for(i=0;i<ic->nb_streams;i++)
3291
        if (!printed[i])
3292
            dump_stream_format(ic, i, index, is_output);
3293

    
3294
    av_free(printed);
3295
}
3296

    
3297
#if FF_API_PARSE_FRAME_PARAM
3298
#include "libavcore/parseutils.h"
3299

    
3300
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3301
{
3302
    return av_parse_video_size(width_ptr, height_ptr, str);
3303
}
3304

    
3305
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3306
{
3307
    AVRational frame_rate;
3308
    int ret = av_parse_video_rate(&frame_rate, arg);
3309
    *frame_rate_num= frame_rate.num;
3310
    *frame_rate_den= frame_rate.den;
3311
    return ret;
3312
}
3313
#endif
3314

    
3315
int64_t av_gettime(void)
3316
{
3317
    struct timeval tv;
3318
    gettimeofday(&tv,NULL);
3319
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3320
}
3321

    
3322
uint64_t ff_ntp_time(void)
3323
{
3324
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3325
}
3326

    
3327
int64_t parse_date(const char *datestr, int duration)
3328
{
3329
    const char *p;
3330
    int64_t t;
3331
    struct tm dt;
3332
    int i;
3333
    static const char * const date_fmt[] = {
3334
        "%Y-%m-%d",
3335
        "%Y%m%d",
3336
    };
3337
    static const char * const time_fmt[] = {
3338
        "%H:%M:%S",
3339
        "%H%M%S",
3340
    };
3341
    const char *q;
3342
    int is_utc, len;
3343
    char lastch;
3344
    int negative = 0;
3345

    
3346
#undef time
3347
    time_t now = time(0);
3348

    
3349
    len = strlen(datestr);
3350
    if (len > 0)
3351
        lastch = datestr[len - 1];
3352
    else
3353
        lastch = '\0';
3354
    is_utc = (lastch == 'z' || lastch == 'Z');
3355

    
3356
    memset(&dt, 0, sizeof(dt));
3357

    
3358
    p = datestr;
3359
    q = NULL;
3360
    if (!duration) {
3361
        if (!strncasecmp(datestr, "now", len))
3362
            return (int64_t) now * 1000000;
3363

    
3364
        /* parse the year-month-day part */
3365
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3366
            q = small_strptime(p, date_fmt[i], &dt);
3367
            if (q) {
3368
                break;
3369
            }
3370
        }
3371

    
3372
        /* if the year-month-day part is missing, then take the
3373
         * current year-month-day time */
3374
        if (!q) {
3375
            if (is_utc) {
3376
                dt = *gmtime(&now);
3377
            } else {
3378
                dt = *localtime(&now);
3379
            }
3380
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3381
        } else {
3382
            p = q;
3383
        }
3384

    
3385
        if (*p == 'T' || *p == 't' || *p == ' ')
3386
            p++;
3387

    
3388
        /* parse the hour-minute-second part */
3389
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3390
            q = small_strptime(p, time_fmt[i], &dt);
3391
            if (q) {
3392
                break;
3393
            }
3394
        }
3395
    } else {
3396
        /* parse datestr as a duration */
3397
        if (p[0] == '-') {
3398
            negative = 1;
3399
            ++p;
3400
        }
3401
        /* parse datestr as HH:MM:SS */
3402
        q = small_strptime(p, time_fmt[0], &dt);
3403
        if (!q) {
3404
            /* parse datestr as S+ */
3405
            dt.tm_sec = strtol(p, (char **)&q, 10);
3406
            if (q == p)
3407
                /* the parsing didn't succeed */
3408
                return INT64_MIN;
3409
            dt.tm_min = 0;
3410
            dt.tm_hour = 0;
3411
        }
3412
    }
3413

    
3414
    /* Now we have all the fields that we can get */
3415
    if (!q) {
3416
        return INT64_MIN;
3417
    }
3418

    
3419
    if (duration) {
3420
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3421
    } else {
3422
        dt.tm_isdst = -1;       /* unknown */
3423
        if (is_utc) {
3424
            t = mktimegm(&dt);
3425
        } else {
3426
            t = mktime(&dt);
3427
        }
3428
    }
3429

    
3430
    t *= 1000000;
3431

    
3432
    /* parse the .m... part */
3433
    if (*q == '.') {
3434
        int val, n;
3435
        q++;
3436
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3437
            if (!isdigit(*q))
3438
                break;
3439
            val += n * (*q - '0');
3440
        }
3441
        t += val;
3442
    }
3443
    return negative ? -t : t;
3444
}
3445

    
3446
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3447
{
3448
    const char *p;
3449
    char tag[128], *q;
3450

    
3451
    p = info;
3452
    if (*p == '?')
3453
        p++;
3454
    for(;;) {
3455
        q = tag;
3456
        while (*p != '\0' && *p != '=' && *p != '&') {
3457
            if ((q - tag) < sizeof(tag) - 1)
3458
                *q++ = *p;
3459
            p++;
3460
        }
3461
        *q = '\0';
3462
        q = arg;
3463
        if (*p == '=') {
3464
            p++;
3465
            while (*p != '&' && *p != '\0') {
3466
                if ((q - arg) < arg_size - 1) {
3467
                    if (*p == '+')
3468
                        *q++ = ' ';
3469
                    else
3470
                        *q++ = *p;
3471
                }
3472
                p++;
3473
            }
3474
        }
3475
        *q = '\0';
3476
        if (!strcmp(tag, tag1))
3477
            return 1;
3478
        if (*p != '&')
3479
            break;
3480
        p++;
3481
    }
3482
    return 0;
3483
}
3484

    
3485
int av_get_frame_filename(char *buf, int buf_size,
3486
                          const char *path, int number)
3487
{
3488
    const char *p;
3489
    char *q, buf1[20], c;
3490
    int nd, len, percentd_found;
3491

    
3492
    q = buf;
3493
    p = path;
3494
    percentd_found = 0;
3495
    for(;;) {
3496
        c = *p++;
3497
        if (c == '\0')
3498
            break;
3499
        if (c == '%') {
3500
            do {
3501
                nd = 0;
3502
                while (isdigit(*p)) {
3503
                    nd = nd * 10 + *p++ - '0';
3504
                }
3505
                c = *p++;
3506
            } while (isdigit(c));
3507

    
3508
            switch(c) {
3509
            case '%':
3510
                goto addchar;
3511
            case 'd':
3512
                if (percentd_found)
3513
                    goto fail;
3514
                percentd_found = 1;
3515
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3516
                len = strlen(buf1);
3517
                if ((q - buf + len) > buf_size - 1)
3518
                    goto fail;
3519
                memcpy(q, buf1, len);
3520
                q += len;
3521
                break;
3522
            default:
3523
                goto fail;
3524
            }
3525
        } else {
3526
        addchar:
3527
            if ((q - buf) < buf_size - 1)
3528
                *q++ = c;
3529
        }
3530
    }
3531
    if (!percentd_found)
3532
        goto fail;
3533
    *q = '\0';
3534
    return 0;
3535
 fail:
3536
    *q = '\0';
3537
    return -1;
3538
}
3539

    
3540
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3541
{
3542
    int len, i, j, c;
3543
#undef fprintf
3544
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3545

    
3546
    for(i=0;i<size;i+=16) {
3547
        len = size - i;
3548
        if (len > 16)
3549
            len = 16;
3550
        PRINT("%08x ", i);
3551
        for(j=0;j<16;j++) {
3552
            if (j < len)
3553
                PRINT(" %02x", buf[i+j]);
3554
            else
3555
                PRINT("   ");
3556
        }
3557
        PRINT(" ");
3558
        for(j=0;j<len;j++) {
3559
            c = buf[i+j];
3560
            if (c < ' ' || c > '~')
3561
                c = '.';
3562
            PRINT("%c", c);
3563
        }
3564
        PRINT("\n");
3565
    }
3566
#undef PRINT
3567
}
3568

    
3569
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3570
{
3571
    hex_dump_internal(NULL, f, 0, buf, size);
3572
}
3573

    
3574
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3575
{
3576
    hex_dump_internal(avcl, NULL, level, buf, size);
3577
}
3578

    
3579
 //FIXME needs to know the time_base
3580
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3581
{
3582
#undef fprintf
3583
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3584
    PRINT("stream #%d:\n", pkt->stream_index);
3585
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3586
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3587
    /* DTS is _always_ valid after av_read_frame() */
3588
    PRINT("  dts=");
3589
    if (pkt->dts == AV_NOPTS_VALUE)
3590
        PRINT("N/A");
3591
    else
3592
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3593
    /* PTS may not be known if B-frames are present. */
3594
    PRINT("  pts=");
3595
    if (pkt->pts == AV_NOPTS_VALUE)
3596
        PRINT("N/A");
3597
    else
3598
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3599
    PRINT("\n");
3600
    PRINT("  size=%d\n", pkt->size);
3601
#undef PRINT
3602
    if (dump_payload)
3603
        av_hex_dump(f, pkt->data, pkt->size);
3604
}
3605

    
3606
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3607
{
3608
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3609
}
3610

    
3611
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3612
{
3613
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3614
}
3615

    
3616
#if FF_API_URL_SPLIT
3617
attribute_deprecated
3618
void ff_url_split(char *proto, int proto_size,
3619
                  char *authorization, int authorization_size,
3620
                  char *hostname, int hostname_size,
3621
                  int *port_ptr,
3622
                  char *path, int path_size,
3623
                  const char *url)
3624
{
3625
    av_url_split(proto, proto_size,
3626
                 authorization, authorization_size,
3627
                 hostname, hostname_size,
3628
                 port_ptr,
3629
                 path, path_size,
3630
                 url);
3631
}
3632
#endif
3633

    
3634
void av_url_split(char *proto, int proto_size,
3635
                  char *authorization, int authorization_size,
3636
                  char *hostname, int hostname_size,
3637
                  int *port_ptr,
3638
                  char *path, int path_size,
3639
                  const char *url)
3640
{
3641
    const char *p, *ls, *at, *col, *brk;
3642

    
3643
    if (port_ptr)               *port_ptr = -1;
3644
    if (proto_size > 0)         proto[0] = 0;
3645
    if (authorization_size > 0) authorization[0] = 0;
3646
    if (hostname_size > 0)      hostname[0] = 0;
3647
    if (path_size > 0)          path[0] = 0;
3648

    
3649
    /* parse protocol */
3650
    if ((p = strchr(url, ':'))) {
3651
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3652
        p++; /* skip ':' */
3653
        if (*p == '/') p++;
3654
        if (*p == '/') p++;
3655
    } else {
3656
        /* no protocol means plain filename */
3657
        av_strlcpy(path, url, path_size);
3658
        return;
3659
    }
3660

    
3661
    /* separate path from hostname */
3662
    ls = strchr(p, '/');
3663
    if(!ls)
3664
        ls = strchr(p, '?');
3665
    if(ls)
3666
        av_strlcpy(path, ls, path_size);
3667
    else
3668
        ls = &p[strlen(p)]; // XXX
3669

    
3670
    /* the rest is hostname, use that to parse auth/port */
3671
    if (ls != p) {
3672
        /* authorization (user[:pass]@hostname) */
3673
        if ((at = strchr(p, '@')) && at < ls) {
3674
            av_strlcpy(authorization, p,
3675
                       FFMIN(authorization_size, at + 1 - p));
3676
            p = at + 1; /* skip '@' */
3677
        }
3678

    
3679
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3680
            /* [host]:port */
3681
            av_strlcpy(hostname, p + 1,
3682
                       FFMIN(hostname_size, brk - p));
3683
            if (brk[1] == ':' && port_ptr)
3684
                *port_ptr = atoi(brk + 2);
3685
        } else if ((col = strchr(p, ':')) && col < ls) {
3686
            av_strlcpy(hostname, p,
3687
                       FFMIN(col + 1 - p, hostname_size));
3688
            if (port_ptr) *port_ptr = atoi(col + 1);
3689
        } else
3690
            av_strlcpy(hostname, p,
3691
                       FFMIN(ls + 1 - p, hostname_size));
3692
    }
3693
}
3694

    
3695
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3696
{
3697
    int i;
3698
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3699
                                           '4', '5', '6', '7',
3700
                                           '8', '9', 'A', 'B',
3701
                                           'C', 'D', 'E', 'F' };
3702
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3703
                                           '4', '5', '6', '7',
3704
                                           '8', '9', 'a', 'b',
3705
                                           'c', 'd', 'e', 'f' };
3706
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3707

    
3708
    for(i = 0; i < s; i++) {
3709
        buff[i * 2]     = hex_table[src[i] >> 4];
3710
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3711
    }
3712

    
3713
    return buff;
3714
}
3715

    
3716
int ff_hex_to_data(uint8_t *data, const char *p)
3717
{
3718
    int c, len, v;
3719

    
3720
    len = 0;
3721
    v = 1;
3722
    for (;;) {
3723
        p += strspn(p, SPACE_CHARS);
3724
        if (*p == '\0')
3725
            break;
3726
        c = toupper((unsigned char) *p++);
3727
        if (c >= '0' && c <= '9')
3728
            c = c - '0';
3729
        else if (c >= 'A' && c <= 'F')
3730
            c = c - 'A' + 10;
3731
        else
3732
            break;
3733
        v = (v << 4) | c;
3734
        if (v & 0x100) {
3735
            if (data)
3736
                data[len] = v;
3737
            len++;
3738
            v = 1;
3739
        }
3740
    }
3741
    return len;
3742
}
3743

    
3744
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3745
                     unsigned int pts_num, unsigned int pts_den)
3746
{
3747
    s->pts_wrap_bits = pts_wrap_bits;
3748

    
3749
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3750
        if(s->time_base.num != pts_num)
3751
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3752
    }else
3753
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3754

    
3755
    if(!s->time_base.num || !s->time_base.den)
3756
        s->time_base.num= s->time_base.den= 0;
3757
}
3758

    
3759
int ff_url_join(char *str, int size, const char *proto,
3760
                const char *authorization, const char *hostname,
3761
                int port, const char *fmt, ...)
3762
{
3763
#if CONFIG_NETWORK
3764
    struct addrinfo hints, *ai;
3765
#endif
3766

    
3767
    str[0] = '\0';
3768
    if (proto)
3769
        av_strlcatf(str, size, "%s://", proto);
3770
    if (authorization && authorization[0])
3771
        av_strlcatf(str, size, "%s@", authorization);
3772
#if CONFIG_NETWORK && defined(AF_INET6)
3773
    /* Determine if hostname is a numerical IPv6 address,
3774
     * properly escape it within [] in that case. */
3775
    memset(&hints, 0, sizeof(hints));
3776
    hints.ai_flags = AI_NUMERICHOST;
3777
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3778
        if (ai->ai_family == AF_INET6) {
3779
            av_strlcat(str, "[", size);
3780
            av_strlcat(str, hostname, size);
3781
            av_strlcat(str, "]", size);
3782
        } else {
3783
            av_strlcat(str, hostname, size);
3784
        }
3785
        freeaddrinfo(ai);
3786
    } else
3787
#endif
3788
        /* Not an IPv6 address, just output the plain string. */
3789
        av_strlcat(str, hostname, size);
3790

    
3791
    if (port >= 0)
3792
        av_strlcatf(str, size, ":%d", port);
3793
    if (fmt) {
3794
        va_list vl;
3795
        int len = strlen(str);
3796

    
3797
        va_start(vl, fmt);
3798
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3799
        va_end(vl);
3800
    }
3801
    return strlen(str);
3802
}
3803

    
3804
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3805
                     AVFormatContext *src)
3806
{
3807
    AVPacket local_pkt;
3808

    
3809
    local_pkt = *pkt;
3810
    local_pkt.stream_index = dst_stream;
3811
    if (pkt->pts != AV_NOPTS_VALUE)
3812
        local_pkt.pts = av_rescale_q(pkt->pts,
3813
                                     src->streams[pkt->stream_index]->time_base,
3814
                                     dst->streams[dst_stream]->time_base);
3815
    if (pkt->dts != AV_NOPTS_VALUE)
3816
        local_pkt.dts = av_rescale_q(pkt->dts,
3817
                                     src->streams[pkt->stream_index]->time_base,
3818
                                     dst->streams[dst_stream]->time_base);
3819
    return av_write_frame(dst, &local_pkt);
3820
}
3821

    
3822
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3823
                        void *context)
3824
{
3825
    const char *ptr = str;
3826

    
3827
    /* Parse key=value pairs. */
3828
    for (;;) {
3829
        const char *key;
3830
        char *dest = NULL, *dest_end;
3831
        int key_len, dest_len = 0;
3832

    
3833
        /* Skip whitespace and potential commas. */
3834
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3835
            ptr++;
3836
        if (!*ptr)
3837
            break;
3838

    
3839
        key = ptr;
3840

    
3841
        if (!(ptr = strchr(key, '=')))
3842
            break;
3843
        ptr++;
3844
        key_len = ptr - key;
3845

    
3846
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3847
        dest_end = dest + dest_len - 1;
3848

    
3849
        if (*ptr == '\"') {
3850
            ptr++;
3851
            while (*ptr && *ptr != '\"') {
3852
                if (*ptr == '\\') {
3853
                    if (!ptr[1])
3854
                        break;
3855
                    if (dest && dest < dest_end)
3856
                        *dest++ = ptr[1];
3857
                    ptr += 2;
3858
                } else {
3859
                    if (dest && dest < dest_end)
3860
                        *dest++ = *ptr;
3861
                    ptr++;
3862
                }
3863
            }
3864
            if (*ptr == '\"')
3865
                ptr++;
3866
        } else {
3867
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3868
                if (dest && dest < dest_end)
3869
                    *dest++ = *ptr;
3870
        }
3871
        if (dest)
3872
            *dest = 0;
3873
    }
3874
}
3875

    
3876
int ff_find_stream_index(AVFormatContext *s, int id)
3877
{
3878
    int i;
3879
    for (i = 0; i < s->nb_streams; i++) {
3880
        if (s->streams[i]->id == id)
3881
            return i;
3882
    }
3883
    return -1;
3884
}