Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 133208ff

History | View | Annotate | Download (125 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

    
22
/* #define DEBUG */
23

    
24
#include "avformat.h"
25
#include "avio_internal.h"
26
#include "internal.h"
27
#include "libavcodec/internal.h"
28
#include "libavcodec/raw.h"
29
#include "libavutil/opt.h"
30
#include "metadata.h"
31
#include "id3v2.h"
32
#include "libavutil/avstring.h"
33
#include "riff.h"
34
#include "audiointerleave.h"
35
#include "url.h"
36
#include <sys/time.h>
37
#include <time.h>
38
#include <strings.h>
39
#include <stdarg.h>
40
#if CONFIG_NETWORK
41
#include "network.h"
42
#endif
43

    
44
#undef NDEBUG
45
#include <assert.h>
46

    
47
/**
48
 * @file
49
 * various utility functions for use within FFmpeg
50
 */
51

    
52
unsigned avformat_version(void)
53
{
54
    return LIBAVFORMAT_VERSION_INT;
55
}
56

    
57
const char *avformat_configuration(void)
58
{
59
    return FFMPEG_CONFIGURATION;
60
}
61

    
62
const char *avformat_license(void)
63
{
64
#define LICENSE_PREFIX "libavformat license: "
65
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
66
}
67

    
68
/* fraction handling */
69

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

    
92
/**
93
 * Fractional addition to f: f = f + (incr / f->den).
94
 *
95
 * @param f fractional number
96
 * @param incr increment, can be positive or negative
97
 */
98
static void av_frac_add(AVFrac *f, int64_t incr)
99
{
100
    int64_t num, den;
101

    
102
    num = f->num + incr;
103
    den = f->den;
104
    if (num < 0) {
105
        f->val += num / den;
106
        num = num % den;
107
        if (num < 0) {
108
            num += den;
109
            f->val--;
110
        }
111
    } else if (num >= den) {
112
        f->val += num / den;
113
        num = num % den;
114
    }
115
    f->num = num;
116
}
117

    
118
/** head of registered input format linked list */
119
#if !FF_API_FIRST_FORMAT
120
static
121
#endif
122
AVInputFormat *first_iformat = NULL;
123
/** head of registered output format linked list */
124
#if !FF_API_FIRST_FORMAT
125
static
126
#endif
127
AVOutputFormat *first_oformat = NULL;
128

    
129
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
130
{
131
    if(f) return f->next;
132
    else  return first_iformat;
133
}
134

    
135
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
136
{
137
    if(f) return f->next;
138
    else  return first_oformat;
139
}
140

    
141
void av_register_input_format(AVInputFormat *format)
142
{
143
    AVInputFormat **p;
144
    p = &first_iformat;
145
    while (*p != NULL) p = &(*p)->next;
146
    *p = format;
147
    format->next = NULL;
148
}
149

    
150
void av_register_output_format(AVOutputFormat *format)
151
{
152
    AVOutputFormat **p;
153
    p = &first_oformat;
154
    while (*p != NULL) p = &(*p)->next;
155
    *p = format;
156
    format->next = NULL;
157
}
158

    
159
int av_match_ext(const char *filename, const char *extensions)
160
{
161
    const char *ext, *p;
162
    char ext1[32], *q;
163

    
164
    if(!filename)
165
        return 0;
166

    
167
    ext = strrchr(filename, '.');
168
    if (ext) {
169
        ext++;
170
        p = extensions;
171
        for(;;) {
172
            q = ext1;
173
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
174
                *q++ = *p++;
175
            *q = '\0';
176
            if (!strcasecmp(ext1, ext))
177
                return 1;
178
            if (*p == '\0')
179
                break;
180
            p++;
181
        }
182
    }
183
    return 0;
184
}
185

    
186
static int match_format(const char *name, const char *names)
187
{
188
    const char *p;
189
    int len, namelen;
190

    
191
    if (!name || !names)
192
        return 0;
193

    
194
    namelen = strlen(name);
195
    while ((p = strchr(names, ','))) {
196
        len = FFMAX(p - names, namelen);
197
        if (!strncasecmp(name, names, len))
198
            return 1;
199
        names = p+1;
200
    }
201
    return !strcasecmp(name, names);
202
}
203

    
204
#if FF_API_GUESS_FORMAT
205
AVOutputFormat *guess_format(const char *short_name, const char *filename,
206
                             const char *mime_type)
207
{
208
    return av_guess_format(short_name, filename, mime_type);
209
}
210
#endif
211

    
212
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
213
                                const char *mime_type)
214
{
215
    AVOutputFormat *fmt = NULL, *fmt_found;
216
    int score_max, score;
217

    
218
    /* specific test for image sequences */
219
#if CONFIG_IMAGE2_MUXER
220
    if (!short_name && filename &&
221
        av_filename_number_test(filename) &&
222
        ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
223
        return av_guess_format("image2", NULL, NULL);
224
    }
225
#endif
226
    /* Find the proper file type. */
227
    fmt_found = NULL;
228
    score_max = 0;
229
    while ((fmt = av_oformat_next(fmt))) {
230
        score = 0;
231
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
232
            score += 100;
233
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
234
            score += 10;
235
        if (filename && fmt->extensions &&
236
            av_match_ext(filename, fmt->extensions)) {
237
            score += 5;
238
        }
239
        if (score > score_max) {
240
            score_max = score;
241
            fmt_found = fmt;
242
        }
243
    }
244
    return fmt_found;
245
}
246

    
247
#if FF_API_GUESS_FORMAT
248
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
249
                             const char *mime_type)
250
{
251
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
252

    
253
    if (fmt) {
254
        AVOutputFormat *stream_fmt;
255
        char stream_format_name[64];
256

    
257
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
258
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
259

    
260
        if (stream_fmt)
261
            fmt = stream_fmt;
262
    }
263

    
264
    return fmt;
265
}
266
#endif
267

    
268
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
269
                            const char *filename, const char *mime_type, enum AVMediaType type){
270
    if(type == AVMEDIA_TYPE_VIDEO){
271
        enum CodecID codec_id= CODEC_ID_NONE;
272

    
273
#if CONFIG_IMAGE2_MUXER
274
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
275
            codec_id= ff_guess_image2_codec(filename);
276
        }
277
#endif
278
        if(codec_id == CODEC_ID_NONE)
279
            codec_id= fmt->video_codec;
280
        return codec_id;
281
    }else if(type == AVMEDIA_TYPE_AUDIO)
282
        return fmt->audio_codec;
283
    else if (type == AVMEDIA_TYPE_SUBTITLE)
284
        return fmt->subtitle_codec;
285
    else
286
        return CODEC_ID_NONE;
287
}
288

    
289
AVInputFormat *av_find_input_format(const char *short_name)
290
{
291
    AVInputFormat *fmt = NULL;
292
    while ((fmt = av_iformat_next(fmt))) {
293
        if (match_format(short_name, fmt->name))
294
            return fmt;
295
    }
296
    return NULL;
297
}
298

    
299
#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
300
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
301
{
302
    av_destruct_packet_nofree(pkt);
303
}
304

    
305
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
306
{
307
    av_destruct_packet(pkt);
308
}
309

    
310
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
311
{
312
    return av_new_packet(pkt, size);
313
}
314

    
315
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
316
{
317
    return av_dup_packet(pkt);
318
}
319

    
320
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
321
{
322
    av_free_packet(pkt);
323
}
324

    
325
FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
326
{
327
    av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
328
    av_init_packet(pkt);
329
}
330
#endif
331

    
332
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
333
{
334
    int ret= av_new_packet(pkt, size);
335

    
336
    if(ret<0)
337
        return ret;
338

    
339
    pkt->pos= avio_tell(s);
340

    
341
    ret= avio_read(s, pkt->data, size);
342
    if(ret<=0)
343
        av_free_packet(pkt);
344
    else
345
        av_shrink_packet(pkt, ret);
346

    
347
    return ret;
348
}
349

    
350
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
351
{
352
    int ret;
353
    int old_size;
354
    if (!pkt->size)
355
        return av_get_packet(s, pkt, size);
356
    old_size = pkt->size;
357
    ret = av_grow_packet(pkt, size);
358
    if (ret < 0)
359
        return ret;
360
    ret = avio_read(s, pkt->data + old_size, size);
361
    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
362
    return ret;
363
}
364

    
365

    
366
int av_filename_number_test(const char *filename)
367
{
368
    char buf[1024];
369
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
370
}
371

    
372
AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
373
{
374
    AVProbeData lpd = *pd;
375
    AVInputFormat *fmt1 = NULL, *fmt;
376
    int score, score_max=0;
377

    
378
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
379
        int id3len = ff_id3v2_tag_len(lpd.buf);
380
        if (lpd.buf_size > id3len + 16) {
381
            lpd.buf += id3len;
382
            lpd.buf_size -= id3len;
383
        }
384
    }
385

    
386
    fmt = NULL;
387
    while ((fmt1 = av_iformat_next(fmt1))) {
388
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
389
            continue;
390
        score = 0;
391
        if (fmt1->read_probe) {
392
            score = fmt1->read_probe(&lpd);
393
            if(!score && fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
394
                score = 1;
395
        } else if (fmt1->extensions) {
396
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
397
                score = 50;
398
            }
399
        }
400
        if (score > score_max) {
401
            score_max = score;
402
            fmt = fmt1;
403
        }else if (score == score_max)
404
            fmt = NULL;
405
    }
406
    *score_ret= score_max;
407
    return fmt;
408
}
409

    
410
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
411
{
412
    int score_ret;
413
    AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
414
    if(score_ret > *score_max){
415
        *score_max= score_ret;
416
        return fmt;
417
    }else
418
        return NULL;
419
}
420

    
421
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
422
    int score=0;
423
    return av_probe_input_format2(pd, is_opened, &score);
424
}
425

    
426
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
427
{
428
    static const struct {
429
        const char *name; enum CodecID id; enum AVMediaType type;
430
    } fmt_id_type[] = {
431
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
432
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
433
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
434
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
435
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
436
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
437
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
438
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
439
        { 0 }
440
    };
441
    int score;
442
    AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
443

    
444
    if (fmt) {
445
        int i;
446
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
447
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
448
        for (i = 0; fmt_id_type[i].name; i++) {
449
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
450
                st->codec->codec_id   = fmt_id_type[i].id;
451
                st->codec->codec_type = fmt_id_type[i].type;
452
                break;
453
            }
454
        }
455
    }
456
    return score;
457
}
458

    
459
/************************************************************/
460
/* input media file */
461

    
462
/**
463
 * Open a media file from an IO stream. 'fmt' must be specified.
464
 */
465
int av_open_input_stream(AVFormatContext **ic_ptr,
466
                         AVIOContext *pb, const char *filename,
467
                         AVInputFormat *fmt, AVFormatParameters *ap)
468
{
469
    int err;
470
    AVFormatContext *ic;
471
    AVFormatParameters default_ap;
472

    
473
    if(!ap){
474
        ap=&default_ap;
475
        memset(ap, 0, sizeof(default_ap));
476
    }
477

    
478
    if(!ap->prealloced_context)
479
        ic = avformat_alloc_context();
480
    else
481
        ic = *ic_ptr;
482
    if (!ic) {
483
        err = AVERROR(ENOMEM);
484
        goto fail;
485
    }
486
    ic->iformat = fmt;
487
    ic->pb = pb;
488
    ic->duration = AV_NOPTS_VALUE;
489
    ic->start_time = AV_NOPTS_VALUE;
490
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
491

    
492
    /* allocate private data */
493
    if (fmt->priv_data_size > 0) {
494
        ic->priv_data = av_mallocz(fmt->priv_data_size);
495
        if (!ic->priv_data) {
496
            err = AVERROR(ENOMEM);
497
            goto fail;
498
        }
499
    } else {
500
        ic->priv_data = NULL;
501
    }
502

    
503
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
504
    if (ic->pb)
505
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
506

    
507
    if (ic->iformat->read_header) {
508
        err = ic->iformat->read_header(ic, ap);
509
        if (err < 0)
510
            goto fail;
511
    }
512

    
513
    if (pb && !ic->data_offset)
514
        ic->data_offset = avio_tell(ic->pb);
515

    
516
#if FF_API_OLD_METADATA
517
    ff_metadata_demux_compat(ic);
518
#endif
519

    
520
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
521

    
522
    *ic_ptr = ic;
523
    return 0;
524
 fail:
525
    if (ic) {
526
        int i;
527
        av_freep(&ic->priv_data);
528
        for(i=0;i<ic->nb_streams;i++) {
529
            AVStream *st = ic->streams[i];
530
            if (st) {
531
                av_free(st->priv_data);
532
                av_free(st->codec->extradata);
533
                av_free(st->codec);
534
                av_free(st->info);
535
            }
536
            av_free(st);
537
        }
538
    }
539
    av_free(ic);
540
    *ic_ptr = NULL;
541
    return err;
542
}
543

    
544
/** size of probe buffer, for guessing file type from file contents */
545
#define PROBE_BUF_MIN 2048
546
#define PROBE_BUF_MAX (1<<20)
547

    
548
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
549
                          const char *filename, void *logctx,
550
                          unsigned int offset, unsigned int max_probe_size)
551
{
552
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
553
    unsigned char *buf = NULL;
554
    int ret = 0, probe_size;
555

    
556
    if (!max_probe_size) {
557
        max_probe_size = PROBE_BUF_MAX;
558
    } else if (max_probe_size > PROBE_BUF_MAX) {
559
        max_probe_size = PROBE_BUF_MAX;
560
    } else if (max_probe_size < PROBE_BUF_MIN) {
561
        return AVERROR(EINVAL);
562
    }
563

    
564
    if (offset >= max_probe_size) {
565
        return AVERROR(EINVAL);
566
    }
567

    
568
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
569
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
570
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
571
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
572

    
573
        if (probe_size < offset) {
574
            continue;
575
        }
576

    
577
        /* read probe data */
578
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
579
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
580
            /* fail if error was not end of file, otherwise, lower score */
581
            if (ret != AVERROR_EOF) {
582
                av_free(buf);
583
                return ret;
584
            }
585
            score = 0;
586
            ret = 0;            /* error was end of file, nothing read */
587
        }
588
        pd.buf_size += ret;
589
        pd.buf = &buf[offset];
590

    
591
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
592

    
593
        /* guess file format */
594
        *fmt = av_probe_input_format2(&pd, 1, &score);
595
        if(*fmt){
596
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
597
                av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
598
            }else
