Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 56a10009

History | View | Annotate | Download (124 KB)

1
/*
2
 * various utility functions for use within Libav
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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 Libav
48
 */
49

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

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

    
60
const char *avformat_license(void)
61
{
62
#define LICENSE_PREFIX "libavformat license: "
63
    return LICENSE_PREFIX LIBAV_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, id3 = 0;
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
        id3 = 1;
383
    }
384

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

    
404
    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
405
    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4) {
406
        while ((fmt = av_iformat_next(fmt)))
407
            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
408
                *score_max = AVPROBE_SCORE_MAX/4;
409
                break;
410
            }
411
    }
412

    
413
    return fmt;
414
}
415

    
416
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
417
    int score=0;
418
    return av_probe_input_format2(pd, is_opened, &score);
419
}
420

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

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

    
453
/************************************************************/
454
/* input media file */
455

    
456
/**
457
 * Open a media file from an IO stream. 'fmt' must be specified.
458
 */
459
int av_open_input_stream(AVFormatContext **ic_ptr,
460
                         AVIOContext *pb, const char *filename,
461
                         AVInputFormat *fmt, AVFormatParameters *ap)
462
{
463
    int err;
464
    AVFormatContext *ic;
465
    AVFormatParameters default_ap;
466

    
467
    if(!ap){
468
        ap=&default_ap;
469
        memset(ap, 0, sizeof(default_ap));
470
    }
471

    
472
    if(!ap->prealloced_context)
473
        ic = avformat_alloc_context();
474
    else
475
        ic = *ic_ptr;
476
    if (!ic) {
477
        err = AVERROR(ENOMEM);
478
        goto fail;
479
    }
480
    ic->iformat = fmt;
481
    ic->pb = pb;
482
    ic->duration = AV_NOPTS_VALUE;
483
    ic->start_time = AV_NOPTS_VALUE;
484
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
485

    
486
    /* allocate private data */
487
    if (fmt->priv_data_size > 0) {
488
        ic->priv_data = av_mallocz(fmt->priv_data_size);
489
        if (!ic->priv_data) {
490
            err = AVERROR(ENOMEM);
491
            goto fail;
492
        }
493
    } else {
494
        ic->priv_data = NULL;
495
    }
496

    
497
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
498
    if (ic->pb)
499
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
500

    
501
    if (ic->iformat->read_header) {
502
        err = ic->iformat->read_header(ic, ap);
503
        if (err < 0)
504
            goto fail;
505
    }
506

    
507
    if (pb && !ic->data_offset)
508
        ic->data_offset = avio_tell(ic->pb);
509

    
510
#if FF_API_OLD_METADATA
511
    ff_metadata_demux_compat(ic);
512
#endif
513

    
514
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
515

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

    
538
/** size of probe buffer, for guessing file type from file contents */
539
#define PROBE_BUF_MIN 2048
540
#define PROBE_BUF_MAX (1<<20)
541

    
542
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
543
                          const char *filename, void *logctx,
544
                          unsigned int offset, unsigned int max_probe_size)
545
{
546
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
547
    unsigned char *buf = NULL;
548
    int ret = 0, probe_size;
549

    
550
    if (!max_probe_size) {
551
        max_probe_size = PROBE_BUF_MAX;
552
    } else if (max_probe_size > PROBE_BUF_MAX) {
553
        max_probe_size = PROBE_BUF_MAX;
554
    } else if (max_probe_size < PROBE_BUF_MIN) {
555
        return AVERROR(EINVAL);
556
    }
557

    
558
    if (offset >= max_probe_size) {
559
        return AVERROR(EINVAL);
560
    }
561

    
562
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
563
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
564
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
565
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
566

    
567
        if (probe_size < offset) {
568
            continue;
569
        }
570

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

    
585
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
586

    
587
        /* guess file format */
588
        *fmt = av_probe_input_format2(&pd, 1, &score);
589
        if(*fmt){
590
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
591
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
592
            }else
593
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
594
        }
595
    }
596

    
597
    if (!*fmt) {
598
        av_free(buf);
599
        return AVERROR_INVALIDDATA;
600
    }
601

    
602
    /* rewind. reuse probe buffer to avoid seeking */
603
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
604
        av_free(buf);
605

    
606
    return ret;
607
}
608

    
609
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
610
                       AVInputFormat *fmt,
611
                       int buf_size,
612
                       AVFormatParameters *ap)
613
{
614
    int err;
615
    AVProbeData probe_data, *pd = &probe_data;
616
    AVIOContext *pb = NULL;
617
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
618

    
619
    pd->filename = "";
620
    if (filename)
621
        pd->filename = filename;
622
    pd->buf = NULL;
623
    pd->buf_size = 0;
624

    
625
    if (!fmt) {
626
        /* guess format if no file can be opened */
627
        fmt = av_probe_input_format(pd, 0);
628
    }
629

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

    
645
    /* if still no format found, error */
646
    if (!fmt) {
647
        err = AVERROR_INVALIDDATA;
648
        goto fail;
649
    }
650

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

    
671
}
672

    
673
/*******************************************************/
674

    
675
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
676
                               AVPacketList **plast_pktl){
677
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
678
    if (!pktl)
679
        return NULL;
680

    
681
    if (*packet_buffer)
682
        (*plast_pktl)->next = pktl;
683
    else
684
        *packet_buffer = pktl;
685

    
686
    /* add the packet in the buffered packet list */
687
    *plast_pktl = pktl;
688
    pktl->pkt= *pkt;
689
    return &pktl->pkt;
690
}
691

    
692
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
693
{
694
    int ret, i;
695
    AVStream *st;
696

    
697
    for(;;){
698
        AVPacketList *pktl = s->raw_packet_buffer;
699

    
700
        if (pktl) {
701
            *pkt = pktl->pkt;
702
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
703
               !s->streams[pkt->stream_index]->probe_packets ||
704
               s->raw_packet_buffer_remaining_size < pkt->size){
705
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
706
                av_freep(&pd->buf);
707
                pd->buf_size = 0;
708
                s->raw_packet_buffer = pktl->next;
709
                s->raw_packet_buffer_remaining_size += pkt->size;
710
                av_free(pktl);
711
                return 0;
712
            }
713
        }
714

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

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

    
738
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
739
                     !st->probe_packets))
740
            return ret;
741

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

    
745
        if(st->codec->codec_id == CODEC_ID_PROBE){
746
            AVProbeData *pd = &st->probe_data;
747
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
748
            --st->probe_packets;
749

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

    
755
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
756
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
757
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
758
                if(st->codec->codec_id != CODEC_ID_PROBE){
759
                    pd->buf_size=0;
760
                    av_freep(&pd->buf);
761
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
762
                }
763
            }
764
        }
765
    }
766
}
767

    
768
/**********************************************************/
769

    
770
/**
771
 * Get the number of samples of an audio frame. Return -1 on error.
772
 */
773
static int get_audio_frame_size(AVCodecContext *enc, int size)
774
{
775
    int frame_size;
776

    
777
    if(enc->codec_id == CODEC_ID_VORBIS)
778
        return -1;
779

    
780
    if (enc->frame_size <= 1) {
781
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
782

    
783
        if (bits_per_sample) {
784
            if (enc->channels == 0)
785
                return -1;
786
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
787
        } else {
788
            /* used for example by ADPCM codecs */
789
            if (enc->bit_rate == 0)
790
                return -1;
791
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
792
        }
793
    } else {
794
        frame_size = enc->frame_size;
795
    }
796
    return frame_size;
797
}
798

    
799

    
800
/**
801
 * Return the frame duration in seconds. Return 0 if not available.
802
 */
