Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ c5dcb3d4

History | View | Annotate | Download (122 KB)

1
/*
2
 * various utility functions for use within FFmpeg
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* #define DEBUG */
23

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

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

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

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

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

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

    
66
/* fraction handling */
67

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

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

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

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

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

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

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

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

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

    
162
    if(!filename)
163
        return 0;
164

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

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

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

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

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

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

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

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

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

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

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

    
262
    return fmt;
263
}
264
#endif
265

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

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

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

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

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

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

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

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

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

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

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

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

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

    
345
    return ret;
346
}
347

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

    
363

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
503
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
504

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

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

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

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

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

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

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

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

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

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

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

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

    
595
    return ret;
596
}
597

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

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

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

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

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

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

    
660
}
661

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

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

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

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

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

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

    
689
        if (pktl) {
690
            *pkt = pktl->pkt;
691
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
692
               !s->streams[pkt->stream_index]->probe_packets ||
693
               s->raw_packet_buffer_remaining_size < pkt->size){
694
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
695
                av_freep(&pd->buf);
696
                pd->buf_size = 0;
697
                s->raw_packet_buffer = pktl->next;
698
                s->raw_packet_buffer_remaining_size += pkt->size;
699
                av_free(pktl);
700
                return 0;
701
            }
702
        }
703

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

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

    
727
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
728
                     !st->probe_packets))
729
            return ret;
730

    
731
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
732
        s->raw_packet_buffer_remaining_size -= pkt->size;
733

    
734
        if(st->codec->codec_id == CODEC_ID_PROBE){
735
            AVProbeData *pd = &st->probe_data;
736
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
737
            --st->probe_packets;
738

    
739
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
740
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
741
            pd->buf_size += pkt->size;
742
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
743

    
744
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
745
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
746
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
747
                if(st->codec->codec_id != CODEC_ID_PROBE){
748
                    pd->buf_size=0;
749
                    av_freep(&pd->buf);
750
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
751
                }
752
            }
753
        }
754
    }
755
}
756

    
757
/**********************************************************/
758

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

    
766
    if(enc->codec_id == CODEC_ID_VORBIS)
767
        return -1;
768

    
769
    if (enc->frame_size <= 1) {
770
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
771

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

    
788

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

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

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

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

    
859
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
860
        return;
861

    
862
    st->first_dts= dts - st->cur_dts;
863
    st->cur_dts= dts;
864

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

    
872
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
873
            pktl->pkt.dts += st->first_dts;
874

    
875
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
876
            st->start_time= pktl->pkt.pts;
877
    }
878
    if (st->start_time == AV_NOPTS_VALUE)
879
        st->start_time = pts;
880
}
881

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

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

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

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

    
924
    if (s->flags & AVFMT_FLAG_NOFILLIN)
925
        return;
926

    
927
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
928
        pkt->dts= AV_NOPTS_VALUE;
929

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

    
934
    /* do we have a video B-frame ? */
935
    delay= st->codec->has_b_frames;
936
    presentation_delayed = 0;
937

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

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

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

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

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

    
967
            if(pkt->duration != 0 && s->packet_buffer)
968
                update_initial_durations(s, st, pkt);
969
        }
970
    }
971

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

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

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

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

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

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

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

    
1064
//    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);
1065

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

    
1081

    
1082
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1083
{
1084
    AVStream *st;
1085
    int len, ret, i;
1086

    
1087
    av_init_packet(pkt);
1088

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

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

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

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

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

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

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

    
1220
    return 0;
1221
}
1222

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

    
1229
    for(;;){
1230
        pktl = s->packet_buffer;
1231
        if (pktl) {
1232
            AVPacket *next_pkt= &pktl->pkt;
1233

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

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

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

    
1277
/* XXX: suppress the packet queue */
1278
static void flush_packet_queue(AVFormatContext *s)
1279
{
1280
    AVPacketList *pktl;
1281

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

    
1301
/*******************************************************/
1302
/* seek support */
1303

    
1304
int av_find_default_stream_index(AVFormatContext *s)
1305
{
1306
    int first_audio_index = -1;
1307
    int i;
1308
    AVStream *st;
1309

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

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

    
1331
    flush_packet_queue(s);
1332

    
1333
    s->cur_st = NULL;
1334

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

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

    
1351
        st->probe_packets = MAX_PROBE_PACKETS;
1352

    
1353
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1354
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1355
    }
1356
}
1357

    
1358
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1359
    int i;
1360

    
1361
    for(i = 0; i < s->nb_streams; i++) {
1362
        AVStream *st = s->streams[i];
1363

    
1364
        st->cur_dts = av_rescale(timestamp,
1365
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1366
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1367
    }
1368
}
1369

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

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

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

    
1391
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1392
        return -1;
1393

    
1394
    entries = av_fast_realloc(*index_entries,
1395
                              index_entries_allocated_size,
1396
                              (*nb_index_entries + 1) *
1397
                              sizeof(AVIndexEntry));
1398
    if(!entries)
1399
        return -1;
1400

    
1401
    *index_entries= entries;
1402

    
1403
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1404

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

    
1420
    ie->pos = pos;
1421
    ie->timestamp = timestamp;
1422
    ie->min_distance= distance;
1423
    ie->size= size;
1424
    ie->flags = flags;
1425

    
1426
    return index;
1427
}
1428

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

    
1437
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1438
                              int64_t wanted_timestamp, int flags)
1439
{
1440
    int a, b, m;
1441
    int64_t timestamp;
1442

    
1443
    a = - 1;
1444
    b = nb_entries;
1445

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

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

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

    
1466
    if(m == nb_entries)
1467
        return -1;
1468
    return  m;
1469
}
1470

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

    
1478
#define DEBUG_SEEK
1479

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

    
1488
    if (stream_index < 0)
1489
        return -1;
1490

    
1491
#ifdef DEBUG_SEEK
1492
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1493
#endif
1494

    
1495
    ts_max=
1496
    ts_min= AV_NOPTS_VALUE;
1497
    pos_limit= -1; //gcc falsely says it may be uninitialized
1498

    
1499
    st= s->streams[stream_index];
