Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 6bfc2683

History | View | Annotate | Download (119 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
278
        return CODEC_ID_NONE;
279
}
280

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

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

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

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

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

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

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

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

    
328
    if(ret<0)
329
        return ret;
330

    
331
    pkt->pos= url_ftell(s);
332

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

    
339
    return ret;
340
}
341

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

    
357

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

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

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

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

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

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

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

    
436
/************************************************************/
437
/* input media file */
438

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

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

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

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

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

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

    
490
    if (pb && !ic->data_offset)
491
        ic->data_offset = url_ftell(ic->pb);
492

    
493
#if FF_API_OLD_METADATA
494
    ff_metadata_demux_compat(ic);
495
#endif
496

    
497
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
498

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

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

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

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

    
541
    if (offset >= max_probe_size) {
542
        return AVERROR(EINVAL);
543
    }
544

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

    
550
        if (probe_size < offset) {
551
            continue;
552
        }
553

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

    
568
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
569

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

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

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

    
589
    return ret;
590
}
591

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

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

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

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

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

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

    
654
}
655

    
656
/*******************************************************/
657

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

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

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

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

    
680
    for(;;){
681
        AVPacketList *pktl = s->raw_packet_buffer;
682

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

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

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

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

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

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

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

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

    
751
/**********************************************************/
752

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

    
760
    if(enc->codec_id == CODEC_ID_VORBIS)
761
        return -1;
762

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

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

    
782

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

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

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

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

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

    
856
    st->first_dts= dts - st->cur_dts;
857
    st->cur_dts= dts;
858

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

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

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

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

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

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

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

    
918
    if (s->flags & AVFMT_FLAG_NOFILLIN)
919
        return;
920

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1052
//    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);
1053

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

    
1069

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

    
1075
    av_init_packet(pkt);
1076

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

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

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

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

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

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

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

    
1208
    return 0;
1209
}
1210

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

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

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

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

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

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

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

    
1289
/*******************************************************/
1290
/* seek support */
1291

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

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

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

    
1319
    flush_packet_queue(s);
1320

    
1321
    s->cur_st = NULL;
1322

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

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

    
1339
        st->probe_packets = MAX_PROBE_PACKETS;
1340

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

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

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

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

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

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

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

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

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

    
1387
    st->index_entries= entries;
1388

    
1389
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1390

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

    
1406
    ie->pos = pos;
1407
    ie->timestamp = timestamp;
1408
    ie->min_distance= distance;
1409
    ie->size= size;
1410
    ie->flags = flags;
1411

    
1412
    return index;
1413
}
1414

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

    
1423
    a = - 1;
1424
    b = nb_entries;
1425

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

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

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

    
1446
    if(m == nb_entries)
1447
        return -1;
1448
    return  m;
1449
}
1450

    
1451
#define DEBUG_SEEK
1452

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

    
1461
    if (stream_index < 0)
1462
        return -1;
1463

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

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

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

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

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

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

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

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

    
1514
    av_update_cur_dts(s, st, ts);
1515

    
1516
    return 0;
1517
}
1518

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

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

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

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

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

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

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

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

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

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

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

1639
    if (stream_index < 0)
1640
        return -1;
1641

1642
    st= s->streams[stream_index];
1643
#endif
1644

    
1645
    pos_min = s->data_offset;
1646
    pos_max = url_fsize(s->pb) - 1;
1647

    
1648
    if     (pos < pos_min) pos= pos_min;
1649
    else if(pos > pos_max) pos= pos_max;
1650

    
1651
    url_fseek(s->pb, pos, SEEK_SET);
1652

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

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

    
1667
    st = s->streams[stream_index];
1668

    
1669
    index = av_index_search_timestamp(st, timestamp, flags);
1670

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

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

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

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

    
1716
    return 0;
1717
}
1718

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

    
1724
    ff_read_frame_flush(s);
1725

    
1726
    if(flags & AVSEEK_FLAG_BYTE)
1727
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1728

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

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

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

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

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

    
1759
    ff_read_frame_flush(s);
1760

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

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

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

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

    
1776
/*******************************************************/
1777

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

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

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

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

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

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

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

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

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

    
1896
#define DURATION_MAX_READ_SIZE 250000
1897
#define DURATION_MAX_RETRY 3
1898

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

    
1909
    ic->cur_st = NULL;
1910

    
1911
    /* flush packet queue */
1912
    flush_packet_queue(ic);
1913

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

    
1919
        if (st->parser) {
1920
            av_parser_close(st->parser);
1921
            st->parser= NULL;
1922
            av_free_packet(&st->cur_pkt);
1923
        }
1924
    }
1925

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

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

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

    
1968
    fill_all_stream_timings(ic);
