Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 38aab35f

History | View | Annotate | Download (120 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
AVInputFormat *first_iformat = NULL;
114
/** head of registered output format linked list */
115
AVOutputFormat *first_oformat = NULL;
116

    
117
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
118
{
119
    if(f) return f->next;
120
    else  return first_iformat;
121
}
122

    
123
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
124
{
125
    if(f) return f->next;
126
    else  return first_oformat;
127
}
128

    
129
void av_register_input_format(AVInputFormat *format)
130
{
131
    AVInputFormat **p;
132
    p = &first_iformat;
133
    while (*p != NULL) p = &(*p)->next;
134
    *p = format;
135
    format->next = NULL;
136
}
137

    
138
void av_register_output_format(AVOutputFormat *format)
139
{
140
    AVOutputFormat **p;
141
    p = &first_oformat;
142
    while (*p != NULL) p = &(*p)->next;
143
    *p = format;
144
    format->next = NULL;
145
}
146

    
147
int av_match_ext(const char *filename, const char *extensions)
148
{
149
    const char *ext, *p;
150
    char ext1[32], *q;
151

    
152
    if(!filename)
153
        return 0;
154

    
155
    ext = strrchr(filename, '.');
156
    if (ext) {
157
        ext++;
158
        p = extensions;
159
        for(;;) {
160
            q = ext1;
161
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
162
                *q++ = *p++;
163
            *q = '\0';
164
            if (!strcasecmp(ext1, ext))
165
                return 1;
166
            if (*p == '\0')
167
                break;
168
            p++;
169
        }
170
    }
171
    return 0;
172
}
173

    
174
static int match_format(const char *name, const char *names)
175
{
176
    const char *p;
177
    int len, namelen;
178

    
179
    if (!name || !names)
180
        return 0;
181

    
182
    namelen = strlen(name);
183
    while ((p = strchr(names, ','))) {
184
        len = FFMAX(p - names, namelen);
185
        if (!strncasecmp(name, names, len))
186
            return 1;
187
        names = p+1;
188
    }
189
    return !strcasecmp(name, names);
190
}
191

    
192
#if LIBAVFORMAT_VERSION_MAJOR < 53
193
AVOutputFormat *guess_format(const char *short_name, const char *filename,
194
                             const char *mime_type)
195
{
196
    return av_guess_format(short_name, filename, mime_type);
197
}
198
#endif
199

    
200
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
201
                                const char *mime_type)
202
{
203
    AVOutputFormat *fmt, *fmt_found;
204
    int score_max, score;
205

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

    
237
#if LIBAVFORMAT_VERSION_MAJOR < 53
238
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
239
                             const char *mime_type)
240
{
241
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
242

    
243
    if (fmt) {
244
        AVOutputFormat *stream_fmt;
245
        char stream_format_name[64];
246

    
247
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
248
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
249

    
250
        if (stream_fmt)
251
            fmt = stream_fmt;
252
    }
253

    
254
    return fmt;
255
}
256
#endif
257

    
258
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
259
                            const char *filename, const char *mime_type, enum AVMediaType type){
260
    if(type == AVMEDIA_TYPE_VIDEO){
261
        enum CodecID codec_id= CODEC_ID_NONE;
262

    
263
#if CONFIG_IMAGE2_MUXER
264
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
265
            codec_id= av_guess_image2_codec(filename);
266
        }
267
#endif
268
        if(codec_id == CODEC_ID_NONE)
269
            codec_id= fmt->video_codec;
270
        return codec_id;
271
    }else if(type == AVMEDIA_TYPE_AUDIO)
272
        return fmt->audio_codec;
273
    else
274
        return CODEC_ID_NONE;
275
}
276

    
277
AVInputFormat *av_find_input_format(const char *short_name)
278
{
279
    AVInputFormat *fmt;
280
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
281
        if (match_format(short_name, fmt->name))
282
            return fmt;
283
    }
284
    return NULL;
285
}
286

    
287
#if LIBAVFORMAT_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
288
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
289
{
290
    av_destruct_packet_nofree(pkt);
291
}
292

    
293
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
294
{
295
    av_destruct_packet(pkt);
296
}
297

    
298
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
299
{
300
    return av_new_packet(pkt, size);
301
}
302

    
303
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
304
{
305
    return av_dup_packet(pkt);
306
}
307

    
308
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
309
{
310
    av_free_packet(pkt);
311
}
312

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

    
320
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
321
{
322
    int ret= av_new_packet(pkt, size);
323

    
324
    if(ret<0)
325
        return ret;
326

    
327
    pkt->pos= url_ftell(s);
328

    
329
    ret= get_buffer(s, pkt->data, size);
330
    if(ret<=0)
331
        av_free_packet(pkt);
332
    else
333
        av_shrink_packet(pkt, ret);
334

    
335
    return ret;
336
}
337

    
338

    
339
int av_filename_number_test(const char *filename)
340
{
341
    char buf[1024];
342
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
343
}
344

    
345
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
346
{
347
    AVProbeData lpd = *pd;
348
    AVInputFormat *fmt1, *fmt;
349
    int score;
350

    
351
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
352
        int id3len = ff_id3v2_tag_len(lpd.buf);
353
        if (lpd.buf_size > id3len + 16) {
354
            lpd.buf += id3len;
355
            lpd.buf_size -= id3len;
356
        }
357
    }
358

    
359
    fmt = NULL;
360
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
361
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
362
            continue;
363
        score = 0;
364
        if (fmt1->read_probe) {
365
            score = fmt1->read_probe(&lpd);
366
        } else if (fmt1->extensions) {
367
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
368
                score = 50;
369
            }
370
        }
371
        if (score > *score_max) {
372
            *score_max = score;
373
            fmt = fmt1;
374
        }else if (score == *score_max)
375
            fmt = NULL;
376
    }
377
    return fmt;
378
}
379

    
380
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
381
    int score=0;
382
    return av_probe_input_format2(pd, is_opened, &score);
383
}
384

    
385
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
386
{
387
    static const struct {
388
        const char *name; enum CodecID id; enum AVMediaType type;
389
    } fmt_id_type[] = {
390
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
391
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
392
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
393
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
394
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
395
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
396
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
397
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
398
        { 0 }
399
    };
400
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
401

    
402
    if (fmt) {
403
        int i;
404
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
405
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
406
        for (i = 0; fmt_id_type[i].name; i++) {
407
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
408
                st->codec->codec_id   = fmt_id_type[i].id;
409
                st->codec->codec_type = fmt_id_type[i].type;
410
                break;
411
            }
412
        }
413
    }
414
    return !!fmt;
415
}
416

    
417
/************************************************************/
418
/* input media file */
419

    
420
/**
421
 * Open a media file from an IO stream. 'fmt' must be specified.
422
 */
423
int av_open_input_stream(AVFormatContext **ic_ptr,
424
                         ByteIOContext *pb, const char *filename,
425
                         AVInputFormat *fmt, AVFormatParameters *ap)
426
{
427
    int err;
428
    AVFormatContext *ic;
429
    AVFormatParameters default_ap;
430

    
431
    if(!ap){
432
        ap=&default_ap;
433
        memset(ap, 0, sizeof(default_ap));
434
    }
435

    
436
    if(!ap->prealloced_context)
437
        ic = avformat_alloc_context();
438
    else
439
        ic = *ic_ptr;
440
    if (!ic) {
441
        err = AVERROR(ENOMEM);
442
        goto fail;
443
    }
444
    ic->iformat = fmt;
445
    ic->pb = pb;
446
    ic->duration = AV_NOPTS_VALUE;
447
    ic->start_time = AV_NOPTS_VALUE;
448
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
449

    
450
    /* allocate private data */
451
    if (fmt->priv_data_size > 0) {
452
        ic->priv_data = av_mallocz(fmt->priv_data_size);
453
        if (!ic->priv_data) {
454
            err = AVERROR(ENOMEM);
455
            goto fail;
456
        }
457
    } else {
458
        ic->priv_data = NULL;
459
    }
460

    
461
    // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
462
    if (ic->pb)
463
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
464

    
465
    if (ic->iformat->read_header) {
466
        err = ic->iformat->read_header(ic, ap);
467
        if (err < 0)
468
            goto fail;
469
    }
470

    
471
    if (pb && !ic->data_offset)
472
        ic->data_offset = url_ftell(ic->pb);
473

    
474
#if FF_API_OLD_METADATA
475
    ff_metadata_demux_compat(ic);
476
#endif
477

    
478
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
479

    
480
    *ic_ptr = ic;
481
    return 0;
482
 fail:
483
    if (ic) {
484
        int i;
485
        av_freep(&ic->priv_data);
486
        for(i=0;i<ic->nb_streams;i++) {
487
            AVStream *st = ic->streams[i];
488
            if (st) {
489
                av_free(st->priv_data);
490
                av_free(st->codec->extradata);
491
                av_free(st->codec);
492
            }
493
            av_free(st);
494
        }
495
    }
496
    av_free(ic);
497
    *ic_ptr = NULL;
498
    return err;
499
}
500

    
501
/** size of probe buffer, for guessing file type from file contents */
502
#define PROBE_BUF_MIN 2048
503
#define PROBE_BUF_MAX (1<<20)
504

    
505
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
506
                          const char *filename, void *logctx,
507
                          unsigned int offset, unsigned int max_probe_size)
508
{
509
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
510
    unsigned char *buf = NULL;
511
    int ret = 0, probe_size;
512

    
513
    if (!max_probe_size) {
514
        max_probe_size = PROBE_BUF_MAX;
515
    } else if (max_probe_size > PROBE_BUF_MAX) {
516
        max_probe_size = PROBE_BUF_MAX;
517
    } else if (max_probe_size < PROBE_BUF_MIN) {
518
        return AVERROR(EINVAL);
519
    }
520

    
521
    if (offset >= max_probe_size) {
522
        return AVERROR(EINVAL);
523
    }
524

    
525
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
526
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
527
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
528
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
529

    
530
        if (probe_size < offset) {
531
            continue;
532
        }
533

    
534
        /* read probe data */
535
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
536
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
537
            /* fail if error was not end of file, otherwise, lower score */
538
            if (ret != AVERROR_EOF) {
539
                av_free(buf);
540
                return ret;
541
            }
542
            score = 0;
543
            ret = 0;            /* error was end of file, nothing read */
544
        }
545
        pd.buf_size += ret;
546
        pd.buf = &buf[offset];
547

    
548
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
549

    
550
        /* guess file format */
551
        *fmt = av_probe_input_format2(&pd, 1, &score);
552
        if(*fmt){
553
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
554
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
555
            }else
556
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
557
        }
558
    }
559

    
560
    if (!*fmt) {
561
        av_free(buf);
562
        return AVERROR_INVALIDDATA;
563
    }
564

    
565
    /* rewind. reuse probe buffer to avoid seeking */
566
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
567
        av_free(buf);
568

    
569
    return ret;
570
}
571

    
572
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
573
                       AVInputFormat *fmt,
574
                       int buf_size,
575
                       AVFormatParameters *ap)
