Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 15957b19

History | View | Annotate | Download (124 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 "libavutil/opt.h"
29
#include "metadata.h"
30
#include "id3v2.h"
31
#include "libavutil/avstring.h"
32
#include "riff.h"
33
#include "audiointerleave.h"
34
#include <sys/time.h>
35
#include <time.h>
36
#include <strings.h>
37
#include <stdarg.h>
38
#if CONFIG_NETWORK
39
#include "network.h"
40
#endif
41

    
42
#undef NDEBUG
43
#include <assert.h>
44

    
45
/**
46
 * @file
47
 * various utility functions for use within FFmpeg
48
 */
49

    
50
unsigned avformat_version(void)
51
{
52
    return LIBAVFORMAT_VERSION_INT;
53
}
54

    
55
const char *avformat_configuration(void)
56
{
57
    return FFMPEG_CONFIGURATION;
58
}
59

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

    
66
/* fraction handling */
67

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

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

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

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

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

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

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

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

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

    
162
    if(!filename)
163
        return 0;
164

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

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

    
189
    if (!name || !names)
190
        return 0;
191

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

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

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

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

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

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

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

    
258
        if (stream_fmt)
259
            fmt = stream_fmt;
260
    }
261

    
262
    return fmt;
263
}
264
#endif
265

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

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

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

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

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

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

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

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

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

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

    
334
    if(ret<0)
335
        return ret;
336

    
337
    pkt->pos= avio_tell(s);
338

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

    
345
    return ret;
346
}
347

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

    
363

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

    
370
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
371
{
372
    AVProbeData lpd = *pd;
373
    AVInputFormat *fmt1 = NULL, *fmt;
374
    int score;
375

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

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

    
405
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
406
    int score=0;
407
    return av_probe_input_format2(pd, is_opened, &score);
408
}
409

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

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

    
442
/************************************************************/
443
/* input media file */
444

    
445
/**
446
 * Open a media file from an IO stream. 'fmt' must be specified.
447
 */
448
int av_open_input_stream(AVFormatContext **ic_ptr,
449
                         AVIOContext *pb, const char *filename,
450
                         AVInputFormat *fmt, AVFormatParameters *ap)
451
{
452
    int err;
453
    AVFormatContext *ic;
454
    AVFormatParameters default_ap;
455

    
456
    if(!ap){
457
        ap=&default_ap;
458
        memset(ap, 0, sizeof(default_ap));
459
    }
460

    
461
    if(!ap->prealloced_context)
462
        ic = avformat_alloc_context();
463
    else
464
        ic = *ic_ptr;
465
    if (!ic) {
466
        err = AVERROR(ENOMEM);
467
        goto fail;
468
    }
469
    ic->iformat = fmt;
470
    ic->pb = pb;
471
    ic->duration = AV_NOPTS_VALUE;
472
    ic->start_time = AV_NOPTS_VALUE;
473
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
474

    
475
    /* allocate private data */
476
    if (fmt->priv_data_size > 0) {
477
        ic->priv_data = av_mallocz(fmt->priv_data_size);
478
        if (!ic->priv_data) {
479
            err = AVERROR(ENOMEM);
480
            goto fail;
481
        }
482
    } else {
483
        ic->priv_data = NULL;
484
    }
485

    
486
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
487
    if (ic->pb)
488
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
489

    
490
    if (ic->iformat->read_header) {
491
        err = ic->iformat->read_header(ic, ap);
492
        if (err < 0)
493
            goto fail;
494
    }
495

    
496
    if (pb && !ic->data_offset)
497
        ic->data_offset = avio_tell(ic->pb);
498

    
499
#if FF_API_OLD_METADATA
500
    ff_metadata_demux_compat(ic);
501
#endif
502

    
503
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
504

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

    
527
/** size of probe buffer, for guessing file type from file contents */
528
#define PROBE_BUF_MIN 2048
529
#define PROBE_BUF_MAX (1<<20)
530

    
531
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
532
                          const char *filename, void *logctx,
533
                          unsigned int offset, unsigned int max_probe_size)
534
{
535
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
536
    unsigned char *buf = NULL;
537
    int ret = 0, probe_size;
538

    
539
    if (!max_probe_size) {
540
        max_probe_size = PROBE_BUF_MAX;
541
    } else if (max_probe_size > PROBE_BUF_MAX) {
542
        max_probe_size = PROBE_BUF_MAX;
543
    } else if (max_probe_size < PROBE_BUF_MIN) {
544
        return AVERROR(EINVAL);
545
    }
546

    
547
    if (offset >= max_probe_size) {
548
        return AVERROR(EINVAL);
549
    }
550

    
551
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
552
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
553
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
554
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
555

    
556
        if (probe_size < offset) {
557
            continue;
558
        }
559

    
560
        /* read probe data */
561
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
562
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
563
            /* fail if error was not end of file, otherwise, lower score */
564
            if (ret != AVERROR_EOF) {
565
                av_free(buf);
566
                return ret;
567
            }
568
            score = 0;
569
            ret = 0;            /* error was end of file, nothing read */
570
        }
571
        pd.buf_size += ret;
572
        pd.buf = &buf[offset];
573

    
574
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
575

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

    
586
    if (!*fmt) {
587
        av_free(buf);
588
        return AVERROR_INVALIDDATA;
589
    }
590

    
591
    /* rewind. reuse probe buffer to avoid seeking */
592
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
593
        av_free(buf);
594

    
595
    return ret;
596
}
597

    
598
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
599
                       AVInputFormat *fmt,
600
                       int buf_size,
601
                       AVFormatParameters *ap)
602
{
603
    int err;
604
    AVProbeData probe_data, *pd = &probe_data;
605
    AVIOContext *pb = NULL;
606
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
607

    
608
    pd->filename = "";
609
    if (filename)
610
        pd->filename = filename;
611
    pd->buf = NULL;
612
    pd->buf_size = 0;
613

    
614
    if (!fmt) {
615
        /* guess format if no file can be opened */
616
        fmt = av_probe_input_format(pd, 0);
617
    }
618

    
619
    /* Do not open file if the format does not need it. XXX: specific
620
       hack needed to handle RTSP/TCP */
621
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
622
        /* if no file needed do not try to open one */
623
        if ((err=avio_open(&pb, filename, URL_RDONLY)) < 0) {
624
            goto fail;
625
        }
626
        if (buf_size > 0) {
627
            ffio_set_buf_size(pb, buf_size);
628
        }
629
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
630
            goto fail;
631
        }
632
    }
633

    
634
    /* if still no format found, error */
635
    if (!fmt) {
636
        err = AVERROR_INVALIDDATA;
637
        goto fail;
638
    }
639

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

    
660
}
661

    
662
/*******************************************************/
663

    
664
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
665
                               AVPacketList **plast_pktl){
666
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
667
    if (!pktl)
668
        return NULL;
669

    
670
    if (*packet_buffer)
671
        (*plast_pktl)->next = pktl;
672
    else
673
        *packet_buffer = pktl;
674

    
675
    /* add the packet in the buffered packet list */
676
    *plast_pktl = pktl;
677
    pktl->pkt= *pkt;
678
    return &pktl->pkt;
679
}
680

    
681
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
682
{
683
    int ret, i;
684
    AVStream *st;
685

    
686
    for(;;){
687
        AVPacketList *pktl = s->raw_packet_buffer;
688

    
689
        if (pktl) {
690
            *pkt = pktl->pkt;
691
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
692
               !s->streams[pkt->stream_index]->probe_packets){
693
                s->raw_packet_buffer = pktl->next;
694
                s->raw_packet_buffer_remaining_size += pkt->size;
695
                av_free(pktl);
696
                return 0;
697
            }
698
        }
699

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

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

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

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

    
730
        if(st->codec->codec_id == CODEC_ID_PROBE && st->probe_packets){
731
            AVProbeData *pd = &st->probe_data;
732
            int end;
733
            av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
734
            --st->probe_packets;
735

    
736
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
737
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
738
            pd->buf_size += pkt->size;
739
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
740

    
741
            end=    s->raw_packet_buffer_remaining_size <= 0
742
                 || st->probe_packets<=0;
743

    
744
            if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
745
                set_codec_from_probe_data(s, st, pd, end ? 0 : AVPROBE_SCORE_MAX/4);
746
                if(st->codec->codec_id != CODEC_ID_PROBE || end){
747
                    pd->buf_size=0;
748
                    av_freep(&pd->buf);
749
                    st->probe_packets= 0;
750
                    if(st->codec->codec_id != CODEC_ID_PROBE){
751
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
752
                    }else
753
                        av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
754
                }
755
            }
756
        }
757
    }
758
}
759

    
760
/**********************************************************/
761

    
762
/**
763
 * Get the number of samples of an audio frame. Return -1 on error.
764
 */
765
static int get_audio_frame_size(AVCodecContext *enc, int size)
766
{
767
    int frame_size;
768

    
769
    if(enc->codec_id == CODEC_ID_VORBIS)
770
        return -1;
771

    
772
    if (enc->frame_size <= 1) {
773
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
774

    
775
        if (bits_per_sample) {
776
            if (enc->channels == 0)
777
                return -1;
778
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
779
        } else {
780
            /* used for example by ADPCM codecs */
781
            if (enc->bit_rate == 0)
782
                return -1;
783
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
784
        }
785
    } else {
786
        frame_size = enc->frame_size;
787
    }
788
    return frame_size;
789
}
790

    
791

    
792
/**
793
 * Return the frame duration in seconds. Return 0 if not available.
794
 */
795
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
796
                                   AVCodecParserContext *pc, AVPacket *pkt)
797
{
798
    int frame_size;
799

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

    
832
static int is_intra_only(AVCodecContext *enc){
833
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
834
        return 1;
835
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
836
        switch(enc->codec_id){
837
        case CODEC_ID_MJPEG:
838
        case CODEC_ID_MJPEGB:
839
        case CODEC_ID_LJPEG:
840
        case CODEC_ID_RAWVIDEO:
841
        case CODEC_ID_DVVIDEO:
842
        case CODEC_ID_HUFFYUV:
843
        case CODEC_ID_FFVHUFF:
844
        case CODEC_ID_ASV1:
845
        case CODEC_ID_ASV2:
846
        case CODEC_ID_VCR1:
847
        case CODEC_ID_DNXHD:
848
        case CODEC_ID_JPEG2000:
849
            return 1;
850
        default: break;
851
        }
852
    }
853
    return 0;
854
}
855

    
856
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
857
                                      int64_t dts, int64_t pts)
858
{
859
    AVStream *st= s->streams[stream_index];
860
    AVPacketList *pktl= s->packet_buffer;
861

    
862
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
863
        return;
864

    
865
    st->first_dts= dts - st->cur_dts;
866
    st->cur_dts= dts;
867

    
868
    for(; pktl; pktl= pktl->next){
869
        if(pktl->pkt.stream_index != stream_index)
870
            continue;
871
        //FIXME think more about this check
872
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
873
            pktl->pkt.pts += st->first_dts;
874

    
875
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
876
            pktl->pkt.dts += st->first_dts;
877

    
878
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
879
            st->start_time= pktl->pkt.pts;
880
    }
881
    if (st->start_time == AV_NOPTS_VALUE)
882
        st->start_time = pts;
883
}
884

    
885
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
886
{
887
    AVPacketList *pktl= s->packet_buffer;
888
    int64_t cur_dts= 0;
889

    
890
    if(st->first_dts != AV_NOPTS_VALUE){
891
        cur_dts= st->first_dts;
892
        for(; pktl; pktl= pktl->next){
893
            if(pktl->pkt.stream_index == pkt->stream_index){
894
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
895
                    break;
896
                cur_dts -= pkt->duration;
897
            }
898
        }
899
        pktl= s->packet_buffer;
900
        st->first_dts = cur_dts;
901
    }else if(st->cur_dts)
902
        return;
903

    
904
    for(; pktl; pktl= pktl->next){
905
        if(pktl->pkt.stream_index != pkt->stream_index)
906
            continue;
907
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
908
           && !pktl->pkt.duration){
909
            pktl->pkt.dts= cur_dts;
910
            if(!st->codec->has_b_frames)
911
                pktl->pkt.pts= cur_dts;
912
            cur_dts += pkt->duration;
913
            pktl->pkt.duration= pkt->duration;
914
        }else
915
            break;
916
    }
917
    if(st->first_dts == AV_NOPTS_VALUE)
918
        st->cur_dts= cur_dts;
919
}
920

    
921
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
922
                               AVCodecParserContext *pc, AVPacket *pkt)
