Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ f124b087

History | View | Annotate | Download (123 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 || st->codec->sample_rate <= 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 ff_add_index_entry(AVIndexEntry **index_entries,
1374
                       int *nb_index_entries,
1375
                       unsigned int *index_entries_allocated_size,
1376
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1377
{
1378
    AVIndexEntry *entries, *ie;
1379
    int index;
1380

    
1381
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1382
        return -1;
1383

    
1384
    entries = av_fast_realloc(*index_entries,
1385
                              index_entries_allocated_size,
1386
                              (*nb_index_entries + 1) *
1387
                              sizeof(AVIndexEntry));
1388
    if(!entries)
1389
        return -1;
1390

    
1391
    *index_entries= entries;
1392

    
1393
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1394

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

    
1410
    ie->pos = pos;
1411
    ie->timestamp = timestamp;
1412
    ie->min_distance= distance;
1413
    ie->size= size;
1414
    ie->flags = flags;
1415

    
1416
    return index;
1417
}
1418

    
1419
int av_add_index_entry(AVStream *st,
1420
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1421
{
1422
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1423
                              &st->index_entries_allocated_size, pos,
1424
                              timestamp, size, distance, flags);
1425
}
1426

    
1427
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1428
                              int64_t wanted_timestamp, int flags)
1429
{
1430
    int a, b, m;
1431
    int64_t timestamp;
1432

    
1433
    a = - 1;
1434
    b = nb_entries;
1435

    
1436
    //optimize appending index entries at the end
1437
    if(b && entries[b-1].timestamp < wanted_timestamp)
1438
        a= b-1;
1439

    
1440
    while (b - a > 1) {
1441
        m = (a + b) >> 1;
1442
        timestamp = entries[m].timestamp;
1443
        if(timestamp >= wanted_timestamp)
1444
            b = m;
1445
        if(timestamp <= wanted_timestamp)
1446
            a = m;
1447
    }
1448
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1449

    
1450
    if(!(flags & AVSEEK_FLAG_ANY)){
1451
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1452
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1453
        }
1454
    }
1455

    
1456
    if(m == nb_entries)
1457
        return -1;
1458
    return  m;
1459
}
1460

    
1461
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1462
                              int flags)
1463
{
1464
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1465
                                     wanted_timestamp, flags);
1466
}
1467

    
1468
#define DEBUG_SEEK
1469

    
1470
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1471
    AVInputFormat *avif= s->iformat;
1472
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1473
    int64_t ts_min, ts_max, ts;
1474
    int index;
1475
    int64_t ret;
1476
    AVStream *st;
1477

    
1478
    if (stream_index < 0)
1479
        return -1;
1480

    
1481
#ifdef DEBUG_SEEK
1482
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1483
#endif
1484

    
1485
    ts_max=
1486
    ts_min= AV_NOPTS_VALUE;
1487
    pos_limit= -1; //gcc falsely says it may be uninitialized
1488

    
1489
    st= s->streams[stream_index];
1490
    if(st->index_entries){
1491
        AVIndexEntry *e;
1492

    
1493
        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()
1494
        index= FFMAX(index, 0);
1495
        e= &st->index_entries[index];
1496

    
1497
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1498
            pos_min= e->pos;
1499
            ts_min= e->timestamp;
1500
#ifdef DEBUG_SEEK
1501
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1502
                   pos_min,ts_min);
1503
#endif
1504
        }else{
1505
            assert(index==0);
1506
        }
1507

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

    
1523
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1524
    if(pos<0)
1525
        return -1;
1526

    
1527
    /* do the seek */
1528
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1529
        return ret;
1530

    
1531
    av_update_cur_dts(s, st, ts);
1532

    
1533
    return 0;
1534
}
1535

    
1536
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 )){
1537
    int64_t pos, ts;
1538
    int64_t start_pos, filesize;
1539
    int no_change;
1540

    
1541
#ifdef DEBUG_SEEK
1542
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1543
#endif
1544

    
1545
    if(ts_min == AV_NOPTS_VALUE){
1546
        pos_min = s->data_offset;
1547
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1548
        if (ts_min == AV_NOPTS_VALUE)
1549
            return -1;
1550
    }
1551

    
1552
    if(ts_max == AV_NOPTS_VALUE){
1553
        int step= 1024;
1554
        filesize = url_fsize(s->pb);
1555
        pos_max = filesize - 1;
1556
        do{
1557
            pos_max -= step;
1558
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1559
            step += step;
1560
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1561
        if (ts_max == AV_NOPTS_VALUE)
1562
            return -1;
1563

    
1564
        for(;;){
1565
            int64_t tmp_pos= pos_max + 1;
1566
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1567
            if(tmp_ts == AV_NOPTS_VALUE)
1568
                break;
1569
            ts_max= tmp_ts;
1570
            pos_max= tmp_pos;
1571
            if(tmp_pos >= filesize)
1572
                break;
1573
        }
1574
        pos_limit= pos_max;
1575
    }
1576

    
1577
    if(ts_min > ts_max){
1578
        return -1;
1579
    }else if(ts_min == ts_max){
1580
        pos_limit= pos_min;
1581
    }
1582

    
1583
    no_change=0;
1584
    while (pos_min < pos_limit) {
1585
#ifdef DEBUG_SEEK
1586
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1587
               pos_min, pos_max,
1588
               ts_min, ts_max);
1589
#endif
1590
        assert(pos_limit <= pos_max);
1591

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

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

    
1637
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1638
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1639
#ifdef DEBUG_SEEK
1640
    pos_min = pos;
1641
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1642
    pos_min++;
1643
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1644
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1645
           pos, ts_min, target_ts, ts_max);
1646
#endif
1647
    *ts_ret= ts;
1648
    return pos;
1649
}
1650

    
1651
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1652
    int64_t pos_min, pos_max;
1653
#if 0
1654
    AVStream *st;
1655

1656
    if (stream_index < 0)
1657
        return -1;
1658

1659
    st= s->streams[stream_index];
1660
#endif
1661

    
1662
    pos_min = s->data_offset;
1663
    pos_max = url_fsize(s->pb) - 1;
1664

    
1665
    if     (pos < pos_min) pos= pos_min;
1666
    else if(pos > pos_max) pos= pos_max;
1667

    
1668
    url_fseek(s->pb, pos, SEEK_SET);
1669

    
1670
#if 0
1671
    av_update_cur_dts(s, st, ts);
1672
#endif
1673
    return 0;
1674
}
1675

    
1676
static int av_seek_frame_generic(AVFormatContext *s,
1677
                                 int stream_index, int64_t timestamp, int flags)