576
{
577
    int err;
578
    AVProbeData probe_data, *pd = &probe_data;
579
    ByteIOContext *pb = NULL;
580
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
581

    
582
    pd->filename = "";
583
    if (filename)
584
        pd->filename = filename;
585
    pd->buf = NULL;
586
    pd->buf_size = 0;
587

    
588
    if (!fmt) {
589
        /* guess format if no file can be opened */
590
        fmt = av_probe_input_format(pd, 0);
591
    }
592

    
593
    /* Do not open file if the format does not need it. XXX: specific
594
       hack needed to handle RTSP/TCP */
595
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
596
        /* if no file needed do not try to open one */
597
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
598
            goto fail;
599
        }
600
        if (buf_size > 0) {
601
            url_setbufsize(pb, buf_size);
602
        }
603
        if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
604
            goto fail;
605
        }
606
    }
607

    
608
    /* if still no format found, error */
609
    if (!fmt) {
610
        err = AVERROR_INVALIDDATA;
611
        goto fail;
612
    }
613

    
614
    /* check filename in case an image number is expected */
615
    if (fmt->flags & AVFMT_NEEDNUMBER) {
616
        if (!av_filename_number_test(filename)) {
617
            err = AVERROR_NUMEXPECTED;
618
            goto fail;
619
        }
620
    }
621
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
622
    if (err)
623
        goto fail;
624
    return 0;
625
 fail:
626
    av_freep(&pd->buf);
627
    if (pb)
628
        url_fclose(pb);
629
    if (ap && ap->prealloced_context)
630
        av_free(*ic_ptr);
631
    *ic_ptr = NULL;
632
    return err;
633

    
634
}
635

    
636
/*******************************************************/
637

    
638
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
639
                               AVPacketList **plast_pktl){
640
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
641
    if (!pktl)
642
        return NULL;
643

    
644
    if (*packet_buffer)
645
        (*plast_pktl)->next = pktl;
646
    else
647
        *packet_buffer = pktl;
648

    
649
    /* add the packet in the buffered packet list */
650
    *plast_pktl = pktl;
651
    pktl->pkt= *pkt;
652
    return &pktl->pkt;
653
}
654

    
655
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
656
{
657
    int ret, i;
658
    AVStream *st;
659

    
660
    for(;;){
661
        AVPacketList *pktl = s->raw_packet_buffer;
662

    
663
        if (pktl) {
664
            *pkt = pktl->pkt;
665
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
666
               !s->streams[pkt->stream_index]->probe_packets ||
667
               s->raw_packet_buffer_remaining_size < pkt->size){
668
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
669
                av_freep(&pd->buf);
670
                pd->buf_size = 0;
671
                s->raw_packet_buffer = pktl->next;
672
                s->raw_packet_buffer_remaining_size += pkt->size;
673
                av_free(pktl);
674
                return 0;
675
            }
676
        }
677

    
678
        av_init_packet(pkt);
679
        ret= s->iformat->read_packet(s, pkt);
680
        if (ret < 0) {
681
            if (!pktl || ret == AVERROR(EAGAIN))
682
                return ret;
683
            for (i = 0; i < s->nb_streams; i++)
684
                s->streams[i]->probe_packets = 0;
685
            continue;
686
        }
687
        st= s->streams[pkt->stream_index];
688

    
689
        switch(st->codec->codec_type){
690
        case AVMEDIA_TYPE_VIDEO:
691
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
692
            break;
693
        case AVMEDIA_TYPE_AUDIO:
694
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
695
            break;
696
        case AVMEDIA_TYPE_SUBTITLE:
697
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
698
            break;
699
        }
700

    
701
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
702
                     !st->probe_packets))
703
            return ret;
704

    
705
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
706
        s->raw_packet_buffer_remaining_size -= pkt->size;
707

    
708
        if(st->codec->codec_id == CODEC_ID_PROBE){
709
            AVProbeData *pd = &st->probe_data;
710
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
711
            --st->probe_packets;
712

    
713
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
714
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
715
            pd->buf_size += pkt->size;
716
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
717

    
718
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
719
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
720
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
721
                if(st->codec->codec_id != CODEC_ID_PROBE){
722
                    pd->buf_size=0;
723
                    av_freep(&pd->buf);
724
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
725
                }
726
            }
727
        }
728
    }
729
}
730

    
731
/**********************************************************/
732

    
733
/**
734
 * Get the number of samples of an audio frame. Return -1 on error.
735
 */
736
static int get_audio_frame_size(AVCodecContext *enc, int size)
737
{
738
    int frame_size;
739

    
740
    if(enc->codec_id == CODEC_ID_VORBIS)
741
        return -1;
742

    
743
    if (enc->frame_size <= 1) {
744
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
745

    
746
        if (bits_per_sample) {
747
            if (enc->channels == 0)
748
                return -1;
749
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
750
        } else {
751
            /* used for example by ADPCM codecs */
752
            if (enc->bit_rate == 0)
753
                return -1;
754
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
755
        }
756
    } else {
757
        frame_size = enc->frame_size;
758
    }
759
    return frame_size;
760
}
761

    
762

    
763
/**
764
 * Return the frame duration in seconds. Return 0 if not available.
765
 */
766
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
767
                                   AVCodecParserContext *pc, AVPacket *pkt)
768
{
769
    int frame_size;
770

    
771
    *pnum = 0;
772
    *pden = 0;
773
    switch(st->codec->codec_type) {
774
    case AVMEDIA_TYPE_VIDEO:
775
        if(st->time_base.num*1000LL > st->time_base.den){
776
            *pnum = st->time_base.num;
777
            *pden = st->time_base.den;
778
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
779
            *pnum = st->codec->time_base.num;
780
            *pden = st->codec->time_base.den;
781
            if (pc && pc->repeat_pict) {
782
                *pnum = (*pnum) * (1 + pc->repeat_pict);
783
            }
784
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
785
            //Thus if we have no parser in such case leave duration undefined.
786
            if(st->codec->ticks_per_frame>1 && !pc){
787
                *pnum = *pden = 0;
788
            }
789
        }
790
        break;
791
    case AVMEDIA_TYPE_AUDIO:
792
        frame_size = get_audio_frame_size(st->codec, pkt->size);
793
        if (frame_size < 0)
794
            break;
795
        *pnum = frame_size;
796
        *pden = st->codec->sample_rate;
797
        break;
798
    default:
799
        break;
800
    }
801
}
802

    
803
static int is_intra_only(AVCodecContext *enc){
804
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
805
        return 1;
806
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
807
        switch(enc->codec_id){
808
        case CODEC_ID_MJPEG:
809
        case CODEC_ID_MJPEGB:
810
        case CODEC_ID_LJPEG:
811
        case CODEC_ID_RAWVIDEO:
812
        case CODEC_ID_DVVIDEO:
813
        case CODEC_ID_HUFFYUV:
814
        case CODEC_ID_FFVHUFF:
815
        case CODEC_ID_ASV1:
816
        case CODEC_ID_ASV2:
817
        case CODEC_ID_VCR1:
818
        case CODEC_ID_DNXHD:
819
        case CODEC_ID_JPEG2000:
820
            return 1;
821
        default: break;
822
        }
823
    }
824
    return 0;
825
}
826

    
827
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
828
                                      int64_t dts, int64_t pts)
829
{
830
    AVStream *st= s->streams[stream_index];
831
    AVPacketList *pktl= s->packet_buffer;
832

    
833
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
834
        return;
835

    
836
    st->first_dts= dts - st->cur_dts;
837
    st->cur_dts= dts;
838

    
839
    for(; pktl; pktl= pktl->next){
840
        if(pktl->pkt.stream_index != stream_index)
841
            continue;
842
        //FIXME think more about this check
843
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
844
            pktl->pkt.pts += st->first_dts;
845

    
846
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
847
            pktl->pkt.dts += st->first_dts;
848

    
849
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
850
            st->start_time= pktl->pkt.pts;
851
    }
852
    if (st->start_time == AV_NOPTS_VALUE)
853
        st->start_time = pts;
854
}
855

    
856
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
857
{
858
    AVPacketList *pktl= s->packet_buffer;
859
    int64_t cur_dts= 0;
860

    
861
    if(st->first_dts != AV_NOPTS_VALUE){
862
        cur_dts= st->first_dts;
863
        for(; pktl; pktl= pktl->next){
864
            if(pktl->pkt.stream_index == pkt->stream_index){
865
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
866
                    break;
867
                cur_dts -= pkt->duration;
868
            }
869
        }
870
        pktl= s->packet_buffer;
871
        st->first_dts = cur_dts;
872
    }else if(st->cur_dts)
873
        return;
874

    
875
    for(; pktl; pktl= pktl->next){
876
        if(pktl->pkt.stream_index != pkt->stream_index)
877
            continue;
878
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
879
           && !pktl->pkt.duration){
880
            pktl->pkt.dts= cur_dts;
881
            if(!st->codec->has_b_frames)
882
                pktl->pkt.pts= cur_dts;
883
            cur_dts += pkt->duration;
884
            pktl->pkt.duration= pkt->duration;
885
        }else
886
            break;
887
    }
888
    if(st->first_dts == AV_NOPTS_VALUE)
889
        st->cur_dts= cur_dts;
890
}
891

    
892
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
893
                               AVCodecParserContext *pc, AVPacket *pkt)
894
{
895
    int num, den, presentation_delayed, delay, i;
896
    int64_t offset;
897

    
898
    if (s->flags & AVFMT_FLAG_NOFILLIN)
899
        return;
900

    
901
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
902
        pkt->dts= AV_NOPTS_VALUE;
903

    
904
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
905
        //FIXME Set low_delay = 0 when has_b_frames = 1
906
        st->codec->has_b_frames = 1;
907

    
908
    /* do we have a video B-frame ? */
909
    delay= st->codec->has_b_frames;
910
    presentation_delayed = 0;
911
    /* XXX: need has_b_frame, but cannot get it if the codec is
912
        not initialized */
913
    if (delay &&
914
        pc && pc->pict_type != FF_B_TYPE)
915
        presentation_delayed = 1;
916

    
917
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
918
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
919
        pkt->dts -= 1LL<<st->pts_wrap_bits;
920
    }
921

    
922
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
923
    // we take the conservative approach and discard both
924
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
925
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
926
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
927
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
928
    }
929

    
930
    if (pkt->duration == 0) {
931
        compute_frame_duration(&num, &den, st, pc, pkt);
932
        if (den && num) {
933
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
934

    
935
            if(pkt->duration != 0 && s->packet_buffer)
936
                update_initial_durations(s, st, pkt);
937
        }
938
    }
939

    
940
    /* correct timestamps with byte offset if demuxers only have timestamps
941
       on packet boundaries */
942
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
943
        /* this will estimate bitrate based on this frame's duration and size */
944
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
945
        if(pkt->pts != AV_NOPTS_VALUE)
946
            pkt->pts += offset;
947
        if(pkt->dts != AV_NOPTS_VALUE)
948
            pkt->dts += offset;
949
    }