923
{
924
    int num, den, presentation_delayed, delay, i;
925
    int64_t offset;
926

    
927
    if (s->flags & AVFMT_FLAG_NOFILLIN)
928
        return;
929

    
930
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
931
        pkt->dts= AV_NOPTS_VALUE;
932

    
933
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
934
        //FIXME Set low_delay = 0 when has_b_frames = 1
935
        st->codec->has_b_frames = 1;
936

    
937
    /* do we have a video B-frame ? */
938
    delay= st->codec->has_b_frames;
939
    presentation_delayed = 0;
940

    
941
    // ignore delay caused by frame threading so that the mpeg2-without-dts
942
    // warning will not trigger
943
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
944
        delay -= st->codec->thread_count-1;
945

    
946
    /* XXX: need has_b_frame, but cannot get it if the codec is
947
        not initialized */
948
    if (delay &&
949
        pc && pc->pict_type != FF_B_TYPE)
950
        presentation_delayed = 1;
951

    
952
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
953
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
954
        pkt->dts -= 1LL<<st->pts_wrap_bits;
955
    }
956

    
957
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
958
    // we take the conservative approach and discard both
959
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
960
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
961
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
962
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
963
    }
964

    
965
    if (pkt->duration == 0) {
966
        compute_frame_duration(&num, &den, st, pc, pkt);
967
        if (den && num) {
968
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
969

    
970
            if(pkt->duration != 0 && s->packet_buffer)
971
                update_initial_durations(s, st, pkt);
972
        }
973
    }
974

    
975
    /* correct timestamps with byte offset if demuxers only have timestamps
976
       on packet boundaries */
977
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
978
        /* this will estimate bitrate based on this frame's duration and size */
979
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
980
        if(pkt->pts != AV_NOPTS_VALUE)
981
            pkt->pts += offset;
982
        if(pkt->dts != AV_NOPTS_VALUE)
983
            pkt->dts += offset;
984
    }
985

    
986
    if (pc && pc->dts_sync_point >= 0) {
987
        // we have synchronization info from the parser
988
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
989
        if (den > 0) {
990
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
991
            if (pkt->dts != AV_NOPTS_VALUE) {
992
                // got DTS from the stream, update reference timestamp
993
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
994
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
995
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
996
                // compute DTS based on reference timestamp
997
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
998
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
999
            }
1000
            if (pc->dts_sync_point > 0)
1001
                st->reference_dts = pkt->dts; // new reference
1002
        }
1003
    }
1004

    
1005
    /* This may be redundant, but it should not hurt. */
1006
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1007
        presentation_delayed = 1;
1008

    
1009
//    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);
1010
    /* interpolate PTS and DTS if they are not present */
1011
    //We skip H264 currently because delay and has_b_frames are not reliably set
1012
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1013
        if (presentation_delayed) {
1014
            /* DTS = decompression timestamp */
1015
            /* PTS = presentation timestamp */
1016
            if (pkt->dts == AV_NOPTS_VALUE)
1017
                pkt->dts = st->last_IP_pts;
1018
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1019
            if (pkt->dts == AV_NOPTS_VALUE)
1020
                pkt->dts = st->cur_dts;
1021

    
1022
            /* this is tricky: the dts must be incremented by the duration
1023
            of the frame we are displaying, i.e. the last I- or P-frame */
1024
            if (st->last_IP_duration == 0)
1025
                st->last_IP_duration = pkt->duration;
1026
            if(pkt->dts != AV_NOPTS_VALUE)
1027
                st->cur_dts = pkt->dts + st->last_IP_duration;
1028
            st->last_IP_duration  = pkt->duration;
1029
            st->last_IP_pts= pkt->pts;
1030
            /* cannot compute PTS if not present (we can compute it only
1031
            by knowing the future */
1032
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1033
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1034
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1035
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1036
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1037
                    pkt->pts += pkt->duration;
1038
    //                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);
1039
                }
1040
            }
1041

    
1042
            /* presentation is not delayed : PTS and DTS are the same */
1043
            if(pkt->pts == AV_NOPTS_VALUE)
1044
                pkt->pts = pkt->dts;
1045
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1046
            if(pkt->pts == AV_NOPTS_VALUE)
1047
                pkt->pts = st->cur_dts;
1048
            pkt->dts = pkt->pts;
1049
            if(pkt->pts != AV_NOPTS_VALUE)
1050
                st->cur_dts = pkt->pts + pkt->duration;
1051
        }
1052
    }
1053

    
1054
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1055
        st->pts_buffer[0]= pkt->pts;
1056
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1057
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1058
        if(pkt->dts == AV_NOPTS_VALUE)
1059
            pkt->dts= st->pts_buffer[0];
1060
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1061
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1062
        }
1063
        if(pkt->dts > st->cur_dts)
1064
            st->cur_dts = pkt->dts;
1065
    }
1066

    
1067
//    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);
1068

    
1069
    /* update flags */
1070
    if(is_intra_only(st->codec))
1071
        pkt->flags |= AV_PKT_FLAG_KEY;
1072
    else if (pc) {
1073
        pkt->flags = 0;
1074
        /* keyframe computation */
1075
        if (pc->key_frame == 1)
1076
            pkt->flags |= AV_PKT_FLAG_KEY;
1077
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1078
            pkt->flags |= AV_PKT_FLAG_KEY;
1079
    }
1080
    if (pc)
1081
        pkt->convergence_duration = pc->convergence_duration;
1082
}
1083

    
1084

    
1085
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1086
{
1087
    AVStream *st;
1088
    int len, ret, i;
1089

    
1090
    av_init_packet(pkt);
1091

    
1092
    for(;;) {
1093
        /* select current input stream component */
1094
        st = s->cur_st;
1095
        if (st) {
1096
            if (!st->need_parsing || !st->parser) {
1097
                /* no parsing needed: we just output the packet as is */
1098
                /* raw data support */
1099
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1100
                compute_pkt_fields(s, st, NULL, pkt);
1101
                s->cur_st = NULL;
1102
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1103
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1104
                    ff_reduce_index(s, st->index);
1105
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1106
                }
1107
                break;
1108
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1109
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1110
                                       st->cur_ptr, st->cur_len,
1111
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1112
                                       st->cur_pkt.pos);
1113
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1114
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1115
                /* increment read pointer */
1116
                st->cur_ptr += len;
1117
                st->cur_len -= len;
1118

    
1119
                /* return packet if any */
1120
                if (pkt->size) {
1121
                got_packet:
1122
                    pkt->duration = 0;
1123
                    pkt->stream_index = st->index;
1124
                    pkt->pts = st->parser->pts;
1125
                    pkt->dts = st->parser->dts;
1126
                    pkt->pos = st->parser->pos;
1127
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1128
                        s->cur_st = NULL;
1129
                        pkt->destruct= st->cur_pkt.destruct;
1130
                        st->cur_pkt.destruct= NULL;
1131
                        st->cur_pkt.data    = NULL;
1132
                        assert(st->cur_len == 0);
1133
                    }else{
1134
                    pkt->destruct = NULL;
1135
                    }
1136
                    compute_pkt_fields(s, st, st->parser, pkt);
1137

    
1138
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1139
                        ff_reduce_index(s, st->index);
1140
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1141
                                           0, 0, AVINDEX_KEYFRAME);
1142
                    }
1143

    
1144
                    break;
1145
                }
1146
            } else {
1147
                /* free packet */
1148
                av_free_packet(&st->cur_pkt);
1149
                s->cur_st = NULL;
1150
            }
1151
        } else {
1152
            AVPacket cur_pkt;
1153
            /* read next packet */
1154
            ret = av_read_packet(s, &cur_pkt);
1155
            if (ret < 0) {
1156
                if (ret == AVERROR(EAGAIN))
1157
                    return ret;
1158
                /* return the last frames, if any */
1159
                for(i = 0; i < s->nb_streams; i++) {
1160
                    st = s->streams[i];
1161
                    if (st->parser && st->need_parsing) {
1162
                        av_parser_parse2(st->parser, st->codec,
1163
                                        &pkt->data, &pkt->size,
1164
                                        NULL, 0,
1165
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1166
                                        AV_NOPTS_VALUE);
1167
                        if (pkt->size)
1168
                            goto got_packet;
1169
                    }
1170
                }
1171
                /* no more packets: really terminate parsing */
1172
                return ret;
1173
            }
1174
            st = s->streams[cur_pkt.stream_index];
1175
            st->cur_pkt= cur_pkt;
1176

    
1177
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1178
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1179
               st->cur_pkt.pts < st->cur_pkt.dts){
1180
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1181
                    st->cur_pkt.stream_index,
1182
                    st->cur_pkt.pts,
1183
                    st->cur_pkt.dts,
1184
                    st->cur_pkt.size);
1185
//                av_free_packet(&st->cur_pkt);
1186
//                return -1;
1187
            }
1188

    
1189
            if(s->debug & FF_FDEBUG_TS)
1190
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1191
                    st->cur_pkt.stream_index,
1192
                    st->cur_pkt.pts,
1193
                    st->cur_pkt.dts,
1194
                    st->cur_pkt.size,
1195
                    st->cur_pkt.duration,
1196
                    st->cur_pkt.flags);
1197

    
1198
            s->cur_st = st;
1199
            st->cur_ptr = st->cur_pkt.data;
1200
            st->cur_len = st->cur_pkt.size;
1201
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1202
                st->parser = av_parser_init(st->codec->codec_id);
1203
                if (!st->parser) {
1204
                    /* no parser available: just output the raw packets */
1205
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1206
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1207
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1208
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1209
                    st->parser->flags |= PARSER_FLAG_ONCE;
1210
                }
1211
            }
1212
        }
1213
    }
1214
    if(s->debug & FF_FDEBUG_TS)
1215
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1216
            pkt->stream_index,
1217
            pkt->pts,
1218
            pkt->dts,
1219
            pkt->size,
1220
            pkt->duration,
1221
            pkt->flags);
1222

    
1223
    return 0;
1224
}
1225

    
1226
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1227
{
1228
    AVPacketList *pktl;
1229
    int eof=0;
1230
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1231

    
1232
    for(;;){
1233
        pktl = s->packet_buffer;
1234
        if (pktl) {
1235
            AVPacket *next_pkt= &pktl->pkt;
1236

    
1237
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1238
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1239
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1240
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1241
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1242
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1243
                        next_pkt->pts= pktl->pkt.dts;
1244
                    }
1245
                    pktl= pktl->next;
1246
                }
1247
                pktl = s->packet_buffer;
1248
            }
1249

    
1250
            if(   next_pkt->pts != AV_NOPTS_VALUE
1251
               || next_pkt->dts == AV_NOPTS_VALUE
1252
               || !genpts || eof){
1253
                /* read packet from packet buffer, if there is data */
1254
                *pkt = *next_pkt;
1255
                s->packet_buffer = pktl->next;
1256
                av_free(pktl);
1257
                return 0;
1258
            }
1259
        }
1260
        if(genpts){
1261
            int ret= av_read_frame_internal(s, pkt);
1262
            if(ret<0){
1263
                if(pktl && ret != AVERROR(EAGAIN)){
1264
                    eof=1;
1265
                    continue;
1266
                }else
1267
                    return ret;
1268
            }
1269

    
1270
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1271
                                           &s->packet_buffer_end)) < 0)
1272
                return AVERROR(ENOMEM);
1273
        }else{
1274
            assert(!s->packet_buffer);
1275
            return av_read_frame_internal(s, pkt);
1276
        }
1277
    }
1278
}
1279

    
1280
/* XXX: suppress the packet queue */
1281
static void flush_packet_queue(AVFormatContext *s)
1282
{
1283
    AVPacketList *pktl;
1284

    
1285
    for(;;) {
1286
        pktl = s->packet_buffer;
1287
        if (!pktl)
1288
            break;
1289
        s->packet_buffer = pktl->next;
1290
        av_free_packet(&pktl->pkt);
1291
        av_free(pktl);
1292
    }
1293
    while(s->raw_packet_buffer){
1294
        pktl = s->raw_packet_buffer;
1295
        s->raw_packet_buffer = pktl->next;
1296
        av_free_packet(&pktl->pkt);
1297
        av_free(pktl);
1298
    }
1299
    s->packet_buffer_end=
1300
    s->raw_packet_buffer_end= NULL;
1301
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1302
}
1303

    
1304
/*******************************************************/
1305
/* seek support */
1306

    
1307
int av_find_default_stream_index(AVFormatContext *s)
1308
{
1309
    int first_audio_index = -1;
1310
    int i;
1311
    AVStream *st;
1312

    
1313
    if (s->nb_streams <= 0)
1314
        return -1;
1315
    for(i = 0; i < s->nb_streams; i++) {
1316
        st = s->streams[i];
1317
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1318
            return i;
1319
        }
1320
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1321
            first_audio_index = i;
1322
    }
1323
    return first_audio_index >= 0 ? first_audio_index : 0;
1324
}
1325

    
1326
/**
1327
 * Flush the frame reader.
1328
 */