1678
{
1679
    int index;
1680
    int64_t ret;
1681
    AVStream *st;
1682
    AVIndexEntry *ie;
1683

    
1684
    st = s->streams[stream_index];
1685

    
1686
    index = av_index_search_timestamp(st, timestamp, flags);
1687

    
1688
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1689
        return -1;
1690

    
1691
    if(index < 0 || index==st->nb_index_entries-1){
1692
        int i;
1693
        AVPacket pkt;
1694

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

    
1723
    ff_read_frame_flush(s);
1724
    if (s->iformat->read_seek){
1725
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1726
            return 0;
1727
    }
1728
    ie = &st->index_entries[index];
1729
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1730
        return ret;
1731
    av_update_cur_dts(s, st, ie->timestamp);
1732

    
1733
    return 0;
1734
}
1735

    
1736
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1737
{
1738
    int ret;
1739
    AVStream *st;
1740

    
1741
    ff_read_frame_flush(s);
1742

    
1743
    if(flags & AVSEEK_FLAG_BYTE)
1744
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1745

    
1746
    if(stream_index < 0){
1747
        stream_index= av_find_default_stream_index(s);
1748
        if(stream_index < 0)
1749
            return -1;
1750

    
1751
        st= s->streams[stream_index];
1752
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1753
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1754
    }
1755

    
1756
    /* first, we try the format specific seek */
1757
    if (s->iformat->read_seek)
1758
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1759
    else
1760
        ret = -1;
1761
    if (ret >= 0) {
1762
        return 0;
1763
    }
1764

    
1765
    if(s->iformat->read_timestamp)
1766
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1767
    else
1768
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1769
}
1770

    
1771
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1772
{
1773
    if(min_ts > ts || max_ts < ts)
1774
        return -1;
1775

    
1776
    ff_read_frame_flush(s);
1777

    
1778
    if (s->iformat->read_seek2)
1779
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1780

    
1781
    if(s->iformat->read_timestamp){
1782
        //try to seek via read_timestamp()
1783
    }
1784

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

    
1790
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1791
}
1792

    
1793
/*******************************************************/
1794

    
1795
/**
1796
 * Return TRUE if the stream has accurate duration in any stream.
1797
 *
1798
 * @return TRUE if the stream has accurate duration for at least one component.
1799
 */
1800
static int av_has_duration(AVFormatContext *ic)
1801
{
1802
    int i;
1803
    AVStream *st;
1804

    
1805
    for(i = 0;i < ic->nb_streams; i++) {
1806
        st = ic->streams[i];
1807
        if (st->duration != AV_NOPTS_VALUE)
1808
            return 1;
1809
    }
1810
    return 0;
1811
}
1812

    
1813
/**
1814
 * Estimate the stream timings from the one of each components.
1815
 *
1816
 * Also computes the global bitrate if possible.
1817
 */
1818
static void av_update_stream_timings(AVFormatContext *ic)
1819
{
1820
    int64_t start_time, start_time1, end_time, end_time1;
1821
    int64_t duration, duration1;
1822
    int i;
1823
    AVStream *st;
1824

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

    
1864
static void fill_all_stream_timings(AVFormatContext *ic)
1865
{
1866
    int i;
1867
    AVStream *st;
1868

    
1869
    av_update_stream_timings(ic);
1870
    for(i = 0;i < ic->nb_streams; i++) {
1871
        st = ic->streams[i];
1872
        if (st->start_time == AV_NOPTS_VALUE) {
1873
            if(ic->start_time != AV_NOPTS_VALUE)
1874
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1875
            if(ic->duration != AV_NOPTS_VALUE)
1876
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1877
        }
1878
    }
1879
}
1880

    
1881
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1882
{
1883
    int64_t filesize, duration;
1884
    int bit_rate, i;
1885
    AVStream *st;
1886

    
1887
    /* if bit_rate is already set, we believe it */
1888
    if (ic->bit_rate <= 0) {
1889
        bit_rate = 0;
1890
        for(i=0;i<ic->nb_streams;i++) {
1891
            st = ic->streams[i];
1892
            if (st->codec->bit_rate > 0)
1893
            bit_rate += st->codec->bit_rate;
1894
        }
1895
        ic->bit_rate = bit_rate;
1896
    }
1897

    
1898
    /* if duration is already set, we believe it */
1899
    if (ic->duration == AV_NOPTS_VALUE &&
1900
        ic->bit_rate != 0 &&
1901
        ic->file_size != 0)  {
1902
        filesize = ic->file_size;
1903
        if (filesize > 0) {
1904
            for(i = 0; i < ic->nb_streams; i++) {
1905
                st = ic->streams[i];
1906
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1907
                if (st->duration == AV_NOPTS_VALUE)
1908
                    st->duration = duration;
1909
            }
1910
        }
1911
    }
1912
}
1913

    
1914
#define DURATION_MAX_READ_SIZE 250000
1915
#define DURATION_MAX_RETRY 3
1916

    
1917
/* only usable for MPEG-PS streams */
1918
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1919
{
1920
    AVPacket pkt1, *pkt = &pkt1;
1921
    AVStream *st;
1922
    int read_size, i, ret;
1923
    int64_t end_time;
1924
    int64_t filesize, offset, duration;
1925
    int retry=0;
1926

    
1927
    ic->cur_st = NULL;
1928

    
1929
    /* flush packet queue */
1930
    flush_packet_queue(ic);
1931

    
1932
    for (i=0; i<ic->nb_streams; i++) {
1933
        st = ic->streams[i];
1934
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1935
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1936

    
1937
        if (st->parser) {
1938
            av_parser_close(st->parser);
1939
            st->parser= NULL;
1940
            av_free_packet(&st->cur_pkt);
1941
        }
1942
    }
1943

    
1944
    /* estimate the end time (duration) */
1945
    /* XXX: may need to support wrapping */
1946
    filesize = ic->file_size;
1947
    end_time = AV_NOPTS_VALUE;
1948
    do{
1949
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1950
    if (offset < 0)
1951
        offset = 0;
1952

    
1953
    url_fseek(ic->pb, offset, SEEK_SET);
1954
    read_size = 0;
1955
    for(;;) {
1956
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1957
            break;
1958

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

    
1986
    fill_all_stream_timings(ic);
1987

    
1988
    url_fseek(ic->pb, old_offset, SEEK_SET);
1989
    for (i=0; i<ic->nb_streams; i++) {
1990
        st= ic->streams[i];
1991
        st->cur_dts= st->first_dts;
1992
        st->last_IP_pts = AV_NOPTS_VALUE;
1993
    }
1994
}
1995

    
1996
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1997
{
1998
    int64_t file_size;
1999

    
2000
    /* get the file size, if possible */
2001
    if (ic->iformat->flags & AVFMT_NOFILE) {
2002
        file_size = 0;
2003
    } else {
2004
        file_size = url_fsize(ic->pb);
2005
        if (file_size < 0)
2006
            file_size = 0;
2007
    }
2008
    ic->file_size = file_size;
2009

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

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

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

    
2069
static int has_decode_delay_been_guessed(AVStream *st)
2070
{
2071
    return st->codec->codec_id != CODEC_ID_H264 ||
2072
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2073
}
2074

    
2075
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2076
{
2077
    int16_t *samples;
2078
    AVCodec *codec;
2079
    int got_picture, data_size, ret=0;
2080
    AVFrame picture;
2081

    
2082
    if(!st->codec->codec){
2083
        codec = avcodec_find_decoder(st->codec->codec_id);
2084
        if (!codec)
2085
            return -1;
2086
        ret = avcodec_open(st->codec, codec);
2087
        if (ret < 0)
2088
            return ret;
2089
    }
2090

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

    
2115
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2116
{
2117
    while (tags->id != CODEC_ID_NONE) {
2118
        if (tags->id == id)
2119
            return tags->tag;
2120
        tags++;
2121
    }
2122
    return 0;
2123
}
2124

    
2125
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2126
{
2127
    int i;
2128
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2129
        if(tag == tags[i].tag)
2130
            return tags[i].id;
2131
    }
2132
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2133
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2134
            return tags[i].id;
2135
    }
2136
    return CODEC_ID_NONE;
2137
}
2138

    
2139
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2140
{
2141
    int i;
2142
    for(i=0; tags && tags[i]; i++){
2143
        int tag= ff_codec_get_tag(tags[i], id);
2144
        if(tag) return tag;
2145
    }
2146
    return 0;
2147
}
2148

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

    
2159
static void compute_chapters_end(AVFormatContext *s)
2160
{
2161
    unsigned int i;
2162

    
2163
    for (i=0; i+1<s->nb_chapters; i++)
2164
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2165
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2166
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2167
            s->chapters[i]->end = s->chapters[i+1]->start;
2168
        }
2169

    
2170
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2171
        assert(s->start_time != AV_NOPTS_VALUE);
2172
        assert(s->duration > 0);
2173
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2174
                                           AV_TIME_BASE_Q,
2175
                                           s->chapters[i]->time_base);
2176
    }
2177
}
2178

    
2179
static int get_std_framerate(int i){
2180
    if(i<60*12) return i*1001;
2181
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2182
}
2183

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

    
2204
int av_find_stream_info(AVFormatContext *ic)
2205
{
2206
    int i, count, ret, read_size, j;
2207
    AVStream *st;
2208
    AVPacket pkt1, *pkt;
2209
    int64_t old_offset = url_ftell(ic->pb);
2210

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

    
2236
        /* Force decoding of at least one frame of codec data
2237
         * this makes sure the codec initializes the channel configuration
2238
         * and does not trust the values from the container.
2239
         */
2240
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2241
            st->codec->channels = 0;
2242

    
2243
        /* Ensure that subtitle_header is properly set. */
2244
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2245
            && codec && !st->codec->codec)
2246
            avcodec_open(st->codec, codec);
2247

    
2248
        //try to just open decoders, in case this is enough to get parameters
2249
        if(!has_codec_parameters(st->codec)){
2250
            if (codec && !st->codec->codec)
2251
                avcodec_open(st->codec, codec);
2252
        }
2253
    }