950

    
951
    if (pc && pc->dts_sync_point >= 0) {
952
        // we have synchronization info from the parser
953
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
954
        if (den > 0) {
955
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
956
            if (pkt->dts != AV_NOPTS_VALUE) {
957
                // got DTS from the stream, update reference timestamp
958
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
959
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
960
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
961
                // compute DTS based on reference timestamp
962
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
963
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
964
            }
965
            if (pc->dts_sync_point > 0)
966
                st->reference_dts = pkt->dts; // new reference
967
        }
968
    }
969

    
970
    /* This may be redundant, but it should not hurt. */
971
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
972
        presentation_delayed = 1;
973

    
974
//    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);
975
    /* interpolate PTS and DTS if they are not present */
976
    //We skip H264 currently because delay and has_b_frames are not reliably set
977
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
978
        if (presentation_delayed) {
979
            /* DTS = decompression timestamp */
980
            /* PTS = presentation timestamp */
981
            if (pkt->dts == AV_NOPTS_VALUE)
982
                pkt->dts = st->last_IP_pts;
983
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
984
            if (pkt->dts == AV_NOPTS_VALUE)
985
                pkt->dts = st->cur_dts;
986

    
987
            /* this is tricky: the dts must be incremented by the duration
988
            of the frame we are displaying, i.e. the last I- or P-frame */
989
            if (st->last_IP_duration == 0)
990
                st->last_IP_duration = pkt->duration;
991
            if(pkt->dts != AV_NOPTS_VALUE)
992
                st->cur_dts = pkt->dts + st->last_IP_duration;
993
            st->last_IP_duration  = pkt->duration;
994
            st->last_IP_pts= pkt->pts;
995
            /* cannot compute PTS if not present (we can compute it only
996
            by knowing the future */
997
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
998
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
999
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1000
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1001
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1002
                    pkt->pts += pkt->duration;
1003
    //                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);
1004
                }
1005
            }
1006

    
1007
            /* presentation is not delayed : PTS and DTS are the same */
1008
            if(pkt->pts == AV_NOPTS_VALUE)
1009
                pkt->pts = pkt->dts;
1010
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1011
            if(pkt->pts == AV_NOPTS_VALUE)
1012
                pkt->pts = st->cur_dts;
1013
            pkt->dts = pkt->pts;
1014
            if(pkt->pts != AV_NOPTS_VALUE)
1015
                st->cur_dts = pkt->pts + pkt->duration;
1016
        }
1017
    }
1018

    
1019
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1020
        st->pts_buffer[0]= pkt->pts;
1021
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1022
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1023
        if(pkt->dts == AV_NOPTS_VALUE)
1024
            pkt->dts= st->pts_buffer[0];
1025
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1026
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1027
        }
1028
        if(pkt->dts > st->cur_dts)
1029
            st->cur_dts = pkt->dts;
1030
    }
1031

    
1032
//    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);
1033

    
1034
    /* update flags */
1035
    if(is_intra_only(st->codec))
1036
        pkt->flags |= AV_PKT_FLAG_KEY;
1037
    else if (pc) {
1038
        pkt->flags = 0;
1039
        /* keyframe computation */
1040
        if (pc->key_frame == 1)
1041
            pkt->flags |= AV_PKT_FLAG_KEY;
1042
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1043
            pkt->flags |= AV_PKT_FLAG_KEY;
1044
    }
1045
    if (pc)
1046
        pkt->convergence_duration = pc->convergence_duration;
1047
}
1048

    
1049

    
1050
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1051
{
1052
    AVStream *st;
1053
    int len, ret, i;
1054

    
1055
    av_init_packet(pkt);
1056

    
1057
    for(;;) {
1058
        /* select current input stream component */
1059
        st = s->cur_st;
1060
        if (st) {
1061
            if (!st->need_parsing || !st->parser) {
1062
                /* no parsing needed: we just output the packet as is */
1063
                /* raw data support */
1064
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1065
                compute_pkt_fields(s, st, NULL, pkt);
1066
                s->cur_st = NULL;
1067
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1068
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1069
                    ff_reduce_index(s, st->index);
1070
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1071
                }
1072
                break;
1073
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1074
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1075
                                       st->cur_ptr, st->cur_len,
1076
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1077
                                       st->cur_pkt.pos);
1078
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1079
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1080
                /* increment read pointer */
1081
                st->cur_ptr += len;
1082
                st->cur_len -= len;
1083

    
1084
                /* return packet if any */
1085
                if (pkt->size) {
1086
                got_packet:
1087
                    pkt->duration = 0;
1088
                    pkt->stream_index = st->index;
1089
                    pkt->pts = st->parser->pts;
1090
                    pkt->dts = st->parser->dts;
1091
                    pkt->pos = st->parser->pos;
1092
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1093
                        s->cur_st = NULL;
1094
                        pkt->destruct= st->cur_pkt.destruct;
1095
                        st->cur_pkt.destruct= NULL;
1096
                        st->cur_pkt.data    = NULL;
1097
                        assert(st->cur_len == 0);
1098
                    }else{
1099
                    pkt->destruct = NULL;
1100
                    }
1101
                    compute_pkt_fields(s, st, st->parser, pkt);
1102

    
1103
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1104
                        ff_reduce_index(s, st->index);
1105
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1106
                                           0, 0, AVINDEX_KEYFRAME);
1107
                    }
1108

    
1109
                    break;
1110
                }
1111
            } else {
1112
                /* free packet */
1113
                av_free_packet(&st->cur_pkt);
1114
                s->cur_st = NULL;
1115
            }
1116
        } else {
1117
            AVPacket cur_pkt;
1118
            /* read next packet */
1119
            ret = av_read_packet(s, &cur_pkt);
1120
            if (ret < 0) {
1121
                if (ret == AVERROR(EAGAIN))
1122
                    return ret;
1123
                /* return the last frames, if any */
1124
                for(i = 0; i < s->nb_streams; i++) {
1125
                    st = s->streams[i];
1126
                    if (st->parser && st->need_parsing) {
1127
                        av_parser_parse2(st->parser, st->codec,
1128
                                        &pkt->data, &pkt->size,
1129
                                        NULL, 0,
1130
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1131
                                        AV_NOPTS_VALUE);
1132
                        if (pkt->size)
1133
                            goto got_packet;
1134
                    }
1135
                }
1136
                /* no more packets: really terminate parsing */
1137
                return ret;
1138
            }
1139
            st = s->streams[cur_pkt.stream_index];
1140
            st->cur_pkt= cur_pkt;
1141

    
1142
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1143
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1144
               st->cur_pkt.pts < st->cur_pkt.dts){
1145
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1146
                    st->cur_pkt.stream_index,
1147
                    st->cur_pkt.pts,
1148
                    st->cur_pkt.dts,
1149
                    st->cur_pkt.size);
1150
//                av_free_packet(&st->cur_pkt);
1151
//                return -1;
1152
            }
1153

    
1154
            if(s->debug & FF_FDEBUG_TS)
1155
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1156
                    st->cur_pkt.stream_index,
1157
                    st->cur_pkt.pts,
1158
                    st->cur_pkt.dts,
1159
                    st->cur_pkt.size,
1160
                    st->cur_pkt.duration,
1161
                    st->cur_pkt.flags);
1162

    
1163
            s->cur_st = st;
1164
            st->cur_ptr = st->cur_pkt.data;
1165
            st->cur_len = st->cur_pkt.size;
1166
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1167
                st->parser = av_parser_init(st->codec->codec_id);
1168
                if (!st->parser) {
1169
                    /* no parser available: just output the raw packets */
1170
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1171
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1172
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1173
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1174
                    st->parser->flags |= PARSER_FLAG_ONCE;
1175
                }
1176
            }
1177
        }
1178
    }
1179
    if(s->debug & FF_FDEBUG_TS)
1180
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1181
            pkt->stream_index,
1182
            pkt->pts,
1183
            pkt->dts,
1184
            pkt->size,
1185
            pkt->duration,
1186
            pkt->flags);
1187

    
1188
    return 0;
1189
}
1190

    
1191
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1192
{
1193
    AVPacketList *pktl;
1194
    int eof=0;
1195
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1196

    
1197
    for(;;){
1198
        pktl = s->packet_buffer;
1199
        if (pktl) {
1200
            AVPacket *next_pkt= &pktl->pkt;
1201

    
1202
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1203
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1204
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1205
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1206
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1207
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1208
                        next_pkt->pts= pktl->pkt.dts;
1209
                    }
1210
                    pktl= pktl->next;
1211
                }
1212
                pktl = s->packet_buffer;
1213
            }
1214

    
1215
            if(   next_pkt->pts != AV_NOPTS_VALUE
1216
               || next_pkt->dts == AV_NOPTS_VALUE
1217
               || !genpts || eof){
1218
                /* read packet from packet buffer, if there is data */
1219
                *pkt = *next_pkt;
1220
                s->packet_buffer = pktl->next;
1221
                av_free(pktl);
1222
                return 0;
1223
            }
1224
        }
1225
        if(genpts){
1226
            int ret= av_read_frame_internal(s, pkt);
1227
            if(ret<0){
1228
                if(pktl && ret != AVERROR(EAGAIN)){
1229
                    eof=1;
1230
                    continue;
1231
                }else
1232
                    return ret;
1233
            }
1234

    
1235
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1236
                                           &s->packet_buffer_end)) < 0)
1237
                return AVERROR(ENOMEM);
1238
        }else{
1239
            assert(!s->packet_buffer);
1240
            return av_read_frame_internal(s, pkt);
1241
        }
1242
    }
1243
}
1244

    
1245
/* XXX: suppress the packet queue */
1246
static void flush_packet_queue(AVFormatContext *s)
1247
{
1248
    AVPacketList *pktl;
1249

    
1250
    for(;;) {
1251
        pktl = s->packet_buffer;
1252
        if (!pktl)
1253
            break;
1254
        s->packet_buffer = pktl->next;
1255
        av_free_packet(&pktl->pkt);
1256
        av_free(pktl);
1257
    }
1258
    while(s->raw_packet_buffer){
1259
        pktl = s->raw_packet_buffer;
1260
        s->raw_packet_buffer = pktl->next;
1261
        av_free_packet(&pktl->pkt);
1262
        av_free(pktl);
1263
    }
1264
    s->packet_buffer_end=
1265
    s->raw_packet_buffer_end= NULL;
1266
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1267
}
1268

    
1269
/*******************************************************/
1270
/* seek support */
1271

    
1272
int av_find_default_stream_index(AVFormatContext *s)
1273
{
1274
    int first_audio_index = -1;
1275
    int i;
1276
    AVStream *st;
1277

    
1278
    if (s->nb_streams <= 0)
1279
        return -1;
1280
    for(i = 0; i < s->nb_streams; i++) {
1281
        st = s->streams[i];
1282
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1283
            return i;
1284
        }
1285
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1286
            first_audio_index = i;
1287
    }
1288
    return first_audio_index >= 0 ? first_audio_index : 0;
1289
}
1290

    
1291
/**
1292
 * Flush the frame reader.
1293
 */