1329
void ff_read_frame_flush(AVFormatContext *s)
1330
{
1331
    AVStream *st;
1332
    int i, j;
1333

    
1334
    flush_packet_queue(s);
1335

    
1336
    s->cur_st = NULL;
1337

    
1338
    /* for each stream, reset read state */
1339
    for(i = 0; i < s->nb_streams; i++) {
1340
        st = s->streams[i];
1341

    
1342
        if (st->parser) {
1343
            av_parser_close(st->parser);
1344
            st->parser = NULL;
1345
            av_free_packet(&st->cur_pkt);
1346
        }
1347
        st->last_IP_pts = AV_NOPTS_VALUE;
1348
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1349
        st->reference_dts = AV_NOPTS_VALUE;
1350
        /* fail safe */
1351
        st->cur_ptr = NULL;
1352
        st->cur_len = 0;
1353

    
1354
        st->probe_packets = MAX_PROBE_PACKETS;
1355

    
1356
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1357
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1358
    }
1359
}
1360

    
1361
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1362
    int i;
1363

    
1364
    for(i = 0; i < s->nb_streams; i++) {
1365
        AVStream *st = s->streams[i];
1366

    
1367
        st->cur_dts = av_rescale(timestamp,
1368
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1369
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1370
    }
1371
}
1372

    
1373
void ff_reduce_index(AVFormatContext *s, int stream_index)
1374
{
1375
    AVStream *st= s->streams[stream_index];
1376
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1377

    
1378
    if((unsigned)st->nb_index_entries >= max_entries){
1379
        int i;
1380
        for(i=0; 2*i<st->nb_index_entries; i++)
1381
            st->index_entries[i]= st->index_entries[2*i];
1382
        st->nb_index_entries= i;
1383
    }
1384
}
1385

    
1386
int ff_add_index_entry(AVIndexEntry **index_entries,
1387
                       int *nb_index_entries,
1388
                       unsigned int *index_entries_allocated_size,
1389
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1390
{
1391
    AVIndexEntry *entries, *ie;
1392
    int index;
1393

    
1394
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1395
        return -1;
1396

    
1397
    entries = av_fast_realloc(*index_entries,
1398
                              index_entries_allocated_size,
1399
                              (*nb_index_entries + 1) *
1400
                              sizeof(AVIndexEntry));
1401
    if(!entries)
1402
        return -1;
1403

    
1404
    *index_entries= entries;
1405

    
1406
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1407

    
1408
    if(index<0){
1409
        index= (*nb_index_entries)++;
1410
        ie= &entries[index];
1411
        assert(index==0 || ie[-1].timestamp < timestamp);
1412
    }else{
1413
        ie= &entries[index];
1414
        if(ie->timestamp != timestamp){
1415
            if(ie->timestamp <= timestamp)
1416
                return -1;
1417
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1418
            (*nb_index_entries)++;
1419
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1420
            distance= ie->min_distance;
1421
    }
1422

    
1423
    ie->pos = pos;
1424
    ie->timestamp = timestamp;
1425
    ie->min_distance= distance;
1426
    ie->size= size;
1427
    ie->flags = flags;
1428

    
1429
    return index;
1430
}
1431

    
1432
int av_add_index_entry(AVStream *st,
1433
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1434
{
1435
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1436
                              &st->index_entries_allocated_size, pos,
1437
                              timestamp, size, distance, flags);
1438
}
1439

    
1440
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1441
                              int64_t wanted_timestamp, int flags)
1442
{
1443
    int a, b, m;
1444
    int64_t timestamp;
1445

    
1446
    a = - 1;
1447
    b = nb_entries;
1448

    
1449
    //optimize appending index entries at the end
1450
    if(b && entries[b-1].timestamp < wanted_timestamp)
1451
        a= b-1;
1452

    
1453
    while (b - a > 1) {
1454
        m = (a + b) >> 1;
1455
        timestamp = entries[m].timestamp;
1456
        if(timestamp >= wanted_timestamp)
1457
            b = m;
1458
        if(timestamp <= wanted_timestamp)
1459
            a = m;
1460
    }
1461
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1462

    
1463
    if(!(flags & AVSEEK_FLAG_ANY)){
1464
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1465
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1466
        }
1467
    }
1468

    
1469
    if(m == nb_entries)
1470
        return -1;
1471
    return  m;
1472
}
1473

    
1474
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1475
                              int flags)
1476
{
1477
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1478
                                     wanted_timestamp, flags);
1479
}
1480

    
1481
#define DEBUG_SEEK
1482

    
1483
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1484
    AVInputFormat *avif= s->iformat;
1485
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1486
    int64_t ts_min, ts_max, ts;
1487
    int index;
1488
    int64_t ret;
1489
    AVStream *st;
1490

    
1491
    if (stream_index < 0)
1492
        return -1;
1493

    
1494
#ifdef DEBUG_SEEK
1495
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1496
#endif
1497

    
1498
    ts_max=
1499
    ts_min= AV_NOPTS_VALUE;
1500
    pos_limit= -1; //gcc falsely says it may be uninitialized
1501

    
1502
    st= s->streams[stream_index];
1503
    if(st->index_entries){
1504
        AVIndexEntry *e;
1505

    
1506
        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()
1507
        index= FFMAX(index, 0);
1508
        e= &st->index_entries[index];
1509

    
1510
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1511
            pos_min= e->pos;
1512
            ts_min= e->timestamp;
1513
#ifdef DEBUG_SEEK
1514
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1515
                   pos_min,ts_min);
1516
#endif
1517
        }else{
1518
            assert(index==0);
1519
        }
1520

    
1521
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1522
        assert(index < st->nb_index_entries);
1523
        if(index >= 0){
1524
            e= &st->index_entries[index];
1525
            assert(e->timestamp >= target_ts);
1526
            pos_max= e->pos;
1527
            ts_max= e->timestamp;
1528
            pos_limit= pos_max - e->min_distance;
1529
#ifdef DEBUG_SEEK
1530
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1531
                   pos_max,pos_limit, ts_max);
1532
#endif
1533
        }
1534
    }
1535

    
1536
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1537
    if(pos<0)
1538
        return -1;
1539

    
1540
    /* do the seek */
1541
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1542
        return ret;
1543

    
1544
    av_update_cur_dts(s, st, ts);
1545

    
1546
    return 0;
1547
}
1548

    
1549
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 )){
1550
    int64_t pos, ts;
1551
    int64_t start_pos, filesize;
1552
    int no_change;
1553

    
1554
#ifdef DEBUG_SEEK
1555
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1556
#endif
1557

    
1558
    if(ts_min == AV_NOPTS_VALUE){
1559
        pos_min = s->data_offset;
1560
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1561
        if (ts_min == AV_NOPTS_VALUE)
1562
            return -1;
1563
    }
1564

    
1565
    if(ts_max == AV_NOPTS_VALUE){
1566
        int step= 1024;
1567
        filesize = avio_size(s->pb);
1568
        pos_max = filesize - 1;
1569
        do{
1570
            pos_max -= step;
1571
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1572
            step += step;
1573
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1574
        if (ts_max == AV_NOPTS_VALUE)
1575
            return -1;
1576

    
1577
        for(;;){
1578
            int64_t tmp_pos= pos_max + 1;
1579
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1580
            if(tmp_ts == AV_NOPTS_VALUE)
1581
                break;
1582
            ts_max= tmp_ts;
1583
            pos_max= tmp_pos;
1584
            if(tmp_pos >= filesize)
1585
                break;
1586
        }
1587
        pos_limit= pos_max;
1588
    }
1589

    
1590
    if(ts_min > ts_max){
1591
        return -1;
1592
    }else if(ts_min == ts_max){
1593
        pos_limit= pos_min;
1594
    }
1595

    
1596
    no_change=0;
1597
    while (pos_min < pos_limit) {
1598
#ifdef DEBUG_SEEK
1599
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1600
               pos_min, pos_max,
1601
               ts_min, ts_max);
1602
#endif
1603
        assert(pos_limit <= pos_max);
1604

    
1605
        if(no_change==0){
1606
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1607
            // interpolate position (better than dichotomy)
1608
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1609
                + pos_min - approximate_keyframe_distance;
1610
        }else if(no_change==1){
1611
            // bisection, if interpolation failed to change min or max pos last time
1612
            pos = (pos_min + pos_limit)>>1;
1613
        }else{
1614
            /* linear search if bisection failed, can only happen if there
1615
               are very few or no keyframes between min/max */
1616
            pos=pos_min;
1617
        }
1618
        if(pos <= pos_min)
1619
            pos= pos_min + 1;
1620
        else if(pos > pos_limit)
1621
            pos= pos_limit;
1622
        start_pos= pos;
1623

    
1624
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1625
        if(pos == pos_max)
1626
            no_change++;
1627
        else
1628
            no_change=0;
1629
#ifdef DEBUG_SEEK
1630
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1631
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1632
               start_pos, no_change);
1633
#endif
1634
        if(ts == AV_NOPTS_VALUE){
1635
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1636
            return -1;
1637
        }
1638
        assert(ts != AV_NOPTS_VALUE);
1639
        if (target_ts <= ts) {
1640
            pos_limit = start_pos - 1;
1641
            pos_max = pos;
1642
            ts_max = ts;
1643
        }
1644
        if (target_ts >= ts) {
1645
            pos_min = pos;
1646
            ts_min = ts;
1647
        }
1648
    }
1649

    
1650
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1651
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1652
#ifdef DEBUG_SEEK
1653
    pos_min = pos;
1654
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1655
    pos_min++;
1656
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1657
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1658
           pos, ts_min, target_ts, ts_max);
1659
#endif
1660
    *ts_ret= ts;
1661
    return pos;
1662
}
1663

    
1664
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1665
    int64_t pos_min, pos_max;
1666
#if 0
1667
    AVStream *st;
1668

1669
    if (stream_index < 0)
1670
        return -1;
1671

1672
    st= s->streams[stream_index];
1673
#endif
1674

    
1675
    pos_min = s->data_offset;
1676
    pos_max = avio_size(s->pb) - 1;
1677

    
1678
    if     (pos < pos_min) pos= pos_min;
1679
    else if(pos > pos_max) pos= pos_max;
1680

    
1681
    avio_seek(s->pb, pos, SEEK_SET);
1682

    
1683
#if 0
1684
    av_update_cur_dts(s, st, ts);
1685
#endif
1686
    return 0;
1687
}
1688

    
1689
static int av_seek_frame_generic(AVFormatContext *s,
1690
                                 int stream_index, int64_t timestamp, int flags)
1691
{
1692
    int index;
1693
    int64_t ret;
1694
    AVStream *st;
1695
    AVIndexEntry *ie;
1696

    
1697
    st = s->streams[stream_index];
1698

    
1699
    index = av_index_search_timestamp(st, timestamp, flags);
1700

    
1701
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1702
        return -1;
1703

    
1704
    if(index < 0 || index==st->nb_index_entries-1){
1705
        int i;
1706
        AVPacket pkt;
1707

    
1708
        if(st->nb_index_entries){
1709
            assert(st->index_entries);
1710
            ie= &st->index_entries[st->nb_index_entries-1];
1711
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1712
                return ret;
1713
            av_update_cur_dts(s, st, ie->timestamp);
1714
        }else{
1715
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1716
                return ret;
1717
        }
1718
        for(i=0;; i++) {
1719
            int ret;
1720
            do{
1721
                ret = av_read_frame(s, &pkt);
1722
            }while(ret == AVERROR(EAGAIN));
1723
            if(ret<0)
1724
                break;
1725
            av_free_packet(&pkt);
1726
            if(stream_index == pkt.stream_index){
1727
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1728
                    break;
1729
            }
1730
        }
1731
        index = av_index_search_timestamp(st, timestamp, flags);
1732
    }
1733
    if (index < 0)
1734
        return -1;
1735

    
1736
    ff_read_frame_flush(s);
1737
    if (s->iformat->read_seek){
1738
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1739
            return 0;
1740
    }
1741
    ie = &st->index_entries[index];
1742
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1743
        return ret;
1744
    av_update_cur_dts(s, st, ie->timestamp);
1745

    
1746
    return 0;
1747
}
1748

    
1749
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1750
{
1751
    int ret;
1752
    AVStream *st;
1753

    
1754
    ff_read_frame_flush(s);
1755

    
1756
    if(flags & AVSEEK_FLAG_BYTE)
1757
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1758

    
1759
    if(stream_index < 0){
1760
        stream_index= av_find_default_stream_index(s);
1761
        if(stream_index < 0)
1762
            return -1;
1763

    
1764
        st= s->streams[stream_index];
1765
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1766
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1767
    }
1768

    
1769
    /* first, we try the format specific seek */
1770
    if (s->iformat->read_seek)
1771
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1772
    else
1773
        ret = -1;
1774
    if (ret >= 0) {
1775
        return 0;
1776
    }
1777

    
1778
    if(s->iformat->read_timestamp)
1779
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1780
    else
1781
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1782
}
1783

    
1784
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1785
{
1786
    if(min_ts > ts || max_ts < ts)
1787
        return -1;
1788

    
1789
    ff_read_frame_flush(s);
1790

    
1791
    if (s->iformat->read_seek2)
1792
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1793

    
1794
    if(s->iformat->read_timestamp){
1795
        //try to seek via read_timestamp()
1796
    }
1797

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

    
1803
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1804
}
1805

    
1806
/*******************************************************/
1807

    
1808
/**
1809
 * Return TRUE if the stream has accurate duration in any stream.
1810
 *
1811
 * @return TRUE if the stream has accurate duration for at least one component.
1812
 */