2254

    
2255
    for (i=0; i<ic->nb_streams; i++) {
2256
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2257
    }
2258

    
2259
    count = 0;
2260
    read_size = 0;
2261
    for(;;) {
2262
        if(url_interrupt_cb()){
2263
            ret= AVERROR(EINTR);
2264
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2265
            break;
2266
        }
2267

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

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

    
2319
        if (ret == AVERROR(EAGAIN))
2320
            continue;
2321

    
2322
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2323
        if ((ret = av_dup_packet(pkt)) < 0)
2324
            goto find_stream_info_err;
2325

    
2326
        read_size += pkt->size;
2327

    
2328
        st = ic->streams[pkt->stream_index];
2329
        if (st->codec_info_nb_frames>1) {
2330
            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) {
2331
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2332
                break;
2333
            }
2334
            st->info->codec_info_duration += pkt->duration;
2335
        }
2336
        {
2337
            int64_t last = st->info->last_dts;
2338
            int64_t duration= pkt->dts - last;
2339

    
2340
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2341
                double dur= duration * av_q2d(st->time_base);
2342

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

    
2371
        /* if still no information, we try to open the codec and to
2372
           decompress the frame. We try to avoid that in most cases as
2373
           it takes longer and uses more memory. For MPEG-4, we need to
2374
           decompress for QuickTime. */
2375
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2376
            try_decode_frame(st, pkt);
2377

    
2378
        st->codec_info_nb_frames++;
2379
        count++;
2380
    }
2381

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

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

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

    
2425
            if (!st->r_frame_rate.num){
2426
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2427
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2428
                    st->r_frame_rate.num = st->codec->time_base.den;
2429
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2430
                }else{
2431
                    st->r_frame_rate.num = st->time_base.den;
2432
                    st->r_frame_rate.den = st->time_base.num;
2433
                }
2434
            }
2435
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2436
            if(!st->codec->bits_per_coded_sample)
2437
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2438
        }
2439
    }
2440

    
2441
    av_estimate_timings(ic, old_offset);
2442

    
2443
    compute_chapters_end(ic);
2444

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

    
2470
 find_stream_info_err:
2471
    for (i=0; i < ic->nb_streams; i++)
2472
        av_freep(&ic->streams[i]->info);
2473
    return ret;
2474
}
2475

    
2476
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2477
{
2478
    int i, j;
2479

    
2480
    for (i = 0; i < ic->nb_programs; i++)
2481
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2482
            if (ic->programs[i]->stream_index[j] == s)
2483
                return ic->programs[i];
2484
    return NULL;
2485
}
2486

    
2487
int av_find_best_stream(AVFormatContext *ic,
2488
                        enum AVMediaType type,
2489
                        int wanted_stream_nb,
2490
                        int related_stream,
2491
                        AVCodec **decoder_ret,
2492
                        int flags)