1294
void ff_read_frame_flush(AVFormatContext *s)
1295
{
1296
    AVStream *st;
1297
    int i, j;
1298

    
1299
    flush_packet_queue(s);
1300

    
1301
    s->cur_st = NULL;
1302

    
1303
    /* for each stream, reset read state */
1304
    for(i = 0; i < s->nb_streams; i++) {
1305
        st = s->streams[i];
1306

    
1307
        if (st->parser) {
1308
            av_parser_close(st->parser);
1309
            st->parser = NULL;
1310
            av_free_packet(&st->cur_pkt);
1311
        }
1312
        st->last_IP_pts = AV_NOPTS_VALUE;
1313
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1314
        st->reference_dts = AV_NOPTS_VALUE;
1315
        /* fail safe */
1316
        st->cur_ptr = NULL;
1317
        st->cur_len = 0;
1318

    
1319
        st->probe_packets = MAX_PROBE_PACKETS;
1320

    
1321
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1322
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1323
    }
1324
}
1325

    
1326
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1327
    int i;
1328

    
1329
    for(i = 0; i < s->nb_streams; i++) {
1330
        AVStream *st = s->streams[i];
1331

    
1332
        st->cur_dts = av_rescale(timestamp,
1333
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1334
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1335
    }
1336
}
1337

    
1338
void ff_reduce_index(AVFormatContext *s, int stream_index)
1339
{
1340
    AVStream *st= s->streams[stream_index];
1341
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1342

    
1343
    if((unsigned)st->nb_index_entries >= max_entries){
1344
        int i;
1345
        for(i=0; 2*i<st->nb_index_entries; i++)
1346
            st->index_entries[i]= st->index_entries[2*i];
1347
        st->nb_index_entries= i;
1348
    }
1349
}
1350

    
1351
int av_add_index_entry(AVStream *st,
1352
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1353
{
1354
    AVIndexEntry *entries, *ie;
1355
    int index;
1356

    
1357
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1358
        return -1;
1359

    
1360
    entries = av_fast_realloc(st->index_entries,
1361
                              &st->index_entries_allocated_size,
1362
                              (st->nb_index_entries + 1) *
1363
                              sizeof(AVIndexEntry));
1364
    if(!entries)
1365
        return -1;
1366

    
1367
    st->index_entries= entries;
1368

    
1369
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1370

    
1371
    if(index<0){
1372
        index= st->nb_index_entries++;
1373
        ie= &entries[index];
1374
        assert(index==0 || ie[-1].timestamp < timestamp);
1375
    }else{
1376
        ie= &entries[index];
1377
        if(ie->timestamp != timestamp){
1378
            if(ie->timestamp <= timestamp)
1379
                return -1;
1380
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1381
            st->nb_index_entries++;
1382
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1383
            distance= ie->min_distance;
1384
    }
1385

    
1386
    ie->pos = pos;
1387
    ie->timestamp = timestamp;
1388
    ie->min_distance= distance;
1389
    ie->size= size;
1390
    ie->flags = flags;
1391

    
1392
    return index;
1393
}
1394

    
1395
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1396
                              int flags)
1397
{
1398
    AVIndexEntry *entries= st->index_entries;
1399
    int nb_entries= st->nb_index_entries;
1400
    int a, b, m;
1401
    int64_t timestamp;
1402

    
1403
    a = - 1;
1404
    b = nb_entries;
1405

    
1406
    //optimize appending index entries at the end
1407
    if(b && entries[b-1].timestamp < wanted_timestamp)
1408
        a= b-1;
1409

    
1410
    while (b - a > 1) {
1411
        m = (a + b) >> 1;
1412
        timestamp = entries[m].timestamp;
1413
        if(timestamp >= wanted_timestamp)
1414
            b = m;
1415
        if(timestamp <= wanted_timestamp)
1416
            a = m;
1417
    }
1418
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1419

    
1420
    if(!(flags & AVSEEK_FLAG_ANY)){
1421
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1422
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1423
        }
1424
    }
1425

    
1426
    if(m == nb_entries)
1427
        return -1;
1428
    return  m;
1429
}
1430

    
1431
#define DEBUG_SEEK
1432

    
1433
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1434
    AVInputFormat *avif= s->iformat;
1435
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1436
    int64_t ts_min, ts_max, ts;
1437
    int index;
1438
    int64_t ret;
1439
    AVStream *st;
1440

    
1441
    if (stream_index < 0)
1442
        return -1;
1443

    
1444
#ifdef DEBUG_SEEK
1445
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1446
#endif
1447

    
1448
    ts_max=
1449
    ts_min= AV_NOPTS_VALUE;
1450
    pos_limit= -1; //gcc falsely says it may be uninitialized
1451

    
1452
    st= s->streams[stream_index];
1453
    if(st->index_entries){
1454
        AVIndexEntry *e;
1455

    
1456
        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()
1457
        index= FFMAX(index, 0);
1458
        e= &st->index_entries[index];
1459

    
1460
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1461
            pos_min= e->pos;
1462
            ts_min= e->timestamp;
1463
#ifdef DEBUG_SEEK
1464
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1465
                   pos_min,ts_min);
1466
#endif
1467
        }else{
1468
            assert(index==0);
1469
        }
1470

    
1471
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1472
        assert(index < st->nb_index_entries);
1473
        if(index >= 0){
1474
            e= &st->index_entries[index];
1475
            assert(e->timestamp >= target_ts);
1476
            pos_max= e->pos;
1477
            ts_max= e->timestamp;
1478
            pos_limit= pos_max - e->min_distance;
1479
#ifdef DEBUG_SEEK
1480
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1481
                   pos_max,pos_limit, ts_max);
1482
#endif
1483
        }
1484
    }
1485

    
1486
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1487
    if(pos<0)
1488
        return -1;
1489

    
1490
    /* do the seek */
1491
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1492
        return ret;
1493

    
1494
    av_update_cur_dts(s, st, ts);
1495

    
1496
    return 0;
1497
}
1498

    
1499
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 )){
1500
    int64_t pos, ts;
1501
    int64_t start_pos, filesize;
1502
    int no_change;
1503

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

    
1508
    if(ts_min == AV_NOPTS_VALUE){
1509
        pos_min = s->data_offset;
1510
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1511
        if (ts_min == AV_NOPTS_VALUE)
1512
            return -1;
1513
    }
1514

    
1515
    if(ts_max == AV_NOPTS_VALUE){
1516
        int step= 1024;
1517
        filesize = url_fsize(s->pb);
1518
        pos_max = filesize - 1;
1519
        do{
1520
            pos_max -= step;
1521
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1522
            step += step;
1523
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1524
        if (ts_max == AV_NOPTS_VALUE)
1525
            return -1;
1526

    
1527
        for(;;){
1528
            int64_t tmp_pos= pos_max + 1;
1529
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1530
            if(tmp_ts == AV_NOPTS_VALUE)
1531
                break;
1532
            ts_max= tmp_ts;
1533
            pos_max= tmp_pos;
1534
            if(tmp_pos >= filesize)
1535
                break;
1536
        }
1537
        pos_limit= pos_max;
1538
    }
1539

    
1540
    if(ts_min > ts_max){
1541
        return -1;
1542
    }else if(ts_min == ts_max){
1543
        pos_limit= pos_min;
1544
    }
1545

    
1546
    no_change=0;
1547
    while (pos_min < pos_limit) {
1548
#ifdef DEBUG_SEEK
1549
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1550
               pos_min, pos_max,
1551
               ts_min, ts_max);
1552
#endif
1553
        assert(pos_limit <= pos_max);
1554

    
1555
        if(no_change==0){
1556
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1557
            // interpolate position (better than dichotomy)
1558
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1559
                + pos_min - approximate_keyframe_distance;
1560
        }else if(no_change==1){
1561
            // bisection, if interpolation failed to change min or max pos last time
1562
            pos = (pos_min + pos_limit)>>1;
1563
        }else{
1564
            /* linear search if bisection failed, can only happen if there
1565
               are very few or no keyframes between min/max */
1566
            pos=pos_min;
1567
        }
1568
        if(pos <= pos_min)
1569
            pos= pos_min + 1;
1570
        else if(pos > pos_limit)
1571
            pos= pos_limit;
1572
        start_pos= pos;
1573

    
1574
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1575
        if(pos == pos_max)
1576
            no_change++;
1577
        else
1578
            no_change=0;
1579
#ifdef DEBUG_SEEK
1580
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1581
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1582
               start_pos, no_change);
1583
#endif
1584
        if(ts == AV_NOPTS_VALUE){
1585
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1586
            return -1;
1587
        }
1588
        assert(ts != AV_NOPTS_VALUE);
1589
        if (target_ts <= ts) {
1590
            pos_limit = start_pos - 1;
1591
            pos_max = pos;
1592
            ts_max = ts;
1593
        }
1594
        if (target_ts >= ts) {
1595
            pos_min = pos;
1596
            ts_min = ts;
1597
        }
1598
    }
1599

    
1600
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1601
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1602
#ifdef DEBUG_SEEK
1603
    pos_min = pos;
1604
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1605
    pos_min++;
1606
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1607
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1608
           pos, ts_min, target_ts, ts_max);
1609
#endif
1610
    *ts_ret= ts;
1611
    return pos;
1612
}
1613

    
1614
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1615
    int64_t pos_min, pos_max;
1616
#if 0
1617
    AVStream *st;
1618

1619
    if (stream_index < 0)
1620
        return -1;
1621

1622
    st= s->streams[stream_index];
1623
#endif
1624

    
1625
    pos_min = s->data_offset;
1626
    pos_max = url_fsize(s->pb) - 1;
1627

    
1628
    if     (pos < pos_min) pos= pos_min;
1629
    else if(pos > pos_max) pos= pos_max;
1630

    
1631
    url_fseek(s->pb, pos, SEEK_SET);
1632

    
1633
#if 0
1634
    av_update_cur_dts(s, st, ts);
1635
#endif
1636
    return 0;
1637
}
1638

    
1639
static int av_seek_frame_generic(AVFormatContext *s,
1640
                                 int stream_index, int64_t timestamp, int flags)