1500
    if(st->index_entries){
1501
        AVIndexEntry *e;
1502

    
1503
        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()
1504
        index= FFMAX(index, 0);
1505
        e= &st->index_entries[index];
1506

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

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

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

    
1537
    /* do the seek */
1538
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1539
        return ret;
1540

    
1541
    av_update_cur_dts(s, st, ts);
1542

    
1543
    return 0;
1544
}
1545

    
1546
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 )){
1547
    int64_t pos, ts;
1548
    int64_t start_pos, filesize;
1549
    int no_change;
1550

    
1551
#ifdef DEBUG_SEEK
1552
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1553
#endif
1554

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

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

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

    
1587
    if(ts_min > ts_max){
1588
        return -1;
1589
    }else if(ts_min == ts_max){
1590
        pos_limit= pos_min;
1591
    }
1592

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

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

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

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

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

1666
    if (stream_index < 0)
1667
        return -1;
1668

1669
    st= s->streams[stream_index];
1670
#endif
1671

    
1672
    pos_min = s->data_offset;
1673
    pos_max = avio_size(s->pb) - 1;
1674

    
1675
    if     (pos < pos_min) pos= pos_min;
1676
    else if(pos > pos_max) pos= pos_max;
1677

    
1678
    avio_seek(s->pb, pos, SEEK_SET);
1679

    
1680
#if 0
1681
    av_update_cur_dts(s, st, ts);
1682
#endif
1683
    return 0;
1684
}
1685

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

    
1694
    st = s->streams[stream_index];
1695

    
1696
    index = av_index_search_timestamp(st, timestamp, flags);
1697

    
1698
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1699
        return -1;
1700

    
1701
    if(index < 0 || index==st->nb_index_entries-1){
1702
        int i;
1703
        AVPacket pkt;
1704

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

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

    
1743
    return 0;
1744
}
1745

    
1746
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1747
{
1748
    int ret;
1749
    AVStream *st;
1750

    
1751
    ff_read_frame_flush(s);
1752

    
1753
    if(flags & AVSEEK_FLAG_BYTE)
1754
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1755

    
1756
    if(stream_index < 0){
1757
        stream_index= av_find_default_stream_index(s);
1758
        if(stream_index < 0)
1759
            return -1;
1760

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

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

    
1775
    if(s->iformat->read_timestamp)
1776
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1777
    else
1778
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1779
}
1780

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

    
1786
    ff_read_frame_flush(s);
1787

    
1788
    if (s->iformat->read_seek2)
1789
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1790

    
1791
    if(s->iformat->read_timestamp){
1792
        //try to seek via read_timestamp()
1793
    }
1794

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

    
1800
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1801
}
1802

    
1803
/*******************************************************/
1804

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

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

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

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

    
1874
static void fill_all_stream_timings(AVFormatContext *ic)
1875
{
1876
    int i;
1877
    AVStream *st;
1878

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

    
1891
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1892
{
1893
    int64_t filesize, duration;
1894
    int bit_rate, i;
1895
    AVStream *st;
1896

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

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

    
1924
#define DURATION_MAX_READ_SIZE 250000
1925
#define DURATION_MAX_RETRY 3
1926

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

    
1937
    ic->cur_st = NULL;
1938

    
1939
    /* flush packet queue */
1940
    flush_packet_queue(ic);
1941

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

    
1947
        if (st->parser) {
1948
            av_parser_close(st->parser);
1949
            st->parser= NULL;
1950
            av_free_packet(&st->cur_pkt);
1951
        }
1952
    }
1953

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

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

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

    
1996
    fill_all_stream_timings(ic);
1997

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

    
2006
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2007
{
2008
    int64_t file_size;
2009

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

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

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

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

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

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

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

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

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

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

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

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

    
2169
static void compute_chapters_end(AVFormatContext *s)
2170
{
2171
    unsigned int i;
2172

    
2173
    for (i=0; i+1<s->nb_chapters; i++)
2174
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2175
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2176
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2177
            s->chapters[i]->end = s->chapters[i+1]->start;
2178
        }
2179

    
2180
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2181
        assert(s->start_time != AV_NOPTS_VALUE);
2182
        assert(s->duration > 0);
2183
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2184
                                           AV_TIME_BASE_Q,
2185
                                           s->chapters[i]->time_base);
2186
    }
2187
}
2188

    
2189
static int get_std_framerate(int i){
2190
    if(i<60*12) return i*1001;
2191
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2192
}
2193

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

    
2214
int av_find_stream_info(AVFormatContext *ic)
2215
{
2216
    int i, count, ret, read_size, j;
2217
    AVStream *st;
2218
    AVPacket pkt1, *pkt;
2219
    int64_t old_offset = avio_tell(ic->pb);
2220

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

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

    
2253
        /* Ensure that subtitle_header is properly set. */
2254
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2255
            && codec && !st->codec->codec)
2256
            avcodec_open(st->codec, codec);
2257

    
2258
        //try to just open decoders, in case this is enough to get parameters
2259
        if(!has_codec_parameters(st->codec)){
2260
            if (codec && !st->codec->codec)
2261
                avcodec_open(st->codec, codec);
2262
        }
2263
    }
2264

    
2265
    for (i=0; i<ic->nb_streams; i++) {
2266
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2267
    }
2268

    
2269
    count = 0;
2270
    read_size = 0;
2271
    for(;;) {
2272
        if(url_interrupt_cb()){
2273
            ret= AVERROR_EXIT;
2274
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2275
            break;
2276
        }
2277

    
2278
        /* check if one codec still needs to be handled */
2279
        for(i=0;i<ic->nb_streams;i++) {
2280
            st = ic->streams[i];
2281
            if (!has_codec_parameters(st->codec))
2282
                break;
2283
            /* variable fps and no guess at the real fps */
2284
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2285
               && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2286
                break;
2287
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2288
                break;
2289
            if(st->first_dts == AV_NOPTS_VALUE)
2290
                break;
2291
        }
2292
        if (i == ic->nb_streams) {
2293
            /* NOTE: if the format has no header, then we need to read
2294
               some packets to get most of the streams, so we cannot
2295
               stop here */
2296
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2297
                /* if we found the info for all the codecs, we can stop */
2298
                ret = count;
2299
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2300
                break;
2301
            }
2302
        }