599
                av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
600
        }
601
    }
602

    
603
    if (!*fmt) {
604
        av_free(buf);
605
        return AVERROR_INVALIDDATA;
606
    }
607

    
608
    /* rewind. reuse probe buffer to avoid seeking */
609
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
610
        av_free(buf);
611

    
612
    return ret;
613
}
614

    
615
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
616
                       AVInputFormat *fmt,
617
                       int buf_size,
618
                       AVFormatParameters *ap)
619
{
620
    int err;
621
    AVProbeData probe_data, *pd = &probe_data;
622
    AVIOContext *pb = NULL;
623
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
624

    
625
    pd->filename = "";
626
    if (filename)
627
        pd->filename = filename;
628
    pd->buf = NULL;
629
    pd->buf_size = 0;
630

    
631
    if (!fmt) {
632
        /* guess format if no file can be opened */
633
        fmt = av_probe_input_format(pd, 0);
634
    }
635

    
636
    /* Do not open file if the format does not need it. XXX: specific
637
       hack needed to handle RTSP/TCP */
638
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
639
        /* if no file needed do not try to open one */
640
        if ((err=avio_open(&pb, filename, AVIO_RDONLY)) < 0) {
641
            goto fail;
642
        }
643
        if (buf_size > 0) {
644
            ffio_set_buf_size(pb, buf_size);
645
        }
646
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
647
            goto fail;
648
        }
649
    }
650

    
651
    /* if still no format found, error */
652
    if (!fmt) {
653
        err = AVERROR_INVALIDDATA;
654
        goto fail;
655
    }
656

    
657
    /* check filename in case an image number is expected */
658
    if (fmt->flags & AVFMT_NEEDNUMBER) {
659
        if (!av_filename_number_test(filename)) {
660
            err = AVERROR_NUMEXPECTED;
661
            goto fail;
662
        }
663
    }
664
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
665
    if (err)
666
        goto fail;
667
    return 0;
668
 fail:
669
    av_freep(&pd->buf);
670
    if (pb)
671
        avio_close(pb);
672
    if (ap && ap->prealloced_context)
673
        av_free(*ic_ptr);
674
    *ic_ptr = NULL;
675
    return err;
676

    
677
}
678

    
679
/*******************************************************/
680

    
681
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
682
                               AVPacketList **plast_pktl){
683
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
684
    if (!pktl)
685
        return NULL;
686

    
687
    if (*packet_buffer)
688
        (*plast_pktl)->next = pktl;
689
    else
690
        *packet_buffer = pktl;
691

    
692
    /* add the packet in the buffered packet list */
693
    *plast_pktl = pktl;
694
    pktl->pkt= *pkt;
695
    return &pktl->pkt;
696
}
697

    
698
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
699
{
700
    int ret, i;
701
    AVStream *st;
702

    
703
    for(;;){
704
        AVPacketList *pktl = s->raw_packet_buffer;
705

    
706
        if (pktl) {
707
            *pkt = pktl->pkt;
708
            if(s->streams[pkt->stream_index]->request_probe <= 0){
709
                s->raw_packet_buffer = pktl->next;
710
                s->raw_packet_buffer_remaining_size += pkt->size;
711
                av_free(pktl);
712
                return 0;
713
            }
714
        }
715

    
716
        av_init_packet(pkt);
717
        ret= s->iformat->read_packet(s, pkt);
718
        if (ret < 0) {
719
            if (!pktl || ret == AVERROR(EAGAIN))
720
                return ret;
721
            for (i = 0; i < s->nb_streams; i++)
722
                if(s->streams[i]->request_probe > 0)
723
                    s->streams[i]->request_probe = -1;
724
            continue;
725
        }
726
        st= s->streams[pkt->stream_index];
727

    
728
        switch(st->codec->codec_type){
729
        case AVMEDIA_TYPE_VIDEO:
730
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
731
            break;
732
        case AVMEDIA_TYPE_AUDIO:
733
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
734
            break;
735
        case AVMEDIA_TYPE_SUBTITLE:
736
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
737
            break;
738
        }
739

    
740
        if(!pktl && st->request_probe <= 0)
741
            return ret;
742

    
743
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
744
        s->raw_packet_buffer_remaining_size -= pkt->size;
745

    
746
        if(st->request_probe>0){
747
            AVProbeData *pd = &st->probe_data;
748
            int end;
749
            av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
750
            --st->probe_packets;
751

    
752
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
753
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
754
            pd->buf_size += pkt->size;
755
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
756

    
757
            end=    s->raw_packet_buffer_remaining_size <= 0
758
                 || st->probe_packets<=0;
759

    
760
            if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
761
                int score= set_codec_from_probe_data(s, st, pd);
762
                if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
763
                    || end){
764
                    pd->buf_size=0;
765
                    av_freep(&pd->buf);
766
                    st->request_probe= -1;
767
                    if(st->codec->codec_id != CODEC_ID_NONE){
768
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
769
                    }else
770
                        av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
771
                }
772
            }
773
        }
774
    }
775
}
776

    
777
/**********************************************************/
778

    
779
/**
780
 * Get the number of samples of an audio frame. Return -1 on error.
781
 */
782
static int get_audio_frame_size(AVCodecContext *enc, int size)
783
{
784
    int frame_size;
785

    
786
    if(enc->codec_id == CODEC_ID_VORBIS)
787
        return -1;
788

    
789
    if (enc->frame_size <= 1) {
790
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
791

    
792
        if (bits_per_sample) {
793
            if (enc->channels == 0)
794
                return -1;
795
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
796
        } else {
797
            /* used for example by ADPCM codecs */
798
            if (enc->bit_rate == 0)
799
                return -1;
800
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
801
        }
802
    } else {
803
        frame_size = enc->frame_size;
804
    }
805
    return frame_size;
806
}
807

    
808

    
809
/**
810
 * Return the frame duration in seconds. Return 0 if not available.
811
 */
812
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
813
                                   AVCodecParserContext *pc, AVPacket *pkt)
814
{
815
    int frame_size;
816

    
817
    *pnum = 0;
818
    *pden = 0;
819
    switch(st->codec->codec_type) {
820
    case AVMEDIA_TYPE_VIDEO:
821
        if(st->time_base.num*1000LL > st->time_base.den){
822
            *pnum = st->time_base.num;
823
            *pden = st->time_base.den;
824
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
825
            *pnum = st->codec->time_base.num;
826
            *pden = st->codec->time_base.den;
827
            if (pc && pc->repeat_pict) {
828
                *pnum = (*pnum) * (1 + pc->repeat_pict);
829
            }
830
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
831
            //Thus if we have no parser in such case leave duration undefined.
832
            if(st->codec->ticks_per_frame>1 && !pc){
833
                *pnum = *pden = 0;
834
            }
835
        }
836
        break;
837
    case AVMEDIA_TYPE_AUDIO:
838
        frame_size = get_audio_frame_size(st->codec, pkt->size);
839
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
840
            break;
841
        *pnum = frame_size;
842
        *pden = st->codec->sample_rate;
843
        break;
844
    default:
845
        break;
846
    }
847
}
848

    
849
static int is_intra_only(AVCodecContext *enc){
850
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
851
        return 1;
852
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
853
        switch(enc->codec_id){
854
        case CODEC_ID_MJPEG:
855
        case CODEC_ID_MJPEGB:
856
        case CODEC_ID_LJPEG:
857
        case CODEC_ID_RAWVIDEO:
858
        case CODEC_ID_DVVIDEO:
859
        case CODEC_ID_HUFFYUV:
860
        case CODEC_ID_FFVHUFF:
861
        case CODEC_ID_ASV1:
862
        case CODEC_ID_ASV2:
863
        case CODEC_ID_VCR1:
864
        case CODEC_ID_DNXHD:
865
        case CODEC_ID_JPEG2000:
866
            return 1;
867
        default: break;
868
        }
869
    }
870
    return 0;
871
}
872

    
873
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
874
                                      int64_t dts, int64_t pts)
875
{
876
    AVStream *st= s->streams[stream_index];
877
    AVPacketList *pktl= s->packet_buffer;
878

    
879
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
880
        return;
881

    
882
    st->first_dts= dts - st->cur_dts;
883
    st->cur_dts= dts;
884

    
885
    for(; pktl; pktl= pktl->next){
886
        if(pktl->pkt.stream_index != stream_index)
887
            continue;
888
        //FIXME think more about this check
889
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
890
            pktl->pkt.pts += st->first_dts;
891

    
892
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
893
            pktl->pkt.dts += st->first_dts;
894

    
895
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
896
            st->start_time= pktl->pkt.pts;
897
    }
898
    if (st->start_time == AV_NOPTS_VALUE)
899
        st->start_time = pts;
900
}
901

    
902
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
903
{
904
    AVPacketList *pktl= s->packet_buffer;
905
    int64_t cur_dts= 0;
906

    
907
    if(st->first_dts != AV_NOPTS_VALUE){
908
        cur_dts= st->first_dts;
909
        for(; pktl; pktl= pktl->next){
910
            if(pktl->pkt.stream_index == pkt->stream_index){
911
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
912
                    break;
913
                cur_dts -= pkt->duration;
914
            }
915
        }
916
        pktl= s->packet_buffer;
917
        st->first_dts = cur_dts;
918
    }else if(st->cur_dts)
919
        return;
920

    
921
    for(; pktl; pktl= pktl->next){
922
        if(pktl->pkt.stream_index != pkt->stream_index)
923
            continue;
924
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
925
           && !pktl->pkt.duration){
926
            pktl->pkt.dts= cur_dts;
927
            if(!st->codec->has_b_frames)
928
                pktl->pkt.pts= cur_dts;
929
            cur_dts += pkt->duration;
930
            pktl->pkt.duration= pkt->duration;
931
        }else
932
            break;
933
    }
934
    if(st->first_dts == AV_NOPTS_VALUE)
935
        st->cur_dts= cur_dts;
936
}
937

    
938
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
939
                               AVCodecParserContext *pc, AVPacket *pkt)
940
{
941
    int num, den, presentation_delayed, delay, i;
942
    int64_t offset;
943

    
944
    if (s->flags & AVFMT_FLAG_NOFILLIN)
945
        return;
946

    
947
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
948
        pkt->dts= AV_NOPTS_VALUE;
949

    
950
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
951
        //FIXME Set low_delay = 0 when has_b_frames = 1
952
        st->codec->has_b_frames = 1;
953

    
954
    /* do we have a video B-frame ? */
955
    delay= st->codec->has_b_frames;
956
    presentation_delayed = 0;
957

    
958
    // ignore delay caused by frame threading so that the mpeg2-without-dts
959
    // warning will not trigger
960
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
961
        delay -= st->codec->thread_count-1;
962

    
963
    /* XXX: need has_b_frame, but cannot get it if the codec is
964
        not initialized */
965
    if (delay &&
966
        pc && pc->pict_type != FF_B_TYPE)
967
        presentation_delayed = 1;
968

    
969
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
970
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
971
        pkt->dts -= 1LL<<st->pts_wrap_bits;
972
    }
973

    
974
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
975
    // we take the conservative approach and discard both
976
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
977
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
978
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
979
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
980
    }
981

    
982
    if (pkt->duration == 0) {
983
        compute_frame_duration(&num, &den, st, pc, pkt);
984
        if (den && num) {
985
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
986

    
987
            if(pkt->duration != 0 && s->packet_buffer)
988
                update_initial_durations(s, st, pkt);
989
        }
990
    }
991

    
992
    /* correct timestamps with byte offset if demuxers only have timestamps
993
       on packet boundaries */
994
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
995
        /* this will estimate bitrate based on this frame's duration and size */
996
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
997
        if(pkt->pts != AV_NOPTS_VALUE)
998
            pkt->pts += offset;
999
        if(pkt->dts != AV_NOPTS_VALUE)
1000
            pkt->dts += offset;
1001
    }
1002

    
1003
    if (pc && pc->dts_sync_point >= 0) {
1004
        // we have synchronization info from the parser
1005
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1006
        if (den > 0) {
1007
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1008
            if (pkt->dts != AV_NOPTS_VALUE) {
1009
                // got DTS from the stream, update reference timestamp
1010
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1011
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1012
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
1013
                // compute DTS based on reference timestamp
1014
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1015
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1016
            }
1017
            if (pc->dts_sync_point > 0)
1018
                st->reference_dts = pkt->dts; // new reference
1019
        }
1020
    }
1021

    
1022
    /* This may be redundant, but it should not hurt. */
1023
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1024
        presentation_delayed = 1;
1025

    
1026
//    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);
1027
    /* interpolate PTS and DTS if they are not present */
1028
    //We skip H264 currently because delay and has_b_frames are not reliably set
1029
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1030
        if (presentation_delayed) {
1031
            /* DTS = decompression timestamp */
1032
            /* PTS = presentation timestamp */
1033
            if (pkt->dts == AV_NOPTS_VALUE)
1034
                pkt->dts = st->last_IP_pts;
1035
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1036
            if (pkt->dts == AV_NOPTS_VALUE)
1037
                pkt->dts = st->cur_dts;
1038

    
1039
            /* this is tricky: the dts must be incremented by the duration
1040
            of the frame we are displaying, i.e. the last I- or P-frame */
1041
            if (st->last_IP_duration == 0)
1042
                st->last_IP_duration = pkt->duration;
1043
            if(pkt->dts != AV_NOPTS_VALUE)
1044
                st->cur_dts = pkt->dts + st->last_IP_duration;
1045
            st->last_IP_duration  = pkt->duration;
1046
            st->last_IP_pts= pkt->pts;
1047
            /* cannot compute PTS if not present (we can compute it only
1048
            by knowing the future */
1049
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1050
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1051
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1052
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1053
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1054
                    pkt->pts += pkt->duration;
1055
    //                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);
1056
                }
1057
            }
1058

    
1059
            /* presentation is not delayed : PTS and DTS are the same */
1060
            if(pkt->pts == AV_NOPTS_VALUE)
1061
                pkt->pts = pkt->dts;
1062
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1063
            if(pkt->pts == AV_NOPTS_VALUE)
1064
                pkt->pts = st->cur_dts;
1065
            pkt->dts = pkt->pts;
1066
            if(pkt->pts != AV_NOPTS_VALUE)
1067
                st->cur_dts = pkt->pts + pkt->duration;
1068
        }
1069
    }
1070

    
1071
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1072
        st->pts_buffer[0]= pkt->pts;