1969

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

    
1978
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1979
{
1980
    int64_t file_size;
1981

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

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

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

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

    
2051
static int has_decode_delay_been_guessed(AVStream *st)
2052
{
2053
    return st->codec->codec_id != CODEC_ID_H264 ||
2054
        st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2055
}
2056

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

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

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

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

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

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

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

    
2141
static void compute_chapters_end(AVFormatContext *s)
2142
{
2143
    unsigned int i;
2144

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

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

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

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

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

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

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

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

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

    
2237
    for (i=0; i<ic->nb_streams; i++) {
2238
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2239
    }
2240

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

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

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

    
2301
        if (ret == AVERROR(EAGAIN))
2302
            continue;
2303

    
2304
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2305
        if ((ret = av_dup_packet(pkt)) < 0)
2306
            goto find_stream_info_err;
2307

    
2308
        read_size += pkt->size;
2309

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

    
2322
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2323
                double dur= duration * av_q2d(st->time_base);
2324

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

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

    
2360
        st->codec_info_nb_frames++;
2361
        count++;
2362
    }
2363

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

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

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

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

    
2423
    av_estimate_timings(ic, old_offset);
2424

    
2425
    compute_chapters_end(ic);
2426

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

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

    
2458
/*******************************************************/
2459

    
2460
int av_read_play(AVFormatContext *s)
2461
{
2462
    if (s->iformat->read_play)
2463
        return s->iformat->read_play(s);
2464
    if (s->pb)
2465
        return av_url_read_fpause(s->pb, 0);
2466
    return AVERROR(ENOSYS);
2467
}
2468

    
2469
int av_read_pause(AVFormatContext *s)
2470
{
2471
    if (s->iformat->read_pause)
2472
        return s->iformat->read_pause(s);
2473
    if (s->pb)
2474
        return av_url_read_fpause(s->pb, 1);
2475
    return AVERROR(ENOSYS);
2476
}
2477

    
2478
void av_close_input_stream(AVFormatContext *s)
2479
{
2480
    int i;
2481
    AVStream *st;
2482

    
2483
    if (s->iformat->read_close)
2484
        s->iformat->read_close(s);
2485
    for(i=0;i<s->nb_streams;i++) {
2486
        /* free all data in a stream component */
2487
        st = s->streams[i];
2488
        if (st->parser) {
2489
            av_parser_close(st->parser);
2490
            av_free_packet(&st->cur_pkt);
2491
        }
2492
        av_metadata_free(&st->metadata);
2493
        av_free(st->index_entries);
2494
        av_free(st->codec->extradata);
2495
        av_free(st->codec->subtitle_header);
2496
        av_free(st->codec);
2497
#if FF_API_OLD_METADATA
2498
        av_free(st->filename);
2499
#endif
2500
        av_free(st->priv_data);
2501
        av_free(st->info);
2502
        av_free(st);
2503
    }
2504
    for(i=s->nb_programs-1; i>=0; i--) {
2505
#if FF_API_OLD_METADATA
2506
        av_freep(&s->programs[i]->provider_name);
2507
        av_freep(&s->programs[i]->name);
2508
#endif
2509
        av_metadata_free(&s->programs[i]->metadata);
2510
        av_freep(&s->programs[i]->stream_index);
2511
        av_freep(&s->programs[i]);
2512
    }
2513
    av_freep(&s->programs);
2514
    flush_packet_queue(s);
2515
    av_freep(&s->priv_data);
2516
    while(s->nb_chapters--) {
2517
#if FF_API_OLD_METADATA
2518
        av_free(s->chapters[s->nb_chapters]->title);
2519
#endif
2520
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2521
        av_free(s->chapters[s->nb_chapters]);
2522
    }
2523
    av_freep(&s->chapters);
2524
    av_metadata_free(&s->metadata);
2525
    av_freep(&s->key);
2526
    av_free(s);
2527
}
2528

    
2529
void av_close_input_file(AVFormatContext *s)
2530
{
2531
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2532
    av_close_input_stream(s);
2533
    if (pb)
2534
        url_fclose(pb);
2535
}
2536

    
2537
AVStream *av_new_stream(AVFormatContext *s, int id)
2538
{
2539
    AVStream *st;
2540
    int i;
2541

    
2542
#if FF_API_MAX_STREAMS
2543
    if (s->nb_streams >= MAX_STREAMS){
2544
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2545
        return NULL;
2546
    }
2547
#else
2548
    AVStream **streams;
2549

    
2550
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2551
        return NULL;
2552
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2553
    if (!streams)
2554
        return NULL;
2555
    s->streams = streams;
2556
#endif
2557

    
2558
    st = av_mallocz(sizeof(AVStream));
2559
    if (!st)
2560
        return NULL;
2561
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2562
        av_free(st);
2563
        return NULL;
2564
    }
2565

    
2566
    st->codec= avcodec_alloc_context();
2567
    if (s->iformat) {
2568
        /* no default bitrate if decoding */
2569
        st->codec->bit_rate = 0;
2570
    }
2571
    st->index = s->nb_streams;
2572
    st->id = id;
2573
    st->start_time = AV_NOPTS_VALUE;
2574
    st->duration = AV_NOPTS_VALUE;
2575
        /* we set the current DTS to 0 so that formats without any timestamps
2576
           but durations get some timestamps, formats with some unknown
2577
           timestamps have their first few packets buffered and the
2578
           timestamps corrected before they are returned to the user */
2579
    st->cur_dts = 0;
2580
    st->first_dts = AV_NOPTS_VALUE;
2581
    st->probe_packets = MAX_PROBE_PACKETS;
2582

    
2583
    /* default pts setting is MPEG-like */
2584
    av_set_pts_info(st, 33, 1, 90000);
2585
    st->last_IP_pts = AV_NOPTS_VALUE;
2586
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2587
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2588
    st->reference_dts = AV_NOPTS_VALUE;
2589

    
2590
    st->sample_aspect_ratio = (AVRational){0,1};
2591

    
2592
    s->streams[s->nb_streams++] = st;
2593
    return st;
2594
}
2595

    
2596
AVProgram *av_new_program(AVFormatContext *ac, int id)
2597
{
2598
    AVProgram *program=NULL;
2599
    int i;
2600

    
2601
#ifdef DEBUG_SI
2602
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2603
#endif
2604

    
2605
    for(i=0; i<ac->nb_programs; i++)
2606
        if(ac->programs[i]->id == id)
2607
            program = ac->programs[i];
2608

    
2609
    if(!program){
2610
        program = av_mallocz(sizeof(AVProgram));
2611
        if (!program)
2612
            return NULL;
2613
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2614
        program->discard = AVDISCARD_NONE;
2615
    }
2616
    program->id = id;
2617

    
2618
    return program;
2619
}
2620

    
2621
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2622
{
2623
    AVChapter *chapter = NULL;
2624
    int i;
2625

    
2626
    for(i=0; i<s->nb_chapters; i++)
2627
        if(s->chapters[i]->id == id)
2628
            chapter = s->chapters[i];
2629

    
2630
    if(!chapter){
2631
        chapter= av_mallocz(sizeof(AVChapter));
2632
        if(!chapter)
2633
            return NULL;
2634
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2635
    }
2636
#if FF_API_OLD_METADATA
2637
    av_free(chapter->title);
2638
#endif
2639
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2640
    chapter->id    = id;
2641
    chapter->time_base= time_base;
2642
    chapter->start = start;
2643
    chapter->end   = end;
2644

    
2645
    return chapter;
2646
}
2647

    
2648
/************************************************************/
2649
/* output media file */
2650

    
2651
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2652
{
2653
    int ret;
2654

    
2655
    if (s->oformat->priv_data_size > 0) {
2656
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2657
        if (!s->priv_data)
2658
            return AVERROR(ENOMEM);
2659
    } else
2660
        s->priv_data = NULL;
2661

    
2662
    if (s->oformat->set_parameters) {
2663
        ret = s->oformat->set_parameters(s, ap);
2664
        if (ret < 0)
2665
            return ret;
2666
    }
2667
    return 0;
2668
}
2669

    
2670
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2671
{
2672
    const AVCodecTag *avctag;
2673
    int n;
2674
    enum CodecID id = CODEC_ID_NONE;
2675
    unsigned int tag = 0;
2676

    
2677
    /**
2678
     * Check that tag + id is in the table
2679
     * If neither is in the table -> OK
2680
     * If tag is in the table with another id -> FAIL
2681
     * If id is in the table with another tag -> FAIL unless strict < normal
2682
     */
2683
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2684
        avctag = s->oformat->codec_tag[n];
2685
        while (avctag->id != CODEC_ID_NONE) {
2686
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2687
                id = avctag->id;
2688
                if (id == st->codec->codec_id)
2689
                    return 1;
2690
            }
2691
            if (avctag->id == st->codec->codec_id)
2692
                tag = avctag->tag;
2693
            avctag++;
2694
        }