2303
        /* we did not get all the codec info, but we read too much data */
2304
        if (read_size >= ic->probesize) {
2305
            ret = count;
2306
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2307
            break;
2308
        }
2309

    
2310
        /* NOTE: a new stream can be added there if no header in file
2311
           (AVFMTCTX_NOHEADER) */
2312
        ret = av_read_frame_internal(ic, &pkt1);
2313
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2314
            /* EOF or error */
2315
            ret = -1; /* we could not have all the codec parameters before EOF */
2316
            for(i=0;i<ic->nb_streams;i++) {
2317
                st = ic->streams[i];
2318
                if (!has_codec_parameters(st->codec)){
2319
                    char buf[256];
2320
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2321
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2322
                } else {
2323
                    ret = 0;
2324
                }
2325
            }
2326
            break;
2327
        }
2328

    
2329
        if (ret == AVERROR(EAGAIN))
2330
            continue;
2331

    
2332
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2333
        if ((ret = av_dup_packet(pkt)) < 0)
2334
            goto find_stream_info_err;
2335

    
2336
        read_size += pkt->size;
2337

    
2338
        st = ic->streams[pkt->stream_index];
2339
        if (st->codec_info_nb_frames>1) {
2340
            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) {
2341
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2342
                break;
2343
            }
2344
            st->info->codec_info_duration += pkt->duration;
2345
        }
2346
        {
2347
            int64_t last = st->info->last_dts;
2348
            int64_t duration= pkt->dts - last;
2349

    
2350
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2351
                double dur= duration * av_q2d(st->time_base);
2352

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

    
2381
        /* if still no information, we try to open the codec and to
2382
           decompress the frame. We try to avoid that in most cases as
2383
           it takes longer and uses more memory. For MPEG-4, we need to
2384
           decompress for QuickTime. */
2385
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2386
            try_decode_frame(st, pkt);
2387

    
2388
        st->codec_info_nb_frames++;
2389
        count++;
2390
    }
2391

    
2392
    // close codecs which were opened in try_decode_frame()
2393
    for(i=0;i<ic->nb_streams;i++) {
2394
        st = ic->streams[i];
2395
        if(st->codec->codec)
2396
            avcodec_close(st->codec);
2397
    }
2398
    for(i=0;i<ic->nb_streams;i++) {
2399
        st = ic->streams[i];
2400
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2401
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2402
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2403
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2404
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2405
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2406
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2407

    
2408
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2409
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2410
            // ipmovie.c produces.
2411
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2412
                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);
2413
            if (st->info->duration_count && !st->r_frame_rate.num
2414
               && tb_unreliable(st->codec) /*&&
2415
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2416
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2417
                int num = 0;
2418
                double best_error= 2*av_q2d(st->time_base);
2419
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2420

    
2421
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2422
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2423
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2424
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2425
                    if(error < best_error){
2426
                        best_error= error;
2427
                        num = get_std_framerate(j);
2428
                    }
2429
                }
2430
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2431
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2432
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2433
            }
2434

    
2435
            if (!st->r_frame_rate.num){
2436
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2437
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2438
                    st->r_frame_rate.num = st->codec->time_base.den;
2439
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2440
                }else{
2441
                    st->r_frame_rate.num = st->time_base.den;
2442
                    st->r_frame_rate.den = st->time_base.num;
2443
                }
2444
            }
2445
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2446
            if(!st->codec->bits_per_coded_sample)
2447
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2448
        }
2449
    }
2450

    
2451
    av_estimate_timings(ic, old_offset);
2452

    
2453
    compute_chapters_end(ic);
2454

    
2455
#if 0
2456
    /* correct DTS for B-frame streams with no timestamps */
2457
    for(i=0;i<ic->nb_streams;i++) {
2458
        st = ic->streams[i];
2459
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2460
            if(b-frames){
2461
                ppktl = &ic->packet_buffer;
2462
                while(ppkt1){
2463
                    if(ppkt1->stream_index != i)
2464
                        continue;
2465
                    if(ppkt1->pkt->dts < 0)
2466
                        break;
2467
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2468
                        break;
2469
                    ppkt1->pkt->dts -= delta;
2470
                    ppkt1= ppkt1->next;
2471
                }
2472
                if(ppkt1)
2473
                    continue;
2474
                st->cur_dts -= delta;
2475
            }
2476
        }
2477
    }
2478
#endif
2479

    
2480
 find_stream_info_err:
2481
    for (i=0; i < ic->nb_streams; i++)
2482
        av_freep(&ic->streams[i]->info);
2483
    return ret;
2484
}
2485

    
2486
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2487
{
2488
    int i, j;
2489

    
2490
    for (i = 0; i < ic->nb_programs; i++)
2491
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2492
            if (ic->programs[i]->stream_index[j] == s)
2493
                return ic->programs[i];
2494
    return NULL;
2495
}
2496

    
2497
int av_find_best_stream(AVFormatContext *ic,
2498
                        enum AVMediaType type,
2499
                        int wanted_stream_nb,
2500
                        int related_stream,
2501
                        AVCodec **decoder_ret,
2502
                        int flags)
2503
{
2504
    int i, nb_streams = ic->nb_streams;
2505
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2506
    unsigned *program = NULL;
2507
    AVCodec *decoder = NULL, *best_decoder = NULL;
2508

    
2509
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2510
        AVProgram *p = find_program_from_stream(ic, related_stream);
2511
        if (p) {
2512
            program = p->stream_index;
2513
            nb_streams = p->nb_stream_indexes;
2514
        }
2515
    }