1073
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1074
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1075
        if(pkt->dts == AV_NOPTS_VALUE)
1076
            pkt->dts= st->pts_buffer[0];
1077
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1078
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1079
        }
1080
        if(pkt->dts > st->cur_dts)
1081
            st->cur_dts = pkt->dts;
1082
    }
1083

    
1084
//    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);
1085

    
1086
    /* update flags */
1087
    if(is_intra_only(st->codec))
1088
        pkt->flags |= AV_PKT_FLAG_KEY;
1089
    else if (pc) {
1090
        pkt->flags = 0;
1091
        /* keyframe computation */
1092
        if (pc->key_frame == 1)
1093
            pkt->flags |= AV_PKT_FLAG_KEY;
1094
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1095
            pkt->flags |= AV_PKT_FLAG_KEY;
1096
    }
1097
    if (pc)
1098
        pkt->convergence_duration = pc->convergence_duration;
1099
}
1100

    
1101

    
1102
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1103
{
1104
    AVStream *st;
1105
    int len, ret, i;
1106

    
1107
    av_init_packet(pkt);
1108

    
1109
    for(;;) {
1110
        /* select current input stream component */
1111
        st = s->cur_st;
1112
        if (st) {
1113
            if (!st->need_parsing || !st->parser) {
1114
                /* no parsing needed: we just output the packet as is */
1115
                /* raw data support */
1116
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1117
                compute_pkt_fields(s, st, NULL, pkt);
1118
                s->cur_st = NULL;
1119
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1120
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1121
                    ff_reduce_index(s, st->index);
1122
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1123
                }
1124
                break;
1125
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1126
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1127
                                       st->cur_ptr, st->cur_len,
1128
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1129
                                       st->cur_pkt.pos);
1130
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1131
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1132
                /* increment read pointer */
1133
                st->cur_ptr += len;
1134
                st->cur_len -= len;
1135

    
1136
                /* return packet if any */
1137
                if (pkt->size) {
1138
                got_packet:
1139
                    pkt->duration = 0;
1140
                    pkt->stream_index = st->index;
1141
                    pkt->pts = st->parser->pts;
1142
                    pkt->dts = st->parser->dts;
1143
                    pkt->pos = st->parser->pos;
1144
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1145
                        s->cur_st = NULL;
1146
                        pkt->destruct= st->cur_pkt.destruct;
1147
                        st->cur_pkt.destruct= NULL;
1148
                        st->cur_pkt.data    = NULL;
1149
                        assert(st->cur_len == 0);
1150
                    }else{
1151
                    pkt->destruct = NULL;
1152
                    }
1153
                    compute_pkt_fields(s, st, st->parser, pkt);
1154

    
1155
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1156
                        ff_reduce_index(s, st->index);
1157
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1158
                                           0, 0, AVINDEX_KEYFRAME);
1159
                    }
1160

    
1161
                    break;
1162
                }
1163
            } else {
1164
                /* free packet */
1165
                av_free_packet(&st->cur_pkt);
1166
                s->cur_st = NULL;
1167
            }
1168
        } else {
1169
            AVPacket cur_pkt;
1170
            /* read next packet */
1171
            ret = av_read_packet(s, &cur_pkt);
1172
            if (ret < 0) {
1173
                if (ret == AVERROR(EAGAIN))
1174
                    return ret;
1175
                /* return the last frames, if any */
1176
                for(i = 0; i < s->nb_streams; i++) {
1177
                    st = s->streams[i];
1178
                    if (st->parser && st->need_parsing) {
1179
                        av_parser_parse2(st->parser, st->codec,
1180
                                        &pkt->data, &pkt->size,
1181
                                        NULL, 0,
1182
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1183
                                        AV_NOPTS_VALUE);
1184
                        if (pkt->size)
1185
                            goto got_packet;
1186
                    }
1187
                }
1188
                /* no more packets: really terminate parsing */
1189
                return ret;
1190
            }
1191
            st = s->streams[cur_pkt.stream_index];
1192
            st->cur_pkt= cur_pkt;
1193

    
1194
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1195
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1196
               st->cur_pkt.pts < st->cur_pkt.dts){
1197
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1198
                    st->cur_pkt.stream_index,
1199
                    st->cur_pkt.pts,
1200
                    st->cur_pkt.dts,
1201
                    st->cur_pkt.size);
1202
//                av_free_packet(&st->cur_pkt);
1203
//                return -1;
1204
            }
1205

    
1206
            if(s->debug & FF_FDEBUG_TS)
1207
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1208
                    st->cur_pkt.stream_index,
1209
                    st->cur_pkt.pts,
1210
                    st->cur_pkt.dts,
1211
                    st->cur_pkt.size,
1212
                    st->cur_pkt.duration,
1213
                    st->cur_pkt.flags);
1214

    
1215
            s->cur_st = st;
1216
            st->cur_ptr = st->cur_pkt.data;
1217
            st->cur_len = st->cur_pkt.size;
1218
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1219
                st->parser = av_parser_init(st->codec->codec_id);
1220
                if (!st->parser) {
1221
                    /* no parser available: just output the raw packets */
1222
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1223
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1224
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1225
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1226
                    st->parser->flags |= PARSER_FLAG_ONCE;
1227
                }
1228
            }
1229
        }
1230
    }
1231
    if(s->debug & FF_FDEBUG_TS)
1232
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1233
            pkt->stream_index,
1234
            pkt->pts,
1235
            pkt->dts,
1236
            pkt->size,
1237
            pkt->duration,
1238
            pkt->flags);
1239

    
1240
    return 0;
1241
}
1242

    
1243
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1244
{
1245
    AVPacketList *pktl;
1246
    int eof=0;
1247
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1248

    
1249
    for(;;){
1250
        pktl = s->packet_buffer;
1251
        if (pktl) {
1252
            AVPacket *next_pkt= &pktl->pkt;
1253

    
1254
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1255
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1256
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1257
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1258
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1259
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1260
                        next_pkt->pts= pktl->pkt.dts;
1261
                    }
1262
                    pktl= pktl->next;
1263
                }
1264
                pktl = s->packet_buffer;
1265
            }
1266

    
1267
            if(   next_pkt->pts != AV_NOPTS_VALUE
1268
               || next_pkt->dts == AV_NOPTS_VALUE
1269
               || !genpts || eof){
1270
                /* read packet from packet buffer, if there is data */
1271
                *pkt = *next_pkt;
1272
                s->packet_buffer = pktl->next;
1273
                av_free(pktl);
1274
                return 0;
1275
            }
1276
        }
1277
        if(genpts){
1278
            int ret= av_read_frame_internal(s, pkt);
1279
            if(ret<0){
1280
                if(pktl && ret != AVERROR(EAGAIN)){
1281
                    eof=1;
1282
                    continue;
1283
                }else
1284
                    return ret;
1285
            }
1286

    
1287
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1288
                                           &s->packet_buffer_end)) < 0)
1289
                return AVERROR(ENOMEM);
1290
        }else{
1291
            assert(!s->packet_buffer);
1292
            return av_read_frame_internal(s, pkt);
1293
        }
1294
    }
1295
}
1296

    
1297
/* XXX: suppress the packet queue */
1298
static void flush_packet_queue(AVFormatContext *s)
1299
{
1300
    AVPacketList *pktl;
1301

    
1302
    for(;;) {
1303
        pktl = s->packet_buffer;
1304
        if (!pktl)
1305
            break;
1306
        s->packet_buffer = pktl->next;
1307
        av_free_packet(&pktl->pkt);
1308
        av_free(pktl);
1309
    }
1310
    while(s->raw_packet_buffer){
1311
        pktl = s->raw_packet_buffer;
1312
        s->raw_packet_buffer = pktl->next;
1313
        av_free_packet(&pktl->pkt);
1314
        av_free(pktl);
1315
    }
1316
    s->packet_buffer_end=
1317
    s->raw_packet_buffer_end= NULL;
1318
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1319
}
1320

    
1321
/*******************************************************/
1322
/* seek support */
1323

    
1324
int av_find_default_stream_index(AVFormatContext *s)
1325
{
1326
    int first_audio_index = -1;
1327
    int i;
1328
    AVStream *st;
1329

    
1330
    if (s->nb_streams <= 0)
1331
        return -1;
1332
    for(i = 0; i < s->nb_streams; i++) {
1333
        st = s->streams[i];
1334
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1335
            return i;
1336
        }
1337
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1338
            first_audio_index = i;
1339
    }
1340
    return first_audio_index >= 0 ? first_audio_index : 0;
1341
}
1342

    
1343
/**
1344
 * Flush the frame reader.
1345
 */
1346
void ff_read_frame_flush(AVFormatContext *s)
1347
{
1348
    AVStream *st;
1349
    int i, j;
1350

    
1351
    flush_packet_queue(s);
1352

    
1353
    s->cur_st = NULL;
1354

    
1355
    /* for each stream, reset read state */
1356
    for(i = 0; i < s->nb_streams; i++) {
1357
        st = s->streams[i];
1358

    
1359
        if (st->parser) {
1360
            av_parser_close(st->parser);
1361
            st->parser = NULL;
1362
            av_free_packet(&st->cur_pkt);
1363
        }
1364
        st->last_IP_pts = AV_NOPTS_VALUE;
1365
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1366
        st->reference_dts = AV_NOPTS_VALUE;
1367
        /* fail safe */
1368
        st->cur_ptr = NULL;
1369
        st->cur_len = 0;
1370

    
1371
        st->probe_packets = MAX_PROBE_PACKETS;
1372

    
1373
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1374
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1375
    }
1376
}
1377

    
1378
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1379
    int i;
1380

    
1381
    for(i = 0; i < s->nb_streams; i++) {
1382
        AVStream *st = s->streams[i];
1383

    
1384
        st->cur_dts = av_rescale(timestamp,
1385
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1386
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1387
    }
1388
}
1389

    
1390
void ff_reduce_index(AVFormatContext *s, int stream_index)
1391
{
1392
    AVStream *st= s->streams[stream_index];
1393
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1394

    
1395
    if((unsigned)st->nb_index_entries >= max_entries){
1396
        int i;
1397
        for(i=0; 2*i<st->nb_index_entries; i++)
1398
            st->index_entries[i]= st->index_entries[2*i];
1399
        st->nb_index_entries= i;
1400
    }
1401
}
1402

    
1403
int ff_add_index_entry(AVIndexEntry **index_entries,
1404
                       int *nb_index_entries,
1405
                       unsigned int *index_entries_allocated_size,
1406
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1407
{
1408
    AVIndexEntry *entries, *ie;
1409
    int index;
1410

    
1411
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1412
        return -1;
1413

    
1414
    entries = av_fast_realloc(*index_entries,
1415
                              index_entries_allocated_size,
1416
                              (*nb_index_entries + 1) *
1417
                              sizeof(AVIndexEntry));
1418
    if(!entries)
1419
        return -1;
1420

    
1421
    *index_entries= entries;
1422

    
1423
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1424

    
1425
    if(index<0){
1426
        index= (*nb_index_entries)++;
1427
        ie= &entries[index];
1428
        assert(index==0 || ie[-1].timestamp < timestamp);
1429
    }else{
1430
        ie= &entries[index];
1431
        if(ie->timestamp != timestamp){
1432
            if(ie->timestamp <= timestamp)
1433
                return -1;
1434
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1435
            (*nb_index_entries)++;
1436
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1437
            distance= ie->min_distance;
1438
    }
1439

    
1440
    ie->pos = pos;
1441
    ie->timestamp = timestamp;
1442
    ie->min_distance= distance;
1443
    ie->size= size;
1444
    ie->flags = flags;
1445

    
1446
    return index;
1447
}
1448

    
1449
int av_add_index_entry(AVStream *st,
1450
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1451
{
1452
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1453
                              &st->index_entries_allocated_size, pos,
1454
                              timestamp, size, distance, flags);
1455
}
1456

    
1457
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1458
                              int64_t wanted_timestamp, int flags)
1459
{
1460
    int a, b, m;
1461
    int64_t timestamp;
1462

    
1463
    a = - 1;
1464
    b = nb_entries;
1465

    
1466
    //optimize appending index entries at the end
1467
    if(b && entries[b-1].timestamp < wanted_timestamp)
1468
        a= b-1;
1469

    
1470
    while (b - a > 1) {
1471
        m = (a + b) >> 1;
1472
        timestamp = entries[m].timestamp;
1473
        if(timestamp >= wanted_timestamp)
1474
            b = m;
1475
        if(timestamp <= wanted_timestamp)
1476
            a = m;
1477
    }
1478
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1479

    
1480
    if(!(flags & AVSEEK_FLAG_ANY)){
1481
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1482
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1483
        }
1484
    }
1485

    
1486
    if(m == nb_entries)
1487
        return -1;
1488
    return  m;
1489
}
1490

    
1491
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1492
                              int flags)
1493
{
1494
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1495
                                     wanted_timestamp, flags);
1496
}
1497

    
1498
#define DEBUG_SEEK
1499

    
1500
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1501
    AVInputFormat *avif= s->iformat;
1502
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1503
    int64_t ts_min, ts_max, ts;
1504
    int index;
1505
    int64_t ret;
1506
    AVStream *st;
1507

    
1508
    if (stream_index < 0)
1509
        return -1;
1510

    
1511
#ifdef DEBUG_SEEK
1512
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1513
#endif
1514

    
1515
    ts_max=
1516
    ts_min= AV_NOPTS_VALUE;
1517
    pos_limit= -1; //gcc falsely says it may be uninitialized
1518

    
1519
    st= s->streams[stream_index];
1520
    if(st->index_entries){
1521
        AVIndexEntry *e;
1522

    
1523
        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()
1524
        index= FFMAX(index, 0);
1525
        e= &st->index_entries[index];
1526

    
1527
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1528
            pos_min= e->pos;
1529
            ts_min= e->timestamp;
1530
#ifdef DEBUG_SEEK
1531
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1532
                   pos_min,ts_min);
1533
#endif
1534
        }else{
1535
            assert(index==0);
1536
        }
1537

    
1538
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1539
        assert(index < st->nb_index_entries);
1540
        if(index >= 0){
1541
            e= &st->index_entries[index];
1542
            assert(e->timestamp >= target_ts);
1543
            pos_max= e->pos;
1544
            ts_max= e->timestamp;
1545
            pos_limit= pos_max - e->min_distance;
1546
#ifdef DEBUG_SEEK
1547
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1548
                   pos_max,pos_limit, ts_max);
