Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 3e4318bf

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;
1887
    int64_t filesize, offset, duration;
1888
    int retry=0;
1889

    
1890
    ic->cur_st = NULL;
1891

    
1892
    /* flush packet queue */
1893
    flush_packet_queue(ic);
1894

    
1895
    for (i=0; i<nb_streams; i++) {
1896
        st = ic->streams[i];
1897
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1898
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1899

    
1900
        if (st->parser) {
1901
            av_parser_close(st->parser);
1902
            st->parser= NULL;
1903
            av_free_packet(&st->cur_pkt);
1904
        }
1905
    }
1906

    
1907
    /* estimate the end time (duration) */
1908
    /* XXX: may need to support wrapping */
1909
    filesize = ic->file_size;
1910
    end_time = AV_NOPTS_VALUE;
1911
    do{
1912
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1913
    if (offset < 0)
1914
        offset = 0;
1915

    
1916
    url_fseek(ic->pb, offset, SEEK_SET);
1917
    read_size = 0;
1918
    for(;;) {
1919
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1920
            break;
1921

    
1922
        do{
1923
            ret = av_read_packet(ic, pkt);
1924
        }while(ret == AVERROR(EAGAIN));
1925
        if (ret != 0)
1926
            break;
1927
        read_size += pkt->size;
1928
        st = ic->streams[pkt->stream_index];
1929
        if (pkt->pts != AV_NOPTS_VALUE &&
1930
            (st->start_time != AV_NOPTS_VALUE ||
1931
             st->first_dts  != AV_NOPTS_VALUE)) {
1932
            duration = end_time = pkt->pts;
1933
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1934
            else                                   duration -= st->first_dts;
1935
            if (duration < 0)
1936
                duration += 1LL<<st->pts_wrap_bits;
1937
            if (duration > 0) {
1938
                if (st->duration == AV_NOPTS_VALUE ||
1939
                    st->duration < duration)
1940
                    st->duration = duration;
1941
            }
1942
        }
1943
        av_free_packet(pkt);
1944
    }
1945
    }while(   end_time==AV_NOPTS_VALUE
1946
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1947
           && ++retry <= DURATION_MAX_RETRY);
1948

    
1949
    fill_all_stream_timings(ic);
1950

    
1951
    url_fseek(ic->pb, old_offset, SEEK_SET);
1952
    for (i=0; i<nb_streams; i++) {
1953
        st= ic->streams[i];
1954
        st->cur_dts= st->first_dts;
1955
        st->last_IP_pts = AV_NOPTS_VALUE;
1956
    }
1957
}
1958

    
1959
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1960
{
1961
    int64_t file_size;
1962

    
1963
    /* get the file size, if possible */
1964
    if (ic->iformat->flags & AVFMT_NOFILE) {
1965
        file_size = 0;
1966
    } else {
1967
        file_size = url_fsize(ic->pb);
1968
        if (file_size < 0)
1969
            file_size = 0;
1970
    }
1971
    ic->file_size = file_size;
1972

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

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

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

    
2032
static int has_decode_delay_been_guessed(AVStream *st)
2033
{
2034
    return st->codec->codec_id != CODEC_ID_H264 ||
2035
        st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2036
}
2037

    
2038
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2039
{
2040
    int16_t *samples;
2041
    AVCodec *codec;
2042
    int got_picture, data_size, ret=0;
2043
    AVFrame picture;
2044

    
2045
    if(!st->codec->codec){
2046
        codec = avcodec_find_decoder(st->codec->codec_id);
2047
        if (!codec)
2048
            return -1;
2049
        ret = avcodec_open(st->codec, codec);
2050
        if (ret < 0)
2051
            return ret;
2052
    }
2053

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

    
2078
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2079
{
2080
    while (tags->id != CODEC_ID_NONE) {
2081
        if (tags->id == id)
2082
            return tags->tag;
2083
        tags++;
2084
    }
2085
    return 0;
2086
}
2087

    
2088
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2089
{
2090
    int i;
2091
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2092
        if(tag == tags[i].tag)
2093
            return tags[i].id;
2094
    }
2095
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2096
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2097
            return tags[i].id;
2098
    }
2099
    return CODEC_ID_NONE;
2100
}
2101

    
2102
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2103
{
2104
    int i;
2105
    for(i=0; tags && tags[i]; i++){
2106
        int tag= ff_codec_get_tag(tags[i], id);
2107
        if(tag) return tag;
2108
    }
2109
    return 0;
2110
}
2111

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

    
2122
static void compute_chapters_end(AVFormatContext *s)
2123
{
2124
    unsigned int i;
2125

    
2126
    for (i=0; i+1<s->nb_chapters; i++)
2127
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2128
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2129
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2130
            s->chapters[i]->end = s->chapters[i+1]->start;
2131
        }