2493
{
2494
    int i, nb_streams = ic->nb_streams, stream_number = 0;
2495
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2496
    unsigned *program = NULL;
2497
    AVCodec *decoder = NULL, *best_decoder = NULL;
2498

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

    
2537
/*******************************************************/
2538

    
2539
int av_read_play(AVFormatContext *s)
2540
{
2541
    if (s->iformat->read_play)
2542
        return s->iformat->read_play(s);
2543
    if (s->pb)
2544
        return av_url_read_fpause(s->pb, 0);
2545
    return AVERROR(ENOSYS);
2546
}
2547

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

    
2557
void av_close_input_stream(AVFormatContext *s)
2558
{
2559
    flush_packet_queue(s);
2560
    if (s->iformat->read_close)
2561
        s->iformat->read_close(s);
2562
    avformat_free_context(s);
2563
}
2564

    
2565
void avformat_free_context(AVFormatContext *s)
2566
{
2567
    int i;
2568
    AVStream *st;
2569

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

    
2613
void av_close_input_file(AVFormatContext *s)
2614
{
2615
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2616
    av_close_input_stream(s);
2617
    if (pb)
2618
        url_fclose(pb);
2619
}
2620

    
2621
AVStream *av_new_stream(AVFormatContext *s, int id)
2622
{
2623
    AVStream *st;
2624
    int i;
2625

    
2626
#if FF_API_MAX_STREAMS
2627
    if (s->nb_streams >= MAX_STREAMS){
2628
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2629
        return NULL;
2630
    }
2631
#else
2632
    AVStream **streams;
2633

    
2634
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2635
        return NULL;
2636
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2637
    if (!streams)
2638
        return NULL;
2639
    s->streams = streams;
2640
#endif
2641

    
2642
    st = av_mallocz(sizeof(AVStream));
2643
    if (!st)
2644
        return NULL;
2645
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2646
        av_free(st);
2647
        return NULL;
2648
    }
2649

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

    
2667
    /* default pts setting is MPEG-like */
2668
    av_set_pts_info(st, 33, 1, 90000);
2669
    st->last_IP_pts = AV_NOPTS_VALUE;
2670
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2671
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2672
    st->reference_dts = AV_NOPTS_VALUE;
2673

    
2674
    st->sample_aspect_ratio = (AVRational){0,1};
2675

    
2676
    s->streams[s->nb_streams++] = st;
2677
    return st;
2678
}
2679

    
2680
AVProgram *av_new_program(AVFormatContext *ac, int id)
2681
{
2682
    AVProgram *program=NULL;
2683
    int i;
2684

    
2685
#ifdef DEBUG_SI
2686
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2687
#endif
2688

    
2689
    for(i=0; i<ac->nb_programs; i++)
2690
        if(ac->programs[i]->id == id)
2691
            program = ac->programs[i];
2692

    
2693
    if(!program){
2694
        program = av_mallocz(sizeof(AVProgram));
2695
        if (!program)
2696
            return NULL;
2697
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2698
        program->discard = AVDISCARD_NONE;
2699
    }
2700
    program->id = id;
2701

    
2702
    return program;
2703
}
2704

    
2705
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2706
{
2707
    AVChapter *chapter = NULL;
2708
    int i;
2709

    
2710
    for(i=0; i<s->nb_chapters; i++)
2711
        if(s->chapters[i]->id == id)
2712
            chapter = s->chapters[i];
2713

    
2714
    if(!chapter){
2715
        chapter= av_mallocz(sizeof(AVChapter));
2716
        if(!chapter)
2717
            return NULL;
2718
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2719
    }
2720
#if FF_API_OLD_METADATA
2721
    av_free(chapter->title);
2722
#endif
2723
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2724
    chapter->id    = id;
2725
    chapter->time_base= time_base;
2726
    chapter->start = start;
2727
    chapter->end   = end;
2728

    
2729
    return chapter;
2730
}
2731

    
2732
/************************************************************/
2733
/* output media file */
2734

    
2735
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2736
{
2737
    int ret;
2738

    
2739
    if (s->oformat->priv_data_size > 0) {
2740
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2741
        if (!s->priv_data)
2742
            return AVERROR(ENOMEM);
2743
        if (s->oformat->priv_class) {
2744
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2745
            av_opt_set_defaults(s->priv_data);
2746
        }
2747
    } else
2748
        s->priv_data = NULL;
2749

    
2750
    if (s->oformat->set_parameters) {
2751
        ret = s->oformat->set_parameters(s, ap);
2752
        if (ret < 0)
2753
            return ret;
2754
    }
2755
    return 0;
2756
}
2757

    
2758
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2759
{
2760
    const AVCodecTag *avctag;
2761
    int n;
2762
    enum CodecID id = CODEC_ID_NONE;
2763
    unsigned int tag = 0;
2764

    
2765
    /**
2766
     * Check that tag + id is in the table
2767
     * If neither is in the table -> OK
2768
     * If tag is in the table with another id -> FAIL
2769
     * If id is in the table with another tag -> FAIL unless strict < normal
2770
     */
2771
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2772
        avctag = s->oformat->codec_tag[n];
2773
        while (avctag->id != CODEC_ID_NONE) {
2774
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2775
                id = avctag->id;
2776
                if (id == st->codec->codec_id)
2777
                    return 1;
2778
            }
2779
            if (avctag->id == st->codec->codec_id)
2780
                tag = avctag->tag;
2781
            avctag++;
2782
        }
2783
    }
2784
    if (id != CODEC_ID_NONE)
2785
        return 0;
2786
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2787
        return 0;
2788
    return 1;
2789
}
2790

    
2791
int av_write_header(AVFormatContext *s)
2792
{
2793
    int ret, i;
2794
    AVStream *st;
2795

    
2796
    // some sanity checks
2797
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2798
        av_log(s, AV_LOG_ERROR, "no streams\n");
2799
        return AVERROR(EINVAL);
2800
    }
2801

    
2802
    for(i=0;i<s->nb_streams;i++) {
2803
        st = s->streams[i];
2804

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

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

    
2849
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2850
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2851
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2852
    }
2853

    
2854
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2855
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2856
        if (!s->priv_data)
2857
            return AVERROR(ENOMEM);
2858
    }
2859

    
2860
#if FF_API_OLD_METADATA
2861
    ff_metadata_mux_compat(s);
2862
#endif
2863

    
2864
    /* set muxer identification string */
2865
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2866
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2867
    }
2868

    
2869
    if(s->oformat->write_header){
2870
        ret = s->oformat->write_header(s);
2871
        if (ret < 0)
2872
            return ret;
2873
    }
2874

    
2875
    /* init PTS generation */
2876
    for(i=0;i<s->nb_streams;i++) {
2877
        int64_t den = AV_NOPTS_VALUE;
2878
        st = s->streams[i];
2879

    
2880
        switch (st->codec->codec_type) {
2881
        case AVMEDIA_TYPE_AUDIO:
2882
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2883
            break;
2884
        case AVMEDIA_TYPE_VIDEO:
2885
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2886
            break;
2887
        default:
2888
            break;
2889
        }
2890
        if (den != AV_NOPTS_VALUE) {
2891
            if (den <= 0)
2892
                return AVERROR_INVALIDDATA;
2893
            av_frac_init(&st->pts, 0, 0, den);
2894
        }
2895
    }
2896
    return 0;
2897
}
2898

    
2899
//FIXME merge with compute_pkt_fields
2900
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2901
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2902
    int num, den, frame_size, i;
2903

    
2904
//    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);
2905

    
2906
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2907
        return -1;*/
2908

    
2909
    /* duration field */
2910
    if (pkt->duration == 0) {
2911
        compute_frame_duration(&num, &den, st, NULL, pkt);
2912
        if (den && num) {
2913
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2914
        }
2915
    }
2916

    
2917
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2918
        pkt->pts= pkt->dts;
2919

    
2920
    //XXX/FIXME this is a temporary hack until all encoders output pts
2921
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2922
        pkt->dts=
2923
//        pkt->pts= st->cur_dts;
2924
        pkt->pts= st->pts.val;
2925
    }
2926

    
2927
    //calculate dts from pts
2928
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2929
        st->pts_buffer[0]= pkt->pts;
2930
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2931
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2932
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2933
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2934

    
2935
        pkt->dts= st->pts_buffer[0];
2936
    }
2937

    
2938
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2939
        av_log(s, AV_LOG_ERROR,
2940
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2941
               st->index, st->cur_dts, pkt->dts);
2942
        return -1;
2943
    }
2944
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2945
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2946
        return -1;
2947
    }
2948

    
2949
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2950
    st->cur_dts= pkt->dts;
2951
    st->pts.val= pkt->dts;
2952

    
2953
    /* update pts */