803
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
804
                                   AVCodecParserContext *pc, AVPacket *pkt)
805
{
806
    int frame_size;
807

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

    
840
static int is_intra_only(AVCodecContext *enc){
841
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
842
        return 1;
843
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
844
        switch(enc->codec_id){
845
        case CODEC_ID_MJPEG:
846
        case CODEC_ID_MJPEGB:
847
        case CODEC_ID_LJPEG:
848
        case CODEC_ID_RAWVIDEO:
849
        case CODEC_ID_DVVIDEO:
850
        case CODEC_ID_HUFFYUV:
851
        case CODEC_ID_FFVHUFF:
852
        case CODEC_ID_ASV1:
853
        case CODEC_ID_ASV2:
854
        case CODEC_ID_VCR1:
855
        case CODEC_ID_DNXHD:
856
        case CODEC_ID_JPEG2000:
857
            return 1;
858
        default: break;
859
        }
860
    }
861
    return 0;
862
}
863

    
864
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
865
                                      int64_t dts, int64_t pts)
866
{
867
    AVStream *st= s->streams[stream_index];
868
    AVPacketList *pktl= s->packet_buffer;
869

    
870
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
871
        return;
872

    
873
    st->first_dts= dts - st->cur_dts;
874
    st->cur_dts= dts;
875

    
876
    for(; pktl; pktl= pktl->next){
877
        if(pktl->pkt.stream_index != stream_index)
878
            continue;
879
        //FIXME think more about this check
880
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
881
            pktl->pkt.pts += st->first_dts;
882

    
883
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
884
            pktl->pkt.dts += st->first_dts;
885

    
886
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
887
            st->start_time= pktl->pkt.pts;
888
    }
889
    if (st->start_time == AV_NOPTS_VALUE)
890
        st->start_time = pts;
891
}
892

    
893
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
894
{
895
    AVPacketList *pktl= s->packet_buffer;
896
    int64_t cur_dts= 0;
897

    
898
    if(st->first_dts != AV_NOPTS_VALUE){
899
        cur_dts= st->first_dts;
900
        for(; pktl; pktl= pktl->next){
901
            if(pktl->pkt.stream_index == pkt->stream_index){
902
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
903
                    break;
904
                cur_dts -= pkt->duration;
905
            }
906
        }
907
        pktl= s->packet_buffer;
908
        st->first_dts = cur_dts;
909
    }else if(st->cur_dts)
910
        return;
911

    
912
    for(; pktl; pktl= pktl->next){
913
        if(pktl->pkt.stream_index != pkt->stream_index)
914
            continue;
915
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
916
           && !pktl->pkt.duration){
917
            pktl->pkt.dts= cur_dts;
918
            if(!st->codec->has_b_frames)
919
                pktl->pkt.pts= cur_dts;
920
            cur_dts += pkt->duration;
921
            pktl->pkt.duration= pkt->duration;
922
        }else
923
            break;
924
    }
925
    if(st->first_dts == AV_NOPTS_VALUE)
926
        st->cur_dts= cur_dts;
927
}
928

    
929
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
930
                               AVCodecParserContext *pc, AVPacket *pkt)
931
{
932
    int num, den, presentation_delayed, delay, i;
933
    int64_t offset;
934

    
935
    if (s->flags & AVFMT_FLAG_NOFILLIN)
936
        return;
937

    
938
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
939
        pkt->dts= AV_NOPTS_VALUE;
940

    
941
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
942
        //FIXME Set low_delay = 0 when has_b_frames = 1
943
        st->codec->has_b_frames = 1;
944

    
945
    /* do we have a video B-frame ? */
946
    delay= st->codec->has_b_frames;
947
    presentation_delayed = 0;
948

    
949
    // ignore delay caused by frame threading so that the mpeg2-without-dts
950
    // warning will not trigger
951
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
952
        delay -= st->codec->thread_count-1;
953

    
954
    /* XXX: need has_b_frame, but cannot get it if the codec is
955
        not initialized */
956
    if (delay &&
957
        pc && pc->pict_type != FF_B_TYPE)
958
        presentation_delayed = 1;
959

    
960
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
961
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
962
        pkt->dts -= 1LL<<st->pts_wrap_bits;
963
    }
964

    
965
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
966
    // we take the conservative approach and discard both
967
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
968
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
969
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
970
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
971
    }
972

    
973
    if (pkt->duration == 0) {
974
        compute_frame_duration(&num, &den, st, pc, pkt);
975
        if (den && num) {
976
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
977

    
978
            if(pkt->duration != 0 && s->packet_buffer)
979
                update_initial_durations(s, st, pkt);
980
        }
981
    }
982

    
983
    /* correct timestamps with byte offset if demuxers only have timestamps
984
       on packet boundaries */
985
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
986
        /* this will estimate bitrate based on this frame's duration and size */
987
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
988
        if(pkt->pts != AV_NOPTS_VALUE)
989
            pkt->pts += offset;
990
        if(pkt->dts != AV_NOPTS_VALUE)
991
            pkt->dts += offset;
992
    }
993

    
994
    if (pc && pc->dts_sync_point >= 0) {
995
        // we have synchronization info from the parser
996
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
997
        if (den > 0) {
998
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
999
            if (pkt->dts != AV_NOPTS_VALUE) {
1000
                // got DTS from the stream, update reference timestamp
1001
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1002
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1003
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
1004
                // compute DTS based on reference timestamp
1005
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1006
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1007
            }
1008
            if (pc->dts_sync_point > 0)
1009
                st->reference_dts = pkt->dts; // new reference
1010
        }
1011
    }
1012

    
1013
    /* This may be redundant, but it should not hurt. */
1014
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1015
        presentation_delayed = 1;
1016

    
1017
//    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);
1018
    /* interpolate PTS and DTS if they are not present */
1019
    //We skip H264 currently because delay and has_b_frames are not reliably set
1020
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1021
        if (presentation_delayed) {
1022
            /* DTS = decompression timestamp */
1023
            /* PTS = presentation timestamp */
1024
            if (pkt->dts == AV_NOPTS_VALUE)
1025
                pkt->dts = st->last_IP_pts;
1026
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1027
            if (pkt->dts == AV_NOPTS_VALUE)
1028
                pkt->dts = st->cur_dts;
1029

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

    
1050
            /* presentation is not delayed : PTS and DTS are the same */
1051
            if(pkt->pts == AV_NOPTS_VALUE)
1052
                pkt->pts = pkt->dts;
1053
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1054
            if(pkt->pts == AV_NOPTS_VALUE)
1055
                pkt->pts = st->cur_dts;
1056
            pkt->dts = pkt->pts;
1057
            if(pkt->pts != AV_NOPTS_VALUE)
1058
                st->cur_dts = pkt->pts + pkt->duration;
1059
        }
1060
    }
1061

    
1062
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1063
        st->pts_buffer[0]= pkt->pts;
1064
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1065
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1066
        if(pkt->dts == AV_NOPTS_VALUE)
1067
            pkt->dts= st->pts_buffer[0];
1068
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1069
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1070
        }
1071
        if(pkt->dts > st->cur_dts)
1072
            st->cur_dts = pkt->dts;
1073
    }
1074

    
1075
//    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);
1076

    
1077
    /* update flags */
1078
    if(is_intra_only(st->codec))
1079
        pkt->flags |= AV_PKT_FLAG_KEY;