1641
{
1642
    int index;
1643
    int64_t ret;
1644
    AVStream *st;
1645
    AVIndexEntry *ie;
1646

    
1647
    st = s->streams[stream_index];
1648

    
1649
    index = av_index_search_timestamp(st, timestamp, flags);
1650

    
1651
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1652
        return -1;
1653

    
1654
    if(index < 0 || index==st->nb_index_entries-1){
1655
        int i;
1656
        AVPacket pkt;
1657

    
1658
        if(st->nb_index_entries){
1659
            assert(st->index_entries);
1660
            ie= &st->index_entries[st->nb_index_entries-1];
1661
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1662
                return ret;
1663
            av_update_cur_dts(s, st, ie->timestamp);
1664
        }else{
1665
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1666
                return ret;
1667
        }
1668
        for(i=0;; i++) {
1669
            int ret;
1670
            do{
1671
                ret = av_read_frame(s, &pkt);
1672
            }while(ret == AVERROR(EAGAIN));
1673
            if(ret<0)
1674
                break;
1675
            av_free_packet(&pkt);
1676
            if(stream_index == pkt.stream_index){
1677
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1678
                    break;
1679
            }
1680
        }
1681
        index = av_index_search_timestamp(st, timestamp, flags);
1682
    }
1683
    if (index < 0)
1684
        return -1;
1685

    
1686
    ff_read_frame_flush(s);
1687
    if (s->iformat->read_seek){
1688
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1689
            return 0;
1690
    }
1691
    ie = &st->index_entries[index];
1692
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1693
        return ret;
1694
    av_update_cur_dts(s, st, ie->timestamp);
1695

    
1696
    return 0;
1697
}
1698

    
1699
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1700
{
1701
    int ret;
1702
    AVStream *st;
1703

    
1704
    ff_read_frame_flush(s);
1705

    
1706
    if(flags & AVSEEK_FLAG_BYTE)
1707
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1708

    
1709
    if(stream_index < 0){
1710
        stream_index= av_find_default_stream_index(s);
1711
        if(stream_index < 0)
1712
            return -1;
1713

    
1714
        st= s->streams[stream_index];
1715
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1716
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1717
    }
1718

    
1719
    /* first, we try the format specific seek */
1720
    if (s->iformat->read_seek)
1721
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1722
    else
1723
        ret = -1;
1724
    if (ret >= 0) {
1725
        return 0;
1726
    }
1727

    
1728
    if(s->iformat->read_timestamp)
1729
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1730
    else
1731
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1732
}
1733

    
1734
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1735
{
1736
    if(min_ts > ts || max_ts < ts)
1737
        return -1;
1738

    
1739
    ff_read_frame_flush(s);
1740

    
1741
    if (s->iformat->read_seek2)
1742
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1743

    
1744
    if(s->iformat->read_timestamp){
1745
        //try to seek via read_timestamp()
1746
    }
1747

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

    
1753
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1754
}
1755

    
1756
/*******************************************************/
1757

    
1758
/**
1759
 * Return TRUE if the stream has accurate duration in any stream.
1760
 *
1761
 * @return TRUE if the stream has accurate duration for at least one component.
1762
 */
1763
static int av_has_duration(AVFormatContext *ic)
1764
{
1765
    int i;
1766
    AVStream *st;
1767

    
1768
    for(i = 0;i < ic->nb_streams; i++) {
1769
        st = ic->streams[i];
1770
        if (st->duration != AV_NOPTS_VALUE)
1771
            return 1;
1772
    }
1773
    return 0;
1774
}
1775

    
1776
/**
1777
 * Estimate the stream timings from the one of each components.
1778
 *
1779
 * Also computes the global bitrate if possible.
1780
 */
1781
static void av_update_stream_timings(AVFormatContext *ic)
1782
{
1783
    int64_t start_time, start_time1, end_time, end_time1;
1784
    int64_t duration, duration1;
1785
    int i;
1786
    AVStream *st;
1787

    
1788
    start_time = INT64_MAX;
1789
    end_time = INT64_MIN;
1790
    duration = INT64_MIN;
1791
    for(i = 0;i < ic->nb_streams; i++) {
1792
        st = ic->streams[i];
1793
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1794
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1795
            if (start_time1 < start_time)
1796
                start_time = start_time1;
1797
            if (st->duration != AV_NOPTS_VALUE) {
1798
                end_time1 = start_time1
1799
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1800
                if (end_time1 > end_time)
1801
                    end_time = end_time1;
1802
            }
1803
        }
1804
        if (st->duration != AV_NOPTS_VALUE) {
1805
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1806
            if (duration1 > duration)
1807
                duration = duration1;
1808
        }
1809
    }
1810
    if (start_time != INT64_MAX) {
1811
        ic->start_time = start_time;
1812
        if (end_time != INT64_MIN) {
1813
            if (end_time - start_time > duration)
1814
                duration = end_time - start_time;
1815
        }
1816
    }
1817
    if (duration != INT64_MIN) {
1818
        ic->duration = duration;
1819
        if (ic->file_size > 0) {
1820
            /* compute the bitrate */
1821
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1822
                (double)ic->duration;
1823
        }
1824
    }
1825
}
1826

    
1827
static void fill_all_stream_timings(AVFormatContext *ic)
1828
{
1829
    int i;
1830
    AVStream *st;
1831

    
1832
    av_update_stream_timings(ic);
1833
    for(i = 0;i < ic->nb_streams; i++) {
1834
        st = ic->streams[i];
1835
        if (st->start_time == AV_NOPTS_VALUE) {
1836
            if(ic->start_time != AV_NOPTS_VALUE)
1837
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1838
            if(ic->duration != AV_NOPTS_VALUE)
1839
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1840
        }
1841
    }
1842
}
1843

    
1844
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1845
{
1846
    int64_t filesize, duration;
1847
    int bit_rate, i;
1848
    AVStream *st;
1849

    
1850
    /* if bit_rate is already set, we believe it */
1851
    if (ic->bit_rate == 0) {
1852
        bit_rate = 0;
1853
        for(i=0;i<ic->nb_streams;i++) {
1854
            st = ic->streams[i];
1855
            bit_rate += st->codec->bit_rate;
1856
        }
1857
        ic->bit_rate = bit_rate;
1858
    }
1859

    
1860
    /* if duration is already set, we believe it */
1861
    if (ic->duration == AV_NOPTS_VALUE &&
1862
        ic->bit_rate != 0 &&
1863
        ic->file_size != 0)  {
1864
        filesize = ic->file_size;
1865
        if (filesize > 0) {
1866
            for(i = 0; i < ic->nb_streams; i++) {
1867
                st = ic->streams[i];
1868
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1869
                if (st->duration == AV_NOPTS_VALUE)
1870
                    st->duration = duration;
1871
            }
1872
        }
1873
    }
1874
}
1875

    
1876
#define DURATION_MAX_READ_SIZE 250000
1877
#define DURATION_MAX_RETRY 3
1878

    
1879
/* only usable for MPEG-PS streams */
1880
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1881
{
1882
    unsigned int nb_streams = ic->nb_streams;
1883
    AVPacket pkt1, *pkt = &pkt1;
1884
    AVStream *st;
1885
    int read_size, i, ret;
1886
    int64_t end_time, *start_time;
1887
    int64_t filesize, offset, duration;
1888
    int retry=0;
1889

    
1890
    if (nb_streams >= INT_MAX/sizeof(*start_time) ||
1891
        !(start_time = av_malloc(nb_streams * sizeof(*start_time))))
1892
        return;
1893

    
1894
    ic->cur_st = NULL;
1895

    
1896
    /* flush packet queue */
1897
    flush_packet_queue(ic);
1898

    
1899
    for (i=0; i<nb_streams; i++) {
1900
        st = ic->streams[i];
1901
        if(st->start_time != AV_NOPTS_VALUE){
1902
            start_time[i]= st->start_time;
1903
        }else if(st->first_dts != AV_NOPTS_VALUE){
1904
            start_time[i]= st->first_dts;
1905
        }else
1906
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1907

    
1908
        if (st->parser) {
1909
            av_parser_close(st->parser);
1910
            st->parser= NULL;
1911
            av_free_packet(&st->cur_pkt);
1912
        }
1913
    }
1914

    
1915
    /* estimate the end time (duration) */
1916
    /* XXX: may need to support wrapping */
1917
    filesize = ic->file_size;
1918
    end_time = AV_NOPTS_VALUE;
1919
    do{
1920
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1921
    if (offset < 0)
1922
        offset = 0;
1923

    
1924
    url_fseek(ic->pb, offset, SEEK_SET);
1925
    read_size = 0;
1926
    for(;;) {
1927
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1928
            break;
1929

    
1930
        do{
1931
            ret = av_read_packet(ic, pkt);
1932
        }while(ret == AVERROR(EAGAIN));
1933
        if (ret != 0)
1934
            break;
1935
        read_size += pkt->size;
1936
        st = ic->streams[pkt->stream_index];
1937
        if (pkt->pts != AV_NOPTS_VALUE &&
1938
            start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1939
            end_time = pkt->pts;
1940
            duration = end_time - start_time[pkt->stream_index];
1941
            if (duration < 0)
1942
                duration += 1LL<<st->pts_wrap_bits;
1943
            if (duration > 0) {
1944
                if (st->duration == AV_NOPTS_VALUE ||
1945
                    st->duration < duration)
1946
                    st->duration = duration;
1947
            }
1948
        }
1949
        av_free_packet(pkt);
1950
    }
1951
    }while(   end_time==AV_NOPTS_VALUE
1952
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1953
           && ++retry <= DURATION_MAX_RETRY);
1954
    av_free(start_time);
1955

    
1956
    fill_all_stream_timings(ic);
1957

    
1958
    url_fseek(ic->pb, old_offset, SEEK_SET);
1959
    for (i=0; i<nb_streams; i++) {
1960
        st= ic->streams[i];
1961
        st->cur_dts= st->first_dts;
1962
        st->last_IP_pts = AV_NOPTS_VALUE;
1963
    }
1964
}
1965

    
1966
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1967
{
1968
    int64_t file_size;
1969

    
1970
    /* get the file size, if possible */
1971
    if (ic->iformat->flags & AVFMT_NOFILE) {
1972
        file_size = 0;
1973
    } else {
1974
        file_size = url_fsize(ic->pb);
1975
        if (file_size < 0)
1976
            file_size = 0;
1977
    }
1978
    ic->file_size = file_size;
1979

    
1980
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1981
         !strcmp(ic->iformat->name, "mpegts")) &&
1982
        file_size && !url_is_streamed(ic->pb)) {
1983
        /* get accurate estimate from the PTSes */
1984
        av_estimate_timings_from_pts(ic, old_offset);
1985
    } else if (av_has_duration(ic)) {
1986
        /* at least one component has timings - we use them for all
1987
           the components */
1988
        fill_all_stream_timings(ic);
1989
    } else {
1990
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1991
        /* less precise: use bitrate info */
1992
        av_estimate_timings_from_bit_rate(ic);
1993
    }
1994
    av_update_stream_timings(ic);
1995

    
1996
#if 0
1997
    {
1998
        int i;
1999
        AVStream *st;
2000
        for(i = 0;i < ic->nb_streams; i++) {
2001
            st = ic->streams[i];
2002
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2003
               i, (double)st->start_time / AV_TIME_BASE,
2004
               (double)st->duration / AV_TIME_BASE);
2005
        }
2006
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2007
               (double)ic->start_time / AV_TIME_BASE,
2008
               (double)ic->duration / AV_TIME_BASE,
2009
               ic->bit_rate / 1000);
2010
    }