1813
static int av_has_duration(AVFormatContext *ic)
1814
{
1815
    int i;
1816
    AVStream *st;
1817

    
1818
    for(i = 0;i < ic->nb_streams; i++) {
1819
        st = ic->streams[i];
1820
        if (st->duration != AV_NOPTS_VALUE)
1821
            return 1;
1822
    }
1823
    return 0;
1824
}
1825

    
1826
/**
1827
 * Estimate the stream timings from the one of each components.
1828
 *
1829
 * Also computes the global bitrate if possible.
1830
 */
1831
static void av_update_stream_timings(AVFormatContext *ic)
1832
{
1833
    int64_t start_time, start_time1, end_time, end_time1;
1834
    int64_t duration, duration1;
1835
    int i;
1836
    AVStream *st;
1837

    
1838
    start_time = INT64_MAX;
1839
    end_time = INT64_MIN;
1840
    duration = INT64_MIN;
1841
    for(i = 0;i < ic->nb_streams; i++) {
1842
        st = ic->streams[i];
1843
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1844
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1845
            if (start_time1 < start_time)
1846
                start_time = start_time1;
1847
            if (st->duration != AV_NOPTS_VALUE) {
1848
                end_time1 = start_time1
1849
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1850
                if (end_time1 > end_time)
1851
                    end_time = end_time1;
1852
            }
1853
        }
1854
        if (st->duration != AV_NOPTS_VALUE) {
1855
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1856
            if (duration1 > duration)
1857
                duration = duration1;
1858
        }
1859
    }
1860
    if (start_time != INT64_MAX) {
1861
        ic->start_time = start_time;
1862
        if (end_time != INT64_MIN) {
1863
            if (end_time - start_time > duration)
1864
                duration = end_time - start_time;
1865
        }
1866
    }
1867
    if (duration != INT64_MIN) {
1868
        ic->duration = duration;
1869
        if (ic->file_size > 0) {
1870
            /* compute the bitrate */
1871
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1872
                (double)ic->duration;
1873
        }
1874
    }
1875
}
1876

    
1877
static void fill_all_stream_timings(AVFormatContext *ic)
1878
{
1879
    int i;
1880
    AVStream *st;
1881

    
1882
    av_update_stream_timings(ic);
1883
    for(i = 0;i < ic->nb_streams; i++) {
1884
        st = ic->streams[i];
1885
        if (st->start_time == AV_NOPTS_VALUE) {
1886
            if(ic->start_time != AV_NOPTS_VALUE)
1887
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1888
            if(ic->duration != AV_NOPTS_VALUE)
1889
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1890
        }
1891
    }
1892
}
1893

    
1894
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1895
{
1896
    int64_t filesize, duration;
1897
    int bit_rate, i;
1898
    AVStream *st;
1899

    
1900
    /* if bit_rate is already set, we believe it */
1901
    if (ic->bit_rate <= 0) {
1902
        bit_rate = 0;
1903
        for(i=0;i<ic->nb_streams;i++) {
1904
            st = ic->streams[i];
1905
            if (st->codec->bit_rate > 0)
1906
            bit_rate += st->codec->bit_rate;
1907
        }
1908
        ic->bit_rate = bit_rate;
1909
    }
1910

    
1911
    /* if duration is already set, we believe it */
1912
    if (ic->duration == AV_NOPTS_VALUE &&
1913
        ic->bit_rate != 0 &&
1914
        ic->file_size != 0)  {
1915
        filesize = ic->file_size;
1916
        if (filesize > 0) {
1917
            for(i = 0; i < ic->nb_streams; i++) {
1918
                st = ic->streams[i];
1919
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1920
                if (st->duration == AV_NOPTS_VALUE)
1921
                    st->duration = duration;
1922
            }
1923
        }
1924
    }
1925
}
1926

    
1927
#define DURATION_MAX_READ_SIZE 250000
1928
#define DURATION_MAX_RETRY 3
1929

    
1930
/* only usable for MPEG-PS streams */
1931
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1932
{
1933
    AVPacket pkt1, *pkt = &pkt1;
1934
    AVStream *st;
1935
    int read_size, i, ret;
1936
    int64_t end_time;
1937
    int64_t filesize, offset, duration;
1938
    int retry=0;
1939

    
1940
    ic->cur_st = NULL;
1941

    
1942
    /* flush packet queue */
1943
    flush_packet_queue(ic);
1944

    
1945
    for (i=0; i<ic->nb_streams; i++) {
1946
        st = ic->streams[i];
1947
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1948
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1949

    
1950
        if (st->parser) {
1951
            av_parser_close(st->parser);
1952
            st->parser= NULL;
1953
            av_free_packet(&st->cur_pkt);
1954
        }
1955
    }
1956

    
1957
    /* estimate the end time (duration) */
1958
    /* XXX: may need to support wrapping */
1959
    filesize = ic->file_size;
1960
    end_time = AV_NOPTS_VALUE;
1961
    do{
1962
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1963
    if (offset < 0)
1964
        offset = 0;
1965

    
1966
    avio_seek(ic->pb, offset, SEEK_SET);
1967
    read_size = 0;
1968
    for(;;) {
1969
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1970
            break;
1971

    
1972
        do{
1973
            ret = av_read_packet(ic, pkt);
1974
        }while(ret == AVERROR(EAGAIN));
1975
        if (ret != 0)
1976
            break;
1977
        read_size += pkt->size;
1978
        st = ic->streams[pkt->stream_index];
1979
        if (pkt->pts != AV_NOPTS_VALUE &&
1980
            (st->start_time != AV_NOPTS_VALUE ||
1981
             st->first_dts  != AV_NOPTS_VALUE)) {
1982
            duration = end_time = pkt->pts;
1983
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1984
            else                                   duration -= st->first_dts;
1985
            if (duration < 0)
1986
                duration += 1LL<<st->pts_wrap_bits;
1987
            if (duration > 0) {
1988
                if (st->duration == AV_NOPTS_VALUE ||
1989
                    st->duration < duration)
1990
                    st->duration = duration;
1991
            }
1992
        }
1993
        av_free_packet(pkt);
1994
    }
1995
    }while(   end_time==AV_NOPTS_VALUE
1996
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1997
           && ++retry <= DURATION_MAX_RETRY);
1998

    
1999
    fill_all_stream_timings(ic);
2000

    
2001
    avio_seek(ic->pb, old_offset, SEEK_SET);
2002
    for (i=0; i<ic->nb_streams; i++) {
2003
        st= ic->streams[i];
2004
        st->cur_dts= st->first_dts;
2005
        st->last_IP_pts = AV_NOPTS_VALUE;
2006
    }
2007
}
2008

    
2009
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2010
{
2011
    int64_t file_size;
2012

    
2013
    /* get the file size, if possible */
2014
    if (ic->iformat->flags & AVFMT_NOFILE) {
2015
        file_size = 0;
2016
    } else {
2017
        file_size = avio_size(ic->pb);
2018
        if (file_size < 0)
2019
            file_size = 0;
2020
    }
2021
    ic->file_size = file_size;
2022

    
2023
    if ((!strcmp(ic->iformat->name, "mpeg") ||
2024
         !strcmp(ic->iformat->name, "mpegts")) &&
2025
        file_size && !url_is_streamed(ic->pb)) {
2026
        /* get accurate estimate from the PTSes */
2027
        av_estimate_timings_from_pts(ic, old_offset);
2028
    } else if (av_has_duration(ic)) {
2029
        /* at least one component has timings - we use them for all
2030
           the components */
2031
        fill_all_stream_timings(ic);
2032
    } else {
2033
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2034
        /* less precise: use bitrate info */
2035
        av_estimate_timings_from_bit_rate(ic);
2036
    }
2037
    av_update_stream_timings(ic);
2038

    
2039
#if 0
2040
    {
2041
        int i;
2042
        AVStream *st;
2043
        for(i = 0;i < ic->nb_streams; i++) {
2044
            st = ic->streams[i];
2045
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2046
               i, (double)st->start_time / AV_TIME_BASE,
2047
               (double)st->duration / AV_TIME_BASE);
2048
        }
2049
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2050
               (double)ic->start_time / AV_TIME_BASE,
2051
               (double)ic->duration / AV_TIME_BASE,
2052
               ic->bit_rate / 1000);
2053
    }
2054
#endif
2055
}
2056

    
2057
static int has_codec_parameters(AVCodecContext *enc)
2058
{
2059
    int val;
2060
    switch(enc->codec_type) {
2061
    case AVMEDIA_TYPE_AUDIO:
2062
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2063
        if(!enc->frame_size &&
2064
           (enc->codec_id == CODEC_ID_VORBIS ||
2065
            enc->codec_id == CODEC_ID_AAC ||
2066
            enc->codec_id == CODEC_ID_MP1 ||
2067
            enc->codec_id == CODEC_ID_MP2 ||
2068
            enc->codec_id == CODEC_ID_MP3 ||
2069
            enc->codec_id == CODEC_ID_SPEEX))
2070
            return 0;
2071
        break;
2072
    case AVMEDIA_TYPE_VIDEO:
2073
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2074
        break;
2075
    default:
2076
        val = 1;
2077
        break;
2078
    }
2079
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2080
}
2081

    
2082
static int has_decode_delay_been_guessed(AVStream *st)
2083
{
2084
    return st->codec->codec_id != CODEC_ID_H264 ||
2085
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2086
}
2087

    
2088
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2089
{
2090
    int16_t *samples;
2091
    AVCodec *codec;
2092
    int got_picture, data_size, ret=0;
2093
    AVFrame picture;
2094

    
2095
    if(!st->codec->codec){
2096
        codec = avcodec_find_decoder(st->codec->codec_id);
2097
        if (!codec)
2098
            return -1;
2099
        ret = avcodec_open(st->codec, codec);
2100
        if (ret < 0)
2101
            return ret;
2102
    }
2103

    
2104
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2105
        switch(st->codec->codec_type) {
2106
        case AVMEDIA_TYPE_VIDEO:
2107
            avcodec_get_frame_defaults(&picture);
2108
            ret = avcodec_decode_video2(st->codec, &picture,
2109
                                        &got_picture, avpkt);
2110
            break;
2111
        case AVMEDIA_TYPE_AUDIO:
2112
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2113
            samples = av_malloc(data_size);
2114
            if (!samples)
2115
                goto fail;
2116
            ret = avcodec_decode_audio3(st->codec, samples,
2117
                                        &data_size, avpkt);
2118
            av_free(samples);
2119
            break;
2120
        default:
2121
            break;
2122
        }
2123
    }
2124
 fail:
2125
    return ret;
2126
}
2127

    
2128
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2129
{
2130
    while (tags->id != CODEC_ID_NONE) {
2131
        if (tags->id == id)
2132
            return tags->tag;
2133
        tags++;
2134
    }
2135
    return 0;
2136
}
2137

    
2138
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2139
{
2140
    int i;
2141
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2142
        if(tag == tags[i].tag)
2143
            return tags[i].id;
2144
    }
2145
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2146
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2147
            return tags[i].id;
2148
    }
2149
    return CODEC_ID_NONE;
2150
}
2151

    
2152
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2153
{
2154
    int i;
2155
    for(i=0; tags && tags[i]; i++){
2156
        int tag= ff_codec_get_tag(tags[i], id);
2157
        if(tag) return tag;
2158
    }
2159
    return 0;
2160
}
2161

    
2162
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2163
{
2164
    int i;
2165
    for(i=0; tags && tags[i]; i++){
2166
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2167
        if(id!=CODEC_ID_NONE) return id;
2168
    }
2169
    return CODEC_ID_NONE;
2170
}
2171

    
2172
static void compute_chapters_end(AVFormatContext *s)
2173
{
2174
    unsigned int i, j;
2175
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2176

    
2177
    for (i = 0; i < s->nb_chapters; i++)
2178
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2179
            AVChapter *ch = s->chapters[i];
2180
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2181
                                     : INT64_MAX;
2182

    
2183
            for (j = 0; j < s->nb_chapters; j++) {
2184
                AVChapter *ch1 = s->chapters[j];
2185
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2186
                if (j != i && next_start > ch->start && next_start < end)
2187
                    end = next_start;
2188
            }
2189
            ch->end = (end == INT64_MAX) ? ch->start : end;
2190
        }