2516
    for (i = 0; i < nb_streams; i++) {
2517
        int real_stream_index = program ? program[i] : i;
2518
        AVStream *st = ic->streams[real_stream_index];
2519
        AVCodecContext *avctx = st->codec;
2520
        if (avctx->codec_type != type)
2521
            continue;
2522
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2523
            continue;
2524
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2525
            continue;
2526
        if (decoder_ret) {
2527
            decoder = avcodec_find_decoder(st->codec->codec_id);
2528
            if (!decoder) {
2529
                if (ret < 0)
2530
                    ret = AVERROR_DECODER_NOT_FOUND;
2531
                continue;
2532
            }
2533
        }
2534
        if (best_count >= st->codec_info_nb_frames)
2535
            continue;
2536
        best_count = st->codec_info_nb_frames;
2537
        ret = real_stream_index;
2538
        best_decoder = decoder;
2539
        if (program && i == nb_streams - 1 && ret < 0) {
2540
            program = NULL;
2541
            nb_streams = ic->nb_streams;
2542
            i = 0; /* no related stream found, try again with everything */
2543
        }
2544
    }
2545
    if (decoder_ret)
2546
        *decoder_ret = best_decoder;
2547
    return ret;
2548
}
2549

    
2550
/*******************************************************/
2551

    
2552
int av_read_play(AVFormatContext *s)
2553
{
2554
    if (s->iformat->read_play)
2555
        return s->iformat->read_play(s);
2556
    if (s->pb)
2557
        return av_url_read_fpause(s->pb, 0);
2558
    return AVERROR(ENOSYS);
2559
}
2560

    
2561
int av_read_pause(AVFormatContext *s)
2562
{
2563
    if (s->iformat->read_pause)
2564
        return s->iformat->read_pause(s);
2565
    if (s->pb)
2566
        return av_url_read_fpause(s->pb, 1);
2567
    return AVERROR(ENOSYS);
2568
}
2569

    
2570
void av_close_input_stream(AVFormatContext *s)
2571
{
2572
    flush_packet_queue(s);
2573
    if (s->iformat->read_close)
2574
        s->iformat->read_close(s);
2575
    avformat_free_context(s);
2576
}
2577

    
2578
void avformat_free_context(AVFormatContext *s)
2579
{
2580
    int i;
2581
    AVStream *st;
2582

    
2583
    for(i=0;i<s->nb_streams;i++) {
2584
        /* free all data in a stream component */
2585
        st = s->streams[i];
2586
        if (st->parser) {
2587
            av_parser_close(st->parser);
2588
            av_free_packet(&st->cur_pkt);
2589
        }
2590
        av_metadata_free(&st->metadata);
2591
        av_free(st->index_entries);
2592
        av_free(st->codec->extradata);
2593
        av_free(st->codec->subtitle_header);
2594
        av_free(st->codec);
2595
#if FF_API_OLD_METADATA
2596
        av_free(st->filename);
2597
#endif
2598
        av_free(st->priv_data);
2599
        av_free(st->info);
2600
        av_free(st);
2601
    }
2602
    for(i=s->nb_programs-1; i>=0; i--) {
2603
#if FF_API_OLD_METADATA
2604
        av_freep(&s->programs[i]->provider_name);
2605
        av_freep(&s->programs[i]->name);
2606
#endif
2607
        av_metadata_free(&s->programs[i]->metadata);
2608
        av_freep(&s->programs[i]->stream_index);
2609
        av_freep(&s->programs[i]);
2610
    }
2611
    av_freep(&s->programs);
2612
    av_freep(&s->priv_data);
2613
    while(s->nb_chapters--) {
2614
#if FF_API_OLD_METADATA
2615
        av_free(s->chapters[s->nb_chapters]->title);
2616
#endif
2617
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2618
        av_free(s->chapters[s->nb_chapters]);
2619
    }
2620
    av_freep(&s->chapters);
2621
    av_metadata_free(&s->metadata);
2622
    av_freep(&s->key);
2623
    av_free(s);
2624
}
2625

    
2626
void av_close_input_file(AVFormatContext *s)
2627
{
2628
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2629
    av_close_input_stream(s);
2630
    if (pb)
2631
        avio_close(pb);
2632
}
2633

    
2634
AVStream *av_new_stream(AVFormatContext *s, int id)
2635
{
2636
    AVStream *st;
2637
    int i;
2638

    
2639
#if FF_API_MAX_STREAMS
2640
    if (s->nb_streams >= MAX_STREAMS){
2641
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2642
        return NULL;
2643
    }
2644
#else
2645
    AVStream **streams;
2646

    
2647
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2648
        return NULL;
2649
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2650
    if (!streams)
2651
        return NULL;
2652
    s->streams = streams;
2653
#endif
2654

    
2655
    st = av_mallocz(sizeof(AVStream));
2656
    if (!st)
2657
        return NULL;
2658
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2659
        av_free(st);
2660
        return NULL;
2661
    }
2662

    
2663
    st->codec= avcodec_alloc_context();
2664
    if (s->iformat) {
2665
        /* no default bitrate if decoding */
2666
        st->codec->bit_rate = 0;
2667
    }
2668
    st->index = s->nb_streams;
2669
    st->id = id;
2670
    st->start_time = AV_NOPTS_VALUE;
2671
    st->duration = AV_NOPTS_VALUE;
2672
        /* we set the current DTS to 0 so that formats without any timestamps
2673
           but durations get some timestamps, formats with some unknown
2674
           timestamps have their first few packets buffered and the
2675
           timestamps corrected before they are returned to the user */
2676
    st->cur_dts = 0;
2677
    st->first_dts = AV_NOPTS_VALUE;
2678
    st->probe_packets = MAX_PROBE_PACKETS;
2679

    
2680
    /* default pts setting is MPEG-like */
2681
    av_set_pts_info(st, 33, 1, 90000);
2682
    st->last_IP_pts = AV_NOPTS_VALUE;
2683
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2684
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2685
    st->reference_dts = AV_NOPTS_VALUE;
2686

    
2687
    st->sample_aspect_ratio = (AVRational){0,1};
2688

    
2689
    s->streams[s->nb_streams++] = st;
2690
    return st;