1549
#endif
1550
        }
1551
    }
1552

    
1553
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1554
    if(pos<0)
1555
        return -1;
1556

    
1557
    /* do the seek */
1558
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1559
        return ret;
1560

    
1561
    av_update_cur_dts(s, st, ts);
1562

    
1563
    return 0;
1564
}
1565

    
1566
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 )){
1567
    int64_t pos, ts;
1568
    int64_t start_pos, filesize;
1569
    int no_change;
1570

    
1571
#ifdef DEBUG_SEEK
1572
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1573
#endif
1574

    
1575
    if(ts_min == AV_NOPTS_VALUE){
1576
        pos_min = s->data_offset;
1577
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1578
        if (ts_min == AV_NOPTS_VALUE)
1579
            return -1;
1580
    }
1581

    
1582
    if(ts_max == AV_NOPTS_VALUE){
1583
        int step= 1024;
1584
        filesize = avio_size(s->pb);
1585
        pos_max = filesize - 1;
1586
        do{
1587
            pos_max -= step;
1588
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1589
            step += step;
1590
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1591
        if (ts_max == AV_NOPTS_VALUE)
1592
            return -1;
1593

    
1594
        for(;;){
1595
            int64_t tmp_pos= pos_max + 1;
1596
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1597
            if(tmp_ts == AV_NOPTS_VALUE)
1598
                break;
1599
            ts_max= tmp_ts;
1600
            pos_max= tmp_pos;
1601
            if(tmp_pos >= filesize)
1602
                break;
1603
        }
1604
        pos_limit= pos_max;
1605
    }
1606

    
1607
    if(ts_min > ts_max){
1608
        return -1;
1609
    }else if(ts_min == ts_max){
1610
        pos_limit= pos_min;
1611
    }
1612

    
1613
    no_change=0;
1614
    while (pos_min < pos_limit) {
1615
#ifdef DEBUG_SEEK
1616
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1617
               pos_min, pos_max,
1618
               ts_min, ts_max);
1619
#endif
1620
        assert(pos_limit <= pos_max);
1621

    
1622
        if(no_change==0){
1623
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1624
            // interpolate position (better than dichotomy)
1625
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1626
                + pos_min - approximate_keyframe_distance;
1627
        }else if(no_change==1){
1628
            // bisection, if interpolation failed to change min or max pos last time
1629
            pos = (pos_min + pos_limit)>>1;
1630
        }else{
1631
            /* linear search if bisection failed, can only happen if there
1632
               are very few or no keyframes between min/max */
1633
            pos=pos_min;
1634
        }
1635
        if(pos <= pos_min)
1636
            pos= pos_min + 1;
1637
        else if(pos > pos_limit)
1638
            pos= pos_limit;
1639
        start_pos= pos;
1640

    
1641
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1642
        if(pos == pos_max)
1643
            no_change++;
1644
        else
1645
            no_change=0;
1646
#ifdef DEBUG_SEEK
1647
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1648
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1649
               start_pos, no_change);
1650
#endif
1651
        if(ts == AV_NOPTS_VALUE){
1652
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1653
            return -1;
1654
        }
1655
        assert(ts != AV_NOPTS_VALUE);
1656
        if (target_ts <= ts) {
1657
            pos_limit = start_pos - 1;
1658
            pos_max = pos;
1659
            ts_max = ts;
1660
        }
1661
        if (target_ts >= ts) {
1662
            pos_min = pos;
1663
            ts_min = ts;
1664
        }
1665
    }
1666

    
1667
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1668
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1669
#ifdef DEBUG_SEEK
1670
    pos_min = pos;
1671
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1672
    pos_min++;
1673
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1674
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1675
           pos, ts_min, target_ts, ts_max);
1676
#endif
1677
    *ts_ret= ts;
1678
    return pos;
1679
}
1680

    
1681
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1682
    int64_t pos_min, pos_max;
1683
#if 0
1684
    AVStream *st;
1685

1686
    if (stream_index < 0)
1687
        return -1;
1688

1689
    st= s->streams[stream_index];
1690
#endif
1691

    
1692
    pos_min = s->data_offset;
1693
    pos_max = avio_size(s->pb) - 1;
1694

    
1695
    if     (pos < pos_min) pos= pos_min;
1696
    else if(pos > pos_max) pos= pos_max;
1697

    
1698
    avio_seek(s->pb, pos, SEEK_SET);
1699

    
1700
#if 0
1701
    av_update_cur_dts(s, st, ts);
1702
#endif
1703
    return 0;
1704
}
1705

    
1706
static int av_seek_frame_generic(AVFormatContext *s,
1707
                                 int stream_index, int64_t timestamp, int flags)
1708
{
1709
    int index;
1710
    int64_t ret;
1711
    AVStream *st;
1712
    AVIndexEntry *ie;
1713

    
1714
    st = s->streams[stream_index];
1715

    
1716
    index = av_index_search_timestamp(st, timestamp, flags);
1717

    
1718
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1719
        return -1;
1720

    
1721
    if(index < 0 || index==st->nb_index_entries-1){
1722
        int i;
1723
        AVPacket pkt;
1724

    
1725
        if(st->nb_index_entries){
1726
            assert(st->index_entries);
1727
            ie= &st->index_entries[st->nb_index_entries-1];
1728
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1729
                return ret;
1730
            av_update_cur_dts(s, st, ie->timestamp);
1731
        }else{
1732
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1733
                return ret;
1734
        }
1735
        for(i=0;; i++) {
1736
            int ret;
1737
            do{
1738
                ret = av_read_frame(s, &pkt);
1739
            }while(ret == AVERROR(EAGAIN));
1740
            if(ret<0)
1741
                break;
1742
            av_free_packet(&pkt);
1743
            if(stream_index == pkt.stream_index){
1744
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1745
                    break;
1746
            }
1747
        }
1748
        index = av_index_search_timestamp(st, timestamp, flags);
1749
    }
1750
    if (index < 0)
1751
        return -1;
1752

    
1753
    ff_read_frame_flush(s);
1754
    if (s->iformat->read_seek){
1755
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1756
            return 0;
1757
    }
1758
    ie = &st->index_entries[index];
1759
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1760
        return ret;
1761
    av_update_cur_dts(s, st, ie->timestamp);
1762

    
1763
    return 0;
1764
}
1765

    
1766
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1767
{
1768
    int ret;
1769
    AVStream *st;
1770

    
1771
    ff_read_frame_flush(s);
1772

    
1773
    if(flags & AVSEEK_FLAG_BYTE)
1774
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1775

    
1776
    if(stream_index < 0){
1777
        stream_index= av_find_default_stream_index(s);
1778
        if(stream_index < 0)
1779
            return -1;
1780

    
1781
        st= s->streams[stream_index];
1782
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1783
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1784
    }
1785

    
1786
    /* first, we try the format specific seek */
1787
    if (s->iformat->read_seek)
1788
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1789
    else
1790
        ret = -1;
1791
    if (ret >= 0) {
1792
        return 0;
1793
    }
1794

    
1795
    if(s->iformat->read_timestamp)
1796
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1797
    else
1798
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1799
}
1800

    
1801
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1802
{
1803
    if(min_ts > ts || max_ts < ts)
1804
        return -1;
1805

    
1806
    ff_read_frame_flush(s);
1807

    
1808
    if (s->iformat->read_seek2)
1809
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1810

    
1811
    if(s->iformat->read_timestamp){
1812
        //try to seek via read_timestamp()
1813
    }
1814

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

    
1820
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1821
}
1822

    
1823
/*******************************************************/
1824

    
1825
/**
1826
 * Return TRUE if the stream has accurate duration in any stream.
1827
 *
1828
 * @return TRUE if the stream has accurate duration for at least one component.
1829
 */
1830
static int av_has_duration(AVFormatContext *ic)
1831
{
1832
    int i;
1833
    AVStream *st;
1834

    
1835
    for(i = 0;i < ic->nb_streams; i++) {
1836
        st = ic->streams[i];
1837
        if (st->duration != AV_NOPTS_VALUE)
1838
            return 1;
1839
    }
1840
    return 0;
1841
}
1842

    
1843
/**
1844
 * Estimate the stream timings from the one of each components.
1845
 *
1846
 * Also computes the global bitrate if possible.
1847
 */
1848
static void av_update_stream_timings(AVFormatContext *ic)
1849
{
1850
    int64_t start_time, start_time1, end_time, end_time1;
1851
    int64_t duration, duration1;
1852
    int i;
1853
    AVStream *st;
1854

    
1855
    start_time = INT64_MAX;
1856
    end_time = INT64_MIN;
1857
    duration = INT64_MIN;
1858
    for(i = 0;i < ic->nb_streams; i++) {
1859
        st = ic->streams[i];
1860
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1861
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1862
            if (start_time1 < start_time)
1863
                start_time = start_time1;
1864
            if (st->duration != AV_NOPTS_VALUE) {
1865
                end_time1 = start_time1
1866
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1867
                if (end_time1 > end_time)
1868
                    end_time = end_time1;
1869
            }
1870
        }
1871
        if (st->duration != AV_NOPTS_VALUE) {
1872
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1873
            if (duration1 > duration)
1874
                duration = duration1;
1875
        }
1876
    }
1877
    if (start_time != INT64_MAX) {
1878
        ic->start_time = start_time;
1879
        if (end_time != INT64_MIN) {
1880
            if (end_time - start_time > duration)
1881
                duration = end_time - start_time;
1882
        }
1883
    }
1884
    if (duration != INT64_MIN) {
1885
        ic->duration = duration;
1886
        if (ic->file_size > 0) {
1887
            /* compute the bitrate */
1888
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1889
                (double)ic->duration;
1890
        }
1891
    }
1892
}
1893

    
1894
static void fill_all_stream_timings(AVFormatContext *ic)
1895
{
1896
    int i;
1897
    AVStream *st;
1898

    
1899
    av_update_stream_timings(ic);
1900
    for(i = 0;i < ic->nb_streams; i++) {
1901
        st = ic->streams[i];
1902
        if (st->start_time == AV_NOPTS_VALUE) {
1903
            if(ic->start_time != AV_NOPTS_VALUE)
1904
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1905
            if(ic->duration != AV_NOPTS_VALUE)
1906
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1907
        }
1908
    }
1909
}
1910

    
1911
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1912
{
1913
    int64_t filesize, duration;
1914
    int bit_rate, i;
1915
    AVStream *st;
1916

    
1917
    /* if bit_rate is already set, we believe it */
1918
    if (ic->bit_rate <= 0) {
1919
        bit_rate = 0;
1920
        for(i=0;i<ic->nb_streams;i++) {
1921
            st = ic->streams[i];
1922
            if (st->codec->bit_rate > 0)
1923
            bit_rate += st->codec->bit_rate;
1924
        }
1925
        ic->bit_rate = bit_rate;
1926
    }
1927

    
1928
    /* if duration is already set, we believe it */
1929
    if (ic->duration == AV_NOPTS_VALUE &&
1930
        ic->bit_rate != 0 &&
1931
        ic->file_size != 0)  {
1932
        filesize = ic->file_size;
1933
        if (filesize > 0) {
1934
            for(i = 0; i < ic->nb_streams; i++) {
1935
                st = ic->streams[i];
1936
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1937
                if (st->duration == AV_NOPTS_VALUE)
1938
                    st->duration = duration;
1939
            }
1940
        }
1941
    }
1942
}
1943

    
1944
#define DURATION_MAX_READ_SIZE 250000
1945
#define DURATION_MAX_RETRY 3
1946

    
1947
/* only usable for MPEG-PS streams */
1948
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1949
{
1950
    AVPacket pkt1, *pkt = &pkt1;
1951
    AVStream *st;
1952
    int read_size, i, ret;
1953
    int64_t end_time;
1954
    int64_t filesize, offset, duration;
1955
    int retry=0;
1956

    
1957
    ic->cur_st = NULL;
1958

    
1959
    /* flush packet queue */
1960
    flush_packet_queue(ic);
1961

    
1962
    for (i=0; i<ic->nb_streams; i++) {
1963
        st = ic->streams[i];
1964
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1965
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1966

    
1967
        if (st->parser) {
1968
            av_parser_close(st->parser);
1969
            st->parser= NULL;
1970
            av_free_packet(&st->cur_pkt);
1971
        }
1972
    }
1973

    
1974
    /* estimate the end time (duration) */
1975
    /* XXX: may need to support wrapping */
1976
    filesize = ic->file_size;
1977
    end_time = AV_NOPTS_VALUE;
1978
    do{
1979
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1980
    if (offset < 0)
1981
        offset = 0;
1982

    
1983
    avio_seek(ic->pb, offset, SEEK_SET);
1984
    read_size = 0;
1985
    for(;;) {
1986
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1987
            break;
1988

    
1989
        do{
1990
            ret = av_read_packet(ic, pkt);
1991
        }while(ret == AVERROR(EAGAIN));
1992
        if (ret != 0)
1993
            break;
1994
        read_size += pkt->size;
1995
        st = ic->streams[pkt->stream_index];
1996
        if (pkt->pts != AV_NOPTS_VALUE &&
1997
            (st->start_time != AV_NOPTS_VALUE ||
1998
             st->first_dts  != AV_NOPTS_VALUE)) {
1999
            duration = end_time = pkt->pts;
2000
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
2001
            else                                   duration -= st->first_dts;
2002
            if (duration < 0)
2003
                duration += 1LL<<st->pts_wrap_bits;
2004
            if (duration > 0) {
2005
                if (st->duration == AV_NOPTS_VALUE ||
2006
                    st->duration < duration)
2007
                    st->duration = duration;
2008
            }
2009
        }
2010
        av_free_packet(pkt);
2011
    }
2012
    }while(   end_time==AV_NOPTS_VALUE
2013
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
2014
           && ++retry <= DURATION_MAX_RETRY);
2015

    
2016
    fill_all_stream_timings(ic);
2017

    
2018
    avio_seek(ic->pb, old_offset, SEEK_SET);
2019
    for (i=0; i<ic->nb_streams; i++) {
2020
        st= ic->streams[i];
2021
        st->cur_dts= st->first_dts;
2022
        st->last_IP_pts = AV_NOPTS_VALUE;
2023
        st->reference_dts = AV_NOPTS_VALUE;
2024
    }
2025
}
2026

    
2027
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2028
{
2029
    int64_t file_size;
2030

    
2031
    /* get the file size, if possible */
2032
    if (ic->iformat->flags & AVFMT_NOFILE) {
2033
        file_size = 0;
2034
    } else {
2035
        file_size = avio_size(ic->pb);
2036
        if (file_size < 0)
2037
            file_size = 0;
2038
    }
2039
    ic->file_size = file_size;
2040

    
2041
    if ((!strcmp(ic->iformat->name, "mpeg") ||
2042
         !strcmp(ic->iformat->name, "mpegts")) &&
2043
        file_size && ic->pb->seekable) {
2044
        /* get accurate estimate from the PTSes */
2045
        av_estimate_timings_from_pts(ic, old_offset);
2046
    } else if (av_has_duration(ic)) {
2047
        /* at least one component has timings - we use them for all
2048
           the components */
2049
        fill_all_stream_timings(ic);
2050
    } else {
2051
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2052
        /* less precise: use bitrate info */
2053
        av_estimate_timings_from_bit_rate(ic);
2054
    }
2055
    av_update_stream_timings(ic);
2056

    
2057
#if 0
2058
    {
2059
        int i;
2060
        AVStream *st;
2061
        for(i = 0;i < ic->nb_streams; i++) {
2062
            st = ic->streams[i];
2063
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2064
               i, (double)st->start_time / AV_TIME_BASE,
2065
               (double)st->duration / AV_TIME_BASE);
2066
        }
2067
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2068
               (double)ic->start_time / AV_TIME_BASE,
2069
               (double)ic->duration / AV_TIME_BASE,
2070
               ic->bit_rate / 1000);