2011
#endif
2012
}
2013

    
2014
static int has_codec_parameters(AVCodecContext *enc)
2015
{
2016
    int val;
2017
    switch(enc->codec_type) {
2018
    case AVMEDIA_TYPE_AUDIO:
2019
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
2020
        if(!enc->frame_size &&
2021
           (enc->codec_id == CODEC_ID_VORBIS ||
2022
            enc->codec_id == CODEC_ID_AAC ||
2023
            enc->codec_id == CODEC_ID_MP1 ||
2024
            enc->codec_id == CODEC_ID_MP2 ||
2025
            enc->codec_id == CODEC_ID_MP3 ||
2026
            enc->codec_id == CODEC_ID_SPEEX))
2027
            return 0;
2028
        break;
2029
    case AVMEDIA_TYPE_VIDEO:
2030
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2031
        break;
2032
    default:
2033
        val = 1;
2034
        break;
2035
    }
2036
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2037
}
2038

    
2039
static int has_decode_delay_been_guessed(AVStream *st)
2040
{
2041
    return st->codec->codec_id != CODEC_ID_H264 ||
2042
        st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2043
}
2044

    
2045
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2046
{
2047
    int16_t *samples;
2048
    AVCodec *codec;
2049
    int got_picture, data_size, ret=0;
2050
    AVFrame picture;
2051

    
2052
    if(!st->codec->codec){
2053
        codec = avcodec_find_decoder(st->codec->codec_id);
2054
        if (!codec)
2055
            return -1;
2056
        ret = avcodec_open(st->codec, codec);
2057
        if (ret < 0)
2058
            return ret;
2059
    }
2060

    
2061
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2062
        switch(st->codec->codec_type) {
2063
        case AVMEDIA_TYPE_VIDEO:
2064
            avcodec_get_frame_defaults(&picture);
2065
            ret = avcodec_decode_video2(st->codec, &picture,
2066
                                        &got_picture, avpkt);
2067
            break;
2068
        case AVMEDIA_TYPE_AUDIO:
2069
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2070
            samples = av_malloc(data_size);
2071
            if (!samples)
2072
                goto fail;
2073
            ret = avcodec_decode_audio3(st->codec, samples,
2074
                                        &data_size, avpkt);
2075
            av_free(samples);
2076
            break;
2077
        default:
2078
            break;
2079
        }
2080
    }
2081
 fail:
2082
    return ret;
2083
}
2084

    
2085
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2086
{
2087
    while (tags->id != CODEC_ID_NONE) {
2088
        if (tags->id == id)
2089
            return tags->tag;
2090
        tags++;
2091
    }
2092
    return 0;
2093
}
2094

    
2095
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2096
{
2097
    int i;
2098
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2099
        if(tag == tags[i].tag)
2100
            return tags[i].id;
2101
    }
2102
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2103
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2104
            return tags[i].id;
2105
    }
2106
    return CODEC_ID_NONE;
2107
}
2108

    
2109
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2110
{
2111
    int i;
2112
    for(i=0; tags && tags[i]; i++){
2113
        int tag= ff_codec_get_tag(tags[i], id);
2114
        if(tag) return tag;
2115
    }
2116
    return 0;
2117
}
2118

    
2119
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2120
{
2121
    int i;
2122
    for(i=0; tags && tags[i]; i++){
2123
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2124
        if(id!=CODEC_ID_NONE) return id;
2125
    }
2126
    return CODEC_ID_NONE;
2127
}
2128

    
2129
static void compute_chapters_end(AVFormatContext *s)
2130
{
2131
    unsigned int i;
2132

    
2133
    for (i=0; i+1<s->nb_chapters; i++)
2134
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2135
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2136
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2137
            s->chapters[i]->end = s->chapters[i+1]->start;
2138
        }
2139

    
2140
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2141
        assert(s->start_time != AV_NOPTS_VALUE);
2142
        assert(s->duration > 0);
2143
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2144
                                           AV_TIME_BASE_Q,
2145
                                           s->chapters[i]->time_base);
2146
    }
2147
}
2148

    
2149
#define MAX_STD_TIMEBASES (60*12+5)
2150
static int get_std_framerate(int i){
2151
    if(i<60*12) return i*1001;
2152
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2153
}
2154

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

    
2175
int av_find_stream_info(AVFormatContext *ic)
2176
{
2177
    int i, count, ret, read_size, j;
2178
    AVStream *st;
2179
    AVPacket pkt1, *pkt;
2180
    int64_t old_offset = url_ftell(ic->pb);
2181
    unsigned int nb_streams = ic->nb_streams;
2182
    struct {
2183
        int64_t last_dts;
2184
        int64_t duration_gcd;
2185
        int duration_count;
2186
        double duration_error[MAX_STD_TIMEBASES];
2187
        int64_t codec_info_duration;
2188
    } *info, *tmp_info;
2189

    
2190
    if (ic->nb_streams >= INT_MAX/sizeof(*info) ||
2191
        !(info = av_mallocz(ic->nb_streams * sizeof(*info))))
2192
        return AVERROR(ENOMEM);
2193

    
2194
    for(i=0;i<ic->nb_streams;i++) {
2195
        AVCodec *codec;
2196
        st = ic->streams[i];
2197
        if (st->codec->codec_id == CODEC_ID_AAC) {
2198
            st->codec->sample_rate = 0;
2199
            st->codec->frame_size = 0;
2200
            st->codec->channels = 0;
2201
        }
2202
        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
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
        //try to just open decoders, in case this is enough to get parameters
2226
        if(!has_codec_parameters(st->codec)){
2227
            if (codec)
2228
                avcodec_open(st->codec, codec);
2229
        }
2230
    }
2231

    
2232
    for (i=0; i<ic->nb_streams; i++) {
2233
        info[i].last_dts= AV_NOPTS_VALUE;
2234
    }
2235

    
2236
    count = 0;
2237
    read_size = 0;
2238
    for(;;) {
2239
        if(url_interrupt_cb()){
2240
            ret= AVERROR(EINTR);
2241
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2242
            break;
2243
        }
2244

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

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

    
2296
        if (ic->nb_streams > nb_streams) {
2297
            if (ic->nb_streams >= INT_MAX/sizeof(*info) ||
2298
                !(tmp_info = av_realloc(info, ic->nb_streams*sizeof(*info)))) {
2299
                av_free(info);
2300
                return AVERROR(ENOMEM);
2301
            }
2302
            info = tmp_info;
2303
            memset(info + nb_streams, 0, (ic->nb_streams - nb_streams) * sizeof(*info));
2304
            nb_streams = ic->nb_streams;
2305
        }
2306

    
2307
        if (ret == AVERROR(EAGAIN))
2308
            continue;
2309

    
2310
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2311
        if(av_dup_packet(pkt) < 0) {
2312
            av_free(info);
2313
            return AVERROR(ENOMEM);
2314
        }
2315

    
2316
        read_size += pkt->size;
2317

    
2318
        st = ic->streams[pkt->stream_index];
2319
        if(st->codec_info_nb_frames>1) {
2320
            if (st->time_base.den > 0 && av_rescale_q(info[st->index].codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2321
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2322
                break;
2323
            }
2324
            info[st->index].codec_info_duration += pkt->duration;
2325
        }
2326
        {
2327
            int index= pkt->stream_index;
2328
            int64_t last= info[index].last_dts;
2329
            int64_t duration= pkt->dts - last;
2330

    
2331
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2332
                double dur= duration * av_q2d(st->time_base);
2333

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

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

    
2369
        st->codec_info_nb_frames++;
2370
        count++;
2371
    }
2372

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

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

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

    
2416
            if (!st->r_frame_rate.num){
2417
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2418
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2419
                    st->r_frame_rate.num = st->codec->time_base.den;
2420
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2421
                }else{
2422
                    st->r_frame_rate.num = st->time_base.den;
2423
                    st->r_frame_rate.den = st->time_base.num;
2424
                }
2425
            }
2426
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2427
            if(!st->codec->bits_per_coded_sample)
2428
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2429
        }
2430
    }
2431

    
2432
    av_estimate_timings(ic, old_offset);
2433

    
2434
    compute_chapters_end(ic);
2435

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

    
2461
    av_free(info);
2462
    return ret;
2463
}
2464

    
2465
/*******************************************************/
2466

    
2467
int av_read_play(AVFormatContext *s)
2468
{
2469
    if (s->iformat->read_play)
2470
        return s->iformat->read_play(s);
2471
    if (s->pb)
2472
        return av_url_read_fpause(s->pb, 0);
2473
    return AVERROR(ENOSYS);
2474
}
2475

    
2476
int av_read_pause(AVFormatContext *s)
2477
{
2478
    if (s->iformat->read_pause)
2479
        return s->iformat->read_pause(s);
2480
    if (s->pb)
2481
        return av_url_read_fpause(s->pb, 1);
2482
    return AVERROR(ENOSYS);
2483
}
2484

    
2485
void av_close_input_stream(AVFormatContext *s)
2486
{
2487
    int i;
2488
    AVStream *st;
2489

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

    
2534
void av_close_input_file(AVFormatContext *s)
2535
{
2536
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2537
    av_close_input_stream(s);
2538
    if (pb)
2539
        url_fclose(pb);
2540
}
2541

    
2542
AVStream *av_new_stream(AVFormatContext *s, int id)
2543
{
2544
    AVStream *st;
2545
    int i;
2546
#if LIBAVFORMAT_VERSION_MAJOR >= 53
2547
    AVStream **streams;
2548

    
2549
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2550
        return NULL;
2551
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2552
    if (!streams)
2553
        return NULL;
2554
    s->streams = streams;
2555
#else
2556
    if (s->nb_streams >= MAX_STREAMS){
2557
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2558
        return NULL;
2559
    }
2560
#endif
2561

    
2562
    st = av_mallocz(sizeof(AVStream));
2563
    if (!st)
2564
        return NULL;
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
        AVMetadata *m;
2779
        AVMetadataTag *t;
2780

    
2781
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2782
            return AVERROR(ENOMEM);
2783
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2784
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2785
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2786
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2787
        av_metadata_free(&m);
2788
    }
2789

    
2790
    if(s->oformat->write_header){
2791
        ret = s->oformat->write_header(s);
2792
        if (ret < 0)
2793
            return ret;
2794
    }
2795

    
2796
    /* init PTS generation */
2797
    for(i=0;i<s->nb_streams;i++) {
2798
        int64_t den = AV_NOPTS_VALUE;
2799
        st = s->streams[i];
2800

    
2801
        switch (st->codec->codec_type) {
2802
        case AVMEDIA_TYPE_AUDIO:
2803
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2804
            break;
2805
        case AVMEDIA_TYPE_VIDEO:
2806
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2807
            break;
2808
        default:
2809
            break;
2810
        }
2811
        if (den != AV_NOPTS_VALUE) {
2812
            if (den <= 0)
2813
                return AVERROR_INVALIDDATA;
2814
            av_frac_init(&st->pts, 0, 0, den);
2815
        }
2816
    }
2817
    return 0;
2818
}
2819

    
2820
//FIXME merge with compute_pkt_fields
2821
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2822
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2823
    int num, den, frame_size, i;
2824

    
2825
//    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);
2826

    
2827
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2828
        return -1;*/
2829

    
2830
    /* duration field */
2831
    if (pkt->duration == 0) {
2832
        compute_frame_duration(&num, &den, st, NULL, pkt);
2833
        if (den && num) {
2834
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2835
        }
2836
    }
2837

    
2838
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2839
        pkt->pts= pkt->dts;
2840

    
2841
    //XXX/FIXME this is a temporary hack until all encoders output pts
2842
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2843
        pkt->dts=
2844
//        pkt->pts= st->cur_dts;
2845
        pkt->pts= st->pts.val;
2846
    }