1080
    else if (pc) {
1081
        pkt->flags = 0;
1082
        /* keyframe computation */
1083
        if (pc->key_frame == 1)
1084
            pkt->flags |= AV_PKT_FLAG_KEY;
1085
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1086
            pkt->flags |= AV_PKT_FLAG_KEY;
1087
    }
1088
    if (pc)
1089
        pkt->convergence_duration = pc->convergence_duration;
1090
}
1091

    
1092

    
1093
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1094
{
1095
    AVStream *st;
1096
    int len, ret, i;
1097

    
1098
    av_init_packet(pkt);
1099

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

    
1127
                /* return packet if any */
1128
                if (pkt->size) {
1129
                got_packet:
1130
                    pkt->duration = 0;
1131
                    pkt->stream_index = st->index;
1132
                    pkt->pts = st->parser->pts;
1133
                    pkt->dts = st->parser->dts;
1134
                    pkt->pos = st->parser->pos;
1135
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1136
                        s->cur_st = NULL;
1137
                        pkt->destruct= st->cur_pkt.destruct;
1138
                        st->cur_pkt.destruct= NULL;
1139
                        st->cur_pkt.data    = NULL;
1140
                        assert(st->cur_len == 0);
1141
                    }else{
1142
                    pkt->destruct = NULL;
1143
                    }
1144
                    compute_pkt_fields(s, st, st->parser, pkt);
1145

    
1146
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1147
                        ff_reduce_index(s, st->index);
1148
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1149
                                           0, 0, AVINDEX_KEYFRAME);
1150
                    }
1151

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

    
1185
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1186
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1187
               st->cur_pkt.pts < st->cur_pkt.dts){
1188
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1189
                    st->cur_pkt.stream_index,
1190
                    st->cur_pkt.pts,
1191
                    st->cur_pkt.dts,
1192
                    st->cur_pkt.size);
1193
//                av_free_packet(&st->cur_pkt);
1194
//                return -1;
1195
            }
1196

    
1197
            if(s->debug & FF_FDEBUG_TS)
1198
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1199
                    st->cur_pkt.stream_index,
1200
                    st->cur_pkt.pts,
1201
                    st->cur_pkt.dts,
1202
                    st->cur_pkt.size,
1203
                    st->cur_pkt.duration,
1204
                    st->cur_pkt.flags);
1205

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

    
1231
    return 0;
1232
}
1233

    
1234
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1235
{
1236
    AVPacketList *pktl;
1237
    int eof=0;
1238
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1239

    
1240
    for(;;){
1241
        pktl = s->packet_buffer;
1242
        if (pktl) {
1243
            AVPacket *next_pkt= &pktl->pkt;
1244

    
1245
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1246
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1247
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1248
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1249
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1250
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1251
                        next_pkt->pts= pktl->pkt.dts;
1252
                    }
1253
                    pktl= pktl->next;
1254
                }
1255
                pktl = s->packet_buffer;
1256
            }
1257

    
1258
            if(   next_pkt->pts != AV_NOPTS_VALUE
1259
               || next_pkt->dts == AV_NOPTS_VALUE
1260
               || !genpts || eof){
1261
                /* read packet from packet buffer, if there is data */
1262
                *pkt = *next_pkt;
1263
                s->packet_buffer = pktl->next;
1264
                av_free(pktl);
1265
                return 0;
1266
            }
1267
        }
1268
        if(genpts){
1269
            int ret= av_read_frame_internal(s, pkt);
1270
            if(ret<0){
1271
                if(pktl && ret != AVERROR(EAGAIN)){
1272
                    eof=1;
1273
                    continue;
1274
                }else
1275
                    return ret;
1276
            }
1277

    
1278
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1279
                                           &s->packet_buffer_end)) < 0)
1280
                return AVERROR(ENOMEM);
1281
        }else{
1282
            assert(!s->packet_buffer);
1283
            return av_read_frame_internal(s, pkt);
1284
        }
1285
    }
1286
}
1287

    
1288
/* XXX: suppress the packet queue */
1289
static void flush_packet_queue(AVFormatContext *s)
1290
{
1291
    AVPacketList *pktl;
1292

    
1293
    for(;;) {
1294
        pktl = s->packet_buffer;
1295
        if (!pktl)
1296
            break;
1297
        s->packet_buffer = pktl->next;
1298
        av_free_packet(&pktl->pkt);
1299
        av_free(pktl);
1300
    }
1301
    while(s->raw_packet_buffer){
1302
        pktl = s->raw_packet_buffer;
1303
        s->raw_packet_buffer = pktl->next;
1304
        av_free_packet(&pktl->pkt);
1305
        av_free(pktl);
1306
    }
1307
    s->packet_buffer_end=
1308
    s->raw_packet_buffer_end= NULL;
1309
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1310
}
1311

    
1312
/*******************************************************/
1313
/* seek support */
1314

    
1315
int av_find_default_stream_index(AVFormatContext *s)
1316
{
1317
    int first_audio_index = -1;
1318
    int i;
1319
    AVStream *st;
1320

    
1321
    if (s->nb_streams <= 0)
1322
        return -1;
1323
    for(i = 0; i < s->nb_streams; i++) {
1324
        st = s->streams[i];
1325
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1326
            return i;
1327
        }
1328
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1329
            first_audio_index = i;
1330
    }
1331
    return first_audio_index >= 0 ? first_audio_index : 0;
1332
}
1333

    
1334
/**
1335
 * Flush the frame reader.
1336
 */
1337
void ff_read_frame_flush(AVFormatContext *s)
1338
{
1339
    AVStream *st;
1340
    int i, j;
1341

    
1342
    flush_packet_queue(s);
1343

    
1344
    s->cur_st = NULL;
1345

    
1346
    /* for each stream, reset read state */
1347
    for(i = 0; i < s->nb_streams; i++) {
1348
        st = s->streams[i];
1349

    
1350
        if (st->parser) {
1351
            av_parser_close(st->parser);
1352
            st->parser = NULL;
1353
            av_free_packet(&st->cur_pkt);
1354
        }
1355
        st->last_IP_pts = AV_NOPTS_VALUE;
1356
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1357
        st->reference_dts = AV_NOPTS_VALUE;
1358
        /* fail safe */
1359
        st->cur_ptr = NULL;
1360
        st->cur_len = 0;
1361

    
1362
        st->probe_packets = MAX_PROBE_PACKETS;
1363

    
1364
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1365
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1366
    }
1367
}
1368

    
1369
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1370
    int i;