2191
}
2192

    
2193
static int get_std_framerate(int i){
2194
    if(i<60*12) return i*1001;
2195
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2196
}
2197

    
2198
/*
2199
 * Is the time base unreliable.
2200
 * This is a heuristic to balance between quick acceptance of the values in
2201
 * the headers vs. some extra checks.
2202
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2203
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2204
 * And there are "variable" fps files this needs to detect as well.
2205
 */
2206
static int tb_unreliable(AVCodecContext *c){
2207
    if(   c->time_base.den >= 101L*c->time_base.num
2208
       || c->time_base.den <    5L*c->time_base.num
2209
/*       || c->codec_tag == AV_RL32("DIVX")
2210
       || c->codec_tag == AV_RL32("XVID")*/
2211
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2212
       || c->codec_id == CODEC_ID_H264
2213
       )
2214
        return 1;
2215
    return 0;
2216
}
2217

    
2218
int av_find_stream_info(AVFormatContext *ic)
2219
{
2220
    int i, count, ret, read_size, j;
2221
    AVStream *st;
2222
    AVPacket pkt1, *pkt;
2223
    int64_t old_offset = avio_tell(ic->pb);
2224

    
2225
    for(i=0;i<ic->nb_streams;i++) {
2226
        AVCodec *codec;
2227
        st = ic->streams[i];
2228
        if (st->codec->codec_id == CODEC_ID_AAC) {
2229
            st->codec->sample_rate = 0;
2230
            st->codec->frame_size = 0;
2231
            st->codec->channels = 0;
2232
        }
2233
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2234
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2235
/*            if(!st->time_base.num)
2236
                st->time_base= */
2237
            if(!st->codec->time_base.num)
2238
                st->codec->time_base= st->time_base;
2239
        }
2240
        //only for the split stuff
2241
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2242
            st->parser = av_parser_init(st->codec->codec_id);
2243
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2244
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2245
            }
2246
        }
2247
        assert(!st->codec->codec);
2248
        codec = avcodec_find_decoder(st->codec->codec_id);
2249

    
2250
        /* Force decoding of at least one frame of codec data
2251
         * this makes sure the codec initializes the channel configuration
2252
         * and does not trust the values from the container.
2253
         */
2254
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2255
            st->codec->channels = 0;
2256

    
2257
        /* Ensure that subtitle_header is properly set. */
2258
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2259
            && codec && !st->codec->codec)
2260
            avcodec_open(st->codec, codec);
2261

    
2262
        //try to just open decoders, in case this is enough to get parameters
2263
        if(!has_codec_parameters(st->codec)){
2264
            if (codec && !st->codec->codec)
2265
                avcodec_open(st->codec, codec);
2266
        }
2267
    }
2268

    
2269
    for (i=0; i<ic->nb_streams; i++) {
2270
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2271
    }
2272

    
2273
    count = 0;
2274
    read_size = 0;
2275
    for(;;) {
2276
        if(url_interrupt_cb()){
2277
            ret= AVERROR_EXIT;
2278
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2279
            break;
2280
        }
2281

    
2282
        /* check if one codec still needs to be handled */
2283
        for(i=0;i<ic->nb_streams;i++) {
2284
            int fps_analyze_framecount = 20;
2285

    
2286
            st = ic->streams[i];
2287
            if (!has_codec_parameters(st->codec))
2288
                break;
2289
            /* if the timebase is coarse (like the usual millisecond precision
2290
               of mkv), we need to analyze more frames to reliably arrive at
2291
               the correct fps */
2292
            if (av_q2d(st->time_base) > 0.0005)
2293
                fps_analyze_framecount *= 2;
2294
            /* variable fps and no guess at the real fps */
2295
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2296
               && st->info->duration_count < fps_analyze_framecount
2297
               && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2298
                break;
2299
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2300
                break;
2301
            if(st->first_dts == AV_NOPTS_VALUE)
2302
                break;
2303
        }
2304
        if (i == ic->nb_streams) {
2305
            /* NOTE: if the format has no header, then we need to read
2306
               some packets to get most of the streams, so we cannot
2307
               stop here */
2308
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2309
                /* if we found the info for all the codecs, we can stop */
2310
                ret = count;
2311
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2312
                break;
2313
            }
2314
        }
2315
        /* we did not get all the codec info, but we read too much data */
2316
        if (read_size >= ic->probesize) {
2317
            ret = count;
2318
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2319
            break;
2320
        }
2321

    
2322
        /* NOTE: a new stream can be added there if no header in file
2323
           (AVFMTCTX_NOHEADER) */
2324
        ret = av_read_frame_internal(ic, &pkt1);
2325
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2326
            /* EOF or error */
2327
            ret = -1; /* we could not have all the codec parameters before EOF */
2328
            for(i=0;i<ic->nb_streams;i++) {
2329
                st = ic->streams[i];
2330
                if (!has_codec_parameters(st->codec)){
2331
                    char buf[256];
2332
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2333
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2334
                } else {
2335
                    ret = 0;
2336
                }
2337
            }
2338
            break;
2339
        }
2340

    
2341
        if (ret == AVERROR(EAGAIN))
2342
            continue;
2343

    
2344
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2345
        if ((ret = av_dup_packet(pkt)) < 0)
2346
            goto find_stream_info_err;
2347

    
2348
        read_size += pkt->size;
2349

    
2350
        st = ic->streams[pkt->stream_index];
2351
        if (st->codec_info_nb_frames>1) {
2352
            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) {
2353
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2354
                break;
2355
            }
2356
            st->info->codec_info_duration += pkt->duration;
2357
        }
2358
        {
2359
            int64_t last = st->info->last_dts;
2360
            int64_t duration= pkt->dts - last;
2361

    
2362
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2363
                double dur= duration * av_q2d(st->time_base);
2364

    
2365
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2366
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2367
                if (st->info->duration_count < 2)
2368
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2369
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2370
                    int framerate= get_std_framerate(i);
2371
                    int ticks= lrintf(dur*framerate/(1001*12));
2372
                    double error= dur - ticks*1001*12/(double)framerate;
2373
                    st->info->duration_error[i] += error*error;
2374
                }
2375
                st->info->duration_count++;
2376
                // ignore the first 4 values, they might have some random jitter
2377
                if (st->info->duration_count > 3)
2378
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2379
            }
2380
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2381
                st->info->last_dts = pkt->dts;
2382
        }
2383
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2384
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2385
            if(i){
2386
                st->codec->extradata_size= i;
2387
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2388
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2389
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2390
            }
2391
        }
2392

    
2393
        /* if still no information, we try to open the codec and to
2394
           decompress the frame. We try to avoid that in most cases as
2395
           it takes longer and uses more memory. For MPEG-4, we need to
2396
           decompress for QuickTime. */
2397
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2398
            try_decode_frame(st, pkt);
2399

    
2400
        st->codec_info_nb_frames++;
2401
        count++;
2402
    }
2403

    
2404
    // close codecs which were opened in try_decode_frame()
2405
    for(i=0;i<ic->nb_streams;i++) {
2406
        st = ic->streams[i];
2407
        if(st->codec->codec)
2408
            avcodec_close(st->codec);
2409
    }
2410
    for(i=0;i<ic->nb_streams;i++) {
2411
        st = ic->streams[i];
2412
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2413
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2414
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2415
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2416
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2417
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2418
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2419

    
2420
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2421
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2422
            // ipmovie.c produces.
2423
            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)
2424
                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);
2425
            if (st->info->duration_count && !st->r_frame_rate.num
2426
               && tb_unreliable(st->codec) /*&&
2427
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2428
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2429
                int num = 0;
2430
                double best_error= 2*av_q2d(st->time_base);
2431
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2432

    
2433
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2434
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2435
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2436
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2437
                    if(error < best_error){
2438
                        best_error= error;
2439
                        num = get_std_framerate(j);
2440
                    }
2441
                }
2442
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2443
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2444
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2445
            }
2446

    
2447
            if (!st->r_frame_rate.num){
2448
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2449
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2450
                    st->r_frame_rate.num = st->codec->time_base.den;
2451
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2452
                }else{
2453
                    st->r_frame_rate.num = st->time_base.den;
2454
                    st->r_frame_rate.den = st->time_base.num;
2455
                }
2456
            }
2457
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2458
            if(!st->codec->bits_per_coded_sample)
2459
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2460
            // set stream disposition based on audio service type
2461
            switch (st->codec->audio_service_type) {
2462
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2463
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2464
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2465
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2466
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2467
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2468
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2469
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2470
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2471
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2472
            }
2473
        }
2474
    }
2475

    
2476
    av_estimate_timings(ic, old_offset);
2477

    
2478
    compute_chapters_end(ic);
2479

    
2480
#if 0
2481
    /* correct DTS for B-frame streams with no timestamps */
2482
    for(i=0;i<ic->nb_streams;i++) {
2483
        st = ic->streams[i];
2484
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2485
            if(b-frames){
2486
                ppktl = &ic->packet_buffer;
2487
                while(ppkt1){
2488
                    if(ppkt1->stream_index != i)
2489
                        continue;
2490
                    if(ppkt1->pkt->dts < 0)
2491
                        break;
2492
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2493
                        break;
2494
                    ppkt1->pkt->dts -= delta;
2495
                    ppkt1= ppkt1->next;
2496
                }
2497
                if(ppkt1)
2498
                    continue;
2499
                st->cur_dts -= delta;
2500
            }
2501
        }
2502
    }
2503
#endif
2504

    
2505
 find_stream_info_err:
2506
    for (i=0; i < ic->nb_streams; i++)
2507
        av_freep(&ic->streams[i]->info);
2508
    return ret;
2509
}
2510

    
2511
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2512
{
2513
    int i, j;
2514

    
2515
    for (i = 0; i < ic->nb_programs; i++)
2516
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2517
            if (ic->programs[i]->stream_index[j] == s)
2518
                return ic->programs[i];
2519
    return NULL;
2520
}
2521

    
2522
int av_find_best_stream(AVFormatContext *ic,
2523
                        enum AVMediaType type,
2524
                        int wanted_stream_nb,
2525
                        int related_stream,
2526
                        AVCodec **decoder_ret,
2527
                        int flags)
2528
{
2529
    int i, nb_streams = ic->nb_streams;
2530
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2531
    unsigned *program = NULL;
2532
    AVCodec *decoder = NULL, *best_decoder = NULL;
2533

    
2534
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2535
        AVProgram *p = find_program_from_stream(ic, related_stream);
2536
        if (p) {
2537
            program = p->stream_index;
2538
            nb_streams = p->nb_stream_indexes;
2539
        }
2540
    }
2541
    for (i = 0; i < nb_streams; i++) {
2542
        int real_stream_index = program ? program[i] : i;
2543
        AVStream *st = ic->streams[real_stream_index];
2544
        AVCodecContext *avctx = st->codec;
2545
        if (avctx->codec_type != type)
2546
            continue;
2547
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2548
            continue;
2549
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2550
            continue;
2551
        if (decoder_ret) {
2552
            decoder = avcodec_find_decoder(st->codec->codec_id);
2553
            if (!decoder) {
2554
                if (ret < 0)
2555
                    ret = AVERROR_DECODER_NOT_FOUND;
2556
                continue;
2557
            }
2558
        }
2559
        if (best_count >= st->codec_info_nb_frames)
2560
            continue;
2561
        best_count = st->codec_info_nb_frames;
2562
        ret = real_stream_index;
2563
        best_decoder = decoder;
2564
        if (program && i == nb_streams - 1 && ret < 0) {
2565
            program = NULL;
2566
            nb_streams = ic->nb_streams;
2567
            i = 0; /* no related stream found, try again with everything */
2568
        }
2569
    }
2570
    if (decoder_ret)
2571
        *decoder_ret = best_decoder;
2572
    return ret;