2071
    }
2072
#endif
2073
}
2074

    
2075
static int has_codec_parameters(AVCodecContext *enc)
2076
{
2077
    int val;
2078
    switch(enc->codec_type) {
2079
    case AVMEDIA_TYPE_AUDIO:
2080
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2081
        if(!enc->frame_size &&
2082
           (enc->codec_id == CODEC_ID_VORBIS ||
2083
            enc->codec_id == CODEC_ID_AAC ||
2084
            enc->codec_id == CODEC_ID_MP1 ||
2085
            enc->codec_id == CODEC_ID_MP2 ||
2086
            enc->codec_id == CODEC_ID_MP3 ||
2087
            enc->codec_id == CODEC_ID_SPEEX))
2088
            return 0;
2089
        break;
2090
    case AVMEDIA_TYPE_VIDEO:
2091
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2092
        break;
2093
    default:
2094
        val = 1;
2095
        break;
2096
    }
2097
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2098
}
2099

    
2100
static int has_decode_delay_been_guessed(AVStream *st)
2101
{
2102
    return st->codec->codec_id != CODEC_ID_H264 ||
2103
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2104
}
2105

    
2106
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2107
{
2108
    int16_t *samples;
2109
    AVCodec *codec;
2110
    int got_picture, data_size, ret=0;
2111
    AVFrame picture;
2112

    
2113
    if(!st->codec->codec){
2114
        codec = avcodec_find_decoder(st->codec->codec_id);
2115
        if (!codec)
2116
            return -1;
2117
        ret = avcodec_open(st->codec, codec);
2118
        if (ret < 0)
2119
            return ret;
2120
    }
2121

    
2122
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2123
        switch(st->codec->codec_type) {
2124
        case AVMEDIA_TYPE_VIDEO:
2125
            avcodec_get_frame_defaults(&picture);
2126
            ret = avcodec_decode_video2(st->codec, &picture,
2127
                                        &got_picture, avpkt);
2128
            break;
2129
        case AVMEDIA_TYPE_AUDIO:
2130
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2131
            samples = av_malloc(data_size);
2132
            if (!samples)
2133
                goto fail;
2134
            ret = avcodec_decode_audio3(st->codec, samples,
2135
                                        &data_size, avpkt);
2136
            av_free(samples);
2137
            break;
2138
        default:
2139
            break;
2140
        }
2141
    }
2142
 fail:
2143
    return ret;
2144
}
2145

    
2146
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2147
{
2148
    while (tags->id != CODEC_ID_NONE) {
2149
        if (tags->id == id)
2150
            return tags->tag;
2151
        tags++;
2152
    }
2153
    return 0;
2154
}
2155

    
2156
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2157
{
2158
    int i;
2159
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2160
        if(tag == tags[i].tag)
2161
            return tags[i].id;
2162
    }
2163
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2164
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2165
            return tags[i].id;
2166
    }
2167
    return CODEC_ID_NONE;
2168
}
2169

    
2170
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2171
{
2172
    int i;
2173
    for(i=0; tags && tags[i]; i++){
2174
        int tag= ff_codec_get_tag(tags[i], id);
2175
        if(tag) return tag;
2176
    }
2177
    return 0;
2178
}
2179

    
2180
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2181
{
2182
    int i;
2183
    for(i=0; tags && tags[i]; i++){
2184
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2185
        if(id!=CODEC_ID_NONE) return id;
2186
    }
2187
    return CODEC_ID_NONE;
2188
}
2189

    
2190
static void compute_chapters_end(AVFormatContext *s)
2191
{
2192
    unsigned int i, j;
2193
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2194

    
2195
    for (i = 0; i < s->nb_chapters; i++)
2196
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2197
            AVChapter *ch = s->chapters[i];
2198
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2199
                                     : INT64_MAX;
2200

    
2201
            for (j = 0; j < s->nb_chapters; j++) {
2202
                AVChapter *ch1 = s->chapters[j];
2203
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2204
                if (j != i && next_start > ch->start && next_start < end)
2205
                    end = next_start;
2206
            }
2207
            ch->end = (end == INT64_MAX) ? ch->start : end;
2208
        }
2209
}
2210

    
2211
static int get_std_framerate(int i){
2212
    if(i<60*12) return i*1001;
2213
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2214
}
2215

    
2216
/*
2217
 * Is the time base unreliable.
2218
 * This is a heuristic to balance between quick acceptance of the values in
2219
 * the headers vs. some extra checks.
2220
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2221
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2222
 * And there are "variable" fps files this needs to detect as well.
2223
 */
2224
static int tb_unreliable(AVCodecContext *c){
2225
    if(   c->time_base.den >= 101L*c->time_base.num
2226
       || c->time_base.den <    5L*c->time_base.num
2227
/*       || c->codec_tag == AV_RL32("DIVX")
2228
       || c->codec_tag == AV_RL32("XVID")*/
2229
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2230
       || c->codec_id == CODEC_ID_H264
2231
       )
2232
        return 1;
2233
    return 0;
2234
}
2235

    
2236
int av_find_stream_info(AVFormatContext *ic)
2237
{
2238
    int i, count, ret, read_size, j;
2239
    AVStream *st;
2240
    AVPacket pkt1, *pkt;
2241
    int64_t old_offset = avio_tell(ic->pb);
2242

    
2243
    for(i=0;i<ic->nb_streams;i++) {
2244
        AVCodec *codec;
2245
        st = ic->streams[i];
2246
        if (st->codec->codec_id == CODEC_ID_AAC) {
2247
            st->codec->sample_rate = 0;
2248
            st->codec->frame_size = 0;
2249
            st->codec->channels = 0;
2250
        }
2251
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2252
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2253
/*            if(!st->time_base.num)
2254
                st->time_base= */
2255
            if(!st->codec->time_base.num)
2256
                st->codec->time_base= st->time_base;
2257
        }
2258
        //only for the split stuff
2259
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2260
            st->parser = av_parser_init(st->codec->codec_id);
2261
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2262
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2263
            }
2264
        }
2265
        assert(!st->codec->codec);
2266
        codec = avcodec_find_decoder(st->codec->codec_id);
2267

    
2268
        /* Force decoding of at least one frame of codec data
2269
         * this makes sure the codec initializes the channel configuration
2270
         * and does not trust the values from the container.
2271
         */
2272
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2273
            st->codec->channels = 0;
2274

    
2275
        /* Ensure that subtitle_header is properly set. */
2276
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2277
            && codec && !st->codec->codec)
2278
            avcodec_open(st->codec, codec);
2279

    
2280
        //try to just open decoders, in case this is enough to get parameters
2281
        if(!has_codec_parameters(st->codec)){
2282
            if (codec && !st->codec->codec)
2283
                avcodec_open(st->codec, codec);
2284
        }
2285
    }
2286

    
2287
    for (i=0; i<ic->nb_streams; i++) {
2288
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2289
    }
2290

    
2291
    count = 0;
2292
    read_size = 0;
2293
    for(;;) {
2294
        if(url_interrupt_cb()){
2295
            ret= AVERROR_EXIT;
2296
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2297
            break;
2298
        }
2299

    
2300
        /* check if one codec still needs to be handled */
2301
        for(i=0;i<ic->nb_streams;i++) {
2302
            int fps_analyze_framecount = 20;
2303

    
2304
            st = ic->streams[i];
2305
            if (!has_codec_parameters(st->codec))
2306
                break;
2307
            /* if the timebase is coarse (like the usual millisecond precision
2308
               of mkv), we need to analyze more frames to reliably arrive at
2309
               the correct fps */
2310
            if (av_q2d(st->time_base) > 0.0005)
2311
                fps_analyze_framecount *= 2;
2312
            /* variable fps and no guess at the real fps */
2313
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2314
               && st->info->duration_count < fps_analyze_framecount
2315
               && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2316
                break;
2317
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2318
                break;
2319
            if(st->first_dts == AV_NOPTS_VALUE)
2320
                break;
2321
        }
2322
        if (i == ic->nb_streams) {
2323
            /* NOTE: if the format has no header, then we need to read
2324
               some packets to get most of the streams, so we cannot
2325
               stop here */
2326
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2327
                /* if we found the info for all the codecs, we can stop */
2328
                ret = count;
2329
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2330
                break;
2331
            }
2332
        }
2333
        /* we did not get all the codec info, but we read too much data */
2334
        if (read_size >= ic->probesize) {
2335
            ret = count;
2336
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2337
            break;
2338
        }
2339

    
2340
        /* NOTE: a new stream can be added there if no header in file
2341
           (AVFMTCTX_NOHEADER) */
2342
        ret = av_read_frame_internal(ic, &pkt1);
2343
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2344
            /* EOF or error */
2345
            ret = -1; /* we could not have all the codec parameters before EOF */
2346
            for(i=0;i<ic->nb_streams;i++) {
2347
                st = ic->streams[i];
2348
                if (!has_codec_parameters(st->codec)){
2349
                    char buf[256];
2350
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2351
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2352
                } else {
2353
                    ret = 0;
2354
                }
2355
            }
2356
            break;
2357
        }
2358

    
2359
        if (ret == AVERROR(EAGAIN))
2360
            continue;
2361

    
2362
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2363
        if ((ret = av_dup_packet(pkt)) < 0)
2364
            goto find_stream_info_err;
2365

    
2366
        read_size += pkt->size;
2367

    
2368
        st = ic->streams[pkt->stream_index];
2369
        if (st->codec_info_nb_frames>1) {
2370
            if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2371
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2372
                break;
2373
            }
2374
            st->info->codec_info_duration += pkt->duration;
2375
        }
2376
        {
2377
            int64_t last = st->info->last_dts;
2378
            int64_t duration= pkt->dts - last;
2379

    
2380
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2381
                double dur= duration * av_q2d(st->time_base);
2382

    
2383
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2384
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2385
                if (st->info->duration_count < 2)
2386
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2387
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2388
                    int framerate= get_std_framerate(i);
2389
                    int ticks= lrintf(dur*framerate/(1001*12));
2390
                    double error= dur - ticks*1001*12/(double)framerate;
2391
                    st->info->duration_error[i] += error*error;
2392
                }
2393
                st->info->duration_count++;
2394
                // ignore the first 4 values, they might have some random jitter
2395
                if (st->info->duration_count > 3)
2396
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2397
            }
2398
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2399
                st->info->last_dts = pkt->dts;
2400
        }
2401
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2402
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2403
            if(i){
2404
                st->codec->extradata_size= i;
2405
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2406
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2407
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2408
            }
2409
        }
2410

    
2411
        /* if still no information, we try to open the codec and to
2412
           decompress the frame. We try to avoid that in most cases as
2413
           it takes longer and uses more memory. For MPEG-4, we need to
2414
           decompress for QuickTime. */
2415
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2416
            try_decode_frame(st, pkt);
2417

    
2418
        st->codec_info_nb_frames++;
2419
        count++;
2420
    }
2421

    
2422
    // close codecs which were opened in try_decode_frame()
2423
    for(i=0;i<ic->nb_streams;i++) {
2424
        st = ic->streams[i];
2425
        if(st->codec->codec)
2426
            avcodec_close(st->codec);
2427
    }
2428
    for(i=0;i<ic->nb_streams;i++) {
2429
        st = ic->streams[i];
2430
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2431
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2432
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2433
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2434
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2435
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2436
                uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2437
                if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2438
                    st->codec->codec_tag= tag;
2439
            }
2440

    
2441
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2442
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2443
            // ipmovie.c produces.
2444
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2445
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2446
            if (st->info->duration_count && !st->r_frame_rate.num
2447
               && tb_unreliable(st->codec) /*&&
2448
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2449
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2450
                int num = 0;
2451
                double best_error= 2*av_q2d(st->time_base);
2452
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2453

    
2454
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2455
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2456
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2457
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2458
                    if(error < best_error){
2459
                        best_error= error;
2460
                        num = get_std_framerate(j);
2461
                    }
2462
                }
2463
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2464
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2465
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2466
            }
2467

    
2468
            if (!st->r_frame_rate.num){
2469
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2470
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2471
                    st->r_frame_rate.num = st->codec->time_base.den;
2472
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2473
                }else{
2474
                    st->r_frame_rate.num = st->time_base.den;
2475
                    st->r_frame_rate.den = st->time_base.num;
2476
                }
2477
            }
2478
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2479
            if(!st->codec->bits_per_coded_sample)
2480
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2481
            // set stream disposition based on audio service type
2482
            switch (st->codec->audio_service_type) {
2483
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2484
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2485
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2486
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2487
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2488
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2489
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2490
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2491
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2492
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2493
            }
2494
        }
2495
    }
2496

    
2497
    av_estimate_timings(ic, old_offset);
2498

    
2499
    compute_chapters_end(ic);
2500

    
2501
#if 0
2502
    /* correct DTS for B-frame streams with no timestamps */
2503
    for(i=0;i<ic->nb_streams;i++) {
2504
        st = ic->streams[i];
2505
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2506
            if(b-frames){
2507
                ppktl = &ic->packet_buffer;
2508
                while(ppkt1){
2509
                    if(ppkt1->stream_index != i)
2510
                        continue;
2511
                    if(ppkt1->pkt->dts < 0)
2512
                        break;
2513
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2514
                        break;
2515
                    ppkt1->pkt->dts -= delta;
2516
                    ppkt1= ppkt1->next;
2517
                }
2518
                if(ppkt1)
2519
                    continue;
2520
                st->cur_dts -= delta;
2521
            }
2522
        }
2523
    }