1371

    
1372
    for(i = 0; i < s->nb_streams; i++) {
1373
        AVStream *st = s->streams[i];
1374

    
1375
        st->cur_dts = av_rescale(timestamp,
1376
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1377
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1378
    }
1379
}
1380

    
1381
void ff_reduce_index(AVFormatContext *s, int stream_index)
1382
{
1383
    AVStream *st= s->streams[stream_index];
1384
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1385

    
1386
    if((unsigned)st->nb_index_entries >= max_entries){
1387
        int i;
1388
        for(i=0; 2*i<st->nb_index_entries; i++)
1389
            st->index_entries[i]= st->index_entries[2*i];
1390
        st->nb_index_entries= i;
1391
    }
1392
}
1393

    
1394
int ff_add_index_entry(AVIndexEntry **index_entries,
1395
                       int *nb_index_entries,
1396
                       unsigned int *index_entries_allocated_size,
1397
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1398
{
1399
    AVIndexEntry *entries, *ie;
1400
    int index;
1401

    
1402
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1403
        return -1;
1404

    
1405
    entries = av_fast_realloc(*index_entries,
1406
                              index_entries_allocated_size,
1407
                              (*nb_index_entries + 1) *
1408
                              sizeof(AVIndexEntry));
1409
    if(!entries)
1410
        return -1;
1411

    
1412
    *index_entries= entries;
1413

    
1414
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1415

    
1416
    if(index<0){
1417
        index= (*nb_index_entries)++;
1418
        ie= &entries[index];
1419
        assert(index==0 || ie[-1].timestamp < timestamp);
1420
    }else{
1421
        ie= &entries[index];
1422
        if(ie->timestamp != timestamp){
1423
            if(ie->timestamp <= timestamp)
1424
                return -1;
1425
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1426
            (*nb_index_entries)++;
1427
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1428
            distance= ie->min_distance;
1429
    }
1430

    
1431
    ie->pos = pos;
1432
    ie->timestamp = timestamp;
1433
    ie->min_distance= distance;
1434
    ie->size= size;
1435
    ie->flags = flags;
1436

    
1437
    return index;
1438
}
1439

    
1440
int av_add_index_entry(AVStream *st,
1441
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1442
{
1443
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1444
                              &st->index_entries_allocated_size, pos,
1445
                              timestamp, size, distance, flags);
1446
}
1447

    
1448
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1449
                              int64_t wanted_timestamp, int flags)
1450
{
1451
    int a, b, m;
1452
    int64_t timestamp;
1453

    
1454
    a = - 1;
1455
    b = nb_entries;
1456

    
1457
    //optimize appending index entries at the end
1458
    if(b && entries[b-1].timestamp < wanted_timestamp)
1459
        a= b-1;
1460

    
1461
    while (b - a > 1) {
1462
        m = (a + b) >> 1;
1463
        timestamp = entries[m].timestamp;
1464
        if(timestamp >= wanted_timestamp)
1465
            b = m;
1466
        if(timestamp <= wanted_timestamp)
1467
            a = m;
1468
    }
1469
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1470

    
1471
    if(!(flags & AVSEEK_FLAG_ANY)){
1472
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1473
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1474
        }
1475
    }
1476

    
1477
    if(m == nb_entries)
1478
        return -1;
1479
    return  m;
1480
}
1481

    
1482
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1483
                              int flags)
1484
{
1485
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1486
                                     wanted_timestamp, flags);
1487
}
1488

    
1489
#define DEBUG_SEEK
1490

    
1491
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1492
    AVInputFormat *avif= s->iformat;
1493
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1494
    int64_t ts_min, ts_max, ts;
1495
    int index;
1496
    int64_t ret;
1497
    AVStream *st;
1498

    
1499
    if (stream_index < 0)
1500
        return -1;
1501

    
1502
#ifdef DEBUG_SEEK
1503
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1504
#endif
1505

    
1506
    ts_max=
1507
    ts_min= AV_NOPTS_VALUE;
1508
    pos_limit= -1; //gcc falsely says it may be uninitialized
1509

    
1510
    st= s->streams[stream_index];
1511
    if(st->index_entries){
1512
        AVIndexEntry *e;
1513

    
1514
        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()
1515
        index= FFMAX(index, 0);
1516
        e= &st->index_entries[index];
1517

    
1518
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1519
            pos_min= e->pos;
1520
            ts_min= e->timestamp;
1521
#ifdef DEBUG_SEEK
1522
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1523
                   pos_min,ts_min);
1524
#endif
1525
        }else{
1526
            assert(index==0);
1527
        }
1528

    
1529
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1530
        assert(index < st->nb_index_entries);
1531
        if(index >= 0){
1532
            e= &st->index_entries[index];
1533
            assert(e->timestamp >= target_ts);
1534
            pos_max= e->pos;
1535
            ts_max= e->timestamp;
1536
            pos_limit= pos_max - e->min_distance;
1537
#ifdef DEBUG_SEEK
1538
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1539
                   pos_max,pos_limit, ts_max);
1540
#endif
1541
        }
1542
    }
1543

    
1544
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1545
    if(pos<0)
1546
        return -1;
1547

    
1548
    /* do the seek */
1549
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1550
        return ret;
1551

    
1552
    av_update_cur_dts(s, st, ts);
1553

    
1554
    return 0;
1555
}
1556

    
1557
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 )){
1558
    int64_t pos, ts;
1559
    int64_t start_pos, filesize;
1560
    int no_change;
1561

    
1562
#ifdef DEBUG_SEEK
1563
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1564
#endif
1565

    
1566
    if(ts_min == AV_NOPTS_VALUE){
1567
        pos_min = s->data_offset;
1568
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1569
        if (ts_min == AV_NOPTS_VALUE)
1570
            return -1;
1571
    }
1572

    
1573
    if(ts_max == AV_NOPTS_VALUE){
1574
        int step= 1024;
1575
        filesize = avio_size(s->pb);
1576
        pos_max = filesize - 1;
1577
        do{
1578
            pos_max -= step;
1579
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1580
            step += step;
1581
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1582
        if (ts_max == AV_NOPTS_VALUE)
1583
            return -1;
1584

    
1585
        for(;;){
1586
            int64_t tmp_pos= pos_max + 1;
1587
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1588
            if(tmp_ts == AV_NOPTS_VALUE)
1589
                break;
1590
            ts_max= tmp_ts;
1591
            pos_max= tmp_pos;
1592
            if(tmp_pos >= filesize)
1593
                break;
1594
        }
1595
        pos_limit= pos_max;
1596
    }
1597

    
1598
    if(ts_min > ts_max){
1599
        return -1;
1600
    }else if(ts_min == ts_max){
1601
        pos_limit= pos_min;
1602
    }
1603

    
1604
    no_change=0;
1605
    while (pos_min < pos_limit) {
1606
#ifdef DEBUG_SEEK
1607
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1608
               pos_min, pos_max,
1609
               ts_min, ts_max);
1610
#endif
1611
        assert(pos_limit <= pos_max);
1612

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

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

    
1658
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1659
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1660
#ifdef DEBUG_SEEK
1661
    pos_min = pos;
1662
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1663
    pos_min++;
1664
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1665
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1666
           pos, ts_min, target_ts, ts_max);
1667
#endif
1668
    *ts_ret= ts;
1669
    return pos;
1670
}
1671

    
1672
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1673
    int64_t pos_min, pos_max;
1674
#if 0
1675
    AVStream *st;
1676

1677
    if (stream_index < 0)
1678
        return -1;
1679

1680
    st= s->streams[stream_index];
1681
#endif
1682

    
1683
    pos_min = s->data_offset;
1684
    pos_max = avio_size(s->pb) - 1;
1685

    
1686
    if     (pos < pos_min) pos= pos_min;
1687
    else if(pos > pos_max) pos= pos_max;
1688

    
1689
    avio_seek(s->pb, pos, SEEK_SET);
1690

    
1691
#if 0
1692
    av_update_cur_dts(s, st, ts);
1693
#endif
1694
    return 0;
1695
}
1696

    
1697
static int av_seek_frame_generic(AVFormatContext *s,
1698
                                 int stream_index, int64_t timestamp, int flags)