2132

    
2133
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2134
        assert(s->start_time != AV_NOPTS_VALUE);
2135
        assert(s->duration > 0);
2136
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2137
                                           AV_TIME_BASE_Q,
2138
                                           s->chapters[i]->time_base);
2139
    }
2140
}
2141

    
2142
#define MAX_STD_TIMEBASES (60*12+5)
2143
static int get_std_framerate(int i){
2144
    if(i<60*12) return i*1001;
2145
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2146
}
2147

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

    
2168
int av_find_stream_info(AVFormatContext *ic)
2169
{
2170
    int i, count, ret, read_size, j;
2171
    AVStream *st;
2172
    AVPacket pkt1, *pkt;
2173
    int64_t old_offset = url_ftell(ic->pb);
2174
    unsigned int nb_streams = ic->nb_streams;
2175
    struct {
2176
        int64_t last_dts;
2177
        int64_t duration_gcd;
2178
        int duration_count;
2179
        double duration_error[MAX_STD_TIMEBASES];
2180
        int64_t codec_info_duration;
2181
    } *info, *tmp_info;
2182

    
2183
    if (ic->nb_streams >= INT_MAX/sizeof(*info) ||
2184
        !(info = av_mallocz(ic->nb_streams * sizeof(*info))))
2185
        return AVERROR(ENOMEM);
2186

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

    
2211
        /* Force decoding of at least one frame of codec data
2212
         * this makes sure the codec initializes the channel configuration
2213
         * and does not trust the values from the container.
2214
         */
2215
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2216
            st->codec->channels = 0;
2217

    
2218
        //try to just open decoders, in case this is enough to get parameters
2219
        if(!has_codec_parameters(st->codec)){
2220
            if (codec)
2221
                avcodec_open(st->codec, codec);
2222
        }
2223
    }
2224

    
2225
    for (i=0; i<ic->nb_streams; i++) {
2226
        info[i].last_dts= AV_NOPTS_VALUE;
2227
    }
2228

    
2229
    count = 0;
2230
    read_size = 0;
2231
    for(;;) {
2232
        if(url_interrupt_cb()){
2233
            ret= AVERROR(EINTR);
2234
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2235
            break;
2236
        }
2237

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

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

    
2289
        if (ic->nb_streams > nb_streams) {
2290
            if (ic->nb_streams >= INT_MAX/sizeof(*info) ||
2291
                !(tmp_info = av_realloc(info, ic->nb_streams*sizeof(*info)))) {
2292
                av_free(info);
2293
                return AVERROR(ENOMEM);
2294
            }
2295
            info = tmp_info;
2296
            memset(info + nb_streams, 0, (ic->nb_streams - nb_streams) * sizeof(*info));
2297
            nb_streams = ic->nb_streams;
2298
        }
2299

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

    
2303
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2304
        if(av_dup_packet(pkt) < 0) {
2305
            av_free(info);
2306
            return AVERROR(ENOMEM);
2307
        }
2308

    
2309
        read_size += pkt->size;
2310

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

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

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

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

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

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

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

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

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

    
2425
    av_estimate_timings(ic, old_offset);
2426

    
2427
    compute_chapters_end(ic);
2428

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

    
2454
    av_free(info);
2455
    return ret;
2456
}
2457

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

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

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

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

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

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

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

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

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

    
2556
    st = av_mallocz(sizeof(AVStream));
2557
    if (!st)
2558
        return NULL;
2559

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

    
2577
    /* default pts setting is MPEG-like */
2578
    av_set_pts_info(st, 33, 1, 90000);
2579
    st->last_IP_pts = AV_NOPTS_VALUE;
2580
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2581
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2582
    st->reference_dts = AV_NOPTS_VALUE;
2583

    
2584
    st->sample_aspect_ratio = (AVRational){0,1};
2585

    
2586
    s->streams[s->nb_streams++] = st;