2691
}
2692

    
2693
AVProgram *av_new_program(AVFormatContext *ac, int id)
2694
{
2695
    AVProgram *program=NULL;
2696
    int i;
2697

    
2698
#ifdef DEBUG_SI
2699
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2700
#endif
2701

    
2702
    for(i=0; i<ac->nb_programs; i++)
2703
        if(ac->programs[i]->id == id)
2704
            program = ac->programs[i];
2705

    
2706
    if(!program){
2707
        program = av_mallocz(sizeof(AVProgram));
2708
        if (!program)
2709
            return NULL;
2710
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2711
        program->discard = AVDISCARD_NONE;
2712
    }
2713
    program->id = id;
2714

    
2715
    return program;
2716
}
2717

    
2718
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2719
{
2720
    AVChapter *chapter = NULL;
2721
    int i;
2722

    
2723
    for(i=0; i<s->nb_chapters; i++)
2724
        if(s->chapters[i]->id == id)
2725
            chapter = s->chapters[i];
2726

    
2727
    if(!chapter){
2728
        chapter= av_mallocz(sizeof(AVChapter));
2729
        if(!chapter)
2730
            return NULL;
2731
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2732
    }
2733
#if FF_API_OLD_METADATA
2734
    av_free(chapter->title);
2735
#endif
2736
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2737
    chapter->id    = id;
2738
    chapter->time_base= time_base;
2739
    chapter->start = start;
2740
    chapter->end   = end;
2741

    
2742
    return chapter;
2743
}
2744

    
2745
/************************************************************/
2746
/* output media file */
2747

    
2748
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2749
{
2750
    int ret;
2751

    
2752
    if (s->oformat->priv_data_size > 0) {
2753
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2754
        if (!s->priv_data)
2755
            return AVERROR(ENOMEM);
2756
        if (s->oformat->priv_class) {
2757
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2758
            av_opt_set_defaults(s->priv_data);
2759
        }
2760
    } else
2761
        s->priv_data = NULL;
2762

    
2763
    if (s->oformat->set_parameters) {
2764
        ret = s->oformat->set_parameters(s, ap);
2765
        if (ret < 0)
2766
            return ret;
2767
    }
2768
    return 0;
2769
}
2770

    
2771
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2772
{
2773
    const AVCodecTag *avctag;
2774
    int n;
2775
    enum CodecID id = CODEC_ID_NONE;
2776
    unsigned int tag = 0;
2777

    
2778
    /**
2779
     * Check that tag + id is in the table
2780
     * If neither is in the table -> OK
2781
     * If tag is in the table with another id -> FAIL
2782
     * If id is in the table with another tag -> FAIL unless strict < normal
2783
     */
2784
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2785
        avctag = s->oformat->codec_tag[n];
2786
        while (avctag->id != CODEC_ID_NONE) {
2787
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2788
                id = avctag->id;
2789
                if (id == st->codec->codec_id)
2790
                    return 1;
2791
            }
2792
            if (avctag->id == st->codec->codec_id)
2793
                tag = avctag->tag;
2794
            avctag++;
2795
        }
2796
    }
2797
    if (id != CODEC_ID_NONE)
2798
        return 0;
2799
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2800
        return 0;
2801
    return 1;
2802
}
2803

    
2804
int av_write_header(AVFormatContext *s)
2805
{
2806
    int ret, i;
2807
    AVStream *st;
2808

    
2809
    // some sanity checks
2810
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2811
        av_log(s, AV_LOG_ERROR, "no streams\n");
2812
        return AVERROR(EINVAL);
2813
    }
2814

    
2815
    for(i=0;i<s->nb_streams;i++) {
2816
        st = s->streams[i];
2817

    
2818
        switch (st->codec->codec_type) {
2819
        case AVMEDIA_TYPE_AUDIO:
2820
            if(st->codec->sample_rate<=0){
2821
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2822
                return AVERROR(EINVAL);
2823
            }
2824
            if(!st->codec->block_align)
2825
                st->codec->block_align = st->codec->channels *
2826
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2827
            break;
2828
        case AVMEDIA_TYPE_VIDEO:
2829
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2830
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2831
                return AVERROR(EINVAL);
2832
            }
2833
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2834
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2835
                return AVERROR(EINVAL);
2836
            }
2837
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2838
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2839
                return AVERROR(EINVAL);
2840
            }
2841
            break;
2842
        }
2843

    
2844
        if(s->oformat->codec_tag){
2845
            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)){
2846
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2847
                st->codec->codec_tag= 0;
2848
            }
2849
            if(st->codec->codec_tag){
2850
                if (!validate_codec_tag(s, st)) {
2851
                    char tagbuf[32];
2852
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2853
                    av_log(s, AV_LOG_ERROR,
2854
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2855
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2856
                    return AVERROR_INVALIDDATA;
2857
                }
2858
            }else
2859
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2860
        }
2861

    
2862
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2863
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2864
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2865
    }
2866

    
2867
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2868
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2869
        if (!s->priv_data)
2870
            return AVERROR(ENOMEM);
2871
    }
2872

    
2873
#if FF_API_OLD_METADATA
2874
    ff_metadata_mux_compat(s);
2875
#endif
2876

    
2877
    /* set muxer identification string */
2878
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2879
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2880
    }
2881

    
2882
    if(s->oformat->write_header){
2883
        ret = s->oformat->write_header(s);
2884
        if (ret < 0)
2885
            return ret;
2886
    }
2887

    
2888
    /* init PTS generation */
2889
    for(i=0;i<s->nb_streams;i++) {
2890
        int64_t den = AV_NOPTS_VALUE;
2891
        st = s->streams[i];
2892

    
2893
        switch (st->codec->codec_type) {
2894
        case AVMEDIA_TYPE_AUDIO:
2895
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2896
            break;
2897
        case AVMEDIA_TYPE_VIDEO:
2898
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2899
            break;
2900
        default:
2901
            break;
2902
        }
2903
        if (den != AV_NOPTS_VALUE) {
2904
            if (den <= 0)
2905
                return AVERROR_INVALIDDATA;
2906
            av_frac_init(&st->pts, 0, 0, den);
2907
        }
2908
    }
2909
    return 0;
2910
}
2911

    
2912
//FIXME merge with compute_pkt_fields
2913
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2914
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2915
    int num, den, frame_size, i;