1699
{
1700
    int index;
1701
    int64_t ret;
1702
    AVStream *st;
1703
    AVIndexEntry *ie;
1704

    
1705
    st = s->streams[stream_index];
1706

    
1707
    index = av_index_search_timestamp(st, timestamp, flags);
1708

    
1709
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1710
        return -1;
1711

    
1712
    if(index < 0 || index==st->nb_index_entries-1){
1713
        int i;
1714
        AVPacket pkt;
1715

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

    
1744
    ff_read_frame_flush(s);
1745
    if (s->iformat->read_seek){
1746
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1747
            return 0;
1748
    }
1749
    ie = &st->index_entries[index];
1750
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1751
        return ret;
1752
    av_update_cur_dts(s, st, ie->timestamp);
1753

    
1754
    return 0;
1755
}
1756

    
1757
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1758
{
1759
    int ret;
1760
    AVStream *st;
1761

    
1762
    ff_read_frame_flush(s);
1763

    
1764
    if(flags & AVSEEK_FLAG_BYTE)
1765
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1766

    
1767
    if(stream_index < 0){
1768
        stream_index= av_find_default_stream_index(s);
1769
        if(stream_index < 0)
1770
            return -1;
1771

    
1772
        st= s->streams[stream_index];
1773
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1774
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1775
    }
1776

    
1777
    /* first, we try the format specific seek */
1778
    if (s->iformat->read_seek)
1779
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1780
    else
1781
        ret = -1;
1782
    if (ret >= 0) {
1783
        return 0;
1784
    }
1785

    
1786
    if(s->iformat->read_timestamp)
1787
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1788
    else
1789
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1790
}
1791

    
1792
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1793
{
1794
    if(min_ts > ts || max_ts < ts)
1795
        return -1;
1796

    
1797
    ff_read_frame_flush(s);
1798

    
1799
    if (s->iformat->read_seek2)
1800
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1801

    
1802
    if(s->iformat->read_timestamp){
1803
        //try to seek via read_timestamp()
1804
    }
1805

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

    
1811
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1812
}
1813

    
1814
/*******************************************************/
1815

    
1816
/**
1817
 * Return TRUE if the stream has accurate duration in any stream.
1818
 *
1819
 * @return TRUE if the stream has accurate duration for at least one component.
1820
 */
1821
static int av_has_duration(AVFormatContext *ic)
1822
{
1823
    int i;
1824
    AVStream *st;
1825

    
1826
    for(i = 0;i < ic->nb_streams; i++) {
1827
        st = ic->streams[i];
1828
        if (st->duration != AV_NOPTS_VALUE)
1829
            return 1;
1830
    }
1831
    return 0;
1832
}
1833

    
1834
/**
1835
 * Estimate the stream timings from the one of each components.
1836
 *
1837
 * Also computes the global bitrate if possible.
1838
 */
1839
static void av_update_stream_timings(AVFormatContext *ic)
1840
{
1841
    int64_t start_time, start_time1, end_time, end_time1;
1842
    int64_t duration, duration1;
1843
    int i;
1844
    AVStream *st;
1845

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

    
1885
static void fill_all_stream_timings(AVFormatContext *ic)
1886
{
1887
    int i;
1888
    AVStream *st;
1889

    
1890
    av_update_stream_timings(ic);
1891
    for(i = 0;i < ic->nb_streams; i++) {
1892
        st = ic->streams[i];
1893
        if (st->start_time == AV_NOPTS_VALUE) {
1894
            if(ic->start_time != AV_NOPTS_VALUE)
1895
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1896
            if(ic->duration != AV_NOPTS_VALUE)
1897
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1898
        }
1899
    }
1900
}
1901

    
1902
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1903
{
1904
    int64_t filesize, duration;
1905
    int bit_rate, i;
1906
    AVStream *st;
1907

    
1908
    /* if bit_rate is already set, we believe it */
1909
    if (ic->bit_rate <= 0) {
1910
        bit_rate = 0;
1911
        for(i=0;i<ic->nb_streams;i++) {
1912
            st = ic->streams[i];
1913
            if (st->codec->bit_rate > 0)
1914
            bit_rate += st->codec->bit_rate;
1915
        }
1916
        ic->bit_rate = bit_rate;
1917
    }
1918

    
1919
    /* if duration is already set, we believe it */
1920
    if (ic->duration == AV_NOPTS_VALUE &&
1921
        ic->bit_rate != 0 &&
1922
        ic->file_size != 0)  {
1923
        filesize = ic->file_size;
1924
        if (filesize > 0) {
1925
            for(i = 0; i < ic->nb_streams; i++) {
1926
                st = ic->streams[i];
1927
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1928
                if (st->duration == AV_NOPTS_VALUE)
1929
                    st->duration = duration;
1930
            }
1931
        }
1932
    }
1933
}
1934

    
1935
#define DURATION_MAX_READ_SIZE 250000
1936
#define DURATION_MAX_RETRY 3
1937

    
1938
/* only usable for MPEG-PS streams */
1939
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1940
{
1941
    AVPacket pkt1, *pkt = &pkt1;
1942
    AVStream *st;
1943
    int read_size, i, ret;
1944
    int64_t end_time;
1945
    int64_t filesize, offset, duration;
1946
    int retry=0;
1947

    
1948
    ic->cur_st = NULL;
1949

    
1950
    /* flush packet queue */
1951
    flush_packet_queue(ic);
1952

    
1953
    for (i=0; i<ic->nb_streams; i++) {
1954
        st = ic->streams[i];
1955
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1956
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1957

    
1958
        if (st->parser) {
1959
            av_parser_close(st->parser);
1960
            st->parser= NULL;
1961
            av_free_packet(&st->cur_pkt);
1962
        }
1963
    }
1964

    
1965
    /* estimate the end time (duration) */
1966
    /* XXX: may need to support wrapping */
1967
    filesize = ic->file_size;
1968
    end_time = AV_NOPTS_VALUE;
1969
    do{
1970
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1971
    if (offset < 0)
1972
        offset = 0;
1973

    
1974
    avio_seek(ic->pb, offset, SEEK_SET);
1975
    read_size = 0;
1976
    for(;;) {
1977
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1978
            break;
1979

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

    
2007
    fill_all_stream_timings(ic);
2008

    
2009
    avio_seek(ic->pb, old_offset, SEEK_SET);
2010
    for (i=0; i<ic->nb_streams; i++) {
2011
        st= ic->streams[i];
2012
        st->cur_dts= st->first_dts;
2013
        st->last_IP_pts = AV_NOPTS_VALUE;
2014
    }
2015
}
2016

    
2017
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2018
{
2019
    int64_t file_size;
2020

    
2021
    /* get the file size, if possible */
2022
    if (ic->iformat->flags & AVFMT_NOFILE) {
2023
        file_size = 0;
2024
    } else {
2025
        file_size = avio_size(ic->pb);
2026
        if (file_size < 0)
2027
            file_size = 0;
2028
    }
2029
    ic->file_size = file_size;
2030

    
2031
    if ((!strcmp(ic->iformat->name, "mpeg") ||
2032
         !strcmp(ic->iformat->name, "mpegts")) &&
2033
        file_size && ic->pb->seekable) {
2034
        /* get accurate estimate from the PTSes */
2035
        av_estimate_timings_from_pts(ic, old_offset);
2036
    } else if (av_has_duration(ic)) {
2037
        /* at least one component has timings - we use them for all
2038
           the components */
2039
        fill_all_stream_timings(ic);
2040
    } else {
2041
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2042
        /* less precise: use bitrate info */
2043
        av_estimate_timings_from_bit_rate(ic);
2044
    }
2045
    av_update_stream_timings(ic);
2046

    
2047
#if 0
2048
    {
2049
        int i;
2050
        AVStream *st;
2051
        for(i = 0;i < ic->nb_streams; i++) {
2052
            st = ic->streams[i];
2053
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2054
               i, (double)st->start_time / AV_TIME_BASE,
2055
               (double)st->duration / AV_TIME_BASE);
2056
        }
2057
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2058
               (double)ic->start_time / AV_TIME_BASE,
2059
               (double)ic->duration / AV_TIME_BASE,
2060
               ic->bit_rate / 1000);
2061
    }
2062
#endif
2063
}
2064

    
2065
static int has_codec_parameters(AVCodecContext *enc)
2066
{
2067
    int val;
2068
    switch(enc->codec_type) {
2069
    case AVMEDIA_TYPE_AUDIO:
2070
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2071
        if(!enc->frame_size &&
2072
           (enc->codec_id == CODEC_ID_VORBIS ||
2073
            enc->codec_id == CODEC_ID_AAC ||
2074
            enc->codec_id == CODEC_ID_MP1 ||
2075
            enc->codec_id == CODEC_ID_MP2 ||
2076
            enc->codec_id == CODEC_ID_MP3 ||
2077
            enc->codec_id == CODEC_ID_SPEEX))
2078
            return 0;
2079
        break;
2080
    case AVMEDIA_TYPE_VIDEO:
2081
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2082
        break;
2083
    default:
2084
        val = 1;
2085
        break;
2086
    }
2087
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2088
}
2089

    
2090
static int has_decode_delay_been_guessed(AVStream *st)
2091
{
2092
    return st->codec->codec_id != CODEC_ID_H264 ||
2093
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2094
}
2095

    
2096
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2097
{
2098
    int16_t *samples;
2099
    AVCodec *codec;
2100
    int got_picture, data_size, ret=0;
2101
    AVFrame picture;
2102

    
2103
    if(!st->codec->codec){
2104
        codec = avcodec_find_decoder(st->codec->codec_id);
2105
        if (!codec)
2106
            return -1;
2107
        ret = avcodec_open(st->codec, codec);
2108
        if (ret < 0)
2109
            return ret;
2110
    }
2111

    
2112
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2113
        switch(st->codec->codec_type) {
2114
        case AVMEDIA_TYPE_VIDEO:
2115
            avcodec_get_frame_defaults(&picture);
2116
            ret = avcodec_decode_video2(st->codec, &picture,
2117
                                        &got_picture, avpkt);
2118
            break;
2119
        case AVMEDIA_TYPE_AUDIO:
2120
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2121
            samples = av_malloc(data_size);
2122
            if (!samples)
2123
                goto fail;
2124
            ret = avcodec_decode_audio3(st->codec, samples,
2125
                                        &data_size, avpkt);
2126
            av_free(samples);
2127
            break;
2128
        default:
2129
            break;
2130
        }
2131
    }
2132
 fail:
2133
    return ret;
2134
}
2135

    
2136
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2137
{
2138
    while (tags->id != CODEC_ID_NONE) {
2139
        if (tags->id == id)
2140
            return tags->tag;
2141
        tags++;
2142
    }
2143
    return 0;
2144
}
2145

    
2146
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2147
{
2148
    int i;
2149
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2150
        if(tag == tags[i].tag)
2151
            return tags[i].id;
2152
    }
2153
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2154
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2155
            return tags[i].id;
2156
    }