2587
    return st;
2588
}
2589

    
2590
AVProgram *av_new_program(AVFormatContext *ac, int id)
2591
{
2592
    AVProgram *program=NULL;
2593
    int i;
2594

    
2595
#ifdef DEBUG_SI
2596
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2597
#endif
2598

    
2599
    for(i=0; i<ac->nb_programs; i++)
2600
        if(ac->programs[i]->id == id)
2601
            program = ac->programs[i];
2602

    
2603
    if(!program){
2604
        program = av_mallocz(sizeof(AVProgram));
2605
        if (!program)
2606
            return NULL;
2607
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2608
        program->discard = AVDISCARD_NONE;
2609
    }
2610
    program->id = id;
2611

    
2612
    return program;
2613
}
2614

    
2615
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2616
{
2617
    AVChapter *chapter = NULL;
2618
    int i;
2619

    
2620
    for(i=0; i<s->nb_chapters; i++)
2621
        if(s->chapters[i]->id == id)
2622
            chapter = s->chapters[i];
2623

    
2624
    if(!chapter){
2625
        chapter= av_mallocz(sizeof(AVChapter));
2626
        if(!chapter)
2627
            return NULL;
2628
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2629
    }
2630
#if FF_API_OLD_METADATA
2631
    av_free(chapter->title);
2632
#endif
2633
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2634
    chapter->id    = id;
2635
    chapter->time_base= time_base;
2636
    chapter->start = start;
2637
    chapter->end   = end;
2638

    
2639
    return chapter;
2640
}
2641

    
2642
/************************************************************/
2643
/* output media file */
2644

    
2645
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2646
{
2647
    int ret;
2648

    
2649
    if (s->oformat->priv_data_size > 0) {
2650
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2651
        if (!s->priv_data)
2652
            return AVERROR(ENOMEM);
2653
    } else
2654
        s->priv_data = NULL;
2655

    
2656
    if (s->oformat->set_parameters) {
2657
        ret = s->oformat->set_parameters(s, ap);
2658
        if (ret < 0)
2659
            return ret;
2660
    }
2661
    return 0;
2662
}
2663

    
2664
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2665
{
2666
    const AVCodecTag *avctag;
2667
    int n;
2668
    enum CodecID id = CODEC_ID_NONE;
2669
    unsigned int tag = 0;
2670

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

    
2697
int av_write_header(AVFormatContext *s)
2698
{
2699
    int ret, i;
2700
    AVStream *st;
2701

    
2702
    // some sanity checks
2703
    if (s->nb_streams == 0) {
2704
        av_log(s, AV_LOG_ERROR, "no streams\n");
2705
        return AVERROR(EINVAL);
2706
    }
2707

    
2708
    for(i=0;i<s->nb_streams;i++) {
2709
        st = s->streams[i];
2710

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

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

    
2755
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2756
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2757
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2758
    }
2759

    
2760
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2761
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2762
        if (!s->priv_data)
2763
            return AVERROR(ENOMEM);
2764
    }
2765

    
2766
#if FF_API_OLD_METADATA
2767
    ff_metadata_mux_compat(s);
2768
#endif
2769

    
2770
    /* set muxer identification string */
2771
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2772
        AVMetadata *m;
2773
        AVMetadataTag *t;
2774

    
2775
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2776
            return AVERROR(ENOMEM);
2777
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2778
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2779
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2780
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2781
        av_metadata_free(&m);
2782
    }
2783

    
2784
    if(s->oformat->write_header){
2785
        ret = s->oformat->write_header(s);
2786
        if (ret < 0)
2787
            return ret;
2788
    }
2789

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

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

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

    
2819
//    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);
2820

    
2821
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2822
        return -1;*/
2823

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

    
2832
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2833
        pkt->pts= pkt->dts;
2834

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

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

    
2850
        pkt->dts= st->pts_buffer[0];
2851
    }
2852

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

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

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

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

    
2889
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2890
{
2891
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2892

    
2893
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2894
        return ret;
2895

    
2896
    ret= s->oformat->write_packet(s, pkt);
2897
    if(!ret)
2898
        ret= url_ferror(s->pb);
2899
    return ret;
2900
}
2901

    
2902
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2903
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2904
{
2905
    AVPacketList **next_point, *this_pktl;
2906

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

    
2912
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2913
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2914
    }else
