Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ feb2440c

History | View | Annotate | Download (119 KB)

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

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

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

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

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

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

    
62
/* fraction handling */
63

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

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

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

    
112
/** head of registered input format linked list */
113
AVInputFormat *first_iformat = NULL;
114
/** head of registered output format linked list */
115
AVOutputFormat *first_oformat = NULL;
116

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

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

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

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

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

    
152
    if(!filename)
153
        return 0;
154

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

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

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

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

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

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

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

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

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

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

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

    
254
    return fmt;
255
}
256
#endif
257

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

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

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

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

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

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

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

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

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

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

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

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

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

    
335
    return ret;
336
}
337

    
338

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
478
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
479

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

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

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

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

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

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

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

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

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

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

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

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

    
569
    return ret;
570
}
571

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

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

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

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

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

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

    
634
}
635

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
762

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
974
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
975
    /* interpolate PTS and DTS if they are not present */
976
    //We skip H264 currently because delay and has_b_frames are not reliably set
977
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
978
        if (presentation_delayed) {
979
            /* DTS = decompression timestamp */
980
            /* PTS = presentation timestamp */
981
            if (pkt->dts == AV_NOPTS_VALUE)
982
                pkt->dts = st->last_IP_pts;
983
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
984
            if (pkt->dts == AV_NOPTS_VALUE)
985
                pkt->dts = st->cur_dts;
986

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

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

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

    
1032
//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1033

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

    
1049

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

    
1055
    av_init_packet(pkt);
1056

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

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

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

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

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

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

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

    
1188
    return 0;
1189
}
1190

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

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

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

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

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

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

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

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

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

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

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

    
1299
    flush_packet_queue(s);
1300

    
1301
    s->cur_st = NULL;
1302

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

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

    
1319
        st->probe_packets = MAX_PROBE_PACKETS;
1320

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

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

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

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

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

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

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

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

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

    
1367
    st->index_entries= entries;
1368

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

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

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

    
1392
    return index;
1393
}
1394

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

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

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

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

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

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

    
1431
#define DEBUG_SEEK
1432

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

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

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

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

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

    
1456
        index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1457
        index= FFMAX(index, 0);
1458
        e= &st->index_entries[index];
1459

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

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

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

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

    
1494
    av_update_cur_dts(s, st, ts);
1495

    
1496
    return 0;
1497
}
1498

    
1499
int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1500
    int64_t pos, ts;
1501
    int64_t start_pos, filesize;
1502
    int no_change;
1503

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1696
    return 0;
1697
}
1698

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

    
1704
    ff_read_frame_flush(s);
1705

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

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

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

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

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

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

    
1739
    ff_read_frame_flush(s);
1740

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1876
#define DURATION_MAX_READ_SIZE 250000
1877
#define DURATION_MAX_RETRY 3
1878

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

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

    
1894
    ic->cur_st = NULL;
1895

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

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

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

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

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

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

    
1956
    fill_all_stream_timings(ic);
1957

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2225
        //try to just open decoders, in case this is enough to get parameters
2226
        if(!has_codec_parameters(st->codec)){
2227
            if (codec)
2228
                avcodec_open(st->codec, codec);
2229
        }
2230
    }
2231

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

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

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

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

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

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

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

    
2316
        read_size += pkt->size;
2317

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

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

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

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

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

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

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

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

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

    
2432
    av_estimate_timings(ic, old_offset);
2433

    
2434
    compute_chapters_end(ic);
2435

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

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

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

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

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

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

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

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

    
2542
AVStream *av_new_stream(AVFormatContext *s, int id)
2543
{
2544
    AVStream *st;
2545
    int i;
2546

    
2547
    if (s->nb_streams >= MAX_STREAMS){
2548
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2549
        return NULL;
2550
    }
2551

    
2552
    st = av_mallocz(sizeof(AVStream));
2553
    if (!st)
2554
        return NULL;
2555

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

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

    
2580
    st->sample_aspect_ratio = (AVRational){0,1};
2581

    
2582
    s->streams[s->nb_streams++] = st;
2583
    return st;
2584
}
2585

    
2586
AVProgram *av_new_program(AVFormatContext *ac, int id)
2587
{
2588
    AVProgram *program=NULL;
2589
    int i;
2590

    
2591
#ifdef DEBUG_SI
2592
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2593
#endif
2594

    
2595
    for(i=0; i<ac->nb_programs; i++)
2596
        if(ac->programs[i]->id == id)
2597
            program = ac->programs[i];
2598

    
2599
    if(!program){
2600
        program = av_mallocz(sizeof(AVProgram));
2601
        if (!program)
2602
            return NULL;
2603
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2604
        program->discard = AVDISCARD_NONE;
2605
    }
2606
    program->id = id;
2607

    
2608
    return program;
2609
}
2610

    
2611
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2612
{
2613
    AVChapter *chapter = NULL;
2614
    int i;
2615

    
2616
    for(i=0; i<s->nb_chapters; i++)
2617
        if(s->chapters[i]->id == id)
2618
            chapter = s->chapters[i];
2619

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

    
2635
    return chapter;
2636
}
2637

    
2638
/************************************************************/
2639
/* output media file */
2640

    
2641
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2642
{
2643
    int ret;
2644

    
2645
    if (s->oformat->priv_data_size > 0) {
2646
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2647
        if (!s->priv_data)
2648
            return AVERROR(ENOMEM);
2649
    } else
2650
        s->priv_data = NULL;
2651

    
2652
    if (s->oformat->set_parameters) {
2653
        ret = s->oformat->set_parameters(s, ap);
2654
        if (ret < 0)
2655
            return ret;
2656
    }
2657
    return 0;
2658
}
2659

    
2660
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2661
{
2662
    const AVCodecTag *avctag;
2663
    int n;
2664
    enum CodecID id = CODEC_ID_NONE;
2665
    unsigned int tag = 0;
2666

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

    
2693
int av_write_header(AVFormatContext *s)
2694
{
2695
    int ret, i;
2696
    AVStream *st;
2697

    
2698
    // some sanity checks
2699
    if (s->nb_streams == 0) {
2700
        av_log(s, AV_LOG_ERROR, "no streams\n");
2701
        return AVERROR(EINVAL);
2702
    }
2703

    
2704
    for(i=0;i<s->nb_streams;i++) {
2705
        st = s->streams[i];
2706

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

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

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

    
2756
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2757
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2758
        if (!s->priv_data)
2759
            return AVERROR(ENOMEM);
2760
    }
2761

    
2762
#if FF_API_OLD_METADATA
2763
    ff_metadata_mux_compat(s);
2764
#endif
2765

    
2766
    /* set muxer identification string */
2767
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2768
        AVMetadata *m;
2769
        AVMetadataTag *t;
2770

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2928
    this_pktl->next= *next_point;
2929

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3035
        av_free_packet(&pkt);
3036

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3223
    av_free(printed);
3224
}
3225

    
3226
#if LIBAVFORMAT_VERSION_MAJOR < 53
3227
#include "libavcore/parseutils.h"
3228

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3359
    t *= 1000000;
3360

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3642
    return buff;
3643
}
3644

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3768
        key = ptr;
3769

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

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

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