2157
    return CODEC_ID_NONE;
2158
}
2159

    
2160
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2161
{
2162
    int i;
2163
    for(i=0; tags && tags[i]; i++){
2164
        int tag= ff_codec_get_tag(tags[i], id);
2165
        if(tag) return tag;
2166
    }
2167
    return 0;
2168
}
2169

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

    
2180
static void compute_chapters_end(AVFormatContext *s)
2181
{
2182
    unsigned int i, j;
2183
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2184

    
2185
    for (i = 0; i < s->nb_chapters; i++)
2186
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2187
            AVChapter *ch = s->chapters[i];
2188
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2189
                                     : INT64_MAX;
2190

    
2191
            for (j = 0; j < s->nb_chapters; j++) {
2192
                AVChapter *ch1 = s->chapters[j];
2193
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2194
                if (j != i && next_start > ch->start && next_start < end)
2195
                    end = next_start;
2196
            }
2197
            ch->end = (end == INT64_MAX) ? ch->start : end;
2198
        }
2199
}
2200

    
2201
static int get_std_framerate(int i){
2202
    if(i<60*12) return i*1001;
2203
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2204
}
2205

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

    
2226
int av_find_stream_info(AVFormatContext *ic)
2227
{
2228
    int i, count, ret, read_size, j;
2229
    AVStream *st;
2230
    AVPacket pkt1, *pkt;
2231
    int64_t old_offset = avio_tell(ic->pb);
2232

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

    
2258
        /* Force decoding of at least one frame of codec data
2259
         * this makes sure the codec initializes the channel configuration
2260
         * and does not trust the values from the container.
2261
         */
2262
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2263
            st->codec->channels = 0;
2264

    
2265
        /* Ensure that subtitle_header is properly set. */
2266
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2267
            && codec && !st->codec->codec)
2268
            avcodec_open(st->codec, codec);
2269

    
2270
        //try to just open decoders, in case this is enough to get parameters
2271
        if(!has_codec_parameters(st->codec)){
2272
            if (codec && !st->codec->codec)
2273
                avcodec_open(st->codec, codec);
2274
        }
2275
    }
2276

    
2277
    for (i=0; i<ic->nb_streams; i++) {
2278
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2279
    }
2280

    
2281
    count = 0;
2282
    read_size = 0;
2283
    for(;;) {
2284
        if(url_interrupt_cb()){
2285
            ret= AVERROR_EXIT;
2286
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2287
            break;
2288
        }
2289

    
2290
        /* check if one codec still needs to be handled */
2291
        for(i=0;i<ic->nb_streams;i++) {
2292
            st = ic->streams[i];
2293
            if (!has_codec_parameters(st->codec))
2294
                break;
2295
            /* variable fps and no guess at the real fps */
2296
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2297
               && st->info->duration_count<20 && 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 > 1 && !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, stream_number = 0;
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
        AVStream *st = ic->streams[program ? program[i] : i];
2543
        AVCodecContext *avctx = st->codec;
2544
        if (avctx->codec_type != type)
2545
            continue;
2546
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2547
            continue;
2548
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2549
            continue;
2550
        if (decoder_ret) {
2551
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2552
            if (!decoder) {
2553
                if (ret < 0)
2554
                    ret = AVERROR_DECODER_NOT_FOUND;
2555
                continue;
2556
            }
2557
        }
2558
        if (best_count >= st->codec_info_nb_frames)
2559
            continue;
2560
        best_count = st->codec_info_nb_frames;
2561
        ret = program ? program[i] : i;
2562
        best_decoder = decoder;
2563
        if (program && i == nb_streams - 1 && ret < 0) {
2564
            program = NULL;
2565
            nb_streams = ic->nb_streams;
2566
            i = 0; /* no related stream found, try again with everything */
2567
        }
2568
    }
2569
    if (decoder_ret)
2570
        *decoder_ret = best_decoder;
2571
    return ret;
2572
}
2573

    
2574
/*******************************************************/
2575

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2739
    return program;
2740
}
2741

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

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

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

    
2766
    return chapter;
2767
}
2768

    
2769
/************************************************************/
2770
/* output media file */
2771

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2944
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2945
        return -1;*/
2946

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

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

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

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

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

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

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

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

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

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

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

    
3019
    ret= s->oformat->write_packet(s, pkt);
3020
    return ret;
3021
}
3022

    
3023
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3024
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3025
{
3026
    AVPacketList **next_point, *this_pktl;
3027

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

    
3033
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3034
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3035
    }else