2916

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

    
2920
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2921
        return -1;*/
2922

    
2923
    /* duration field */
2924
    if (pkt->duration == 0) {
2925
        compute_frame_duration(&num, &den, st, NULL, pkt);
2926
        if (den && num) {
2927
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2928
        }
2929
    }
2930

    
2931
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2932
        pkt->pts= pkt->dts;
2933

    
2934
    //XXX/FIXME this is a temporary hack until all encoders output pts
2935
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2936
        pkt->dts=
2937
//        pkt->pts= st->cur_dts;
2938
        pkt->pts= st->pts.val;
2939
    }
2940

    
2941
    //calculate dts from pts
2942
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2943
        st->pts_buffer[0]= pkt->pts;
2944
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2945
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2946
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2947
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2948

    
2949
        pkt->dts= st->pts_buffer[0];
2950
    }
2951

    
2952
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2953
        av_log(s, AV_LOG_ERROR,
2954
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2955
               st->index, st->cur_dts, pkt->dts);
2956
        return -1;
2957
    }
2958
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2959
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2960
        return -1;
2961
    }
2962

    
2963
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2964
    st->cur_dts= pkt->dts;
2965
    st->pts.val= pkt->dts;
2966

    
2967
    /* update pts */
2968
    switch (st->codec->codec_type) {
2969
    case AVMEDIA_TYPE_AUDIO:
2970
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2971

    
2972
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2973
           likely equal to the encoder delay, but it would be better if we
2974
           had the real timestamps from the encoder */
2975
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2976
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2977
        }
2978
        break;
2979
    case AVMEDIA_TYPE_VIDEO:
2980
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2981
        break;
2982
    default:
2983
        break;
2984
    }
2985
    return 0;
2986
}
2987

    
2988
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2989
{
2990
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2991

    
2992
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2993
        return ret;
2994

    
2995
    ret= s->oformat->write_packet(s, pkt);
2996
    if(!ret)
2997
        ret= url_ferror(s->pb);
2998
    return ret;
2999
}
3000

    
3001
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3002
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3003
{
3004
    AVPacketList **next_point, *this_pktl;
3005

    
3006
    this_pktl = av_mallocz(sizeof(AVPacketList));
3007
    this_pktl->pkt= *pkt;
3008
    pkt->destruct= NULL;             // do not free original but only the copy
3009
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3010

    
3011
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3012
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3013
    }else
3014
        next_point = &s->packet_buffer;
3015

    
3016
    if(*next_point){
3017
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3018
            while(!compare(s, &(*next_point)->pkt, pkt)){
3019
                next_point= &(*next_point)->next;
3020
            }
3021
            goto next_non_null;
3022
        }else{
3023
            next_point = &(s->packet_buffer_end->next);
3024
        }
3025
    }
3026
    assert(!*next_point);
3027

    
3028
    s->packet_buffer_end= this_pktl;
3029
next_non_null:
3030

    
3031
    this_pktl->next= *next_point;
3032

    
3033
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3034
    *next_point= this_pktl;
3035
}
3036

    
3037
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3038
{
3039
    AVStream *st = s->streams[ pkt ->stream_index];
3040
    AVStream *st2= s->streams[ next->stream_index];
3041
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3042
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3043
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3044
}
3045

    
3046
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3047
    AVPacketList *pktl;
3048
    int stream_count=0;
3049
    int i;
3050

    
3051
    if(pkt){
3052
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3053
    }
3054

    
3055
    for(i=0; i < s->nb_streams; i++)
3056
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3057

    
3058
    if(stream_count && (s->nb_streams == stream_count || flush)){
3059
        pktl= s->packet_buffer;
3060
        *out= pktl->pkt;
3061

    
3062
        s->packet_buffer= pktl->next;
3063
        if(!s->packet_buffer)
3064
            s->packet_buffer_end= NULL;
3065

    
3066
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3067
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3068
        av_freep(&pktl);
3069
        return 1;
3070
    }else{
3071
        av_init_packet(out);
3072
        return 0;
3073
    }
3074
}
3075

    
3076
/**
3077
 * Interleave an AVPacket correctly so it can be muxed.
3078
 * @param out the interleaved packet will be output here
3079
 * @param in the input packet
3080
 * @param flush 1 if no further packets are available as input and all
3081
 *              remaining packets should be output
3082
 * @return 1 if a packet was output, 0 if no packet could be output,
3083
 *         < 0 if an error occurred
3084
 */
3085
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3086
    if(s->oformat->interleave_packet)
3087
        return s->oformat->interleave_packet(s, out, in, flush);
3088
    else
3089
        return av_interleave_packet_per_dts(s, out, in, flush);
3090
}
3091

    
3092
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3093
    AVStream *st= s->streams[ pkt->stream_index];
3094
    int ret;
3095

    
3096
    //FIXME/XXX/HACK drop zero sized packets
3097
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3098
        return 0;
3099

    
3100
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3101
            pkt->size, pkt->dts, pkt->pts);
3102
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3103
        return ret;
3104

    
3105
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3106
        return AVERROR(EINVAL);
3107

    
3108
    for(;;){
3109
        AVPacket opkt;
3110
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3111
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3112
            return ret;
3113

    
3114
        ret= s->oformat->write_packet(s, &opkt);
3115

    
3116
        av_free_packet(&opkt);
3117
        pkt= NULL;
3118

    
3119
        if(ret<0)
3120
            return ret;
3121
        if(url_ferror(s->pb))
3122
            return url_ferror(s->pb);
3123
    }