2847

    
2848
    //calculate dts from pts
2849
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2850
        st->pts_buffer[0]= pkt->pts;
2851
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2852
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2853
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2854
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2855

    
2856
        pkt->dts= st->pts_buffer[0];
2857
    }
2858

    
2859
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2860
        av_log(s, AV_LOG_ERROR,
2861
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2862
               st->index, st->cur_dts, pkt->dts);
2863
        return -1;
2864
    }
2865
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2866
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2867
        return -1;
2868
    }
2869

    
2870
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2871
    st->cur_dts= pkt->dts;
2872
    st->pts.val= pkt->dts;
2873

    
2874
    /* update pts */
2875
    switch (st->codec->codec_type) {
2876
    case AVMEDIA_TYPE_AUDIO:
2877
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2878

    
2879
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2880
           likely equal to the encoder delay, but it would be better if we
2881
           had the real timestamps from the encoder */
2882
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2883
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2884
        }
2885
        break;
2886
    case AVMEDIA_TYPE_VIDEO:
2887
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2888
        break;
2889
    default:
2890
        break;
2891
    }
2892
    return 0;
2893
}
2894

    
2895
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2896
{
2897
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2898

    
2899
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2900
        return ret;
2901

    
2902
    ret= s->oformat->write_packet(s, pkt);
2903
    if(!ret)
2904
        ret= url_ferror(s->pb);
2905
    return ret;
2906
}
2907

    
2908
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2909
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2910
{
2911
    AVPacketList **next_point, *this_pktl;
2912

    
2913
    this_pktl = av_mallocz(sizeof(AVPacketList));
2914
    this_pktl->pkt= *pkt;
2915
    pkt->destruct= NULL;             // do not free original but only the copy
2916
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2917

    
2918
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2919
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2920
    }else
2921
        next_point = &s->packet_buffer;
2922

    
2923
    if(*next_point){
2924
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2925
            while(!compare(s, &(*next_point)->pkt, pkt)){
2926
                next_point= &(*next_point)->next;
2927
            }
2928
            goto next_non_null;
2929
        }else{
2930
            next_point = &(s->packet_buffer_end->next);
2931
        }
2932
    }
2933
    assert(!*next_point);
2934

    
2935
    s->packet_buffer_end= this_pktl;
2936
next_non_null:
2937

    
2938
    this_pktl->next= *next_point;
2939

    
2940
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2941
    *next_point= this_pktl;
2942
}
2943

    
2944
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2945
{
2946
    AVStream *st = s->streams[ pkt ->stream_index];
2947
    AVStream *st2= s->streams[ next->stream_index];
2948
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2949
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2950
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2951
}
2952

    
2953
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2954
    AVPacketList *pktl;
2955
    int stream_count=0;
2956
    int i;
2957

    
2958
    if(pkt){
2959
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2960
    }
2961

    
2962
    for(i=0; i < s->nb_streams; i++)
2963
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2964

    
2965
    if(stream_count && (s->nb_streams == stream_count || flush)){
2966
        pktl= s->packet_buffer;
2967
        *out= pktl->pkt;
2968

    
2969
        s->packet_buffer= pktl->next;
2970
        if(!s->packet_buffer)
2971
            s->packet_buffer_end= NULL;
2972

    
2973
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2974
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2975
        av_freep(&pktl);
2976
        return 1;
2977
    }else{
2978
        av_init_packet(out);
2979
        return 0;
2980
    }
2981
}
2982

    
2983
/**
2984
 * Interleave an AVPacket correctly so it can be muxed.
2985
 * @param out the interleaved packet will be output here
2986
 * @param in the input packet
2987
 * @param flush 1 if no further packets are available as input and all
2988
 *              remaining packets should be output
2989
 * @return 1 if a packet was output, 0 if no packet could be output,
2990
 *         < 0 if an error occurred
2991
 */
2992
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2993
    if(s->oformat->interleave_packet)
2994
        return s->oformat->interleave_packet(s, out, in, flush);
2995
    else
2996
        return av_interleave_packet_per_dts(s, out, in, flush);
2997
}
2998

    
2999
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3000
    AVStream *st= s->streams[ pkt->stream_index];
3001

    
3002
    //FIXME/XXX/HACK drop zero sized packets
3003
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3004
        return 0;
3005

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

    
3010
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3011
        return -1;
3012

    
3013
    for(;;){
3014
        AVPacket opkt;
3015
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3016
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3017
            return ret;
3018

    
3019
        ret= s->oformat->write_packet(s, &opkt);
3020

    
3021
        av_free_packet(&opkt);
3022
        pkt= NULL;
3023

    
3024
        if(ret<0)
3025
            return ret;
3026
        if(url_ferror(s->pb))
3027
            return url_ferror(s->pb);
3028
    }
3029
}
3030

    
3031
int av_write_trailer(AVFormatContext *s)
3032
{
3033
    int ret, i;
3034

    
3035
    for(;;){
3036
        AVPacket pkt;
3037
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3038
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3039
            goto fail;
3040
        if(!ret)
3041
            break;
3042

    
3043
        ret= s->oformat->write_packet(s, &pkt);
3044

    
3045
        av_free_packet(&pkt);
3046

    
3047
        if(ret<0)
3048
            goto fail;
3049
        if(url_ferror(s->pb))
3050
            goto fail;
3051
    }
3052

    
3053
    if(s->oformat->write_trailer)
3054
        ret = s->oformat->write_trailer(s);
3055
fail:
3056
    if(ret == 0)
3057
       ret=url_ferror(s->pb);
3058
    for(i=0;i<s->nb_streams;i++) {
3059
        av_freep(&s->streams[i]->priv_data);
3060
        av_freep(&s->streams[i]->index_entries);
3061
    }
3062
    av_freep(&s->priv_data);
3063
    return ret;
3064
}
3065

    
3066
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3067
{
3068
    int i, j;
3069
    AVProgram *program=NULL;
3070
    void *tmp;
3071

    
3072
    if (idx >= ac->nb_streams) {
3073
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3074
        return;
3075
    }
3076

    
3077
    for(i=0; i<ac->nb_programs; i++){
3078
        if(ac->programs[i]->id != progid)
3079
            continue;
3080
        program = ac->programs[i];
3081
        for(j=0; j<program->nb_stream_indexes; j++)
3082
            if(program->stream_index[j] == idx)
3083
                return;
3084

    
3085
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3086
        if(!tmp)
3087
            return;
3088
        program->stream_index = tmp;
3089
        program->stream_index[program->nb_stream_indexes++] = idx;
3090
        return;
3091
    }
3092
}
3093

    
3094
static void print_fps(double d, const char *postfix){
3095
    uint64_t v= lrintf(d*100);
3096
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3097
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3098
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3099
}
3100

    
3101
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3102
{
3103
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3104
        AVMetadataTag *tag=NULL;
3105

    
3106
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3107
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3108
            if(strcmp("language", tag->key))
3109
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3110
        }
3111
    }
3112
}
3113

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

    
3157
void dump_format(AVFormatContext *ic,
3158
                 int index,
3159
                 const char *url,
3160
                 int is_output)
3161
{
3162
    int i;
3163
    uint8_t *printed = av_mallocz(ic->nb_streams);
3164
    if (ic->nb_streams && !printed)
3165
        return;
3166

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

    
3210
        dump_metadata(NULL, ch->metadata, "    ");
3211
    }
3212
    if(ic->nb_programs) {
3213
        int j, k, total = 0;
3214
        for(j=0; j<ic->nb_programs; j++) {
3215
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3216
                                                  "name", NULL, 0);
3217
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3218
                   name ? name->value : "");
3219
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3220
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3221
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3222
                printed[ic->programs[j]->stream_index[k]] = 1;
3223
            }
3224
            total += ic->programs[j]->nb_stream_indexes;
3225
        }
3226
        if (total < ic->nb_streams)
3227
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3228
    }
3229
    for(i=0;i<ic->nb_streams;i++)
3230
        if (!printed[i])
3231
            dump_stream_format(ic, i, index, is_output);
3232

    
3233
    av_free(printed);
3234
}
3235

    
3236
#if LIBAVFORMAT_VERSION_MAJOR < 53
3237
#include "libavcore/parseutils.h"
3238

    
3239
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3240
{
3241
    return av_parse_video_size(width_ptr, height_ptr, str);
3242
}
3243

    
3244
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3245
{
3246
    AVRational frame_rate;
3247
    int ret = av_parse_video_rate(&frame_rate, arg);
3248
    *frame_rate_num= frame_rate.num;
3249
    *frame_rate_den= frame_rate.den;
3250
    return ret;
3251
}
3252
#endif
3253

    
3254
int64_t av_gettime(void)
3255
{
3256
    struct timeval tv;
3257
    gettimeofday(&tv,NULL);
3258
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3259
}
3260

    
3261
uint64_t ff_ntp_time(void)
3262
{
3263
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3264
}
3265

    
3266
int64_t parse_date(const char *datestr, int duration)
3267
{
3268
    const char *p;
3269
    int64_t t;
3270
    struct tm dt;
3271
    int i;
3272
    static const char * const date_fmt[] = {
3273
        "%Y-%m-%d",
3274
        "%Y%m%d",
3275
    };
3276
    static const char * const time_fmt[] = {
3277
        "%H:%M:%S",
3278
        "%H%M%S",
3279
    };
3280
    const char *q;
3281
    int is_utc, len;
3282
    char lastch;
3283
    int negative = 0;
3284

    
3285
#undef time
3286
    time_t now = time(0);
3287

    
3288
    len = strlen(datestr);
3289
    if (len > 0)
3290
        lastch = datestr[len - 1];
3291
    else
3292
        lastch = '\0';
3293
    is_utc = (lastch == 'z' || lastch == 'Z');
3294

    
3295
    memset(&dt, 0, sizeof(dt));
3296

    
3297
    p = datestr;
3298
    q = NULL;
3299
    if (!duration) {
3300
        if (!strncasecmp(datestr, "now", len))
3301
            return (int64_t) now * 1000000;
3302

    
3303
        /* parse the year-month-day part */
3304
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3305
            q = small_strptime(p, date_fmt[i], &dt);
3306
            if (q) {
3307
                break;
3308
            }
3309
        }
3310

    
3311
        /* if the year-month-day part is missing, then take the
3312
         * current year-month-day time */
3313
        if (!q) {
3314
            if (is_utc) {
3315
                dt = *gmtime(&now);
3316
            } else {
3317
                dt = *localtime(&now);
3318
            }
3319
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3320
        } else {
3321
            p = q;
3322
        }
3323

    
3324
        if (*p == 'T' || *p == 't' || *p == ' ')
3325
            p++;
3326

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

    
3353
    /* Now we have all the fields that we can get */
3354
    if (!q) {
3355
        return INT64_MIN;
3356
    }
3357

    
3358
    if (duration) {
3359
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3360
    } else {
3361
        dt.tm_isdst = -1;       /* unknown */
3362
        if (is_utc) {
3363
            t = mktimegm(&dt);
3364
        } else {
3365
            t = mktime(&dt);
3366
        }
3367
    }
3368

    
3369
    t *= 1000000;
3370

    
3371
    /* parse the .m... part */
3372
    if (*q == '.') {
3373
        int val, n;
3374
        q++;
3375
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3376
            if (!isdigit(*q))
3377
                break;
3378
            val += n * (*q - '0');
3379
        }
3380
        t += val;
3381
    }