2524
#endif
2525

    
2526
 find_stream_info_err:
2527
    for (i=0; i < ic->nb_streams; i++)
2528
        av_freep(&ic->streams[i]->info);
2529
    return ret;
2530
}
2531

    
2532
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2533
{
2534
    int i, j;
2535

    
2536
    for (i = 0; i < ic->nb_programs; i++)
2537
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2538
            if (ic->programs[i]->stream_index[j] == s)
2539
                return ic->programs[i];
2540
    return NULL;
2541
}
2542

    
2543
int av_find_best_stream(AVFormatContext *ic,
2544
                        enum AVMediaType type,
2545
                        int wanted_stream_nb,
2546
                        int related_stream,
2547
                        AVCodec **decoder_ret,
2548
                        int flags)
2549
{
2550
    int i, nb_streams = ic->nb_streams;
2551
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2552
    unsigned *program = NULL;
2553
    AVCodec *decoder = NULL, *best_decoder = NULL;
2554

    
2555
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2556
        AVProgram *p = find_program_from_stream(ic, related_stream);
2557
        if (p) {
2558
            program = p->stream_index;
2559
            nb_streams = p->nb_stream_indexes;
2560
        }
2561
    }
2562
    for (i = 0; i < nb_streams; i++) {
2563
        int real_stream_index = program ? program[i] : i;
2564
        AVStream *st = ic->streams[real_stream_index];
2565
        AVCodecContext *avctx = st->codec;
2566
        if (avctx->codec_type != type)
2567
            continue;
2568
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2569
            continue;
2570
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2571
            continue;
2572
        if (decoder_ret) {
2573
            decoder = avcodec_find_decoder(st->codec->codec_id);
2574
            if (!decoder) {
2575
                if (ret < 0)
2576
                    ret = AVERROR_DECODER_NOT_FOUND;
2577
                continue;
2578
            }
2579
        }
2580
        if (best_count >= st->codec_info_nb_frames)
2581
            continue;
2582
        best_count = st->codec_info_nb_frames;
2583
        ret = real_stream_index;
2584
        best_decoder = decoder;
2585
        if (program && i == nb_streams - 1 && ret < 0) {
2586
            program = NULL;
2587
            nb_streams = ic->nb_streams;
2588
            i = 0; /* no related stream found, try again with everything */
2589
        }
2590
    }
2591
    if (decoder_ret)
2592
        *decoder_ret = best_decoder;
2593
    return ret;
2594
}
2595

    
2596
/*******************************************************/
2597

    
2598
int av_read_play(AVFormatContext *s)
2599
{
2600
    if (s->iformat->read_play)
2601
        return s->iformat->read_play(s);
2602
    if (s->pb)
2603
        return avio_pause(s->pb, 0);
2604
    return AVERROR(ENOSYS);
2605
}
2606

    
2607
int av_read_pause(AVFormatContext *s)
2608
{
2609
    if (s->iformat->read_pause)
2610
        return s->iformat->read_pause(s);
2611
    if (s->pb)
2612
        return avio_pause(s->pb, 1);
2613
    return AVERROR(ENOSYS);
2614
}
2615

    
2616
void av_close_input_stream(AVFormatContext *s)
2617
{
2618
    flush_packet_queue(s);
2619
    if (s->iformat->read_close)
2620
        s->iformat->read_close(s);
2621
    avformat_free_context(s);
2622
}
2623

    
2624
void avformat_free_context(AVFormatContext *s)
2625
{
2626
    int i;
2627
    AVStream *st;
2628

    
2629
    for(i=0;i<s->nb_streams;i++) {
2630
        /* free all data in a stream component */
2631
        st = s->streams[i];
2632
        if (st->parser) {
2633
            av_parser_close(st->parser);
2634
            av_free_packet(&st->cur_pkt);
2635
        }
2636
        av_metadata_free(&st->metadata);
2637
        av_free(st->index_entries);
2638
        av_free(st->codec->extradata);
2639
        av_free(st->codec->subtitle_header);
2640
        av_free(st->codec);
2641
#if FF_API_OLD_METADATA
2642
        av_free(st->filename);
2643
#endif
2644
        av_free(st->priv_data);
2645
        av_free(st->info);
2646
        av_free(st);
2647
    }
2648
    for(i=s->nb_programs-1; i>=0; i--) {
2649
#if FF_API_OLD_METADATA
2650
        av_freep(&s->programs[i]->provider_name);
2651
        av_freep(&s->programs[i]->name);
2652
#endif
2653
        av_metadata_free(&s->programs[i]->metadata);
2654
        av_freep(&s->programs[i]->stream_index);
2655
        av_freep(&s->programs[i]);
2656
    }
2657
    av_freep(&s->programs);
2658
    av_freep(&s->priv_data);
2659
    while(s->nb_chapters--) {
2660
#if FF_API_OLD_METADATA
2661
        av_free(s->chapters[s->nb_chapters]->title);
2662
#endif
2663
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2664
        av_free(s->chapters[s->nb_chapters]);
2665
    }
2666
    av_freep(&s->chapters);
2667
    av_metadata_free(&s->metadata);
2668
    av_freep(&s->key);
2669
    av_free(s);
2670
}
2671

    
2672
void av_close_input_file(AVFormatContext *s)
2673
{
2674
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2675
    av_close_input_stream(s);
2676
    if (pb)
2677
        avio_close(pb);
2678
}
2679

    
2680
AVStream *av_new_stream(AVFormatContext *s, int id)
2681
{
2682
    AVStream *st;
2683
    int i;
2684

    
2685
#if FF_API_MAX_STREAMS
2686
    if (s->nb_streams >= MAX_STREAMS){
2687
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2688
        return NULL;
2689
    }
2690
#else
2691
    AVStream **streams;
2692

    
2693
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2694
        return NULL;
2695
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2696
    if (!streams)
2697
        return NULL;
2698
    s->streams = streams;
2699
#endif
2700

    
2701
    st = av_mallocz(sizeof(AVStream));
2702
    if (!st)
2703
        return NULL;
2704
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2705
        av_free(st);
2706
        return NULL;
2707
    }
2708

    
2709
    st->codec= avcodec_alloc_context();
2710
    if (s->iformat) {
2711
        /* no default bitrate if decoding */
2712
        st->codec->bit_rate = 0;
2713
    }
2714
    st->index = s->nb_streams;
2715
    st->id = id;
2716
    st->start_time = AV_NOPTS_VALUE;
2717
    st->duration = AV_NOPTS_VALUE;
2718
        /* we set the current DTS to 0 so that formats without any timestamps
2719
           but durations get some timestamps, formats with some unknown
2720
           timestamps have their first few packets buffered and the
2721
           timestamps corrected before they are returned to the user */
2722
    st->cur_dts = 0;
2723
    st->first_dts = AV_NOPTS_VALUE;
2724
    st->probe_packets = MAX_PROBE_PACKETS;
2725

    
2726
    /* default pts setting is MPEG-like */
2727
    av_set_pts_info(st, 33, 1, 90000);
2728
    st->last_IP_pts = AV_NOPTS_VALUE;
2729
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2730
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2731
    st->reference_dts = AV_NOPTS_VALUE;
2732

    
2733
    st->sample_aspect_ratio = (AVRational){0,1};
2734

    
2735
    s->streams[s->nb_streams++] = st;
2736
    return st;
2737
}
2738

    
2739
AVProgram *av_new_program(AVFormatContext *ac, int id)
2740
{
2741
    AVProgram *program=NULL;
2742
    int i;
2743

    
2744
#ifdef DEBUG_SI
2745
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2746
#endif
2747

    
2748
    for(i=0; i<ac->nb_programs; i++)
2749
        if(ac->programs[i]->id == id)
2750
            program = ac->programs[i];
2751

    
2752
    if(!program){
2753
        program = av_mallocz(sizeof(AVProgram));
2754
        if (!program)
2755
            return NULL;
2756
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2757
        program->discard = AVDISCARD_NONE;
2758
    }
2759
    program->id = id;
2760

    
2761
    return program;
2762
}
2763

    
2764
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2765
{
2766
    AVChapter *chapter = NULL;
2767
    int i;
2768

    
2769
    for(i=0; i<s->nb_chapters; i++)
2770
        if(s->chapters[i]->id == id)
2771
            chapter = s->chapters[i];
2772

    
2773
    if(!chapter){
2774
        chapter= av_mallocz(sizeof(AVChapter));
2775
        if(!chapter)
2776
            return NULL;
2777
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2778
    }
2779
#if FF_API_OLD_METADATA
2780
    av_free(chapter->title);
2781
#endif
2782
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2783
    chapter->id    = id;
2784
    chapter->time_base= time_base;
2785
    chapter->start = start;
2786
    chapter->end   = end;
2787

    
2788
    return chapter;
2789
}
2790

    
2791
/************************************************************/
2792
/* output media file */
2793

    
2794
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2795
{
2796
    int ret;
2797

    
2798
    if (s->oformat->priv_data_size > 0) {
2799
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2800
        if (!s->priv_data)
2801
            return AVERROR(ENOMEM);
2802
        if (s->oformat->priv_class) {
2803
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2804
            av_opt_set_defaults(s->priv_data);
2805
        }
2806
    } else
2807
        s->priv_data = NULL;
2808

    
2809
    if (s->oformat->set_parameters) {
2810
        ret = s->oformat->set_parameters(s, ap);
2811
        if (ret < 0)
2812
            return ret;
2813
    }
2814
    return 0;
2815
}
2816

    
2817
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2818
{
2819
    const AVCodecTag *avctag;
2820
    int n;
2821
    enum CodecID id = CODEC_ID_NONE;
2822
    unsigned int tag = 0;
2823

    
2824
    /**
2825
     * Check that tag + id is in the table
2826
     * If neither is in the table -> OK
2827
     * If tag is in the table with another id -> FAIL
2828
     * If id is in the table with another tag -> FAIL unless strict < normal
2829
     */
2830
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2831
        avctag = s->oformat->codec_tag[n];
2832
        while (avctag->id != CODEC_ID_NONE) {
2833
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2834
                id = avctag->id;
2835
                if (id == st->codec->codec_id)
2836
                    return 1;
2837
            }
2838
            if (avctag->id == st->codec->codec_id)
2839
                tag = avctag->tag;
2840
            avctag++;
2841
        }
2842
    }
2843
    if (id != CODEC_ID_NONE)
2844
        return 0;
2845
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2846
        return 0;
2847
    return 1;
2848
}
2849

    
2850
int av_write_header(AVFormatContext *s)
2851
{
2852
    int ret, i;
2853
    AVStream *st;
2854

    
2855
    // some sanity checks
2856
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2857
        av_log(s, AV_LOG_ERROR, "no streams\n");
2858
        return AVERROR(EINVAL);
2859
    }
2860

    
2861
    for(i=0;i<s->nb_streams;i++) {
2862
        st = s->streams[i];
2863

    
2864
        switch (st->codec->codec_type) {
2865
        case AVMEDIA_TYPE_AUDIO:
2866
            if(st->codec->sample_rate<=0){
2867
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2868
                return AVERROR(EINVAL);
2869
            }
2870
            if(!st->codec->block_align)
2871
                st->codec->block_align = st->codec->channels *
2872
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2873
            break;
2874
        case AVMEDIA_TYPE_VIDEO:
2875
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2876
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2877
                return AVERROR(EINVAL);
2878
            }
2879
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2880
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2881
                return AVERROR(EINVAL);
2882
            }
2883
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2884
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2885
                return AVERROR(EINVAL);
2886
            }
2887
            break;
2888
        }
2889

    
2890
        if(s->oformat->codec_tag){
2891
            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)){
2892
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2893
                st->codec->codec_tag= 0;
2894
            }
2895
            if(st->codec->codec_tag){
2896
                if (!validate_codec_tag(s, st)) {
2897
                    char tagbuf[32];
2898
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2899
                    av_log(s, AV_LOG_ERROR,
2900
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2901
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2902
                    return AVERROR_INVALIDDATA;
2903
                }
2904
            }else
2905
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2906
        }
2907

    
2908
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2909
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2910
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2911
    }
2912

    
2913
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2914
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2915
        if (!s->priv_data)
2916
            return AVERROR(ENOMEM);
2917
    }
2918

    
2919
#if FF_API_OLD_METADATA
2920
    ff_metadata_mux_compat(s);
2921
#endif
2922

    
2923
    /* set muxer identification string */
2924
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2925
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2926
    }
2927

    
2928
    if(s->oformat->write_header){
2929
        ret = s->oformat->write_header(s);
2930
        if (ret < 0)
2931
            return ret;
2932
    }
2933

    
2934
    /* init PTS generation */
2935
    for(i=0;i<s->nb_streams;i++) {
2936
        int64_t den = AV_NOPTS_VALUE;
2937
        st = s->streams[i];
2938

    
2939
        switch (st->codec->codec_type) {
2940
        case AVMEDIA_TYPE_AUDIO:
2941
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2942
            break;
2943
        case AVMEDIA_TYPE_VIDEO:
2944
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2945
            break;
2946
        default:
2947
            break;
2948
        }
2949
        if (den != AV_NOPTS_VALUE) {
2950
            if (den <= 0)
2951
                return AVERROR_INVALIDDATA;
2952
            av_frac_init(&st->pts, 0, 0, den);
2953
        }
2954
    }
2955
    return 0;
2956
}
2957

    
2958
//FIXME merge with compute_pkt_fields
2959
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2960
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2961
    int num, den, frame_size, i;
2962

    
2963
    av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2964
            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2965

    
2966
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2967
        return AVERROR(EINVAL);*/
2968

    
2969
    /* duration field */
2970
    if (pkt->duration == 0) {
2971
        compute_frame_duration(&num, &den, st, NULL, pkt);
2972
        if (den && num) {
2973
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2974
        }
2975
    }
2976

    
2977
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2978
        pkt->pts= pkt->dts;