2954
    switch (st->codec->codec_type) {
2955
    case AVMEDIA_TYPE_AUDIO:
2956
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2957

    
2958
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2959
           likely equal to the encoder delay, but it would be better if we
2960
           had the real timestamps from the encoder */
2961
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2962
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2963
        }
2964
        break;
2965
    case AVMEDIA_TYPE_VIDEO:
2966
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2967
        break;
2968
    default:
2969
        break;
2970
    }
2971
    return 0;
2972
}
2973

    
2974
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2975
{
2976
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2977

    
2978
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2979
        return ret;
2980

    
2981
    ret= s->oformat->write_packet(s, pkt);
2982
    if(!ret)
2983
        ret= url_ferror(s->pb);
2984
    return ret;
2985
}
2986

    
2987
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2988
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2989
{
2990
    AVPacketList **next_point, *this_pktl;
2991

    
2992
    this_pktl = av_mallocz(sizeof(AVPacketList));
2993
    this_pktl->pkt= *pkt;
2994
    pkt->destruct= NULL;             // do not free original but only the copy
2995
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2996

    
2997
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2998
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2999
    }else
3000
        next_point = &s->packet_buffer;
3001

    
3002
    if(*next_point){
3003
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3004
            while(!compare(s, &(*next_point)->pkt, pkt)){
3005
                next_point= &(*next_point)->next;
3006
            }
3007
            goto next_non_null;
3008
        }else{
3009
            next_point = &(s->packet_buffer_end->next);
3010
        }
3011
    }
3012
    assert(!*next_point);
3013

    
3014
    s->packet_buffer_end= this_pktl;
3015
next_non_null:
3016

    
3017
    this_pktl->next= *next_point;
3018

    
3019
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3020
    *next_point= this_pktl;
3021
}
3022

    
3023
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3024
{
3025
    AVStream *st = s->streams[ pkt ->stream_index];
3026
    AVStream *st2= s->streams[ next->stream_index];
3027
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3028
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3029
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3030
}
3031

    
3032
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3033
    AVPacketList *pktl;
3034
    int stream_count=0;
3035
    int i;
3036

    
3037
    if(pkt){
3038
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3039
    }
3040

    
3041
    for(i=0; i < s->nb_streams; i++)
3042
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3043

    
3044
    if(stream_count && (s->nb_streams == stream_count || flush)){
3045
        pktl= s->packet_buffer;
3046
        *out= pktl->pkt;
3047

    
3048
        s->packet_buffer= pktl->next;
3049
        if(!s->packet_buffer)
3050
            s->packet_buffer_end= NULL;
3051

    
3052
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3053
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3054
        av_freep(&pktl);
3055
        return 1;
3056
    }else{
3057
        av_init_packet(out);
3058
        return 0;
3059
    }
3060
}
3061

    
3062
/**
3063
 * Interleave an AVPacket correctly so it can be muxed.
3064
 * @param out the interleaved packet will be output here
3065
 * @param in the input packet
3066
 * @param flush 1 if no further packets are available as input and all
3067
 *              remaining packets should be output
3068
 * @return 1 if a packet was output, 0 if no packet could be output,
3069
 *         < 0 if an error occurred
3070
 */
3071
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3072
    if(s->oformat->interleave_packet)
3073
        return s->oformat->interleave_packet(s, out, in, flush);
3074
    else
3075
        return av_interleave_packet_per_dts(s, out, in, flush);
3076
}
3077

    
3078
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3079
    AVStream *st= s->streams[ pkt->stream_index];
3080

    
3081
    //FIXME/XXX/HACK drop zero sized packets
3082
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3083
        return 0;
3084

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

    
3089
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3090
        return -1;
3091

    
3092
    for(;;){
3093
        AVPacket opkt;
3094
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3095
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3096
            return ret;
3097

    
3098
        ret= s->oformat->write_packet(s, &opkt);
3099

    
3100
        av_free_packet(&opkt);
3101
        pkt= NULL;
3102

    
3103
        if(ret<0)
3104
            return ret;
3105
        if(url_ferror(s->pb))
3106
            return url_ferror(s->pb);
3107
    }
3108
}
3109

    
3110
int av_write_trailer(AVFormatContext *s)
3111
{
3112
    int ret, i;
3113

    
3114
    for(;;){
3115
        AVPacket pkt;
3116
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3117
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3118
            goto fail;
3119
        if(!ret)
3120
            break;
3121

    
3122
        ret= s->oformat->write_packet(s, &pkt);
3123

    
3124
        av_free_packet(&pkt);
3125

    
3126
        if(ret<0)
3127
            goto fail;
3128
        if(url_ferror(s->pb))
3129
            goto fail;
3130
    }
3131

    
3132
    if(s->oformat->write_trailer)
3133
        ret = s->oformat->write_trailer(s);
3134
fail:
3135
    if(ret == 0)
3136
       ret=url_ferror(s->pb);
3137
    for(i=0;i<s->nb_streams;i++) {
3138
        av_freep(&s->streams[i]->priv_data);
3139
        av_freep(&s->streams[i]->index_entries);
3140
    }
3141
    av_freep(&s->priv_data);
3142
    return ret;
3143
}
3144

    
3145
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3146
{
3147
    int i, j;
3148
    AVProgram *program=NULL;
3149
    void *tmp;
3150

    
3151
    if (idx >= ac->nb_streams) {
3152
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3153
        return;
3154
    }
3155

    
3156
    for(i=0; i<ac->nb_programs; i++){
3157
        if(ac->programs[i]->id != progid)
3158
            continue;
3159
        program = ac->programs[i];
3160
        for(j=0; j<program->nb_stream_indexes; j++)
3161
            if(program->stream_index[j] == idx)
3162
                return;
3163

    
3164
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3165
        if(!tmp)
3166
            return;
3167
        program->stream_index = tmp;
3168
        program->stream_index[program->nb_stream_indexes++] = idx;
3169
        return;
3170
    }
3171
}
3172

    
3173
static void print_fps(double d, const char *postfix){
3174
    uint64_t v= lrintf(d*100);
3175
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3176
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3177
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3178
}
3179

    
3180
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3181
{
3182
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3183
        AVMetadataTag *tag=NULL;
3184

    
3185
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3186
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3187
            if(strcmp("language", tag->key))
3188
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3189
        }
3190
    }
3191
}
3192

    
3193
/* "user interface" functions */
3194
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3195
{
3196
    char buf[256];
3197
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3198
    AVStream *st = ic->streams[i];
3199
    int g = av_gcd(st->time_base.num, st->time_base.den);
3200
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3201
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3202
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3203
    /* the pid is an important information, so we display it */
3204
    /* XXX: add a generic system */
3205
    if (flags & AVFMT_SHOW_IDS)
3206
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3207
    if (lang)
3208
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3209
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3210
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3211
    if (st->sample_aspect_ratio.num && // default
3212
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3213
        AVRational display_aspect_ratio;
3214
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3215
                  st->codec->width*st->sample_aspect_ratio.num,
3216
                  st->codec->height*st->sample_aspect_ratio.den,
3217
                  1024*1024);
3218
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3219
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3220
                 display_aspect_ratio.num, display_aspect_ratio.den);
3221
    }