3382
    return negative ? -t : t;
3383
}
3384

    
3385
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3386
{
3387
    const char *p;
3388
    char tag[128], *q;
3389

    
3390
    p = info;
3391
    if (*p == '?')
3392
        p++;
3393
    for(;;) {
3394
        q = tag;
3395
        while (*p != '\0' && *p != '=' && *p != '&') {
3396
            if ((q - tag) < sizeof(tag) - 1)
3397
                *q++ = *p;
3398
            p++;
3399
        }
3400
        *q = '\0';
3401
        q = arg;
3402
        if (*p == '=') {
3403
            p++;
3404
            while (*p != '&' && *p != '\0') {
3405
                if ((q - arg) < arg_size - 1) {
3406
                    if (*p == '+')
3407
                        *q++ = ' ';
3408
                    else
3409
                        *q++ = *p;
3410
                }
3411
                p++;
3412
            }
3413
        }
3414
        *q = '\0';
3415
        if (!strcmp(tag, tag1))
3416
            return 1;
3417
        if (*p != '&')
3418
            break;
3419
        p++;
3420
    }
3421
    return 0;
3422
}
3423

    
3424
int av_get_frame_filename(char *buf, int buf_size,
3425
                          const char *path, int number)
3426
{
3427
    const char *p;
3428
    char *q, buf1[20], c;
3429
    int nd, len, percentd_found;
3430

    
3431
    q = buf;
3432
    p = path;
3433
    percentd_found = 0;
3434
    for(;;) {
3435
        c = *p++;
3436
        if (c == '\0')
3437
            break;
3438
        if (c == '%') {
3439
            do {
3440
                nd = 0;
3441
                while (isdigit(*p)) {
3442
                    nd = nd * 10 + *p++ - '0';
3443
                }
3444
                c = *p++;
3445
            } while (isdigit(c));
3446

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

    
3479
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3480
{
3481
    int len, i, j, c;
3482
#undef fprintf
3483
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3484

    
3485
    for(i=0;i<size;i+=16) {
3486
        len = size - i;
3487
        if (len > 16)
3488
            len = 16;
3489
        PRINT("%08x ", i);
3490
        for(j=0;j<16;j++) {
3491
            if (j < len)
3492
                PRINT(" %02x", buf[i+j]);
3493
            else
3494
                PRINT("   ");
3495
        }
3496
        PRINT(" ");
3497
        for(j=0;j<len;j++) {
3498
            c = buf[i+j];
3499
            if (c < ' ' || c > '~')
3500
                c = '.';
3501
            PRINT("%c", c);
3502
        }
3503
        PRINT("\n");
3504
    }
3505
#undef PRINT
3506
}
3507

    
3508
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3509
{
3510
    hex_dump_internal(NULL, f, 0, buf, size);
3511
}
3512

    
3513
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3514
{
3515
    hex_dump_internal(avcl, NULL, level, buf, size);
3516
}
3517

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

    
3545
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3546
{
3547
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3548
}
3549

    
3550
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3551
{
3552
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3553
}
3554

    
3555
#if LIBAVFORMAT_VERSION_MAJOR < 53
3556
attribute_deprecated
3557
void ff_url_split(char *proto, int proto_size,
3558
                  char *authorization, int authorization_size,
3559
                  char *hostname, int hostname_size,
3560
                  int *port_ptr,
3561
                  char *path, int path_size,
3562
                  const char *url)
3563
{
3564
    av_url_split(proto, proto_size,
3565
                 authorization, authorization_size,
3566
                 hostname, hostname_size,
3567
                 port_ptr,
3568
                 path, path_size,
3569
                 url);
3570
}
3571
#endif
3572

    
3573
void av_url_split(char *proto, int proto_size,
3574
                  char *authorization, int authorization_size,
3575
                  char *hostname, int hostname_size,
3576
                  int *port_ptr,
3577
                  char *path, int path_size,
3578
                  const char *url)
3579
{
3580
    const char *p, *ls, *at, *col, *brk;
3581

    
3582
    if (port_ptr)               *port_ptr = -1;
3583
    if (proto_size > 0)         proto[0] = 0;
3584
    if (authorization_size > 0) authorization[0] = 0;
3585
    if (hostname_size > 0)      hostname[0] = 0;
3586
    if (path_size > 0)          path[0] = 0;
3587

    
3588
    /* parse protocol */
3589
    if ((p = strchr(url, ':'))) {
3590
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3591
        p++; /* skip ':' */
3592
        if (*p == '/') p++;
3593
        if (*p == '/') p++;
3594
    } else {
3595
        /* no protocol means plain filename */
3596
        av_strlcpy(path, url, path_size);
3597
        return;
3598
    }
3599

    
3600
    /* separate path from hostname */
3601
    ls = strchr(p, '/');
3602
    if(!ls)
3603
        ls = strchr(p, '?');
3604
    if(ls)
3605
        av_strlcpy(path, ls, path_size);
3606
    else
3607
        ls = &p[strlen(p)]; // XXX
3608

    
3609
    /* the rest is hostname, use that to parse auth/port */
3610
    if (ls != p) {
3611
        /* authorization (user[:pass]@hostname) */
3612
        if ((at = strchr(p, '@')) && at < ls) {
3613
            av_strlcpy(authorization, p,
3614
                       FFMIN(authorization_size, at + 1 - p));
3615
            p = at + 1; /* skip '@' */
3616
        }
3617

    
3618
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3619
            /* [host]:port */
3620
            av_strlcpy(hostname, p + 1,
3621
                       FFMIN(hostname_size, brk - p));
3622
            if (brk[1] == ':' && port_ptr)
3623
                *port_ptr = atoi(brk + 2);
3624
        } else if ((col = strchr(p, ':')) && col < ls) {
3625
            av_strlcpy(hostname, p,
3626
                       FFMIN(col + 1 - p, hostname_size));
3627
            if (port_ptr) *port_ptr = atoi(col + 1);
3628
        } else
3629
            av_strlcpy(hostname, p,
3630
                       FFMIN(ls + 1 - p, hostname_size));
3631
    }
3632
}
3633

    
3634
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3635
{
3636
    int i;
3637
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3638
                                           '4', '5', '6', '7',
3639
                                           '8', '9', 'A', 'B',
3640
                                           'C', 'D', 'E', 'F' };
3641
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3642
                                           '4', '5', '6', '7',
3643
                                           '8', '9', 'a', 'b',
3644
                                           'c', 'd', 'e', 'f' };
3645
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3646

    
3647
    for(i = 0; i < s; i++) {
3648
        buff[i * 2]     = hex_table[src[i] >> 4];
3649
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3650
    }
3651

    
3652
    return buff;
3653
}
3654

    
3655
int ff_hex_to_data(uint8_t *data, const char *p)
3656
{
3657
    int c, len, v;
3658

    
3659
    len = 0;
3660
    v = 1;
3661
    for (;;) {
3662
        p += strspn(p, SPACE_CHARS);
3663
        if (*p == '\0')
3664
            break;
3665
        c = toupper((unsigned char) *p++);
3666
        if (c >= '0' && c <= '9')
3667
            c = c - '0';
3668
        else if (c >= 'A' && c <= 'F')
3669
            c = c - 'A' + 10;
3670
        else
3671
            break;
3672
        v = (v << 4) | c;
3673
        if (v & 0x100) {
3674
            if (data)
3675
                data[len] = v;
3676
            len++;
3677
            v = 1;
3678
        }
3679
    }
3680
    return len;
3681
}
3682

    
3683
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3684
                     unsigned int pts_num, unsigned int pts_den)
3685
{
3686
    s->pts_wrap_bits = pts_wrap_bits;
3687

    
3688
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3689
        if(s->time_base.num != pts_num)
3690
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3691
    }else
3692
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3693

    
3694
    if(!s->time_base.num || !s->time_base.den)
3695
        s->time_base.num= s->time_base.den= 0;
3696
}
3697

    
3698
int ff_url_join(char *str, int size, const char *proto,
3699
                const char *authorization, const char *hostname,
3700
                int port, const char *fmt, ...)
3701
{
3702
#if CONFIG_NETWORK
3703
    struct addrinfo hints, *ai;
3704
#endif
3705

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

    
3730
    if (port >= 0)
3731
        av_strlcatf(str, size, ":%d", port);
3732
    if (fmt) {
3733
        va_list vl;
3734
        int len = strlen(str);
3735

    
3736
        va_start(vl, fmt);
3737
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3738
        va_end(vl);
3739
    }
3740
    return strlen(str);
3741
}
3742

    
3743
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3744
                     AVFormatContext *src)
3745
{
3746
    AVPacket local_pkt;
3747

    
3748
    local_pkt = *pkt;
3749
    local_pkt.stream_index = dst_stream;
3750
    if (pkt->pts != AV_NOPTS_VALUE)
3751
        local_pkt.pts = av_rescale_q(pkt->pts,
3752
                                     src->streams[pkt->stream_index]->time_base,
3753
                                     dst->streams[dst_stream]->time_base);
3754
    if (pkt->dts != AV_NOPTS_VALUE)
3755
        local_pkt.dts = av_rescale_q(pkt->dts,
3756
                                     src->streams[pkt->stream_index]->time_base,
3757
                                     dst->streams[dst_stream]->time_base);
3758
    return av_write_frame(dst, &local_pkt);
3759
}
3760

    
3761
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3762
                        void *context)
3763
{
3764
    const char *ptr = str;
3765

    
3766
    /* Parse key=value pairs. */
3767
    for (;;) {
3768
        const char *key;
3769
        char *dest = NULL, *dest_end;
3770
        int key_len, dest_len = 0;
3771

    
3772
        /* Skip whitespace and potential commas. */
3773
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3774
            ptr++;
3775
        if (!*ptr)
3776
            break;
3777

    
3778
        key = ptr;
3779

    
3780
        if (!(ptr = strchr(key, '=')))
3781
            break;
3782
        ptr++;
3783
        key_len = ptr - key;
3784

    
3785
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3786
        dest_end = dest + dest_len - 1;
3787

    
3788
        if (*ptr == '\"') {
3789
            ptr++;
3790
            while (*ptr && *ptr != '\"') {
3791
                if (*ptr == '\\') {
3792
                    if (!ptr[1])
3793
                        break;
3794
                    if (dest && dest < dest_end)
3795
                        *dest++ = ptr[1];
3796
                    ptr += 2;
3797
                } else {
3798
                    if (dest && dest < dest_end)
3799
                        *dest++ = *ptr;
3800
                    ptr++;
3801
                }
3802
            }
3803
            if (*ptr == '\"')
3804
                ptr++;
3805
        } else {
3806
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3807
                if (dest && dest < dest_end)
3808
                    *dest++ = *ptr;
3809
        }
3810
        if (dest)
3811
            *dest = 0;
3812
    }
3813
}
3814