2695
    }
2696
    if (id != CODEC_ID_NONE)
2697
        return 0;
2698
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2699
        return 0;
2700
    return 1;
2701
}
2702

    
2703
int av_write_header(AVFormatContext *s)
2704
{
2705
    int ret, i;
2706
    AVStream *st;
2707

    
2708
    // some sanity checks
2709
    if (s->nb_streams == 0) {
2710
        av_log(s, AV_LOG_ERROR, "no streams\n");
2711
        return AVERROR(EINVAL);
2712
    }
2713

    
2714
    for(i=0;i<s->nb_streams;i++) {
2715
        st = s->streams[i];
2716

    
2717
        switch (st->codec->codec_type) {
2718
        case AVMEDIA_TYPE_AUDIO:
2719
            if(st->codec->sample_rate<=0){
2720
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2721
                return AVERROR(EINVAL);
2722
            }
2723
            if(!st->codec->block_align)
2724
                st->codec->block_align = st->codec->channels *
2725
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2726
            break;
2727
        case AVMEDIA_TYPE_VIDEO:
2728
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2729
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2730
                return AVERROR(EINVAL);
2731
            }
2732
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2733
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2734
                return AVERROR(EINVAL);
2735
            }
2736
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2737
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2738
                return AVERROR(EINVAL);
2739
            }
2740
            break;
2741
        }
2742

    
2743
        if(s->oformat->codec_tag){
2744
            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)){
2745
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2746
                st->codec->codec_tag= 0;
2747
            }
2748
            if(st->codec->codec_tag){
2749
                if (!validate_codec_tag(s, st)) {
2750
                    char tagbuf[32];
2751
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2752
                    av_log(s, AV_LOG_ERROR,
2753
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2754
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2755
                    return AVERROR_INVALIDDATA;
2756
                }
2757
            }else
2758
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2759
        }
2760

    
2761
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2762
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2763
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2764
    }
2765

    
2766
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2767
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2768
        if (!s->priv_data)
2769
            return AVERROR(ENOMEM);
2770
    }
2771

    
2772
#if FF_API_OLD_METADATA
2773
    ff_metadata_mux_compat(s);
2774
#endif
2775

    
2776
    /* set muxer identification string */
2777
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2778
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2779
    }
2780

    
2781
    if(s->oformat->write_header){
2782
        ret = s->oformat->write_header(s);
2783
        if (ret < 0)
2784
            return ret;
2785
    }
2786

    
2787
    /* init PTS generation */