3124
}
3125

    
3126
int av_write_trailer(AVFormatContext *s)
3127
{
3128
    int ret, i;
3129

    
3130
    for(;;){
3131
        AVPacket pkt;
3132
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3133
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3134
            goto fail;
3135
        if(!ret)
3136
            break;
3137

    
3138
        ret= s->oformat->write_packet(s, &pkt);
3139

    
3140
        av_free_packet(&pkt);
3141

    
3142
        if(ret<0)
3143
            goto fail;
3144
        if(url_ferror(s->pb))
3145
            goto fail;
3146
    }
3147

    
3148
    if(s->oformat->write_trailer)
3149
        ret = s->oformat->write_trailer(s);
3150
fail:
3151
    if(ret == 0)
3152
       ret=url_ferror(s->pb);
3153
    for(i=0;i<s->nb_streams;i++) {
3154
        av_freep(&s->streams[i]->priv_data);
3155
        av_freep(&s->streams[i]->index_entries);
3156
    }
3157
    av_freep(&s->priv_data);
3158
    return ret;
3159
}
3160

    
3161
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3162
{
3163
    int i, j;
3164
    AVProgram *program=NULL;
3165
    void *tmp;
3166

    
3167
    if (idx >= ac->nb_streams) {
3168
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3169
        return;
3170
    }
3171

    
3172
    for(i=0; i<ac->nb_programs; i++){
3173
        if(ac->programs[i]->id != progid)
3174
            continue;
3175
        program = ac->programs[i];
3176
        for(j=0; j<program->nb_stream_indexes; j++)
3177
            if(program->stream_index[j] == idx)
3178
                return;
3179

    
3180
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3181
        if(!tmp)
3182
            return;
3183
        program->stream_index = tmp;
3184
        program->stream_index[program->nb_stream_indexes++] = idx;
3185
        return;
3186
    }
3187
}
3188

    
3189
static void print_fps(double d, const char *postfix){
3190
    uint64_t v= lrintf(d*100);
3191
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3192
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3193
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3194
}
3195

    
3196
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3197
{
3198
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3199
        AVMetadataTag *tag=NULL;
3200

    
3201
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3202
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3203
            if(strcmp("language", tag->key))
3204
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3205
        }
3206
    }
3207
}
3208

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

    
3272
#if FF_API_DUMP_FORMAT
3273
void dump_format(AVFormatContext *ic,
3274
                 int index,
3275
                 const char *url,
3276
                 int is_output)
3277
{
3278
    av_dump_format(ic, index, url, is_output);
3279
}
3280
#endif
3281

    
3282
void av_dump_format(AVFormatContext *ic,
3283
                    int index,
3284
                    const char *url,
3285
                    int is_output)
3286
{
3287
    int i;
3288
    uint8_t *printed = av_mallocz(ic->nb_streams);
3289
    if (ic->nb_streams && !printed)
3290
        return;
3291

    
3292
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3293
            is_output ? "Output" : "Input",
3294
            index,
3295
            is_output ? ic->oformat->name : ic->iformat->name,
3296
            is_output ? "to" : "from", url);
3297
    dump_metadata(NULL, ic->metadata, "  ");
3298
    if (!is_output) {
3299
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3300
        if (ic->duration != AV_NOPTS_VALUE) {
3301
            int hours, mins, secs, us;
3302
            secs = ic->duration / AV_TIME_BASE;
3303
            us = ic->duration % AV_TIME_BASE;
3304
            mins = secs / 60;
3305
            secs %= 60;
3306
            hours = mins / 60;
3307
            mins %= 60;
3308
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3309
                   (100 * us) / AV_TIME_BASE);
3310
        } else {
3311
            av_log(NULL, AV_LOG_INFO, "N/A");
3312
        }
3313
        if (ic->start_time != AV_NOPTS_VALUE) {
3314
            int secs, us;
3315
            av_log(NULL, AV_LOG_INFO, ", start: ");
3316
            secs = ic->start_time / AV_TIME_BASE;
3317
            us = abs(ic->start_time % AV_TIME_BASE);
3318
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3319
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3320
        }
3321
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3322
        if (ic->bit_rate) {
3323
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3324
        } else {
3325
            av_log(NULL, AV_LOG_INFO, "N/A");
3326
        }
3327
        av_log(NULL, AV_LOG_INFO, "\n");
3328
    }
3329
    for (i = 0; i < ic->nb_chapters; i++) {
3330
        AVChapter *ch = ic->chapters[i];
3331
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3332
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3333
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3334

    
3335
        dump_metadata(NULL, ch->metadata, "    ");
3336
    }
3337
    if(ic->nb_programs) {
3338
        int j, k, total = 0;
3339
        for(j=0; j<ic->nb_programs; j++) {
3340
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3341
                                                  "name", NULL, 0);
3342
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3343
                   name ? name->value : "");
3344
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3345
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3346
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3347
                printed[ic->programs[j]->stream_index[k]] = 1;
3348
            }
3349
            total += ic->programs[j]->nb_stream_indexes;
3350
        }
3351
        if (total < ic->nb_streams)
3352
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3353
    }
3354
    for(i=0;i<ic->nb_streams;i++)
3355
        if (!printed[i])
3356
            dump_stream_format(ic, i, index, is_output);
3357

    
3358
    av_free(printed);
3359
}
3360

    
3361
#if FF_API_PARSE_FRAME_PARAM
3362
#include "libavutil/parseutils.h"
3363

    
3364
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3365
{
3366
    return av_parse_video_size(width_ptr, height_ptr, str);
3367
}
3368

    
3369
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3370
{
3371
    AVRational frame_rate;
3372
    int ret = av_parse_video_rate(&frame_rate, arg);
3373
    *frame_rate_num= frame_rate.num;
3374
    *frame_rate_den= frame_rate.den;
3375
    return ret;
3376
}
3377
#endif
3378

    
3379
int64_t av_gettime(void)
3380
{
3381
    struct timeval tv;
3382
    gettimeofday(&tv,NULL);
3383
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3384
}
3385

    
3386
uint64_t ff_ntp_time(void)
3387
{
3388
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3389
}
3390

    
3391
#if FF_API_PARSE_DATE
3392
#include "libavutil/parseutils.h"
3393

    
3394
int64_t parse_date(const char *timestr, int duration)
3395
{
3396
    int64_t timeval;
3397
    av_parse_time(&timeval, timestr, duration);
3398
    return timeval;
3399
}
3400
#endif
3401

    
3402
#if FF_API_FIND_INFO_TAG
3403
#include "libavutil/parseutils.h"
3404

    
3405
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3406
{
3407
    return av_find_info_tag(arg, arg_size, tag1, info);
3408
}
3409
#endif
3410

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

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

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

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

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

    
3495
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3496
{
3497
    hex_dump_internal(NULL, f, 0, buf, size);
3498
}
3499

    
3500
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3501
{
3502
    hex_dump_internal(avcl, NULL, level, buf, size);
3503
}
3504

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

    
3531
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3532
{
3533
    AVRational tb = { 1, AV_TIME_BASE };
3534
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3535
}
3536

    
3537
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3538
{
3539
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3540
}
3541

    
3542
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3543
{
3544
    AVRational tb = { 1, AV_TIME_BASE };
3545
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3546
}
3547

    
3548
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3549
                      AVStream *st)