2573
}
2574

    
2575
/*******************************************************/
2576

    
2577
int av_read_play(AVFormatContext *s)
2578
{
2579
    if (s->iformat->read_play)
2580
        return s->iformat->read_play(s);
2581
    if (s->pb)
2582
        return ffio_read_pause(s->pb, 0);
2583
    return AVERROR(ENOSYS);
2584
}
2585

    
2586
int av_read_pause(AVFormatContext *s)
2587
{
2588
    if (s->iformat->read_pause)
2589
        return s->iformat->read_pause(s);
2590
    if (s->pb)
2591
        return ffio_read_pause(s->pb, 1);
2592
    return AVERROR(ENOSYS);
2593
}
2594

    
2595
void av_close_input_stream(AVFormatContext *s)
2596
{
2597
    flush_packet_queue(s);
2598
    if (s->iformat->read_close)
2599
        s->iformat->read_close(s);
2600
    avformat_free_context(s);
2601
}
2602

    
2603
void avformat_free_context(AVFormatContext *s)
2604
{
2605
    int i;
2606
    AVStream *st;
2607

    
2608
    for(i=0;i<s->nb_streams;i++) {
2609
        /* free all data in a stream component */
2610
        st = s->streams[i];
2611
        if (st->parser) {
2612
            av_parser_close(st->parser);
2613
            av_free_packet(&st->cur_pkt);
2614
        }
2615
        av_metadata_free(&st->metadata);
2616
        av_free(st->index_entries);
2617
        av_free(st->codec->extradata);
2618
        av_free(st->codec->subtitle_header);
2619
        av_free(st->codec);
2620
#if FF_API_OLD_METADATA
2621
        av_free(st->filename);
2622
#endif
2623
        av_free(st->priv_data);
2624
        av_free(st->info);
2625
        av_free(st);
2626
    }
2627
    for(i=s->nb_programs-1; i>=0; i--) {
2628
#if FF_API_OLD_METADATA
2629
        av_freep(&s->programs[i]->provider_name);
2630
        av_freep(&s->programs[i]->name);
2631
#endif
2632
        av_metadata_free(&s->programs[i]->metadata);
2633
        av_freep(&s->programs[i]->stream_index);
2634
        av_freep(&s->programs[i]);
2635
    }
2636
    av_freep(&s->programs);
2637
    av_freep(&s->priv_data);
2638
    while(s->nb_chapters--) {
2639
#if FF_API_OLD_METADATA
2640
        av_free(s->chapters[s->nb_chapters]->title);
2641
#endif
2642
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2643
        av_free(s->chapters[s->nb_chapters]);
2644
    }
2645
    av_freep(&s->chapters);
2646
    av_metadata_free(&s->metadata);
2647
    av_freep(&s->key);
2648
    av_free(s);
2649
}
2650

    
2651
void av_close_input_file(AVFormatContext *s)
2652
{
2653
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2654
    av_close_input_stream(s);
2655
    if (pb)
2656
        avio_close(pb);
2657
}
2658

    
2659
AVStream *av_new_stream(AVFormatContext *s, int id)
2660
{
2661
    AVStream *st;
2662
    int i;
2663

    
2664
#if FF_API_MAX_STREAMS
2665
    if (s->nb_streams >= MAX_STREAMS){
2666
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2667
        return NULL;
2668
    }
2669
#else
2670
    AVStream **streams;
2671

    
2672
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2673
        return NULL;
2674
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2675
    if (!streams)
2676
        return NULL;
2677
    s->streams = streams;
2678
#endif
2679

    
2680
    st = av_mallocz(sizeof(AVStream));
2681
    if (!st)
2682
        return NULL;
2683
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2684
        av_free(st);
2685
        return NULL;
2686
    }
2687

    
2688
    st->codec= avcodec_alloc_context();
2689
    if (s->iformat) {
2690
        /* no default bitrate if decoding */
2691
        st->codec->bit_rate = 0;
2692
    }
2693
    st->index = s->nb_streams;
2694
    st->id = id;
2695
    st->start_time = AV_NOPTS_VALUE;
2696
    st->duration = AV_NOPTS_VALUE;
2697
        /* we set the current DTS to 0 so that formats without any timestamps
2698
           but durations get some timestamps, formats with some unknown
2699
           timestamps have their first few packets buffered and the
2700
           timestamps corrected before they are returned to the user */
2701
    st->cur_dts = 0;
2702
    st->first_dts = AV_NOPTS_VALUE;
2703
    st->probe_packets = MAX_PROBE_PACKETS;
2704

    
2705
    /* default pts setting is MPEG-like */
2706
    av_set_pts_info(st, 33, 1, 90000);
2707
    st->last_IP_pts = AV_NOPTS_VALUE;
2708
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2709
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2710
    st->reference_dts = AV_NOPTS_VALUE;
2711

    
2712
    st->sample_aspect_ratio = (AVRational){0,1};
2713

    
2714
    s->streams[s->nb_streams++] = st;
2715
    return st;
2716
}
2717

    
2718
AVProgram *av_new_program(AVFormatContext *ac, int id)
2719
{
2720
    AVProgram *program=NULL;
2721
    int i;
2722

    
2723
#ifdef DEBUG_SI
2724
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2725
#endif
2726

    
2727
    for(i=0; i<ac->nb_programs; i++)
2728
        if(ac->programs[i]->id == id)
2729
            program = ac->programs[i];
2730

    
2731
    if(!program){
2732
        program = av_mallocz(sizeof(AVProgram));
2733
        if (!program)
2734
            return NULL;
2735
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2736
        program->discard = AVDISCARD_NONE;
2737
    }
2738
    program->id = id;
2739

    
2740
    return program;
2741
}
2742

    
2743
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2744
{
2745
    AVChapter *chapter = NULL;
2746
    int i;
2747

    
2748
    for(i=0; i<s->nb_chapters; i++)
2749
        if(s->chapters[i]->id == id)
2750
            chapter = s->chapters[i];
2751

    
2752
    if(!chapter){
2753
        chapter= av_mallocz(sizeof(AVChapter));
2754
        if(!chapter)
2755
            return NULL;
2756
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2757
    }
2758
#if FF_API_OLD_METADATA
2759
    av_free(chapter->title);
2760
#endif
2761
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2762
    chapter->id    = id;
2763
    chapter->time_base= time_base;
2764
    chapter->start = start;
2765
    chapter->end   = end;
2766

    
2767
    return chapter;
2768
}
2769

    
2770
/************************************************************/
2771
/* output media file */
2772

    
2773
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2774
{
2775
    int ret;
2776

    
2777
    if (s->oformat->priv_data_size > 0) {
2778
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2779
        if (!s->priv_data)
2780
            return AVERROR(ENOMEM);
2781
        if (s->oformat->priv_class) {
2782
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2783
            av_opt_set_defaults(s->priv_data);
2784
        }
2785
    } else
2786
        s->priv_data = NULL;
2787

    
2788
    if (s->oformat->set_parameters) {
2789
        ret = s->oformat->set_parameters(s, ap);
2790
        if (ret < 0)
2791
            return ret;
2792
    }
2793
    return 0;
2794
}
2795

    
2796
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2797
{
2798
    const AVCodecTag *avctag;
2799
    int n;
2800
    enum CodecID id = CODEC_ID_NONE;
2801
    unsigned int tag = 0;
2802

    
2803
    /**
2804
     * Check that tag + id is in the table
2805
     * If neither is in the table -> OK
2806
     * If tag is in the table with another id -> FAIL
2807
     * If id is in the table with another tag -> FAIL unless strict < normal
2808
     */
2809
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2810
        avctag = s->oformat->codec_tag[n];
2811
        while (avctag->id != CODEC_ID_NONE) {
2812
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2813
                id = avctag->id;
2814
                if (id == st->codec->codec_id)
2815
                    return 1;
2816
            }
2817
            if (avctag->id == st->codec->codec_id)
2818
                tag = avctag->tag;
2819
            avctag++;
2820
        }
2821
    }
2822
    if (id != CODEC_ID_NONE)
2823
        return 0;
2824
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2825
        return 0;
2826
    return 1;
2827
}
2828

    
2829
int av_write_header(AVFormatContext *s)
2830
{
2831
    int ret, i;
2832
    AVStream *st;
2833

    
2834
    // some sanity checks
2835
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2836
        av_log(s, AV_LOG_ERROR, "no streams\n");
2837
        return AVERROR(EINVAL);
2838
    }
2839

    
2840
    for(i=0;i<s->nb_streams;i++) {
2841
        st = s->streams[i];
2842

    
2843
        switch (st->codec->codec_type) {
2844
        case AVMEDIA_TYPE_AUDIO:
2845
            if(st->codec->sample_rate<=0){
2846
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2847
                return AVERROR(EINVAL);
2848
            }
2849
            if(!st->codec->block_align)
2850
                st->codec->block_align = st->codec->channels *
2851
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2852
            break;
2853
        case AVMEDIA_TYPE_VIDEO:
2854
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2855
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2856
                return AVERROR(EINVAL);
2857
            }
2858
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2859
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2860
                return AVERROR(EINVAL);
2861
            }
2862
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2863
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2864
                return AVERROR(EINVAL);
2865
            }
2866
            break;
2867
        }
2868

    
2869
        if(s->oformat->codec_tag){
2870
            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)){
2871
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2872
                st->codec->codec_tag= 0;
2873
            }
2874
            if(st->codec->codec_tag){
2875
                if (!validate_codec_tag(s, st)) {
2876
                    char tagbuf[32];
2877
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2878
                    av_log(s, AV_LOG_ERROR,
2879
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2880
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2881
                    return AVERROR_INVALIDDATA;
2882
                }
2883
            }else
2884
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2885
        }
2886

    
2887
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2888
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2889
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2890
    }
2891

    
2892
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2893
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2894
        if (!s->priv_data)
2895
            return AVERROR(ENOMEM);
2896
    }
2897

    
2898
#if FF_API_OLD_METADATA
2899
    ff_metadata_mux_compat(s);
2900
#endif
2901

    
2902
    /* set muxer identification string */
2903
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2904
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2905
    }
2906

    
2907
    if(s->oformat->write_header){
2908
        ret = s->oformat->write_header(s);
2909
        if (ret < 0)
2910
            return ret;
2911
    }
2912

    
2913
    /* init PTS generation */
2914
    for(i=0;i<s->nb_streams;i++) {
2915
        int64_t den = AV_NOPTS_VALUE;
2916
        st = s->streams[i];
2917

    
2918
        switch (st->codec->codec_type) {
2919
        case AVMEDIA_TYPE_AUDIO:
2920
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2921
            break;
2922
        case AVMEDIA_TYPE_VIDEO:
2923
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2924
            break;
2925
        default:
2926
            break;
2927
        }
2928
        if (den != AV_NOPTS_VALUE) {
2929
            if (den <= 0)
2930
                return AVERROR_INVALIDDATA;
2931
            av_frac_init(&st->pts, 0, 0, den);
2932
        }
2933
    }
2934
    return 0;
2935
}
2936

    
2937
//FIXME merge with compute_pkt_fields
2938
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2939
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2940
    int num, den, frame_size, i;
2941

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

    
2945
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2946
        return AVERROR(EINVAL);*/
2947

    
2948
    /* duration field */
2949
    if (pkt->duration == 0) {
2950
        compute_frame_duration(&num, &den, st, NULL, pkt);
2951
        if (den && num) {
2952
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2953
        }
2954
    }
2955

    
2956
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2957
        pkt->pts= pkt->dts;
2958

    
2959
    //XXX/FIXME this is a temporary hack until all encoders output pts
2960
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2961
        pkt->dts=
2962
//        pkt->pts= st->cur_dts;
2963
        pkt->pts= st->pts.val;
2964
    }
2965

    
2966
    //calculate dts from pts
2967
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2968
        st->pts_buffer[0]= pkt->pts;
2969
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2970
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2971
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2972
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2973

    
2974
        pkt->dts= st->pts_buffer[0];
2975
    }
2976

    
2977
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2978
        av_log(s, AV_LOG_ERROR,
2979
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2980
               st->index, st->cur_dts, pkt->dts);
2981
        return AVERROR(EINVAL);
2982
    }
2983
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2984
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2985
        return AVERROR(EINVAL);
2986
    }
2987

    
2988
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2989
    st->cur_dts= pkt->dts;
2990
    st->pts.val= pkt->dts;
2991

    
2992
    /* update pts */
2993
    switch (st->codec->codec_type) {
2994
    case AVMEDIA_TYPE_AUDIO:
2995
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2996

    
2997
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2998
           likely equal to the encoder delay, but it would be better if we
2999
           had the real timestamps from the encoder */
3000
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3001
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3002
        }
3003
        break;
3004
    case AVMEDIA_TYPE_VIDEO:
3005
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3006
        break;
3007
    default:
3008
        break;
3009
    }
3010
    return 0;
3011
}
3012

    
3013
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3014
{
3015
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3016

    
3017
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3018
        return ret;
3019

    
3020
    ret= s->oformat->write_packet(s, pkt);
3021
    if(!ret)
3022
        ret= url_ferror(s->pb);
3023
    return ret;
3024
}
3025

    
3026
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3027
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3028
{
3029
    AVPacketList **next_point, *this_pktl;
3030

    
3031
    this_pktl = av_mallocz(sizeof(AVPacketList));
3032
    this_pktl->pkt= *pkt;
3033
    pkt->destruct= NULL;             // do not free original but only the copy
3034
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3035

    
3036
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3037
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3038
    }else
3039
        next_point = &s->packet_buffer;
3040

    
3041
    if(*next_point){
3042
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3043
            while(!compare(s, &(*next_point)->pkt, pkt)){
3044
                next_point= &(*next_point)->next;
3045
            }
3046
            goto next_non_null;
3047
        }else{
3048
            next_point = &(s->packet_buffer_end->next);
3049
        }
3050
    }
3051
    assert(!*next_point);
3052

    
3053
    s->packet_buffer_end= this_pktl;
3054
next_non_null:
3055

    
3056
    this_pktl->next= *next_point;
3057

    
3058
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3059
    *next_point= this_pktl;