3036
        next_point = &s->packet_buffer;
3037

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

    
3050
    s->packet_buffer_end= this_pktl;
3051
next_non_null:
3052

    
3053
    this_pktl->next= *next_point;
3054

    
3055
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3056
    *next_point= this_pktl;
3057
}
3058

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

    
3068
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3069
    AVPacketList *pktl;
3070
    int stream_count=0;
3071
    int i;
3072

    
3073
    if(pkt){
3074
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3075
    }
3076

    
3077
    for(i=0; i < s->nb_streams; i++)
3078
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3079

    
3080
    if(stream_count && (s->nb_streams == stream_count || flush)){
3081
        pktl= s->packet_buffer;
3082
        *out= pktl->pkt;
3083

    
3084
        s->packet_buffer= pktl->next;
3085
        if(!s->packet_buffer)
3086
            s->packet_buffer_end= NULL;
3087

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

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

    
3114
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3115
    AVStream *st= s->streams[ pkt->stream_index];
3116
    int ret;
3117

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

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

    
3127
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3128
        return AVERROR(EINVAL);
3129

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

    
3136
        ret= s->oformat->write_packet(s, &opkt);
3137

    
3138
        av_free_packet(&opkt);
3139
        pkt= NULL;
3140

    
3141
        if(ret<0)
3142
            return ret;
3143
    }
3144
}
3145

    
3146
int av_write_trailer(AVFormatContext *s)
3147
{
3148
    int ret, i;
3149

    
3150
    for(;;){
3151
        AVPacket pkt;
3152
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3153
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3154
            goto fail;
3155
        if(!ret)
3156
            break;
3157

    
3158
        ret= s->oformat->write_packet(s, &pkt);
3159

    
3160
        av_free_packet(&pkt);
3161

    
3162
        if(ret<0)
3163
            goto fail;
3164
    }
3165

    
3166
    if(s->oformat->write_trailer)
3167
        ret = s->oformat->write_trailer(s);
3168
fail:
3169
    for(i=0;i<s->nb_streams;i++) {
3170
        av_freep(&s->streams[i]->priv_data);
3171
        av_freep(&s->streams[i]->index_entries);
3172
    }
3173
    av_freep(&s->priv_data);
3174
    return ret;
3175
}
3176

    
3177
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3178
{
3179
    int i, j;
3180
    AVProgram *program=NULL;
3181
    void *tmp;
3182

    
3183
    if (idx >= ac->nb_streams) {
3184
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3185
        return;
3186
    }
3187

    
3188
    for(i=0; i<ac->nb_programs; i++){
3189
        if(ac->programs[i]->id != progid)
3190
            continue;
3191
        program = ac->programs[i];
3192
        for(j=0; j<program->nb_stream_indexes; j++)
3193
            if(program->stream_index[j] == idx)
3194
                return;
3195

    
3196
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3197
        if(!tmp)
3198
            return;
3199
        program->stream_index = tmp;
3200
        program->stream_index[program->nb_stream_indexes++] = idx;
3201
        return;
3202
    }
3203
}
3204

    
3205
static void print_fps(double d, const char *postfix){
3206
    uint64_t v= lrintf(d*100);
3207
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3208
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3209
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3210
}
3211

    
3212
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3213
{
3214
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3215
        AVMetadataTag *tag=NULL;
3216

    
3217
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3218
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3219
            if(strcmp("language", tag->key))
3220
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3221
        }
3222
    }
3223
}
3224

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

    
3288
#if FF_API_DUMP_FORMAT
3289
void dump_format(AVFormatContext *ic,
3290
                 int index,
3291
                 const char *url,
3292
                 int is_output)
3293
{
3294
    av_dump_format(ic, index, url, is_output);
3295
}
3296
#endif
3297

    
3298
void av_dump_format(AVFormatContext *ic,
3299
                    int index,
3300
                    const char *url,
3301
                    int is_output)
3302
{
3303
    int i;
3304
    uint8_t *printed = av_mallocz(ic->nb_streams);
3305
    if (ic->nb_streams && !printed)
3306
        return;
3307

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

    
3351
        dump_metadata(NULL, ch->metadata, "    ");
3352
    }
3353
    if(ic->nb_programs) {
3354
        int j, k, total = 0;
3355
        for(j=0; j<ic->nb_programs; j++) {
3356
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3357
                                                  "name", NULL, 0);
3358
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3359
                   name ? name->value : "");
3360
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3361
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3362
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3363
                printed[ic->programs[j]->stream_index[k]] = 1;
3364
            }
3365
            total += ic->programs[j]->nb_stream_indexes;
3366
        }
3367
        if (total < ic->nb_streams)
3368
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3369
    }
3370
    for(i=0;i<ic->nb_streams;i++)
3371
        if (!printed[i])
3372
            dump_stream_format(ic, i, index, is_output);
3373

    
3374
    av_free(printed);
3375
}
3376

    
3377
#if FF_API_PARSE_FRAME_PARAM
3378
#include "libavutil/parseutils.h"
3379

    
3380
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3381
{
3382
    return av_parse_video_size(width_ptr, height_ptr, str);
3383
}
3384

    
3385
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3386
{
3387
    AVRational frame_rate;
3388
    int ret = av_parse_video_rate(&frame_rate, arg);
3389
    *frame_rate_num= frame_rate.num;
3390
    *frame_rate_den= frame_rate.den;
3391
    return ret;
3392
}
3393
#endif
3394

    
3395
int64_t av_gettime(void)
3396
{
3397
    struct timeval tv;
3398
    gettimeofday(&tv,NULL);
3399
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3400
}
3401

    
3402
uint64_t ff_ntp_time(void)
3403
{
3404
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3405
}
3406

    
3407
#if FF_API_PARSE_DATE
3408
#include "libavutil/parseutils.h"
3409

    
3410
int64_t parse_date(const char *timestr, int duration)
3411
{
3412
    int64_t timeval;
3413
    av_parse_time(&timeval, timestr, duration);
3414
    return timeval;
3415
}
3416
#endif
3417

    
3418
#if FF_API_FIND_INFO_TAG
3419
#include "libavutil/parseutils.h"
3420

    
3421
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3422
{
3423
    return av_find_info_tag(arg, arg_size, tag1, info);
3424
}
3425
#endif
3426

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

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

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

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

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

    
3511
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3512
{
3513
    hex_dump_internal(NULL, f, 0, buf, size);
3514
}
3515

    
3516
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3517
{
3518
    hex_dump_internal(avcl, NULL, level, buf, size);
3519
}
3520

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

    
3547
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3548
{
3549
    AVRational tb = { 1, AV_TIME_BASE };
3550
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3551
}
3552

    
3553
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3554
{
3555
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3556
}
3557

    
3558
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3559
{
3560
    AVRational tb = { 1, AV_TIME_BASE };
3561
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3562
}
3563

    
3564
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3565
                      AVStream *st)
3566
{
3567
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3568
}
3569

    
3570
#if FF_API_URL_SPLIT
3571
attribute_deprecated
3572
void ff_url_split(char *proto, int proto_size,
3573
                  char *authorization, int authorization_size,
3574
                  char *hostname, int hostname_size,
3575
                  int *port_ptr,
3576
                  char *path, int path_size,
3577
                  const char *url)
3578
{
3579
    av_url_split(proto, proto_size,
3580
                 authorization, authorization_size,
3581
                 hostname, hostname_size,
3582
                 port_ptr,
3583
                 path, path_size,
3584
                 url);
3585
}
3586
#endif
3587

    
3588
void av_url_split(char *proto, int proto_size,
3589
                  char *authorization, int authorization_size,
3590
                  char *hostname, int hostname_size,
3591
                  int *port_ptr,
3592
                  char *path, int path_size,
3593
                  const char *url)