2788
    for(i=0;i<s->nb_streams;i++) {
2789
        int64_t den = AV_NOPTS_VALUE;
2790
        st = s->streams[i];
2791

    
2792
        switch (st->codec->codec_type) {
2793
        case AVMEDIA_TYPE_AUDIO:
2794
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2795
            break;
2796
        case AVMEDIA_TYPE_VIDEO:
2797
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2798
            break;
2799
        default:
2800
            break;
2801
        }
2802
        if (den != AV_NOPTS_VALUE) {
2803
            if (den <= 0)
2804
                return AVERROR_INVALIDDATA;
2805
            av_frac_init(&st->pts, 0, 0, den);
2806
        }
2807
    }
2808
    return 0;
2809
}
2810

    
2811
//FIXME merge with compute_pkt_fields
2812
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2813
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2814
    int num, den, frame_size, i;
2815

    
2816
//    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);
2817

    
2818
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2819
        return -1;*/
2820

    
2821
    /* duration field */
2822
    if (pkt->duration == 0) {
2823
        compute_frame_duration(&num, &den, st, NULL, pkt);
2824
        if (den && num) {
2825
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2826
        }
2827
    }
2828

    
2829
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2830
        pkt->pts= pkt->dts;
2831

    
2832
    //XXX/FIXME this is a temporary hack until all encoders output pts
2833
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2834
        pkt->dts=
2835
//        pkt->pts= st->cur_dts;
2836
        pkt->pts= st->pts.val;
2837
    }
2838

    
2839
    //calculate dts from pts
2840
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2841
        st->pts_buffer[0]= pkt->pts;
2842
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2843
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2844
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2845
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2846

    
2847
        pkt->dts= st->pts_buffer[0];
2848
    }
2849

    
2850
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2851
        av_log(s, AV_LOG_ERROR,
2852
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2853
               st->index, st->cur_dts, pkt->dts);
2854
        return -1;
2855
    }
2856
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2857
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2858
        return -1;
2859
    }
2860

    
2861
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2862
    st->cur_dts= pkt->dts;
2863
    st->pts.val= pkt->dts;
2864

    
2865
    /* update pts */
2866
    switch (st->codec->codec_type) {
2867
    case AVMEDIA_TYPE_AUDIO:
2868
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2869

    
2870
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2871
           likely equal to the encoder delay, but it would be better if we
2872
           had the real timestamps from the encoder */
2873
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2874
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2875
        }
2876
        break;
2877
    case AVMEDIA_TYPE_VIDEO:
2878
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2879
        break;
2880
    default:
2881
        break;
2882
    }
2883
    return 0;
2884
}
2885

    
2886
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2887
{
2888
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2889

    
2890
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2891
        return ret;
2892

    
2893
    ret= s->oformat->write_packet(s, pkt);
2894
    if(!ret)
2895
        ret= url_ferror(s->pb);
2896
    return ret;
2897
}
2898

    
2899
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2900
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2901
{
2902
    AVPacketList **next_point, *this_pktl;
2903

    
2904
    this_pktl = av_mallocz(sizeof(AVPacketList));
2905
    this_pktl->pkt= *pkt;
2906
    pkt->destruct= NULL;             // do not free original but only the copy
2907
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2908

    
2909
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2910
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2911
    }else
2912
        next_point = &s->packet_buffer;
2913

    
2914
    if(*next_point){
2915
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2916
            while(!compare(s, &(*next_point)->pkt, pkt)){
2917
                next_point= &(*next_point)->next;
2918
            }
2919
            goto next_non_null;
2920
        }else{
2921
            next_point = &(s->packet_buffer_end->next);
2922
        }
2923
    }
2924
    assert(!*next_point);
2925

    
2926
    s->packet_buffer_end= this_pktl;
2927
next_non_null:
2928

    
2929
    this_pktl->next= *next_point;
2930

    
2931
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2932
    *next_point= this_pktl;
2933
}
2934

    
2935
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2936
{
2937
    AVStream *st = s->streams[ pkt ->stream_index];
2938
    AVStream *st2= s->streams[ next->stream_index];
2939
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2940
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2941
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2942
}
2943

    
2944
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2945
    AVPacketList *pktl;
2946
    int stream_count=0;
2947
    int i;
2948

    
2949
    if(pkt){
2950
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2951
    }
2952

    
2953
    for(i=0; i < s->nb_streams; i++)
2954
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2955

    
2956
    if(stream_count && (s->nb_streams == stream_count || flush)){
2957
        pktl= s->packet_buffer;
2958
        *out= pktl->pkt;
2959

    
2960
        s->packet_buffer= pktl->next;
2961
        if(!s->packet_buffer)
2962
            s->packet_buffer_end= NULL;
2963

    
2964
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2965
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2966
        av_freep(&pktl);
2967
        return 1;
2968
    }else{
2969
        av_init_packet(out);
2970
        return 0;
2971
    }
2972
}
2973

    
2974
/**
2975
 * Interleave an AVPacket correctly so it can be muxed.
2976
 * @param out the interleaved packet will be output here
2977
 * @param in the input packet
2978
 * @param flush 1 if no further packets are available as input and all
2979
 *              remaining packets should be output
2980
 * @return 1 if a packet was output, 0 if no packet could be output,
2981
 *         < 0 if an error occurred
2982
 */
2983
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2984
    if(s->oformat->interleave_packet)
2985
        return s->oformat->interleave_packet(s, out, in, flush);
2986
    else