3060
}
3061

    
3062
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3063
{
3064
    AVStream *st = s->streams[ pkt ->stream_index];
3065
    AVStream *st2= s->streams[ next->stream_index];
3066
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3067
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3068
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3069
}
3070

    
3071
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3072
    AVPacketList *pktl;
3073
    int stream_count=0;
3074
    int i;
3075

    
3076
    if(pkt){
3077
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3078
    }
3079

    
3080
    for(i=0; i < s->nb_streams; i++)
3081
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3082

    
3083
    if(stream_count && (s->nb_streams == stream_count || flush)){
3084
        pktl= s->packet_buffer;
3085
        *out= pktl->pkt;
3086

    
3087
        s->packet_buffer= pktl->next;
3088
        if(!s->packet_buffer)
3089
            s->packet_buffer_end= NULL;
3090

    
3091
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3092
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3093
        av_freep(&pktl);
3094
        return 1;
3095
    }else{
3096
        av_init_packet(out);
3097
        return 0;
3098
    }
3099
}
3100

    
3101
/**
3102
 * Interleave an AVPacket correctly so it can be muxed.
3103
 * @param out the interleaved packet will be output here
3104
 * @param in the input packet
3105
 * @param flush 1 if no further packets are available as input and all
3106
 *              remaining packets should be output
3107
 * @return 1 if a packet was output, 0 if no packet could be output,
3108
 *         < 0 if an error occurred
3109
 */
3110
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3111
    if(s->oformat->interleave_packet)
3112
        return s->oformat->interleave_packet(s, out, in, flush);
3113
    else
3114
        return av_interleave_packet_per_dts(s, out, in, flush);
3115
}
3116

    
3117
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3118
    AVStream *st= s->streams[ pkt->stream_index];
3119
    int ret;
3120

    
3121
    //FIXME/XXX/HACK drop zero sized packets
3122
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3123
        return 0;
3124

    
3125
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3126
            pkt->size, pkt->dts, pkt->pts);
3127
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3128
        return ret;
3129

    
3130
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3131
        return AVERROR(EINVAL);
3132

    
3133
    for(;;){
3134
        AVPacket opkt;
3135
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3136
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3137
            return ret;
3138

    
3139
        ret= s->oformat->write_packet(s, &opkt);
3140

    
3141
        av_free_packet(&opkt);
3142
        pkt= NULL;
3143

    
3144
        if(ret<0)
3145
            return ret;
3146
        if(url_ferror(s->pb))
3147
            return url_ferror(s->pb);
3148
    }
3149
}
3150

    
3151
int av_write_trailer(AVFormatContext *s)
3152
{
3153
    int ret, i;
3154

    
3155
    for(;;){
3156
        AVPacket pkt;
3157
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3158
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3159
            goto fail;
3160
        if(!ret)
3161
            break;
3162

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

    
3165
        av_free_packet(&pkt);
3166

    
3167
        if(ret<0)
3168
            goto fail;
3169
        if(url_ferror(s->pb))
3170
            goto fail;
3171
    }
3172

    
3173
    if(s->oformat->write_trailer)
3174
        ret = s->oformat->write_trailer(s);
3175
fail:
3176
    if(ret == 0)
3177
       ret=url_ferror(s->pb);
3178
    for(i=0;i<s->nb_streams;i++) {
3179
        av_freep(&s->streams[i]->priv_data);
3180
        av_freep(&s->streams[i]->index_entries);
3181
    }
3182
    av_freep(&s->priv_data);
3183
    return ret;
3184
}
3185

    
3186
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3187
{
3188
    int i, j;
3189
    AVProgram *program=NULL;
3190
    void *tmp;
3191

    
3192
    if (idx >= ac->nb_streams) {
3193
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3194
        return;
3195
    }
3196

    
3197
    for(i=0; i<ac->nb_programs; i++){
3198
        if(ac->programs[i]->id != progid)
3199
            continue;
3200
        program = ac->programs[i];
3201
        for(j=0; j<program->nb_stream_indexes; j++)
3202
            if(program->stream_index[j] == idx)
3203
                return;
3204

    
3205
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3206
        if(!tmp)
3207
            return;
3208
        program->stream_index = tmp;
3209
        program->stream_index[program->nb_stream_indexes++] = idx;
3210
        return;
3211
    }
3212
}
3213

    
3214
static void print_fps(double d, const char *postfix){
3215
    uint64_t v= lrintf(d*100);
3216
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3217
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3218
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3219
}
3220

    
3221
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3222
{
3223
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3224
        AVMetadataTag *tag=NULL;
3225

    
3226
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3227
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3228
            if(strcmp("language", tag->key))
3229
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3230
        }
3231
    }
3232
}
3233

    
3234
/* "user interface" functions */
3235
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3236
{
3237
    char buf[256];
3238
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3239
    AVStream *st = ic->streams[i];
3240
    int g = av_gcd(st->time_base.num, st->time_base.den);
3241
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3242
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3243
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3244
    /* the pid is an important information, so we display it */
3245
    /* XXX: add a generic system */
3246
    if (flags & AVFMT_SHOW_IDS)
3247
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3248
    if (lang)
3249
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3250
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3251
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3252
    if (st->sample_aspect_ratio.num && // default
3253
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3254
        AVRational display_aspect_ratio;
3255
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3256
                  st->codec->width*st->sample_aspect_ratio.num,
3257
                  st->codec->height*st->sample_aspect_ratio.den,
3258
                  1024*1024);
3259
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3260
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3261
                 display_aspect_ratio.num, display_aspect_ratio.den);
3262
    }
3263
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3264
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3265
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3266
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3267
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3268
        if(st->time_base.den && st->time_base.num)
3269
            print_fps(1/av_q2d(st->time_base), "tbn");
3270
        if(st->codec->time_base.den && st->codec->time_base.num)
3271
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3272
    }
3273
    if (st->disposition & AV_DISPOSITION_DEFAULT)
3274
        av_log(NULL, AV_LOG_INFO, " (default)");
3275
    if (st->disposition & AV_DISPOSITION_DUB)
3276
        av_log(NULL, AV_LOG_INFO, " (dub)");
3277
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
3278
        av_log(NULL, AV_LOG_INFO, " (original)");
3279
    if (st->disposition & AV_DISPOSITION_COMMENT)
3280
        av_log(NULL, AV_LOG_INFO, " (comment)");
3281
    if (st->disposition & AV_DISPOSITION_LYRICS)
3282
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
3283
    if (st->disposition & AV_DISPOSITION_KARAOKE)
3284
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
3285
    if (st->disposition & AV_DISPOSITION_FORCED)
3286
        av_log(NULL, AV_LOG_INFO, " (forced)");
3287
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3288
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3289
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3290
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3291
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3292
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3293
    av_log(NULL, AV_LOG_INFO, "\n");
3294
    dump_metadata(NULL, st->metadata, "    ");
3295
}
3296

    
3297
#if FF_API_DUMP_FORMAT
3298
void dump_format(AVFormatContext *ic,
3299
                 int index,
3300
                 const char *url,
3301
                 int is_output)
3302
{
3303
    av_dump_format(ic, index, url, is_output);
3304
}
3305
#endif
3306

    
3307
void av_dump_format(AVFormatContext *ic,
3308
                    int index,
3309
                    const char *url,
3310
                    int is_output)
3311
{
3312
    int i;
3313
    uint8_t *printed = av_mallocz(ic->nb_streams);
3314
    if (ic->nb_streams && !printed)
3315
        return;
3316

    
3317
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3318
            is_output ? "Output" : "Input",
3319
            index,
3320
            is_output ? ic->oformat->name : ic->iformat->name,
3321
            is_output ? "to" : "from", url);
3322
    dump_metadata(NULL, ic->metadata, "  ");
3323
    if (!is_output) {
3324
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3325
        if (ic->duration != AV_NOPTS_VALUE) {
3326
            int hours, mins, secs, us;
3327
            secs = ic->duration / AV_TIME_BASE;
3328
            us = ic->duration % AV_TIME_BASE;
3329
            mins = secs / 60;
3330
            secs %= 60;
3331
            hours = mins / 60;
3332
            mins %= 60;
3333
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3334
                   (100 * us) / AV_TIME_BASE);
3335
        } else {
3336
            av_log(NULL, AV_LOG_INFO, "N/A");
3337
        }
3338
        if (ic->start_time != AV_NOPTS_VALUE) {
3339
            int secs, us;
3340
            av_log(NULL, AV_LOG_INFO, ", start: ");
3341
            secs = ic->start_time / AV_TIME_BASE;
3342
            us = abs(ic->start_time % AV_TIME_BASE);
3343
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3344
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3345
        }
3346
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3347
        if (ic->bit_rate) {
3348
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3349
        } else {
3350
            av_log(NULL, AV_LOG_INFO, "N/A");
3351
        }
3352
        av_log(NULL, AV_LOG_INFO, "\n");
3353
    }
3354
    for (i = 0; i < ic->nb_chapters; i++) {
3355
        AVChapter *ch = ic->chapters[i];
3356
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3357
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3358
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3359

    
3360
        dump_metadata(NULL, ch->metadata, "    ");
3361
    }
3362
    if(ic->nb_programs) {
3363
        int j, k, total = 0;
3364
        for(j=0; j<ic->nb_programs; j++) {
3365
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3366
                                                  "name", NULL, 0);
3367
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3368
                   name ? name->value : "");
3369
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3370
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3371
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3372
                printed[ic->programs[j]->stream_index[k]] = 1;
3373
            }
3374
            total += ic->programs[j]->nb_stream_indexes;
3375
        }
3376
        if (total < ic->nb_streams)
3377
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3378
    }
3379
    for(i=0;i<ic->nb_streams;i++)
3380
        if (!printed[i])
3381
            dump_stream_format(ic, i, index, is_output);
3382

    
3383
    av_free(printed);
3384
}
3385

    
3386
#if FF_API_PARSE_FRAME_PARAM
3387
#include "libavutil/parseutils.h"
3388

    
3389
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3390
{
3391
    return av_parse_video_size(width_ptr, height_ptr, str);
3392
}
3393

    
3394
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3395
{
3396
    AVRational frame_rate;
3397
    int ret = av_parse_video_rate(&frame_rate, arg);
3398
    *frame_rate_num= frame_rate.num;
3399
    *frame_rate_den= frame_rate.den;
3400
    return ret;
3401
}
3402
#endif
3403

    
3404
int64_t av_gettime(void)
3405
{
3406
    struct timeval tv;
3407
    gettimeofday(&tv,NULL);
3408
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3409
}
3410

    
3411
uint64_t ff_ntp_time(void)
3412
{
3413
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3414
}
3415

    
3416
#if FF_API_PARSE_DATE
3417
#include "libavutil/parseutils.h"
3418

    
3419
int64_t parse_date(const char *timestr, int duration)
3420
{
3421
    int64_t timeval;
3422
    av_parse_time(&timeval, timestr, duration);
3423
    return timeval;
3424
}
3425
#endif
3426

    
3427
#if FF_API_FIND_INFO_TAG
3428
#include "libavutil/parseutils.h"
3429

    
3430
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3431
{
3432
    return av_find_info_tag(arg, arg_size, tag1, info);
3433
}
3434
#endif
3435

    
3436
int av_get_frame_filename(char *buf, int buf_size,
3437
                          const char *path, int number)