3594
{
3595
    const char *p, *ls, *at, *col, *brk;
3596

    
3597
    if (port_ptr)               *port_ptr = -1;
3598
    if (proto_size > 0)         proto[0] = 0;
3599
    if (authorization_size > 0) authorization[0] = 0;
3600
    if (hostname_size > 0)      hostname[0] = 0;
3601
    if (path_size > 0)          path[0] = 0;
3602

    
3603
    /* parse protocol */
3604
    if ((p = strchr(url, ':'))) {
3605
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3606
        p++; /* skip ':' */
3607
        if (*p == '/') p++;
3608
        if (*p == '/') p++;
3609
    } else {
3610
        /* no protocol means plain filename */
3611
        av_strlcpy(path, url, path_size);
3612
        return;
3613
    }
3614

    
3615
    /* separate path from hostname */
3616
    ls = strchr(p, '/');
3617
    if(!ls)
3618
        ls = strchr(p, '?');
3619
    if(ls)
3620
        av_strlcpy(path, ls, path_size);
3621
    else
3622
        ls = &p[strlen(p)]; // XXX
3623

    
3624
    /* the rest is hostname, use that to parse auth/port */
3625
    if (ls != p) {
3626
        /* authorization (user[:pass]@hostname) */
3627
        if ((at = strchr(p, '@')) && at < ls) {
3628
            av_strlcpy(authorization, p,
3629
                       FFMIN(authorization_size, at + 1 - p));
3630
            p = at + 1; /* skip '@' */
3631
        }
3632

    
3633
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3634
            /* [host]:port */
3635
            av_strlcpy(hostname, p + 1,
3636
                       FFMIN(hostname_size, brk - p));
3637
            if (brk[1] == ':' && port_ptr)
3638
                *port_ptr = atoi(brk + 2);
3639
        } else if ((col = strchr(p, ':')) && col < ls) {
3640
            av_strlcpy(hostname, p,
3641
                       FFMIN(col + 1 - p, hostname_size));
3642
            if (port_ptr) *port_ptr = atoi(col + 1);
3643
        } else
3644
            av_strlcpy(hostname, p,
3645
                       FFMIN(ls + 1 - p, hostname_size));
3646
    }
3647
}
3648

    
3649
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3650
{
3651
    int i;
3652
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3653
                                           '4', '5', '6', '7',
3654
                                           '8', '9', 'A', 'B',
3655
                                           'C', 'D', 'E', 'F' };
3656
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3657
                                           '4', '5', '6', '7',
3658
                                           '8', '9', 'a', 'b',
3659
                                           'c', 'd', 'e', 'f' };
3660
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3661

    
3662
    for(i = 0; i < s; i++) {
3663
        buff[i * 2]     = hex_table[src[i] >> 4];
3664
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3665
    }
3666

    
3667
    return buff;
3668
}
3669

    
3670
int ff_hex_to_data(uint8_t *data, const char *p)
3671
{
3672
    int c, len, v;
3673

    
3674
    len = 0;
3675
    v = 1;
3676
    for (;;) {
3677
        p += strspn(p, SPACE_CHARS);
3678
        if (*p == '\0')
3679
            break;
3680
        c = toupper((unsigned char) *p++);
3681
        if (c >= '0' && c <= '9')
3682
            c = c - '0';
3683
        else if (c >= 'A' && c <= 'F')
3684
            c = c - 'A' + 10;
3685
        else
3686
            break;
3687
        v = (v << 4) | c;
3688
        if (v & 0x100) {
3689
            if (data)
3690
                data[len] = v;
3691
            len++;
3692
            v = 1;
3693
        }
3694
    }
3695
    return len;
3696
}
3697

    
3698
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3699
                     unsigned int pts_num, unsigned int pts_den)
3700
{
3701
    AVRational new_tb;
3702
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3703
        if(new_tb.num != pts_num)
3704
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3705
    }else
3706
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3707

    
3708
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3709
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3710
        return;
3711
    }
3712
    s->time_base = new_tb;
3713
    s->pts_wrap_bits = pts_wrap_bits;
3714
}
3715

    
3716
int ff_url_join(char *str, int size, const char *proto,
3717
                const char *authorization, const char *hostname,
3718
                int port, const char *fmt, ...)
3719
{
3720
#if CONFIG_NETWORK
3721
    struct addrinfo hints, *ai;
3722
#endif
3723

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

    
3748
    if (port >= 0)
3749
        av_strlcatf(str, size, ":%d", port);
3750
    if (fmt) {
3751
        va_list vl;
3752
        int len = strlen(str);
3753

    
3754
        va_start(vl, fmt);
3755
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3756
        va_end(vl);
3757
    }
3758
    return strlen(str);
3759
}
3760

    
3761
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3762
                     AVFormatContext *src)
3763
{
3764
    AVPacket local_pkt;
3765

    
3766
    local_pkt = *pkt;
3767
    local_pkt.stream_index = dst_stream;
3768
    if (pkt->pts != AV_NOPTS_VALUE)
3769
        local_pkt.pts = av_rescale_q(pkt->pts,
3770
                                     src->streams[pkt->stream_index]->time_base,
3771
                                     dst->streams[dst_stream]->time_base);
3772
    if (pkt->dts != AV_NOPTS_VALUE)
3773
        local_pkt.dts = av_rescale_q(pkt->dts,
3774
                                     src->streams[pkt->stream_index]->time_base,
3775
                                     dst->streams[dst_stream]->time_base);
3776
    return av_write_frame(dst, &local_pkt);
3777
}
3778

    
3779
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3780
                        void *context)
3781
{
3782
    const char *ptr = str;
3783

    
3784
    /* Parse key=value pairs. */
3785
    for (;;) {
3786
        const char *key;
3787
        char *dest = NULL, *dest_end;
3788
        int key_len, dest_len = 0;
3789

    
3790
        /* Skip whitespace and potential commas. */
3791
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3792
            ptr++;
3793
        if (!*ptr)
3794
            break;
3795

    
3796
        key = ptr;
3797

    
3798
        if (!(ptr = strchr(key, '=')))
3799
            break;
3800
        ptr++;
3801
        key_len = ptr - key;
3802

    
3803
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3804
        dest_end = dest + dest_len - 1;
3805

    
3806
        if (*ptr == '\"') {
3807
            ptr++;
3808
            while (*ptr && *ptr != '\"') {
3809
                if (*ptr == '\\') {
3810
                    if (!ptr[1])
3811
                        break;
3812
                    if (dest && dest < dest_end)
3813
                        *dest++ = ptr[1];
3814
                    ptr += 2;
3815
                } else {
3816
                    if (dest && dest < dest_end)
3817
                        *dest++ = *ptr;
3818
                    ptr++;
3819
                }
3820
            }
3821
            if (*ptr == '\"')
3822
                ptr++;
3823
        } else {
3824
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3825
                if (dest && dest < dest_end)
3826
                    *dest++ = *ptr;
3827
        }
3828
        if (dest)
3829
            *dest = 0;
3830
    }
3831
}
3832

    
3833
int ff_find_stream_index(AVFormatContext *s, int id)
3834
{
3835
    int i;
3836
    for (i = 0; i < s->nb_streams; i++) {
3837
        if (s->streams[i]->id == id)
3838
            return i;
3839
    }
3840
    return -1;
3841
}
3842

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