2987
        return av_interleave_packet_per_dts(s, out, in, flush);
2988
}
2989

    
2990
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2991
    AVStream *st= s->streams[ pkt->stream_index];
2992

    
2993
    //FIXME/XXX/HACK drop zero sized packets
2994
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2995
        return 0;
2996

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

    
3001
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3002
        return -1;
3003

    
3004
    for(;;){
3005
        AVPacket opkt;
3006
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3007
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3008
            return ret;
3009

    
3010
        ret= s->oformat->write_packet(s, &opkt);
3011

    
3012
        av_free_packet(&opkt);
3013
        pkt= NULL;
3014

    
3015
        if(ret<0)
3016
            return ret;
3017
        if(url_ferror(s->pb))
3018
            return url_ferror(s->pb);
3019
    }
3020
}
3021

    
3022
int av_write_trailer(AVFormatContext *s)
3023
{
3024
    int ret, i;
3025

    
3026
    for(;;){
3027
        AVPacket pkt;
3028
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3029
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3030
            goto fail;
3031
        if(!ret)
3032
            break;
3033

    
3034
        ret= s->oformat->write_packet(s, &pkt);
3035

    
3036
        av_free_packet(&pkt);
3037

    
3038
        if(ret<0)
3039
            goto fail;
3040
        if(url_ferror(s->pb))
3041
            goto fail;
3042
    }
3043

    
3044
    if(s->oformat->write_trailer)
3045
        ret = s->oformat->write_trailer(s);
3046
fail:
3047
    if(ret == 0)
3048
       ret=url_ferror(s->pb);
3049
    for(i=0;i<s->nb_streams;i++) {
3050
        av_freep(&s->streams[i]->priv_data);
3051
        av_freep(&s->streams[i]->index_entries);
3052
    }
3053
    av_freep(&s->priv_data);
3054
    return ret;
3055
}
3056

    
3057
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3058
{
3059
    int i, j;
3060
    AVProgram *program=NULL;
3061
    void *tmp;
3062

    
3063
    if (idx >= ac->nb_streams) {
3064
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3065
        return;
3066
    }
3067

    
3068
    for(i=0; i<ac->nb_programs; i++){
3069
        if(ac->programs[i]->id != progid)
3070
            continue;
3071
        program = ac->programs[i];
3072
        for(j=0; j<program->nb_stream_indexes; j++)
3073
            if(program->stream_index[j] == idx)
3074
                return;
3075

    
3076
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3077
        if(!tmp)
3078
            return;
3079
        program->stream_index = tmp;
3080
        program->stream_index[program->nb_stream_indexes++] = idx;
3081
        return;
3082
    }
3083
}
3084

    
3085
static void print_fps(double d, const char *postfix){
3086
    uint64_t v= lrintf(d*100);
3087
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3088
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3089
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3090
}
3091

    
3092
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3093
{
3094
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3095
        AVMetadataTag *tag=NULL;
3096

    
3097
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3098
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3099
            if(strcmp("language", tag->key))
3100
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3101
        }
3102
    }
3103
}
3104

    
3105
/* "user interface" functions */
3106
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3107
{
3108
    char buf[256];
3109
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3110
    AVStream *st = ic->streams[i];
3111
    int g = av_gcd(st->time_base.num, st->time_base.den);
3112
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3113
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3114
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3115
    /* the pid is an important information, so we display it */
3116
    /* XXX: add a generic system */
3117
    if (flags & AVFMT_SHOW_IDS)
3118
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3119
    if (lang)
3120
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3121
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3122
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3123
    if (st->sample_aspect_ratio.num && // default
3124
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3125
        AVRational display_aspect_ratio;
3126
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3127
                  st->codec->width*st->sample_aspect_ratio.num,
3128
                  st->codec->height*st->sample_aspect_ratio.den,
3129
                  1024*1024);
3130
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3131
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3132
                 display_aspect_ratio.num, display_aspect_ratio.den);
3133
    }
3134
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3135
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3136
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3137
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3138
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3139
        if(st->time_base.den && st->time_base.num)
3140
            print_fps(1/av_q2d(st->time_base), "tbn");
3141
        if(st->codec->time_base.den && st->codec->time_base.num)
3142
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3143
    }
3144
    av_log(NULL, AV_LOG_INFO, "\n");
3145
    dump_metadata(NULL, st->metadata, "    ");
3146
}
3147

    
3148
void dump_format(AVFormatContext *ic,
3149
                 int index,
3150
                 const char *url,
3151
                 int is_output)
3152
{
3153
    int i;
3154
    uint8_t *printed = av_mallocz(ic->nb_streams);
3155
    if (ic->nb_streams && !printed)
3156
        return;
3157

    
3158
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3159
            is_output ? "Output" : "Input",
3160
            index,
3161
            is_output ? ic->oformat->name : ic->iformat->name,
3162
            is_output ? "to" : "from", url);
3163
    dump_metadata(NULL, ic->metadata, "  ");
3164
    if (!is_output) {
3165
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3166
        if (ic->duration != AV_NOPTS_VALUE) {
3167
            int hours, mins, secs, us;
3168
            secs = ic->duration / AV_TIME_BASE;
3169
            us = ic->duration % AV_TIME_BASE;
3170
            mins = secs / 60;
3171
            secs %= 60;
3172
            hours = mins / 60;
3173
            mins %= 60;
3174
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3175
                   (100 * us) / AV_TIME_BASE);
3176
        } else {
3177
            av_log(NULL, AV_LOG_INFO, "N/A");
3178
        }