3222
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3223
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3224
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3225
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3226
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3227
        if(st->time_base.den && st->time_base.num)
3228
            print_fps(1/av_q2d(st->time_base), "tbn");
3229
        if(st->codec->time_base.den && st->codec->time_base.num)
3230
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3231
    }
3232
    av_log(NULL, AV_LOG_INFO, "\n");
3233
    dump_metadata(NULL, st->metadata, "    ");
3234
}
3235

    
3236
void dump_format(AVFormatContext *ic,
3237
                 int index,
3238
                 const char *url,
3239
                 int is_output)
3240
{
3241
    int i;
3242
    uint8_t *printed = av_mallocz(ic->nb_streams);
3243
    if (ic->nb_streams && !printed)
3244
        return;
3245

    
3246
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3247
            is_output ? "Output" : "Input",
3248
            index,
3249
            is_output ? ic->oformat->name : ic->iformat->name,
3250
            is_output ? "to" : "from", url);
3251
    dump_metadata(NULL, ic->metadata, "  ");
3252
    if (!is_output) {
3253
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3254
        if (ic->duration != AV_NOPTS_VALUE) {
3255
            int hours, mins, secs, us;
3256
            secs = ic->duration / AV_TIME_BASE;
3257
            us = ic->duration % AV_TIME_BASE;
3258
            mins = secs / 60;
3259
            secs %= 60;
3260
            hours = mins / 60;
3261
            mins %= 60;
3262
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3263
                   (100 * us) / AV_TIME_BASE);
3264
        } else {
3265
            av_log(NULL, AV_LOG_INFO, "N/A");
3266
        }
3267
        if (ic->start_time != AV_NOPTS_VALUE) {
3268
            int secs, us;
3269
            av_log(NULL, AV_LOG_INFO, ", start: ");
3270
            secs = ic->start_time / AV_TIME_BASE;
3271
            us = abs(ic->start_time % AV_TIME_BASE);
3272
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3273
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3274
        }
3275
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3276
        if (ic->bit_rate) {
3277
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3278
        } else {
3279
            av_log(NULL, AV_LOG_INFO, "N/A");
3280
        }
3281
        av_log(NULL, AV_LOG_INFO, "\n");
3282
    }
3283
    for (i = 0; i < ic->nb_chapters; i++) {
3284
        AVChapter *ch = ic->chapters[i];
3285
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3286
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3287
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3288

    
3289
        dump_metadata(NULL, ch->metadata, "    ");
3290
    }
3291
    if(ic->nb_programs) {
3292
        int j, k, total = 0;
3293
        for(j=0; j<ic->nb_programs; j++) {
3294
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3295
                                                  "name", NULL, 0);
3296
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3297
                   name ? name->value : "");
3298
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3299
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3300
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3301
                printed[ic->programs[j]->stream_index[k]] = 1;
3302
            }
3303
            total += ic->programs[j]->nb_stream_indexes;
3304
        }
3305
        if (total < ic->nb_streams)
3306
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3307
    }
3308
    for(i=0;i<ic->nb_streams;i++)
3309
        if (!printed[i])
3310
            dump_stream_format(ic, i, index, is_output);
3311

    
3312
    av_free(printed);
3313
}
3314

    
3315
#if FF_API_PARSE_FRAME_PARAM
3316
#include "libavcore/parseutils.h"
3317

    
3318
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3319
{
3320
    return av_parse_video_size(width_ptr, height_ptr, str);
3321
}
3322

    
3323
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3324
{
3325
    AVRational frame_rate;
3326
    int ret = av_parse_video_rate(&frame_rate, arg);
3327
    *frame_rate_num= frame_rate.num;
3328
    *frame_rate_den= frame_rate.den;
3329
    return ret;
3330
}
3331
#endif
3332

    
3333
int64_t av_gettime(void)
3334
{
3335
    struct timeval tv;
3336
    gettimeofday(&tv,NULL);
3337
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3338
}
3339

    
3340
uint64_t ff_ntp_time(void)
3341
{
3342
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3343
}
3344

    
3345
int64_t parse_date(const char *datestr, int duration)
3346
{
3347
    const char *p;
3348
    int64_t t;
3349
    struct tm dt;
3350
    int i;
3351
    static const char * const date_fmt[] = {
3352
        "%Y-%m-%d",
3353
        "%Y%m%d",
3354
    };
3355
    static const char * const time_fmt[] = {
3356
        "%H:%M:%S",
3357
        "%H%M%S",
3358
    };
3359
    const char *q;
3360
    int is_utc, len;
3361
    char lastch;
3362
    int negative = 0;
3363

    
3364
#undef time
3365
    time_t now = time(0);
3366

    
3367
    len = strlen(datestr);
3368
    if (len > 0)
3369
        lastch = datestr[len - 1];
3370
    else
3371
        lastch = '\0';
3372
    is_utc = (lastch == 'z' || lastch == 'Z');
3373

    
3374
    memset(&dt, 0, sizeof(dt));
3375

    
3376
    p = datestr;
3377
    q = NULL;
3378
    if (!duration) {
3379
        if (!strncasecmp(datestr, "now", len))
3380
            return (int64_t) now * 1000000;
3381

    
3382
        /* parse the year-month-day part */
3383
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3384
            q = small_strptime(p, date_fmt[i], &dt);
3385
            if (q) {
3386
                break;
3387
            }
3388
        }
3389

    
3390
        /* if the year-month-day part is missing, then take the
3391
         * current year-month-day time */
3392
        if (!q) {
3393
            if (is_utc) {
3394
                dt = *gmtime(&now);
3395
            } else {
3396
                dt = *localtime(&now);
3397
            }
3398
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3399
        } else {
3400
            p = q;
3401
        }
3402

    
3403
        if (*p == 'T' || *p == 't' || *p == ' ')
3404
            p++;
3405

    
3406
        /* parse the hour-minute-second part */
3407
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3408
            q = small_strptime(p, time_fmt[i], &dt);
3409
            if (q) {
3410
                break;
3411
            }
3412
        }
3413
    } else {
3414
        /* parse datestr as a duration */
3415
        if (p[0] == '-') {
3416
            negative = 1;
3417
            ++p;
3418
        }
3419
        /* parse datestr as HH:MM:SS */
3420
        q = small_strptime(p, time_fmt[0], &dt);
3421
        if (!q) {
3422
            /* parse datestr as S+ */
3423
            dt.tm_sec = strtol(p, (char **)&q, 10);
3424
            if (q == p)
3425
                /* the parsing didn't succeed */
3426
                return INT64_MIN;
3427
            dt.tm_min = 0;
3428
            dt.tm_hour = 0;
3429
        }
3430
    }
3431

    
3432
    /* Now we have all the fields that we can get */
3433
    if (!q) {
3434
        return INT64_MIN;
3435
    }
3436

    
3437
    if (duration) {
3438
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3439
    } else {
3440
        dt.tm_isdst = -1;       /* unknown */
3441
        if (is_utc) {
3442
            t = mktimegm(&dt);
3443
        } else {
3444
            t = mktime(&dt);
3445
        }
3446
    }
3447

    
3448
    t *= 1000000;