3438
{
3439
    const char *p;
3440
    char *q, buf1[20], c;
3441
    int nd, len, percentd_found;
3442

    
3443
    q = buf;
3444
    p = path;
3445
    percentd_found = 0;
3446
    for(;;) {
3447
        c = *p++;
3448
        if (c == '\0')
3449
            break;
3450
        if (c == '%') {
3451
            do {
3452
                nd = 0;
3453
                while (isdigit(*p)) {
3454
                    nd = nd * 10 + *p++ - '0';
3455
                }
3456
                c = *p++;
3457
            } while (isdigit(c));
3458

    
3459
            switch(c) {
3460
            case '%':
3461
                goto addchar;
3462
            case 'd':
3463
                if (percentd_found)
3464
                    goto fail;
3465
                percentd_found = 1;
3466
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3467
                len = strlen(buf1);
3468
                if ((q - buf + len) > buf_size - 1)
3469
                    goto fail;
3470
                memcpy(q, buf1, len);
3471
                q += len;
3472
                break;
3473
            default:
3474
                goto fail;
3475
            }
3476
        } else {
3477
        addchar:
3478
            if ((q - buf) < buf_size - 1)
3479
                *q++ = c;
3480
        }
3481
    }
3482
    if (!percentd_found)
3483
        goto fail;
3484
    *q = '\0';
3485
    return 0;
3486
 fail:
3487
    *q = '\0';
3488
    return -1;
3489
}
3490

    
3491
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3492
{
3493
    int len, i, j, c;
3494
#undef fprintf
3495
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3496

    
3497
    for(i=0;i<size;i+=16) {
3498
        len = size - i;
3499
        if (len > 16)
3500
            len = 16;
3501
        PRINT("%08x ", i);
3502
        for(j=0;j<16;j++) {
3503
            if (j < len)
3504
                PRINT(" %02x", buf[i+j]);
3505
            else
3506
                PRINT("   ");
3507
        }
3508
        PRINT(" ");
3509
        for(j=0;j<len;j++) {
3510
            c = buf[i+j];
3511
            if (c < ' ' || c > '~')
3512
                c = '.';
3513
            PRINT("%c", c);
3514
        }
3515
        PRINT("\n");
3516
    }
3517
#undef PRINT
3518
}
3519

    
3520
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3521
{
3522
    hex_dump_internal(NULL, f, 0, buf, size);
3523
}
3524

    
3525
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3526
{
3527
    hex_dump_internal(avcl, NULL, level, buf, size);
3528
}
3529

    
3530
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3531
{
3532
#undef fprintf
3533
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3534
    PRINT("stream #%d:\n", pkt->stream_index);
3535
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3536
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3537
    /* DTS is _always_ valid after av_read_frame() */
3538
    PRINT("  dts=");
3539
    if (pkt->dts == AV_NOPTS_VALUE)
3540
        PRINT("N/A");
3541
    else
3542
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3543
    /* PTS may not be known if B-frames are present. */
3544
    PRINT("  pts=");
3545
    if (pkt->pts == AV_NOPTS_VALUE)
3546
        PRINT("N/A");
3547
    else
3548
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3549
    PRINT("\n");
3550
    PRINT("  size=%d\n", pkt->size);
3551
#undef PRINT
3552
    if (dump_payload)
3553
        av_hex_dump(f, pkt->data, pkt->size);
3554
}
3555

    
3556
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3557
{
3558
    AVRational tb = { 1, AV_TIME_BASE };
3559
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3560
}
3561

    
3562
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3563
{
3564
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3565
}
3566

    
3567
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3568
{
3569
    AVRational tb = { 1, AV_TIME_BASE };
3570
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3571
}
3572

    
3573
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3574
                      AVStream *st)
3575
{
3576
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3577
}
3578

    
3579
#if FF_API_URL_SPLIT
3580
attribute_deprecated
3581
void ff_url_split(char *proto, int proto_size,
3582
                  char *authorization, int authorization_size,
3583
                  char *hostname, int hostname_size,
3584
                  int *port_ptr,
3585
                  char *path, int path_size,
3586
                  const char *url)
3587
{
3588
    av_url_split(proto, proto_size,
3589
                 authorization, authorization_size,
3590
                 hostname, hostname_size,
3591
                 port_ptr,
3592
                 path, path_size,
3593
                 url);
3594
}
3595
#endif
3596

    
3597
void av_url_split(char *proto, int proto_size,
3598
                  char *authorization, int authorization_size,
3599
                  char *hostname, int hostname_size,
3600
                  int *port_ptr,
3601
                  char *path, int path_size,
3602
                  const char *url)
3603
{
3604
    const char *p, *ls, *at, *col, *brk;
3605

    
3606
    if (port_ptr)               *port_ptr = -1;
3607
    if (proto_size > 0)         proto[0] = 0;
3608
    if (authorization_size > 0) authorization[0] = 0;
3609
    if (hostname_size > 0)      hostname[0] = 0;
3610
    if (path_size > 0)          path[0] = 0;
3611

    
3612
    /* parse protocol */
3613
    if ((p = strchr(url, ':'))) {
3614
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3615
        p++; /* skip ':' */
3616
        if (*p == '/') p++;
3617
        if (*p == '/') p++;
3618
    } else {
3619
        /* no protocol means plain filename */
3620
        av_strlcpy(path, url, path_size);
3621
        return;
3622
    }
3623

    
3624
    /* separate path from hostname */
3625
    ls = strchr(p, '/');
3626
    if(!ls)
3627
        ls = strchr(p, '?');
3628
    if(ls)
3629
        av_strlcpy(path, ls, path_size);
3630
    else
3631
        ls = &p[strlen(p)]; // XXX
3632

    
3633
    /* the rest is hostname, use that to parse auth/port */
3634
    if (ls != p) {
3635
        /* authorization (user[:pass]@hostname) */
3636
        if ((at = strchr(p, '@')) && at < ls) {
3637
            av_strlcpy(authorization, p,
3638
                       FFMIN(authorization_size, at + 1 - p));
3639
            p = at + 1; /* skip '@' */
3640
        }
3641

    
3642
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3643
            /* [host]:port */
3644
            av_strlcpy(hostname, p + 1,
3645
                       FFMIN(hostname_size, brk - p));
3646
            if (brk[1] == ':' && port_ptr)
3647
                *port_ptr = atoi(brk + 2);
3648
        } else if ((col = strchr(p, ':')) && col < ls) {
3649
            av_strlcpy(hostname, p,
3650
                       FFMIN(col + 1 - p, hostname_size));
3651
            if (port_ptr) *port_ptr = atoi(col + 1);
3652
        } else
3653
            av_strlcpy(hostname, p,
3654
                       FFMIN(ls + 1 - p, hostname_size));
3655
    }
3656
}
3657

    
3658
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3659
{
3660
    int i;
3661
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3662
                                           '4', '5', '6', '7',
3663
                                           '8', '9', 'A', 'B',
3664
                                           'C', 'D', 'E', 'F' };
3665
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3666
                                           '4', '5', '6', '7',
3667
                                           '8', '9', 'a', 'b',
3668
                                           'c', 'd', 'e', 'f' };
3669
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3670

    
3671
    for(i = 0; i < s; i++) {
3672
        buff[i * 2]     = hex_table[src[i] >> 4];
3673
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3674
    }
3675

    
3676
    return buff;
3677
}
3678

    
3679
int ff_hex_to_data(uint8_t *data, const char *p)
3680
{
3681
    int c, len, v;
3682

    
3683
    len = 0;
3684
    v = 1;
3685
    for (;;) {
3686
        p += strspn(p, SPACE_CHARS);
3687
        if (*p == '\0')
3688
            break;
3689
        c = toupper((unsigned char) *p++);
3690
        if (c >= '0' && c <= '9')
3691
            c = c - '0';
3692
        else if (c >= 'A' && c <= 'F')
3693
            c = c - 'A' + 10;
3694
        else
3695
            break;
3696
        v = (v << 4) | c;
3697
        if (v & 0x100) {
3698
            if (data)
3699
                data[len] = v;
3700
            len++;
3701
            v = 1;
3702
        }
3703
    }
3704
    return len;
3705
}
3706

    
3707
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3708
                     unsigned int pts_num, unsigned int pts_den)
3709
{
3710
    AVRational new_tb;
3711
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3712
        if(new_tb.num != pts_num)
3713
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3714
    }else
3715
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3716

    
3717
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3718
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3719
        return;
3720
    }
3721
    s->time_base = new_tb;
3722
    s->pts_wrap_bits = pts_wrap_bits;
3723
}
3724

    
3725
int ff_url_join(char *str, int size, const char *proto,
3726
                const char *authorization, const char *hostname,
3727
                int port, const char *fmt, ...)
3728
{
3729
#if CONFIG_NETWORK
3730
    struct addrinfo hints, *ai;
3731
#endif
3732

    
3733
    str[0] = '\0';
3734
    if (proto)
3735
        av_strlcatf(str, size, "%s://", proto);
3736
    if (authorization && authorization[0])
3737
        av_strlcatf(str, size, "%s@", authorization);
3738
#if CONFIG_NETWORK && defined(AF_INET6)
3739
    /* Determine if hostname is a numerical IPv6 address,
3740
     * properly escape it within [] in that case. */
3741
    memset(&hints, 0, sizeof(hints));
3742
    hints.ai_flags = AI_NUMERICHOST;
3743
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3744
        if (ai->ai_family == AF_INET6) {
3745
            av_strlcat(str, "[", size);
3746
            av_strlcat(str, hostname, size);
3747
            av_strlcat(str, "]", size);
3748
        } else {
3749
            av_strlcat(str, hostname, size);
3750
        }
3751
        freeaddrinfo(ai);
3752
    } else
3753
#endif
3754
        /* Not an IPv6 address, just output the plain string. */
3755
        av_strlcat(str, hostname, size);
3756

    
3757
    if (port >= 0)
3758
        av_strlcatf(str, size, ":%d", port);
3759
    if (fmt) {
3760
        va_list vl;
3761
        int len = strlen(str);
3762

    
3763
        va_start(vl, fmt);
3764
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3765
        va_end(vl);
3766
    }
3767
    return strlen(str);
3768
}
3769

    
3770
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3771
                     AVFormatContext *src)
3772
{
3773
    AVPacket local_pkt;
3774

    
3775
    local_pkt = *pkt;
3776
    local_pkt.stream_index = dst_stream;
3777
    if (pkt->pts != AV_NOPTS_VALUE)
3778
        local_pkt.pts = av_rescale_q(pkt->pts,
3779
                                     src->streams[pkt->stream_index]->time_base,
3780
                                     dst->streams[dst_stream]->time_base);
3781
    if (pkt->dts != AV_NOPTS_VALUE)
3782
        local_pkt.dts = av_rescale_q(pkt->dts,
3783
                                     src->streams[pkt->stream_index]->time_base,
3784
                                     dst->streams[dst_stream]->time_base);
3785
    return av_write_frame(dst, &local_pkt);
3786
}
3787

    
3788
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3789
                        void *context)
3790
{
3791
    const char *ptr = str;
3792

    
3793
    /* Parse key=value pairs. */
3794
    for (;;) {
3795
        const char *key;
3796
        char *dest = NULL, *dest_end;
3797
        int key_len, dest_len = 0;
3798

    
3799
        /* Skip whitespace and potential commas. */
3800
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3801
            ptr++;
3802
        if (!*ptr)
3803
            break;
3804

    
3805
        key = ptr;
3806

    
3807
        if (!(ptr = strchr(key, '=')))
3808
            break;
3809
        ptr++;
3810
        key_len = ptr - key;
3811

    
3812
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3813
        dest_end = dest + dest_len - 1;
3814

    
3815
        if (*ptr == '\"') {
3816
            ptr++;
3817
            while (*ptr && *ptr != '\"') {
3818
                if (*ptr == '\\') {
3819
                    if (!ptr[1])
3820
                        break;
3821
                    if (dest && dest < dest_end)
3822
                        *dest++ = ptr[1];
3823
                    ptr += 2;
3824
                } else {
3825
                    if (dest && dest < dest_end)
3826
                        *dest++ = *ptr;
3827
                    ptr++;
3828
                }
3829
            }
3830
            if (*ptr == '\"')
3831
                ptr++;
3832
        } else {
3833
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3834
                if (dest && dest < dest_end)
3835
                    *dest++ = *ptr;
3836
        }
3837
        if (dest)
3838
            *dest = 0;
3839
    }
3840
}
3841

    
3842
int ff_find_stream_index(AVFormatContext *s, int id)
3843
{
3844
    int i;
3845
    for (i = 0; i < s->nb_streams; i++) {
3846
        if (s->streams[i]->id == id)
3847
            return i;
3848
    }
3849
    return -1;
3850
}
3851

    
3852
void ff_make_absolute_url(char *buf, int size, const char *base,
3853
                          const char *rel)
3854
{
3855
    char *sep;
3856
    /* Absolute path, relative to the current server */
3857
    if (base && strstr(base, "://") && rel[0] == '/') {
3858
        if (base != buf)
3859
            av_strlcpy(buf, base, size);
3860
        sep = strstr(buf, "://");
3861
        if (sep) {
3862
            sep += 3;
3863
            sep = strchr(sep, '/');
3864
            if (sep)
3865
                *sep = '\0';
3866
        }
3867
        av_strlcat(buf, rel, size);
3868
        return;
3869
    }
3870
    /* If rel actually is an absolute url, just copy it */
3871
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3872
        av_strlcpy(buf, rel, size);
3873
        return;
3874
    }
3875
    if (base != buf)
3876
        av_strlcpy(buf, base, size);
3877
    /* Remove the file name from the base url */
3878
    sep = strrchr(buf, '/');
3879
    if (sep)
3880
        sep[1] = '\0';
3881
    else
3882
        buf[0] = '\0';
3883
    while (av_strstart(rel, "../", NULL) && sep) {
3884
        /* Remove the path delimiter at the end */
3885
        sep[0] = '\0';
3886
        sep = strrchr(buf, '/');
3887
        /* If the next directory name to pop off is "..", break here */
3888
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3889
            /* Readd the slash we just removed */
3890
            av_strlcat(buf, "/", size);
3891
            break;
3892
        }
3893
        /* Cut off the directory name */
3894
        if (sep)
3895
            sep[1] = '\0';
3896
        else
3897
            buf[0] = '\0';
3898
        rel += 3;
3899
    }
3900
    av_strlcat(buf, rel, size);
3901
}