3179
        if (ic->start_time != AV_NOPTS_VALUE) {
3180
            int secs, us;
3181
            av_log(NULL, AV_LOG_INFO, ", start: ");
3182
            secs = ic->start_time / AV_TIME_BASE;
3183
            us = abs(ic->start_time % AV_TIME_BASE);
3184
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3185
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3186
        }
3187
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3188
        if (ic->bit_rate) {
3189
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3190
        } else {
3191
            av_log(NULL, AV_LOG_INFO, "N/A");
3192
        }
3193
        av_log(NULL, AV_LOG_INFO, "\n");
3194
    }
3195
    for (i = 0; i < ic->nb_chapters; i++) {
3196
        AVChapter *ch = ic->chapters[i];
3197
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3198
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3199
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3200

    
3201
        dump_metadata(NULL, ch->metadata, "    ");
3202
    }
3203
    if(ic->nb_programs) {
3204
        int j, k, total = 0;
3205
        for(j=0; j<ic->nb_programs; j++) {
3206
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3207
                                                  "name", NULL, 0);
3208
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3209
                   name ? name->value : "");
3210
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3211
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3212
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3213
                printed[ic->programs[j]->stream_index[k]] = 1;
3214
            }
3215
            total += ic->programs[j]->nb_stream_indexes;
3216
        }
3217
        if (total < ic->nb_streams)
3218
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3219
    }
3220
    for(i=0;i<ic->nb_streams;i++)
3221
        if (!printed[i])
3222
            dump_stream_format(ic, i, index, is_output);
3223

    
3224
    av_free(printed);
3225
}
3226

    
3227
#if FF_API_PARSE_FRAME_PARAM
3228
#include "libavcore/parseutils.h"
3229

    
3230
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3231
{
3232
    return av_parse_video_size(width_ptr, height_ptr, str);
3233
}
3234

    
3235
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3236
{
3237
    AVRational frame_rate;
3238
    int ret = av_parse_video_rate(&frame_rate, arg);
3239
    *frame_rate_num= frame_rate.num;
3240
    *frame_rate_den= frame_rate.den;
3241
    return ret;
3242
}
3243
#endif
3244

    
3245
int64_t av_gettime(void)
3246
{
3247
    struct timeval tv;
3248
    gettimeofday(&tv,NULL);
3249
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3250
}
3251

    
3252
uint64_t ff_ntp_time(void)
3253
{
3254
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3255
}
3256

    
3257
int64_t parse_date(const char *datestr, int duration)
3258
{
3259
    const char *p;
3260
    int64_t t;
3261
    struct tm dt;
3262
    int i;
3263
    static const char * const date_fmt[] = {
3264
        "%Y-%m-%d",
3265
        "%Y%m%d",
3266
    };
3267
    static const char * const time_fmt[] = {
3268
        "%H:%M:%S",
3269
        "%H%M%S",
3270
    };
3271
    const char *q;
3272
    int is_utc, len;
3273
    char lastch;
3274
    int negative = 0;
3275

    
3276
#undef time
3277
    time_t now = time(0);
3278

    
3279
    len = strlen(datestr);
3280
    if (len > 0)
3281
        lastch = datestr[len - 1];
3282
    else
3283
        lastch = '\0';
3284
    is_utc = (lastch == 'z' || lastch == 'Z');
3285

    
3286
    memset(&dt, 0, sizeof(dt));
3287

    
3288
    p = datestr;
3289
    q = NULL;
3290
    if (!duration) {
3291
        if (!strncasecmp(datestr, "now", len))
3292
            return (int64_t) now * 1000000;
3293

    
3294
        /* parse the year-month-day part */
3295
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3296
            q = small_strptime(p, date_fmt[i], &dt);
3297
            if (q) {
3298
                break;
3299
            }
3300
        }
3301

    
3302
        /* if the year-month-day part is missing, then take the
3303
         * current year-month-day time */
3304
        if (!q) {
3305
            if (is_utc) {
3306
                dt = *gmtime(&now);
3307
            } else {
3308
                dt = *localtime(&now);
3309
            }
3310
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3311
        } else {
3312
            p = q;
3313
        }
3314

    
3315
        if (*p == 'T' || *p == 't' || *p == ' ')
3316
            p++;
3317

    
3318
        /* parse the hour-minute-second part */
3319
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3320
            q = small_strptime(p, time_fmt[i], &dt);
3321
            if (q) {
3322
                break;
3323
            }
3324
        }
3325
    } else {
3326
        /* parse datestr as a duration */
3327
        if (p[0] == '-') {
3328
            negative = 1;
3329
            ++p;
3330
        }
3331
        /* parse datestr as HH:MM:SS */
3332
        q = small_strptime(p, time_fmt[0], &dt);
3333
        if (!q) {
3334
            /* parse datestr as S+ */
3335
            dt.tm_sec = strtol(p, (char **)&q, 10);
3336
            if (q == p)
3337
                /* the parsing didn't succeed */
3338
                return INT64_MIN;
3339
            dt.tm_min = 0;
3340
            dt.tm_hour = 0;
3341
        }
3342
    }
3343

    
3344
    /* Now we have all the fields that we can get */
3345
    if (!q) {
3346
        return INT64_MIN;
3347
    }