2979

    
2980
    //XXX/FIXME this is a temporary hack until all encoders output pts
2981
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2982
        pkt->dts=
2983
//        pkt->pts= st->cur_dts;
2984
        pkt->pts= st->pts.val;
2985
    }
2986

    
2987
    //calculate dts from pts
2988
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2989
        st->pts_buffer[0]= pkt->pts;
2990
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2991
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2992
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2993
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2994

    
2995
        pkt->dts= st->pts_buffer[0];
2996
    }
2997

    
2998
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2999
        av_log(s, AV_LOG_ERROR,
3000
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3001
               st->index, st->cur_dts, pkt->dts);
3002
        return AVERROR(EINVAL);
3003
    }
3004
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3005
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3006
        return AVERROR(EINVAL);
3007
    }
3008

    
3009
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3010
    st->cur_dts= pkt->dts;
3011
    st->pts.val= pkt->dts;
3012

    
3013
    /* update pts */
3014
    switch (st->codec->codec_type) {
3015
    case AVMEDIA_TYPE_AUDIO:
3016
        frame_size = get_audio_frame_size(st->codec, pkt->size);
3017

    
3018
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
3019
           likely equal to the encoder delay, but it would be better if we
3020
           had the real timestamps from the encoder */
3021
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3022
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3023
        }
3024
        break;
3025
    case AVMEDIA_TYPE_VIDEO:
3026
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3027
        break;
3028
    default:
3029
        break;
3030
    }
3031
    return 0;
3032
}
3033

    
3034
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3035
{
3036
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3037

    
3038
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3039
        return ret;
3040

    
3041
    ret= s->oformat->write_packet(s, pkt);
3042
    if(!ret)
3043
        ret= url_ferror(s->pb);
3044
    return ret;
3045
}
3046

    
3047
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3048
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3049
{
3050
    AVPacketList **next_point, *this_pktl;
3051

    
3052
    this_pktl = av_mallocz(sizeof(AVPacketList));
3053
    this_pktl->pkt= *pkt;
3054
    pkt->destruct= NULL;             // do not free original but only the copy
3055
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3056

    
3057
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3058
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3059
    }else
3060
        next_point = &s->packet_buffer;
3061

    
3062
    if(*next_point){
3063
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3064
            while(!compare(s, &(*next_point)->pkt, pkt)){
3065
                next_point= &(*next_point)->next;
3066
            }
3067
            goto next_non_null;
3068
        }else{
3069
            next_point = &(s->packet_buffer_end->next);
3070
        }
3071
    }
3072
    assert(!*next_point);
3073

    
3074
    s->packet_buffer_end= this_pktl;
3075
next_non_null:
3076

    
3077
    this_pktl->next= *next_point;
3078

    
3079
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3080
    *next_point= this_pktl;
3081
}
3082

    
3083
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3084
{
3085
    AVStream *st = s->streams[ pkt ->stream_index];
3086
    AVStream *st2= s->streams[ next->stream_index];
3087
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3088
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3089
    int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
3090
    if (dts1==next->dts && dts1==av_rescale_rnd(pkt->dts, b, a, AV_ROUND_UP))
3091
        return pkt->stream_index < next->stream_index;
3092
    return dts1 < next->dts;
3093
}
3094

    
3095
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3096
    AVPacketList *pktl;
3097
    int stream_count=0;
3098
    int i;
3099

    
3100
    if(pkt){
3101
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3102
    }
3103

    
3104
    for(i=0; i < s->nb_streams; i++)
3105
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3106

    
3107
    if(stream_count && (s->nb_streams == stream_count || flush)){
3108
        pktl= s->packet_buffer;
3109
        *out= pktl->pkt;
3110

    
3111
        s->packet_buffer= pktl->next;
3112
        if(!s->packet_buffer)
3113
            s->packet_buffer_end= NULL;
3114

    
3115
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3116
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3117
        av_freep(&pktl);
3118
        return 1;
3119
    }else{
3120
        av_init_packet(out);
3121
        return 0;
3122
    }
3123
}
3124

    
3125
/**
3126
 * Interleave an AVPacket correctly so it can be muxed.
3127
 * @param out the interleaved packet will be output here
3128
 * @param in the input packet
3129
 * @param flush 1 if no further packets are available as input and all
3130
 *              remaining packets should be output
3131
 * @return 1 if a packet was output, 0 if no packet could be output,
3132
 *         < 0 if an error occurred
3133
 */
3134
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3135
    if(s->oformat->interleave_packet)
3136
        return s->oformat->interleave_packet(s, out, in, flush);
3137
    else
3138
        return av_interleave_packet_per_dts(s, out, in, flush);
3139
}
3140

    
3141
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3142
    AVStream *st= s->streams[ pkt->stream_index];
3143
    int ret;
3144

    
3145
    //FIXME/XXX/HACK drop zero sized packets
3146
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3147
        return 0;
3148

    
3149
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3150
            pkt->size, pkt->dts, pkt->pts);
3151
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3152
        return ret;
3153

    
3154
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3155
        return AVERROR(EINVAL);
3156

    
3157
    for(;;){
3158
        AVPacket opkt;
3159
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3160
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3161
            return ret;
3162

    
3163
        ret= s->oformat->write_packet(s, &opkt);
3164

    
3165
        av_free_packet(&opkt);
3166
        pkt= NULL;
3167

    
3168
        if(ret<0)
3169
            return ret;
3170
        if(url_ferror(s->pb))
3171
            return url_ferror(s->pb);
3172
    }
3173
}
3174

    
3175
int av_write_trailer(AVFormatContext *s)
3176
{
3177
    int ret, i;
3178

    
3179
    for(;;){
3180
        AVPacket pkt;
3181
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3182
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3183
            goto fail;
3184
        if(!ret)
3185
            break;
3186

    
3187
        ret= s->oformat->write_packet(s, &pkt);
3188

    
3189
        av_free_packet(&pkt);
3190

    
3191
        if(ret<0)
3192
            goto fail;
3193
        if(url_ferror(s->pb))
3194
            goto fail;
3195
    }
3196

    
3197
    if(s->oformat->write_trailer)
3198
        ret = s->oformat->write_trailer(s);
3199
fail:
3200
    if(ret == 0)
3201
       ret=url_ferror(s->pb);
3202
    for(i=0;i<s->nb_streams;i++) {
3203
        av_freep(&s->streams[i]->priv_data);
3204
        av_freep(&s->streams[i]->index_entries);
3205
    }
3206
    av_freep(&s->priv_data);
3207
    return ret;
3208
}
3209

    
3210
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3211
{
3212
    int i, j;
3213
    AVProgram *program=NULL;
3214
    void *tmp;
3215

    
3216
    if (idx >= ac->nb_streams) {
3217
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3218
        return;
3219
    }
3220

    
3221
    for(i=0; i<ac->nb_programs; i++){
3222
        if(ac->programs[i]->id != progid)
3223
            continue;
3224
        program = ac->programs[i];
3225
        for(j=0; j<program->nb_stream_indexes; j++)
3226
            if(program->stream_index[j] == idx)
3227
                return;
3228

    
3229
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3230
        if(!tmp)
3231
            return;
3232
        program->stream_index = tmp;
3233
        program->stream_index[program->nb_stream_indexes++] = idx;
3234
        return;
3235
    }
3236
}
3237

    
3238
static void print_fps(double d, const char *postfix){
3239
    uint64_t v= lrintf(d*100);
3240
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3241
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3242
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3243
}
3244

    
3245
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3246
{
3247
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3248
        AVMetadataTag *tag=NULL;
3249

    
3250
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3251
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3252
            if(strcmp("language", tag->key))
3253
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3254
        }
3255
    }
3256
}
3257

    
3258
/* "user interface" functions */
3259
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3260
{
3261
    char buf[256];
3262
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3263
    AVStream *st = ic->streams[i];
3264
    int g = av_gcd(st->time_base.num, st->time_base.den);
3265
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3266
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3267
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3268
    /* the pid is an important information, so we display it */
3269
    /* XXX: add a generic system */
3270
    if (flags & AVFMT_SHOW_IDS)
3271
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3272
    if (lang)
3273
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3274
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3275
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3276
    if (st->sample_aspect_ratio.num && // default
3277
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3278
        AVRational display_aspect_ratio;
3279
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3280
                  st->codec->width*st->sample_aspect_ratio.num,
3281
                  st->codec->height*st->sample_aspect_ratio.den,
3282
                  1024*1024);
3283
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3284
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3285
                 display_aspect_ratio.num, display_aspect_ratio.den);
3286
    }
3287
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3288
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3289
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3290
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3291
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3292
        if(st->time_base.den && st->time_base.num)
3293
            print_fps(1/av_q2d(st->time_base), "tbn");
3294
        if(st->codec->time_base.den && st->codec->time_base.num)
3295
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3296
    }
3297
    if (st->disposition & AV_DISPOSITION_DEFAULT)
3298
        av_log(NULL, AV_LOG_INFO, " (default)");
3299
    if (st->disposition & AV_DISPOSITION_DUB)
3300
        av_log(NULL, AV_LOG_INFO, " (dub)");
3301
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
3302
        av_log(NULL, AV_LOG_INFO, " (original)");
3303
    if (st->disposition & AV_DISPOSITION_COMMENT)
3304
        av_log(NULL, AV_LOG_INFO, " (comment)");
3305
    if (st->disposition & AV_DISPOSITION_LYRICS)
3306
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
3307
    if (st->disposition & AV_DISPOSITION_KARAOKE)
3308
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
3309
    if (st->disposition & AV_DISPOSITION_FORCED)
3310
        av_log(NULL, AV_LOG_INFO, " (forced)");
3311
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3312
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3313
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3314
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3315
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3316
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3317
    av_log(NULL, AV_LOG_INFO, "\n");
3318
    dump_metadata(NULL, st->metadata, "    ");
3319
}
3320

    
3321
#if FF_API_DUMP_FORMAT
3322
void dump_format(AVFormatContext *ic,
3323
                 int index,
3324
                 const char *url,
3325
                 int is_output)
3326
{
3327
    av_dump_format(ic, index, url, is_output);
3328
}
3329
#endif
3330

    
3331
void av_dump_format(AVFormatContext *ic,
3332
                    int index,
3333
                    const char *url,
3334
                    int is_output)
3335
{
3336
    int i;
3337
    uint8_t *printed = av_mallocz(ic->nb_streams);
3338
    if (ic->nb_streams && !printed)
3339
        return;
3340

    
3341
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3342
            is_output ? "Output" : "Input",
3343
            index,
3344
            is_output ? ic->oformat->name : ic->iformat->name,
3345
            is_output ? "to" : "from", url);
3346
    dump_metadata(NULL, ic->metadata, "  ");
3347
    if (!is_output) {
3348
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3349
        if (ic->duration != AV_NOPTS_VALUE) {
3350
            int hours, mins, secs, us;
3351
            secs = ic->duration / AV_TIME_BASE;
3352
            us = ic->duration % AV_TIME_BASE;
3353
            mins = secs / 60;
3354
            secs %= 60;
3355
            hours = mins / 60;
3356
            mins %= 60;
3357
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3358
                   (100 * us) / AV_TIME_BASE);
3359
        } else {
3360
            av_log(NULL, AV_LOG_INFO, "N/A");
3361
        }
3362
        if (ic->start_time != AV_NOPTS_VALUE) {
3363
            int secs, us;
3364
            av_log(NULL, AV_LOG_INFO, ", start: ");
3365
            secs = ic->start_time / AV_TIME_BASE;
3366
            us = abs(ic->start_time % AV_TIME_BASE);
3367
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3368
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3369
        }
3370
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3371
        if (ic->bit_rate) {
3372
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3373
        } else {
3374
            av_log(NULL, AV_LOG_INFO, "N/A");
3375
        }
3376
        av_log(NULL, AV_LOG_INFO, "\n");
3377
    }
3378
    for (i = 0; i < ic->nb_chapters; i++) {
3379
        AVChapter *ch = ic->chapters[i];
3380
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3381
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3382
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3383

    
3384
        dump_metadata(NULL, ch->metadata, "    ");
3385
    }
3386
    if(ic->nb_programs) {
3387
        int j, k, total = 0;
3388
        for(j=0; j<ic->nb_programs; j++) {
3389
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3390
                                                  "name", NULL, 0);
3391
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3392
                   name ? name->value : "");
3393
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3394
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3395
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3396
                printed[ic->programs[j]->stream_index[k]] = 1;
3397
            }
3398
            total += ic->programs[j]->nb_stream_indexes;
3399
        }
3400
        if (total < ic->nb_streams)
3401
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3402
    }
3403
    for(i=0;i<ic->nb_streams;i++)
3404
        if (!printed[i])
3405
            dump_stream_format(ic, i, index, is_output);
3406

    
3407
    av_free(printed);
3408
}
3409

    
3410
#if FF_API_PARSE_FRAME_PARAM
3411
#include "libavutil/parseutils.h"
3412

    
3413
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3414
{
3415
    return av_parse_video_size(width_ptr, height_ptr, str);
3416
}
3417

    
3418
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3419
{
3420
    AVRational frame_rate;
3421
    int ret = av_parse_video_rate(&frame_rate, arg);
3422
    *frame_rate_num= frame_rate.num;
3423
    *frame_rate_den= frame_rate.den;
3424
    return ret;
3425
}
3426
#endif
3427

    
3428
int64_t av_gettime(void)
3429
{
3430
    struct timeval tv;
3431
    gettimeofday(&tv,NULL);
3432
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3433
}
3434

    
3435
uint64_t ff_ntp_time(void)
3436
{
3437
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3438
}
3439

    
3440
#if FF_API_PARSE_DATE
3441
#include "libavutil/parseutils.h"
3442

    
3443
int64_t parse_date(const char *timestr, int duration)
3444
{
3445
    int64_t timeval;
3446
    av_parse_time(&timeval, timestr, duration);
3447
    return timeval;
3448
}
3449
#endif
3450

    
3451
#if FF_API_FIND_INFO_TAG
3452
#include "libavutil/parseutils.h"
3453

    
3454
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3455
{
3456
    return av_find_info_tag(arg, arg_size, tag1, info);
3457
}
3458
#endif
3459

    
3460
int av_get_frame_filename(char *buf, int buf_size,
3461
                          const char *path, int number)