3550
{
3551
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3552
}
3553

    
3554
#if FF_API_URL_SPLIT
3555
attribute_deprecated
3556
void ff_url_split(char *proto, int proto_size,
3557
                  char *authorization, int authorization_size,
3558
                  char *hostname, int hostname_size,
3559
                  int *port_ptr,
3560
                  char *path, int path_size,
3561
                  const char *url)
3562
{
3563
    av_url_split(proto, proto_size,
3564
                 authorization, authorization_size,
3565
                 hostname, hostname_size,
3566
                 port_ptr,
3567
                 path, path_size,
3568
                 url);
3569
}
3570
#endif
3571

    
3572
void av_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
    const char *p, *ls, *at, *col, *brk;
3580

    
3581
    if (port_ptr)               *port_ptr = -1;
3582
    if (proto_size > 0)         proto[0] = 0;
3583
    if (authorization_size > 0) authorization[0] = 0;
3584
    if (hostname_size > 0)      hostname[0] = 0;
3585
    if (path_size > 0)          path[0] = 0;
3586

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

    
3599
    /* separate path from hostname */
3600
    ls = strchr(p, '/');
3601
    if(!ls)
3602
        ls = strchr(p, '?');
3603
    if(ls)
3604
        av_strlcpy(path, ls, path_size);
3605
    else
3606
        ls = &p[strlen(p)]; // XXX
3607

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

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

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

    
3646
    for(i = 0; i < s; i++) {
3647
        buff[i * 2]     = hex_table[src[i] >> 4];
3648
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3649
    }
3650

    
3651
    return buff;
3652
}
3653

    
3654
int ff_hex_to_data(uint8_t *data, const char *p)
3655
{
3656
    int c, len, v;
3657

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

    
3682
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3683
                     unsigned int pts_num, unsigned int pts_den)
3684
{
3685
    AVRational new_tb;
3686
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3687
        if(new_tb.num != pts_num)
3688
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3689
    }else
3690
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3691

    
3692
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3693
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3694
        return;
3695
    }
3696
    s->time_base = new_tb;
3697
    s->pts_wrap_bits = pts_wrap_bits;
3698
}
3699

    
3700
int ff_url_join(char *str, int size, const char *proto,
3701
                const char *authorization, const char *hostname,
3702
                int port, const char *fmt, ...)
3703
{
3704
#if CONFIG_NETWORK
3705
    struct addrinfo hints, *ai;
3706
#endif
3707

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

    
3732
    if (port >= 0)
3733
        av_strlcatf(str, size, ":%d", port);
3734
    if (fmt) {
3735
        va_list vl;
3736
        int len = strlen(str);
3737

    
3738
        va_start(vl, fmt);
3739
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3740
        va_end(vl);
3741
    }
3742
    return strlen(str);
3743
}
3744

    
3745
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3746
                     AVFormatContext *src)
3747
{
3748
    AVPacket local_pkt;
3749

    
3750
    local_pkt = *pkt;
3751
    local_pkt.stream_index = dst_stream;
3752
    if (pkt->pts != AV_NOPTS_VALUE)
3753
        local_pkt.pts = av_rescale_q(pkt->pts,
3754
                                     src->streams[pkt->stream_index]->time_base,
3755
                                     dst->streams[dst_stream]->time_base);
3756
    if (pkt->dts != AV_NOPTS_VALUE)
3757
        local_pkt.dts = av_rescale_q(pkt->dts,
3758
                                     src->streams[pkt->stream_index]->time_base,
3759
                                     dst->streams[dst_stream]->time_base);
3760
    return av_write_frame(dst, &local_pkt);
3761
}
3762

    
3763
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3764
                        void *context)
3765
{
3766
    const char *ptr = str;
3767

    
3768
    /* Parse key=value pairs. */
3769
    for (;;) {
3770
        const char *key;
3771
        char *dest = NULL, *dest_end;
3772
        int key_len, dest_len = 0;
3773

    
3774
        /* Skip whitespace and potential commas. */
3775
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3776
            ptr++;
3777
        if (!*ptr)
3778
            break;
3779

    
3780
        key = ptr;
3781

    
3782
        if (!(ptr = strchr(key, '=')))
3783
            break;
3784
        ptr++;
3785
        key_len = ptr - key;
3786

    
3787
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3788
        dest_end = dest + dest_len - 1;
3789

    
3790
        if (*ptr == '\"') {
3791
            ptr++;
3792
            while (*ptr && *ptr != '\"') {
3793
                if (*ptr == '\\') {
3794
                    if (!ptr[1])
3795
                        break;
3796
                    if (dest && dest < dest_end)
3797
                        *dest++ = ptr[1];
3798
                    ptr += 2;
3799
                } else {
3800
                    if (dest && dest < dest_end)
3801
                        *dest++ = *ptr;
3802
                    ptr++;
3803
                }
3804
            }
3805
            if (*ptr == '\"')
3806
                ptr++;
3807
        } else {
3808
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3809
                if (dest && dest < dest_end)
3810
                    *dest++ = *ptr;
3811
        }
3812
        if (dest)
3813
            *dest = 0;
3814
    }
3815
}
3816

    
3817
int ff_find_stream_index(AVFormatContext *s, int id)
3818
{
3819
    int i;
3820
    for (i = 0; i < s->nb_streams; i++) {
3821
        if (s->streams[i]->id == id)
3822
            return i;
3823
    }
3824
    return -1;
3825
}