2915
        next_point = &s->packet_buffer;
2916

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

    
2929
    s->packet_buffer_end= this_pktl;
2930
next_non_null:
2931

    
2932
    this_pktl->next= *next_point;
2933

    
2934
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2935
    *next_point= this_pktl;
2936
}
2937

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

    
2947
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2948
    AVPacketList *pktl;
2949
    int stream_count=0;
2950
    int i;
2951

    
2952
    if(pkt){
2953
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2954
    }
2955

    
2956
    for(i=0; i < s->nb_streams; i++)
2957
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2958

    
2959
    if(stream_count && (s->nb_streams == stream_count || flush)){
2960
        pktl= s->packet_buffer;
2961
        *out= pktl->pkt;
2962

    
2963
        s->packet_buffer= pktl->next;
2964
        if(!s->packet_buffer)
2965
            s->packet_buffer_end= NULL;
2966

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

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

    
2993
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2994
    AVStream *st= s->streams[ pkt->stream_index];
2995

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

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

    
3004
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3005
        return -1;
3006

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

    
3013
        ret= s->oformat->write_packet(s, &opkt);
3014

    
3015
        av_free_packet(&opkt);
3016
        pkt= NULL;
3017

    
3018
        if(ret<0)
3019
            return ret;
3020
        if(url_ferror(s->pb))
3021
            return url_ferror(s->pb);
3022
    }
3023
}
3024

    
3025
int av_write_trailer(AVFormatContext *s)
3026
{
3027
    int ret, i;
3028

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

    
3037
        ret= s->oformat->write_packet(s, &pkt);
3038

    
3039
        av_free_packet(&pkt);
3040

    
3041
        if(ret<0)
3042
            goto fail;
3043
        if(url_ferror(s->pb))
3044
            goto fail;
3045
    }
3046

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

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

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

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

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

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

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

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

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

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

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

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

    
3227
    av_free(printed);
3228
}
3229

    
3230
#if LIBAVFORMAT_VERSION_MAJOR < 53
3231
#include "libavcore/parseutils.h"
3232

    
3233
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3234
{
3235
    return av_parse_video_size(width_ptr, height_ptr, str);
3236
}
3237

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

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

    
3255
uint64_t ff_ntp_time(void)
3256
{
3257
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3258
}
3259

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

    
3279
#undef time
3280
    time_t now = time(0);
3281

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

    
3289
    memset(&dt, 0, sizeof(dt));
3290

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

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

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

    
3318
        if (*p == 'T' || *p == 't' || *p == ' ')
3319
            p++;
3320

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

    
3347
    /* Now we have all the fields that we can get */
3348
    if (!q) {
3349
        return INT64_MIN;
3350
    }
3351

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

    
3363
    t *= 1000000;
3364

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

    
3379
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3380
{
3381
    const char *p;
3382
    char tag[128], *q;
3383

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

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

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

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

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

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

    
3502
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3503
{
3504
    hex_dump_internal(NULL, f, 0, buf, size);
3505
}
3506

    
3507
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3508
{
3509
    hex_dump_internal(avcl, NULL, level, buf, size);
3510
}
3511

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

    
3539
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3540
{
3541
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3542
}
3543

    
3544
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3545
{
3546
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3547
}
3548

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

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

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

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

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

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

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

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

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

    
3646
    return buff;
3647
}
3648

    
3649
int ff_hex_to_data(uint8_t *data, const char *p)
3650
{
3651
    int c, len, v;
3652

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

    
3677
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3678
                     unsigned int pts_num, unsigned int pts_den)
3679
{
3680
    s->pts_wrap_bits = pts_wrap_bits;
3681

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

    
3688
    if(!s->time_base.num || !s->time_base.den)
3689
        s->time_base.num= s->time_base.den= 0;
3690
}
3691

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

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

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

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

    
3737
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3738
                     AVFormatContext *src)
3739
{
3740
    AVPacket local_pkt;
3741

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

    
3755
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3756
                        void *context)
3757
{
3758
    const char *ptr = str;
3759

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

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

    
3772
        key = ptr;
3773

    
3774
        if (!(ptr = strchr(key, '=')))
3775
            break;
3776
        ptr++;
3777
        key_len = ptr - key;
3778

    
3779
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3780
        dest_end = dest + dest_len - 1;
3781

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