3462
{
3463
    const char *p;
3464
    char *q, buf1[20], c;
3465
    int nd, len, percentd_found;
3466

    
3467
    q = buf;
3468
    p = path;
3469
    percentd_found = 0;
3470
    for(;;) {
3471
        c = *p++;
3472
        if (c == '\0')
3473
            break;
3474
        if (c == '%') {
3475
            do {
3476
                nd = 0;
3477
                while (isdigit(*p)) {
3478
                    nd = nd * 10 + *p++ - '0';
3479
                }
3480
                c = *p++;
3481
            } while (isdigit(c));
3482

    
3483
            switch(c) {
3484
            case '%':
3485
                goto addchar;
3486
            case 'd':
3487
                if (percentd_found)
3488
                    goto fail;
3489
                percentd_found = 1;
3490
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3491
                len = strlen(buf1);
3492
                if ((q - buf + len) > buf_size - 1)
3493
                    goto fail;
3494
                memcpy(q, buf1, len);
3495
                q += len;
3496
                break;
3497
            default:
3498
                goto fail;
3499
            }
3500
        } else {
3501
        addchar:
3502
            if ((q - buf) < buf_size - 1)
3503
                *q++ = c;
3504
        }
3505
    }
3506
    if (!percentd_found)
3507
        goto fail;
3508
    *q = '\0';
3509
    return 0;
3510
 fail:
3511
    *q = '\0';
3512
    return -1;
3513
}
3514

    
3515
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3516
{
3517
    int len, i, j, c;
3518
#undef fprintf
3519
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3520

    
3521
    for(i=0;i<size;i+=16) {
3522
        len = size - i;
3523
        if (len > 16)
3524
            len = 16;
3525
        PRINT("%08x ", i);
3526
        for(j=0;j<16;j++) {
3527
            if (j < len)
3528
                PRINT(" %02x", buf[i+j]);
3529
            else
3530
                PRINT("   ");
3531
        }
3532
        PRINT(" ");
3533
        for(j=0;j<len;j++) {
3534
            c = buf[i+j];
3535
            if (c < ' ' || c > '~')
3536
                c = '.';
3537
            PRINT("%c", c);
3538
        }
3539
        PRINT("\n");
3540
    }
3541
#undef PRINT
3542
}
3543

    
3544
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3545
{
3546
    hex_dump_internal(NULL, f, 0, buf, size);
3547
}
3548

    
3549
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3550
{
3551
    hex_dump_internal(avcl, NULL, level, buf, size);
3552
}
3553

    
3554
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3555
{
3556
#undef fprintf
3557
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3558
    PRINT("stream #%d:\n", pkt->stream_index);
3559
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3560
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3561
    /* DTS is _always_ valid after av_read_frame() */
3562
    PRINT("  dts=");
3563
    if (pkt->dts == AV_NOPTS_VALUE)
3564
        PRINT("N/A");
3565
    else
3566
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3567
    /* PTS may not be known if B-frames are present. */
3568
    PRINT("  pts=");
3569
    if (pkt->pts == AV_NOPTS_VALUE)
3570
        PRINT("N/A");
3571
    else
3572
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3573
    PRINT("\n");
3574
    PRINT("  size=%d\n", pkt->size);
3575
#undef PRINT
3576
    if (dump_payload)
3577
        av_hex_dump(f, pkt->data, pkt->size);
3578
}
3579

    
3580
#if FF_API_PKT_DUMP
3581
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3582
{
3583
    AVRational tb = { 1, AV_TIME_BASE };
3584
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3585
}
3586
#endif
3587

    
3588
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3589
{
3590
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3591
}
3592

    
3593
#if FF_API_PKT_DUMP
3594
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3595
{
3596
    AVRational tb = { 1, AV_TIME_BASE };
3597
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3598
}
3599
#endif
3600

    
3601
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3602
                      AVStream *st)
3603
{
3604
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3605
}
3606

    
3607
#if FF_API_URL_SPLIT
3608
attribute_deprecated
3609
void ff_url_split(char *proto, int proto_size,
3610
                  char *authorization, int authorization_size,
3611
                  char *hostname, int hostname_size,
3612
                  int *port_ptr,
3613
                  char *path, int path_size,
3614
                  const char *url)
3615
{
3616
    av_url_split(proto, proto_size,
3617
                 authorization, authorization_size,
3618
                 hostname, hostname_size,
3619
                 port_ptr,
3620
                 path, path_size,
3621
                 url);
3622
}
3623
#endif
3624

    
3625
void av_url_split(char *proto, int proto_size,
3626
                  char *authorization, int authorization_size,
3627
                  char *hostname, int hostname_size,
3628
                  int *port_ptr,
3629
                  char *path, int path_size,
3630
                  const char *url)
3631
{
3632
    const char *p, *ls, *at, *col, *brk;
3633

    
3634
    if (port_ptr)               *port_ptr = -1;
3635
    if (proto_size > 0)         proto[0] = 0;
3636
    if (authorization_size > 0) authorization[0] = 0;
3637
    if (hostname_size > 0)      hostname[0] = 0;
3638
    if (path_size > 0)          path[0] = 0;
3639

    
3640
    /* parse protocol */
3641
    if ((p = strchr(url, ':'))) {
3642
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3643
        p++; /* skip ':' */
3644
        if (*p == '/') p++;
3645
        if (*p == '/') p++;
3646
    } else {
3647
        /* no protocol means plain filename */
3648
        av_strlcpy(path, url, path_size);
3649
        return;
3650
    }
3651

    
3652
    /* separate path from hostname */
3653
    ls = strchr(p, '/');
3654
    if(!ls)
3655
        ls = strchr(p, '?');
3656
    if(ls)
3657
        av_strlcpy(path, ls, path_size);
3658
    else
3659
        ls = &p[strlen(p)]; // XXX
3660

    
3661
    /* the rest is hostname, use that to parse auth/port */
3662
    if (ls != p) {
3663
        /* authorization (user[:pass]@hostname) */
3664
        if ((at = strchr(p, '@')) && at < ls) {
3665
            av_strlcpy(authorization, p,
3666
                       FFMIN(authorization_size, at + 1 - p));
3667
            p = at + 1; /* skip '@' */
3668
        }
3669

    
3670
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3671
            /* [host]:port */
3672
            av_strlcpy(hostname, p + 1,
3673
                       FFMIN(hostname_size, brk - p));
3674
            if (brk[1] == ':' && port_ptr)
3675
                *port_ptr = atoi(brk + 2);
3676
        } else if ((col = strchr(p, ':')) && col < ls) {
3677
            av_strlcpy(hostname, p,
3678
                       FFMIN(col + 1 - p, hostname_size));
3679
            if (port_ptr) *port_ptr = atoi(col + 1);
3680
        } else
3681
            av_strlcpy(hostname, p,
3682
                       FFMIN(ls + 1 - p, hostname_size));
3683
    }
3684
}
3685

    
3686
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3687
{
3688
    int i;
3689
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3690
                                           '4', '5', '6', '7',
3691
                                           '8', '9', 'A', 'B',
3692
                                           'C', 'D', 'E', 'F' };
3693
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3694
                                           '4', '5', '6', '7',
3695
                                           '8', '9', 'a', 'b',
3696
                                           'c', 'd', 'e', 'f' };
3697
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3698

    
3699
    for(i = 0; i < s; i++) {
3700
        buff[i * 2]     = hex_table[src[i] >> 4];
3701
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3702
    }
3703

    
3704
    return buff;
3705
}
3706

    
3707
int ff_hex_to_data(uint8_t *data, const char *p)
3708
{
3709
    int c, len, v;
3710

    
3711
    len = 0;
3712
    v = 1;
3713
    for (;;) {
3714
        p += strspn(p, SPACE_CHARS);
3715
        if (*p == '\0')
3716
            break;
3717
        c = toupper((unsigned char) *p++);
3718
        if (c >= '0' && c <= '9')
3719
            c = c - '0';
3720
        else if (c >= 'A' && c <= 'F')
3721
            c = c - 'A' + 10;
3722
        else
3723
            break;
3724
        v = (v << 4) | c;
3725
        if (v & 0x100) {
3726
            if (data)
3727
                data[len] = v;
3728
            len++;
3729
            v = 1;
3730
        }
3731
    }
3732
    return len;
3733
}
3734

    
3735
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3736
                     unsigned int pts_num, unsigned int pts_den)
3737
{
3738
    AVRational new_tb;
3739
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3740
        if(new_tb.num != pts_num)
3741
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3742
    }else
3743
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3744

    
3745
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3746
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3747
        return;
3748
    }
3749
    s->time_base = new_tb;
3750
    s->pts_wrap_bits = pts_wrap_bits;
3751
}
3752

    
3753
int ff_url_join(char *str, int size, const char *proto,
3754
                const char *authorization, const char *hostname,
3755
                int port, const char *fmt, ...)
3756
{
3757
#if CONFIG_NETWORK
3758
    struct addrinfo hints, *ai;
3759
#endif
3760

    
3761
    str[0] = '\0';
3762
    if (proto)
3763
        av_strlcatf(str, size, "%s://", proto);
3764
    if (authorization && authorization[0])
3765
        av_strlcatf(str, size, "%s@", authorization);
3766
#if CONFIG_NETWORK && defined(AF_INET6)
3767
    /* Determine if hostname is a numerical IPv6 address,
3768
     * properly escape it within [] in that case. */
3769
    memset(&hints, 0, sizeof(hints));
3770
    hints.ai_flags = AI_NUMERICHOST;
3771
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3772
        if (ai->ai_family == AF_INET6) {
3773
            av_strlcat(str, "[", size);
3774
            av_strlcat(str, hostname, size);
3775
            av_strlcat(str, "]", size);
3776
        } else {
3777
            av_strlcat(str, hostname, size);
3778
        }
3779
        freeaddrinfo(ai);
3780
    } else
3781
#endif
3782
        /* Not an IPv6 address, just output the plain string. */
3783
        av_strlcat(str, hostname, size);
3784

    
3785
    if (port >= 0)
3786
        av_strlcatf(str, size, ":%d", port);
3787
    if (fmt) {
3788
        va_list vl;
3789
        int len = strlen(str);
3790

    
3791
        va_start(vl, fmt);
3792
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3793
        va_end(vl);
3794
    }
3795
    return strlen(str);
3796
}
3797

    
3798
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3799
                     AVFormatContext *src)
3800
{
3801
    AVPacket local_pkt;
3802

    
3803
    local_pkt = *pkt;
3804
    local_pkt.stream_index = dst_stream;
3805
    if (pkt->pts != AV_NOPTS_VALUE)
3806
        local_pkt.pts = av_rescale_q(pkt->pts,
3807
                                     src->streams[pkt->stream_index]->time_base,
3808
                                     dst->streams[dst_stream]->time_base);
3809
    if (pkt->dts != AV_NOPTS_VALUE)
3810
        local_pkt.dts = av_rescale_q(pkt->dts,
3811
                                     src->streams[pkt->stream_index]->time_base,
3812
                                     dst->streams[dst_stream]->time_base);
3813
    return av_write_frame(dst, &local_pkt);
3814
}
3815

    
3816
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3817
                        void *context)
3818
{
3819
    const char *ptr = str;
3820

    
3821
    /* Parse key=value pairs. */
3822
    for (;;) {
3823
        const char *key;
3824
        char *dest = NULL, *dest_end;
3825
        int key_len, dest_len = 0;
3826

    
3827
        /* Skip whitespace and potential commas. */
3828
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3829
            ptr++;
3830
        if (!*ptr)
3831
            break;
3832

    
3833
        key = ptr;
3834

    
3835
        if (!(ptr = strchr(key, '=')))
3836
            break;
3837
        ptr++;
3838
        key_len = ptr - key;
3839

    
3840
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3841
        dest_end = dest + dest_len - 1;
3842

    
3843
        if (*ptr == '\"') {
3844
            ptr++;
3845
            while (*ptr && *ptr != '\"') {
3846
                if (*ptr == '\\') {
3847
                    if (!ptr[1])
3848
                        break;
3849
                    if (dest && dest < dest_end)
3850
                        *dest++ = ptr[1];
3851
                    ptr += 2;
3852
                } else {
3853
                    if (dest && dest < dest_end)
3854
                        *dest++ = *ptr;
3855
                    ptr++;
3856
                }
3857
            }
3858
            if (*ptr == '\"')
3859
                ptr++;
3860
        } else {
3861
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3862
                if (dest && dest < dest_end)
3863
                    *dest++ = *ptr;
3864
        }
3865
        if (dest)
3866
            *dest = 0;
3867
    }
3868
}
3869

    
3870
int ff_find_stream_index(AVFormatContext *s, int id)
3871
{
3872
    int i;
3873
    for (i = 0; i < s->nb_streams; i++) {
3874
        if (s->streams[i]->id == id)
3875
            return i;
3876
    }
3877
    return -1;
3878
}
3879

    
3880
void ff_make_absolute_url(char *buf, int size, const char *base,
3881
                          const char *rel)
3882
{
3883
    char *sep;
3884
    /* Absolute path, relative to the current server */
3885
    if (base && strstr(base, "://") && rel[0] == '/') {
3886
        if (base != buf)
3887
            av_strlcpy(buf, base, size);
3888
        sep = strstr(buf, "://");
3889
        if (sep) {
3890
            sep += 3;
3891
            sep = strchr(sep, '/');
3892
            if (sep)
3893
                *sep = '\0';
3894
        }
3895
        av_strlcat(buf, rel, size);
3896
        return;
3897
    }
3898
    /* If rel actually is an absolute url, just copy it */
3899
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3900
        av_strlcpy(buf, rel, size);
3901
        return;
3902
    }
3903
    if (base != buf)
3904
        av_strlcpy(buf, base, size);
3905
    /* Remove the file name from the base url */
3906
    sep = strrchr(buf, '/');
3907
    if (sep)
3908
        sep[1] = '\0';
3909
    else
3910
        buf[0] = '\0';
3911
    while (av_strstart(rel, "../", NULL) && sep) {
3912
        /* Remove the path delimiter at the end */
3913
        sep[0] = '\0';
3914
        sep = strrchr(buf, '/');
3915
        /* If the next directory name to pop off is "..", break here */
3916
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3917
            /* Readd the slash we just removed */
3918
            av_strlcat(buf, "/", size);
3919
            break;
3920
        }
3921
        /* Cut off the directory name */
3922
        if (sep)
3923
            sep[1] = '\0';
3924
        else
3925
            buf[0] = '\0';
3926
        rel += 3;
3927
    }
3928
    av_strlcat(buf, rel, size);
3929
}