3348

    
3349
    if (duration) {
3350
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3351
    } else {
3352
        dt.tm_isdst = -1;       /* unknown */
3353
        if (is_utc) {
3354
            t = mktimegm(&dt);
3355
        } else {
3356
            t = mktime(&dt);
3357
        }
3358
    }
3359

    
3360
    t *= 1000000;
3361

    
3362
    /* parse the .m... part */
3363
    if (*q == '.') {
3364
        int val, n;
3365
        q++;
3366
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3367
            if (!isdigit(*q))
3368
                break;
3369
            val += n * (*q - '0');
3370
        }
3371
        t += val;
3372
    }
3373
    return negative ? -t : t;
3374
}
3375

    
3376
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3377
{
3378
    const char *p;
3379
    char tag[128], *q;
3380

    
3381
    p = info;
3382
    if (*p == '?')
3383
        p++;
3384
    for(;;) {
3385
        q = tag;
3386
        while (*p != '\0' && *p != '=' && *p != '&') {
3387
            if ((q - tag) < sizeof(tag) - 1)
3388
                *q++ = *p;
3389
            p++;
3390
        }
3391
        *q = '\0';
3392
        q = arg;
3393
        if (*p == '=') {
3394
            p++;
3395
            while (*p != '&' && *p != '\0') {
3396
                if ((q - arg) < arg_size - 1) {
3397
                    if (*p == '+')
3398
                        *q++ = ' ';
3399
                    else
3400
                        *q++ = *p;
3401
                }
3402
                p++;
3403
            }
3404
        }
3405
        *q = '\0';
3406
        if (!strcmp(tag, tag1))
3407
            return 1;
3408
        if (*p != '&')
3409
            break;
3410
        p++;
3411
    }
3412
    return 0;
3413
}
3414

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

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

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

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

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

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

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

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

    
3536
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3537
{
3538
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3539
}
3540

    
3541
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3542
{
3543
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3544
}
3545

    
3546
#if FF_API_URL_SPLIT
3547
attribute_deprecated
3548
void ff_url_split(char *proto, int proto_size,
3549
                  char *authorization, int authorization_size,
3550
                  char *hostname, int hostname_size,
3551
                  int *port_ptr,
3552
                  char *path, int path_size,
3553
                  const char *url)
3554
{
3555
    av_url_split(proto, proto_size,
3556
                 authorization, authorization_size,
3557
                 hostname, hostname_size,
3558
                 port_ptr,
3559
                 path, path_size,
3560
                 url);
3561
}
3562
#endif
3563

    
3564
void av_url_split(char *proto, int proto_size,
3565
                  char *authorization, int authorization_size,
3566
                  char *hostname, int hostname_size,
3567
                  int *port_ptr,
3568
                  char *path, int path_size,
3569
                  const char *url)
3570
{
3571
    const char *p, *ls, *at, *col, *brk;
3572

    
3573
    if (port_ptr)               *port_ptr = -1;
3574
    if (proto_size > 0)         proto[0] = 0;
3575
    if (authorization_size > 0) authorization[0] = 0;
3576
    if (hostname_size > 0)      hostname[0] = 0;
3577
    if (path_size > 0)          path[0] = 0;
3578

    
3579
    /* parse protocol */
3580
    if ((p = strchr(url, ':'))) {
3581
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3582
        p++; /* skip ':' */
3583
        if (*p == '/') p++;
3584
        if (*p == '/') p++;
3585
    } else {
3586
        /* no protocol means plain filename */
3587
        av_strlcpy(path, url, path_size);
3588
        return;
3589
    }
3590

    
3591
    /* separate path from hostname */
3592
    ls = strchr(p, '/');
3593
    if(!ls)
3594
        ls = strchr(p, '?');
3595
    if(ls)
3596
        av_strlcpy(path, ls, path_size);
3597
    else
3598
        ls = &p[strlen(p)]; // XXX
3599

    
3600
    /* the rest is hostname, use that to parse auth/port */
3601
    if (ls != p) {
3602
        /* authorization (user[:pass]@hostname) */
3603
        if ((at = strchr(p, '@')) && at < ls) {
3604
            av_strlcpy(authorization, p,
3605
                       FFMIN(authorization_size, at + 1 - p));
3606
            p = at + 1; /* skip '@' */
3607
        }
3608

    
3609
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3610
            /* [host]:port */
3611
            av_strlcpy(hostname, p + 1,
3612
                       FFMIN(hostname_size, brk - p));
3613
            if (brk[1] == ':' && port_ptr)
3614
                *port_ptr = atoi(brk + 2);
3615
        } else if ((col = strchr(p, ':')) && col < ls) {
3616
            av_strlcpy(hostname, p,
3617
                       FFMIN(col + 1 - p, hostname_size));
3618
            if (port_ptr) *port_ptr = atoi(col + 1);
3619
        } else
3620
            av_strlcpy(hostname, p,
3621
                       FFMIN(ls + 1 - p, hostname_size));
3622
    }
3623
}
3624

    
3625
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3626
{
3627
    int i;
3628
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3629
                                           '4', '5', '6', '7',
3630
                                           '8', '9', 'A', 'B',
3631
                                           'C', 'D', 'E', 'F' };
3632
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3633
                                           '4', '5', '6', '7',
3634
                                           '8', '9', 'a', 'b',
3635
                                           'c', 'd', 'e', 'f' };
3636
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3637

    
3638
    for(i = 0; i < s; i++) {
3639
        buff[i * 2]     = hex_table[src[i] >> 4];
3640
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3641
    }