3449

    
3450
    /* parse the .m... part */
3451
    if (*q == '.') {
3452
        int val, n;
3453
        q++;
3454
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3455
            if (!isdigit(*q))
3456
                break;
3457
            val += n * (*q - '0');
3458
        }
3459
        t += val;
3460
    }
3461
    return negative ? -t : t;
3462
}
3463

    
3464
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3465
{
3466
    const char *p;
3467
    char tag[128], *q;
3468

    
3469
    p = info;
3470
    if (*p == '?')
3471
        p++;
3472
    for(;;) {
3473
        q = tag;
3474
        while (*p != '\0' && *p != '=' && *p != '&') {
3475
            if ((q - tag) < sizeof(tag) - 1)
3476
                *q++ = *p;
3477
            p++;
3478
        }
3479
        *q = '\0';
3480
        q = arg;
3481
        if (*p == '=') {
3482
            p++;
3483
            while (*p != '&' && *p != '\0') {
3484
                if ((q - arg) < arg_size - 1) {
3485
                    if (*p == '+')
3486
                        *q++ = ' ';
3487
                    else
3488
                        *q++ = *p;
3489
                }
3490
                p++;
3491
            }
3492
        }
3493
        *q = '\0';
3494
        if (!strcmp(tag, tag1))
3495
            return 1;
3496
        if (*p != '&')
3497
            break;
3498
        p++;
3499
    }
3500
    return 0;
3501
}
3502

    
3503
int av_get_frame_filename(char *buf, int buf_size,
3504
                          const char *path, int number)
3505
{
3506
    const char *p;
3507
    char *q, buf1[20], c;
3508
    int nd, len, percentd_found;
3509

    
3510
    q = buf;
3511
    p = path;
3512
    percentd_found = 0;
3513
    for(;;) {
3514
        c = *p++;
3515
        if (c == '\0')
3516
            break;
3517
        if (c == '%') {
3518
            do {
3519
                nd = 0;
3520
                while (isdigit(*p)) {
3521
                    nd = nd * 10 + *p++ - '0';
3522
                }
3523
                c = *p++;
3524
            } while (isdigit(c));
3525

    
3526
            switch(c) {
3527
            case '%':
3528
                goto addchar;
3529
            case 'd':
3530
                if (percentd_found)
3531
                    goto fail;
3532
                percentd_found = 1;
3533
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3534
                len = strlen(buf1);
3535
                if ((q - buf + len) > buf_size - 1)
3536
                    goto fail;
3537
                memcpy(q, buf1, len);
3538
                q += len;
3539
                break;
3540
            default:
3541
                goto fail;
3542
            }
3543
        } else {
3544
        addchar:
3545
            if ((q - buf) < buf_size - 1)
3546
                *q++ = c;
3547
        }
3548
    }
3549
    if (!percentd_found)
3550
        goto fail;
3551
    *q = '\0';
3552
    return 0;
3553
 fail:
3554
    *q = '\0';
3555
    return -1;
3556
}
3557

    
3558
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3559
{
3560
    int len, i, j, c;
3561
#undef fprintf
3562
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3563

    
3564
    for(i=0;i<size;i+=16) {
3565
        len = size - i;
3566
        if (len > 16)
3567
            len = 16;
3568
        PRINT("%08x ", i);
3569
        for(j=0;j<16;j++) {
3570
            if (j < len)
3571
                PRINT(" %02x", buf[i+j]);
3572
            else
3573
                PRINT("   ");
3574
        }
3575
        PRINT(" ");
3576
        for(j=0;j<len;j++) {
3577
            c = buf[i+j];
3578
            if (c < ' ' || c > '~')
3579
                c = '.';
3580
            PRINT("%c", c);
3581
        }
3582
        PRINT("\n");
3583
    }
3584
#undef PRINT
3585
}
3586

    
3587
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3588
{
3589
    hex_dump_internal(NULL, f, 0, buf, size);
3590
}
3591

    
3592
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3593
{
3594
    hex_dump_internal(avcl, NULL, level, buf, size);
3595
}
3596

    
3597
 //FIXME needs to know the time_base
3598
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3599
{
3600
#undef fprintf
3601
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3602
    PRINT("stream #%d:\n", pkt->stream_index);
3603
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3604
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3605
    /* DTS is _always_ valid after av_read_frame() */
3606
    PRINT("  dts=");
3607
    if (pkt->dts == AV_NOPTS_VALUE)
3608
        PRINT("N/A");
3609
    else
3610
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3611
    /* PTS may not be known if B-frames are present. */
3612
    PRINT("  pts=");
3613
    if (pkt->pts == AV_NOPTS_VALUE)
3614
        PRINT("N/A");
3615
    else
3616
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3617
    PRINT("\n");
3618
    PRINT("  size=%d\n", pkt->size);
3619
#undef PRINT
3620
    if (dump_payload)
3621
        av_hex_dump(f, pkt->data, pkt->size);
3622
}
3623

    
3624
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3625
{
3626
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3627
}
3628

    
3629
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3630
{
3631
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3632
}
3633

    
3634
#if FF_API_URL_SPLIT
3635
attribute_deprecated
3636
void ff_url_split(char *proto, int proto_size,
3637
                  char *authorization, int authorization_size,
3638
                  char *hostname, int hostname_size,
3639
                  int *port_ptr,
3640
                  char *path, int path_size,
3641
                  const char *url)
3642
{
3643
    av_url_split(proto, proto_size,
3644
                 authorization, authorization_size,
3645
                 hostname, hostname_size,
3646
                 port_ptr,
3647
                 path, path_size,
3648
                 url);
3649
}
3650
#endif
3651

    
3652
void av_url_split(char *proto, int proto_size,
3653
                  char *authorization, int authorization_size,
3654
                  char *hostname, int hostname_size,
3655
                  int *port_ptr,
3656
                  char *path, int path_size,
3657
                  const char *url)
3658
{
3659
    const char *p, *ls, *at, *col, *brk;
3660

    
3661
    if (port_ptr)               *port_ptr = -1;
3662
    if (proto_size > 0)         proto[0] = 0;
3663
    if (authorization_size > 0) authorization[0] = 0;
3664
    if (hostname_size > 0)      hostname[0] = 0;
3665
    if (path_size > 0)          path[0] = 0;
3666

    
3667
    /* parse protocol */
3668
    if ((p = strchr(url, ':'))) {
3669
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3670
        p++; /* skip ':' */
3671
        if (*p == '/') p++;
3672
        if (*p == '/') p++;
3673
    } else {
3674
        /* no protocol means plain filename */
3675
        av_strlcpy(path, url, path_size);
3676
        return;
3677
    }
3678

    
3679
    /* separate path from hostname */
3680
    ls = strchr(p, '/');
3681
    if(!ls)
3682
        ls = strchr(p, '?');
3683
    if(ls)
3684
        av_strlcpy(path, ls, path_size);
3685
    else
3686
        ls = &p[strlen(p)]; // XXX
3687

    
3688
    /* the rest is hostname, use that to parse auth/port */
3689
    if (ls != p) {
3690
        /* authorization (user[:pass]@hostname) */
3691
        if ((at = strchr(p, '@')) && at < ls) {
3692
            av_strlcpy(authorization, p,
3693
                       FFMIN(authorization_size, at + 1 - p));
3694
            p = at + 1; /* skip '@' */
3695
        }
3696

    
3697
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3698
            /* [host]:port */
3699
            av_strlcpy(hostname, p + 1,
3700
                       FFMIN(hostname_size, brk - p));
3701
            if (brk[1] == ':' && port_ptr)
3702
                *port_ptr = atoi(brk + 2);
3703
        } else if ((col = strchr(p, ':')) && col < ls) {
3704
            av_strlcpy(hostname, p,
3705
                       FFMIN(col + 1 - p, hostname_size));
3706
            if (port_ptr) *port_ptr = atoi(col + 1);
3707
        } else
3708
            av_strlcpy(hostname, p,
3709
                       FFMIN(ls + 1 - p, hostname_size));
3710
    }
3711
}
3712

    
3713
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3714
{
3715
    int i;
3716
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3717
                                           '4', '5', '6', '7',
3718
                                           '8', '9', 'A', 'B',
3719
                                           'C', 'D', 'E', 'F' };
3720
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3721
                                           '4', '5', '6', '7',
3722
                                           '8', '9', 'a', 'b',
3723
                                           'c', 'd', 'e', 'f' };
3724
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3725

    
3726
    for(i = 0; i < s; i++) {
3727
        buff[i * 2]     = hex_table[src[i] >> 4];
3728
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3729
    }
3730

    
3731
    return buff;
3732
}
3733

    
3734
int ff_hex_to_data(uint8_t *data, const char *p)
3735
{
3736
    int c, len, v;
3737

    
3738
    len = 0;
3739
    v = 1;
3740
    for (;;) {
3741
        p += strspn(p, SPACE_CHARS);
3742
        if (*p == '\0')
3743
            break;
3744
        c = toupper((unsigned char) *p++);
3745
        if (c >= '0' && c <= '9')
3746
            c = c - '0';
3747
        else if (c >= 'A' && c <= 'F')
3748
            c = c - 'A' + 10;
3749
        else
3750
            break;
3751
        v = (v << 4) | c;
3752
        if (v & 0x100) {
3753
            if (data)
3754
                data[len] = v;
3755
            len++;
3756
            v = 1;
3757
        }
3758
    }
3759
    return len;
3760
}
3761

    
3762
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3763
                     unsigned int pts_num, unsigned int pts_den)
3764
{
3765
    s->pts_wrap_bits = pts_wrap_bits;
3766

    
3767
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3768
        if(s->time_base.num != pts_num)
3769
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3770
    }else
3771
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3772

    
3773
    if(!s->time_base.num || !s->time_base.den)
3774
        s->time_base.num= s->time_base.den= 0;
3775
}
3776

    
3777
int ff_url_join(char *str, int size, const char *proto,
3778
                const char *authorization, const char *hostname,
3779
                int port, const char *fmt, ...)
3780
{
3781
#if CONFIG_NETWORK
3782
    struct addrinfo hints, *ai;
3783
#endif
3784

    
3785
    str[0] = '\0';
3786
    if (proto)
3787
        av_strlcatf(str, size, "%s://", proto);
3788
    if (authorization && authorization[0])
3789
        av_strlcatf(str, size, "%s@", authorization);
3790
#if CONFIG_NETWORK && defined(AF_INET6)
3791
    /* Determine if hostname is a numerical IPv6 address,
3792
     * properly escape it within [] in that case. */
3793
    memset(&hints, 0, sizeof(hints));
3794
    hints.ai_flags = AI_NUMERICHOST;
3795
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3796
        if (ai->ai_family == AF_INET6) {
3797
            av_strlcat(str, "[", size);
3798
            av_strlcat(str, hostname, size);
3799
            av_strlcat(str, "]", size);
3800
        } else {
3801
            av_strlcat(str, hostname, size);
3802
        }
3803
        freeaddrinfo(ai);
3804
    } else
3805
#endif
3806
        /* Not an IPv6 address, just output the plain string. */
3807
        av_strlcat(str, hostname, size);
3808

    
3809
    if (port >= 0)
3810
        av_strlcatf(str, size, ":%d", port);
3811
    if (fmt) {
3812
        va_list vl;
3813
        int len = strlen(str);
3814

    
3815
        va_start(vl, fmt);
3816
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3817
        va_end(vl);
3818
    }
3819
    return strlen(str);
3820
}
3821

    
3822
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3823
                     AVFormatContext *src)
3824
{
3825
    AVPacket local_pkt;
3826

    
3827
    local_pkt = *pkt;
3828
    local_pkt.stream_index = dst_stream;
3829
    if (pkt->pts != AV_NOPTS_VALUE)
3830
        local_pkt.pts = av_rescale_q(pkt->pts,
3831
                                     src->streams[pkt->stream_index]->time_base,
3832
                                     dst->streams[dst_stream]->time_base);
3833
    if (pkt->dts != AV_NOPTS_VALUE)
3834
        local_pkt.dts = av_rescale_q(pkt->dts,
3835
                                     src->streams[pkt->stream_index]->time_base,
3836
                                     dst->streams[dst_stream]->time_base);
3837
    return av_write_frame(dst, &local_pkt);
3838
}
3839

    
3840
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3841
                        void *context)
3842
{
3843
    const char *ptr = str;
3844

    
3845
    /* Parse key=value pairs. */
3846
    for (;;) {
3847
        const char *key;
3848
        char *dest = NULL, *dest_end;
3849
        int key_len, dest_len = 0;
3850

    
3851
        /* Skip whitespace and potential commas. */
3852
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3853
            ptr++;
3854
        if (!*ptr)
3855
            break;
3856

    
3857
        key = ptr;
3858

    
3859
        if (!(ptr = strchr(key, '=')))
3860
            break;
3861
        ptr++;
3862
        key_len = ptr - key;
3863

    
3864
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3865
        dest_end = dest + dest_len - 1;
3866

    
3867
        if (*ptr == '\"') {
3868
            ptr++;
3869
            while (*ptr && *ptr != '\"') {
3870
                if (*ptr == '\\') {
3871
                    if (!ptr[1])
3872
                        break;
3873
                    if (dest && dest < dest_end)
3874
                        *dest++ = ptr[1];
3875
                    ptr += 2;
3876
                } else {
3877
                    if (dest && dest < dest_end)
3878
                        *dest++ = *ptr;
3879
                    ptr++;
3880
                }
3881
            }
3882
            if (*ptr == '\"')
3883
                ptr++;
3884
        } else {
3885
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3886
                if (dest && dest < dest_end)
3887
                    *dest++ = *ptr;
3888
        }
3889
        if (dest)
3890
            *dest = 0;
3891
    }
3892
}
3893

    
3894
int ff_find_stream_index(AVFormatContext *s, int id)
3895
{
3896
    int i;
3897
    for (i = 0; i < s->nb_streams; i++) {
3898
        if (s->streams[i]->id == id)
3899
            return i;
3900
    }
3901
    return -1;
3902
}