3642

    
3643
    return buff;
3644
}
3645

    
3646
int ff_hex_to_data(uint8_t *data, const char *p)
3647
{
3648
    int c, len, v;
3649

    
3650
    len = 0;
3651
    v = 1;
3652
    for (;;) {
3653
        p += strspn(p, SPACE_CHARS);
3654
        if (*p == '\0')
3655
            break;
3656
        c = toupper((unsigned char) *p++);
3657
        if (c >= '0' && c <= '9')
3658
            c = c - '0';
3659
        else if (c >= 'A' && c <= 'F')
3660
            c = c - 'A' + 10;
3661
        else
3662
            break;
3663
        v = (v << 4) | c;
3664
        if (v & 0x100) {
3665
            if (data)
3666
                data[len] = v;
3667
            len++;
3668
            v = 1;
3669
        }
3670
    }
3671
    return len;
3672
}
3673

    
3674
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3675
                     unsigned int pts_num, unsigned int pts_den)
3676
{
3677
    s->pts_wrap_bits = pts_wrap_bits;
3678

    
3679
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3680
        if(s->time_base.num != pts_num)
3681
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3682
    }else
3683
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3684

    
3685
    if(!s->time_base.num || !s->time_base.den)
3686
        s->time_base.num= s->time_base.den= 0;
3687
}
3688

    
3689
int ff_url_join(char *str, int size, const char *proto,
3690
                const char *authorization, const char *hostname,
3691
                int port, const char *fmt, ...)
3692
{
3693
#if CONFIG_NETWORK
3694
    struct addrinfo hints, *ai;
3695
#endif
3696

    
3697
    str[0] = '\0';
3698
    if (proto)
3699
        av_strlcatf(str, size, "%s://", proto);
3700
    if (authorization && authorization[0])
3701
        av_strlcatf(str, size, "%s@", authorization);
3702
#if CONFIG_NETWORK && defined(AF_INET6)
3703
    /* Determine if hostname is a numerical IPv6 address,
3704
     * properly escape it within [] in that case. */
3705
    memset(&hints, 0, sizeof(hints));
3706
    hints.ai_flags = AI_NUMERICHOST;
3707
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3708
        if (ai->ai_family == AF_INET6) {
3709
            av_strlcat(str, "[", size);
3710
            av_strlcat(str, hostname, size);
3711
            av_strlcat(str, "]", size);
3712
        } else {
3713
            av_strlcat(str, hostname, size);
3714
        }
3715
        freeaddrinfo(ai);
3716
    } else
3717
#endif
3718
        /* Not an IPv6 address, just output the plain string. */
3719
        av_strlcat(str, hostname, size);
3720

    
3721
    if (port >= 0)
3722
        av_strlcatf(str, size, ":%d", port);
3723
    if (fmt) {
3724
        va_list vl;
3725
        int len = strlen(str);
3726

    
3727
        va_start(vl, fmt);
3728
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3729
        va_end(vl);
3730
    }
3731
    return strlen(str);
3732
}
3733

    
3734
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3735
                     AVFormatContext *src)
3736
{
3737
    AVPacket local_pkt;
3738

    
3739
    local_pkt = *pkt;
3740
    local_pkt.stream_index = dst_stream;
3741
    if (pkt->pts != AV_NOPTS_VALUE)
3742
        local_pkt.pts = av_rescale_q(pkt->pts,
3743
                                     src->streams[pkt->stream_index]->time_base,
3744
                                     dst->streams[dst_stream]->time_base);
3745
    if (pkt->dts != AV_NOPTS_VALUE)
3746
        local_pkt.dts = av_rescale_q(pkt->dts,
3747
                                     src->streams[pkt->stream_index]->time_base,
3748
                                     dst->streams[dst_stream]->time_base);
3749
    return av_write_frame(dst, &local_pkt);
3750
}
3751

    
3752
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3753
                        void *context)
3754
{
3755
    const char *ptr = str;
3756

    
3757
    /* Parse key=value pairs. */
3758
    for (;;) {
3759
        const char *key;
3760
        char *dest = NULL, *dest_end;
3761
        int key_len, dest_len = 0;
3762

    
3763
        /* Skip whitespace and potential commas. */
3764
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3765
            ptr++;
3766
        if (!*ptr)
3767
            break;
3768

    
3769
        key = ptr;
3770

    
3771
        if (!(ptr = strchr(key, '=')))
3772
            break;
3773
        ptr++;
3774
        key_len = ptr - key;
3775

    
3776
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3777
        dest_end = dest + dest_len - 1;
3778

    
3779
        if (*ptr == '\"') {
3780
            ptr++;
3781
            while (*ptr && *ptr != '\"') {
3782
                if (*ptr == '\\') {
3783
                    if (!ptr[1])
3784
                        break;
3785
                    if (dest && dest < dest_end)
3786
                        *dest++ = ptr[1];
3787
                    ptr += 2;
3788
                } else {
3789
                    if (dest && dest < dest_end)
3790
                        *dest++ = *ptr;
3791
                    ptr++;
3792
                }
3793
            }
3794
            if (*ptr == '\"')
3795
                ptr++;
3796
        } else {
3797
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3798
                if (dest && dest < dest_end)
3799
                    *dest++ = *ptr;
3800
        }
3801
        if (dest)
3802
            *dest = 0;
3803
    }
3804
}
3805