Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 35eab0c0

History | View | Annotate | Download (93.8 KB)

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

    
23
#undef NDEBUG
24
#include <assert.h>
25

    
26
/**
27
 * @file libavformat/utils.c
28
 * Various utility functions for using ffmpeg library.
29
 */
30

    
31
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
32
static void av_frac_add(AVFrac *f, int64_t incr);
33
static void av_frac_set(AVFrac *f, int64_t val);
34

    
35
/** head of registered input format linked list. */
36
AVInputFormat *first_iformat = NULL;
37
/** head of registered output format linked list. */
38
AVOutputFormat *first_oformat = NULL;
39
/** head of registered image format linked list. */
40
AVImageFormat *first_image_format = NULL;
41

    
42
void av_register_input_format(AVInputFormat *format)
43
{
44
    AVInputFormat **p;
45
    p = &first_iformat;
46
    while (*p != NULL) p = &(*p)->next;
47
    *p = format;
48
    format->next = NULL;
49
}
50

    
51
void av_register_output_format(AVOutputFormat *format)
52
{
53
    AVOutputFormat **p;
54
    p = &first_oformat;
55
    while (*p != NULL) p = &(*p)->next;
56
    *p = format;
57
    format->next = NULL;
58
}
59

    
60
int match_ext(const char *filename, const char *extensions)
61
{
62
    const char *ext, *p;
63
    char ext1[32], *q;
64

    
65
    if(!filename)
66
        return 0;
67

    
68
    ext = strrchr(filename, '.');
69
    if (ext) {
70
        ext++;
71
        p = extensions;
72
        for(;;) {
73
            q = ext1;
74
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
75
                *q++ = *p++;
76
            *q = '\0';
77
            if (!strcasecmp(ext1, ext))
78
                return 1;
79
            if (*p == '\0')
80
                break;
81
            p++;
82
        }
83
    }
84
    return 0;
85
}
86

    
87
AVOutputFormat *guess_format(const char *short_name, const char *filename,
88
                             const char *mime_type)
89
{
90
    AVOutputFormat *fmt, *fmt_found;
91
    int score_max, score;
92

    
93
    /* specific test for image sequences */
94
#ifdef CONFIG_IMAGE2_MUXER
95
    if (!short_name && filename &&
96
        av_filename_number_test(filename) &&
97
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
98
        return guess_format("image2", NULL, NULL);
99
    }
100
#endif
101
    if (!short_name && filename &&
102
        av_filename_number_test(filename) &&
103
        guess_image_format(filename)) {
104
        return guess_format("image", NULL, NULL);
105
    }
106

    
107
    /* find the proper file type */
108
    fmt_found = NULL;
109
    score_max = 0;
110
    fmt = first_oformat;
111
    while (fmt != NULL) {
112
        score = 0;
113
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
114
            score += 100;
115
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
116
            score += 10;
117
        if (filename && fmt->extensions &&
118
            match_ext(filename, fmt->extensions)) {
119
            score += 5;
120
        }
121
        if (score > score_max) {
122
            score_max = score;
123
            fmt_found = fmt;
124
        }
125
        fmt = fmt->next;
126
    }
127
    return fmt_found;
128
}
129

    
130
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
131
                             const char *mime_type)
132
{
133
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
134

    
135
    if (fmt) {
136
        AVOutputFormat *stream_fmt;
137
        char stream_format_name[64];
138

    
139
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
140
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
141

    
142
        if (stream_fmt)
143
            fmt = stream_fmt;
144
    }
145

    
146
    return fmt;
147
}
148

    
149
/**
150
 * Guesses the codec id based upon muxer and filename.
151
 */
152
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
153
                            const char *filename, const char *mime_type, enum CodecType type){
154
    if(type == CODEC_TYPE_VIDEO){
155
        enum CodecID codec_id= CODEC_ID_NONE;
156

    
157
#ifdef CONFIG_IMAGE2_MUXER
158
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
159
            codec_id= av_guess_image2_codec(filename);
160
        }
161
#endif
162
        if(codec_id == CODEC_ID_NONE)
163
            codec_id= fmt->video_codec;
164
        return codec_id;
165
    }else if(type == CODEC_TYPE_AUDIO)
166
        return fmt->audio_codec;
167
    else
168
        return CODEC_ID_NONE;
169
}
170

    
171
/**
172
 * finds AVInputFormat based on input format's short name.
173
 */
174
AVInputFormat *av_find_input_format(const char *short_name)
175
{
176
    AVInputFormat *fmt;
177
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
178
        if (!strcmp(fmt->name, short_name))
179
            return fmt;
180
    }
181
    return NULL;
182
}
183

    
184
/* memory handling */
185

    
186
/**
187
 * Default packet destructor.
188
 */
189
void av_destruct_packet(AVPacket *pkt)
190
{
191
    av_free(pkt->data);
192
    pkt->data = NULL; pkt->size = 0;
193
}
194

    
195
/**
196
 * Allocate the payload of a packet and intialized its fields to default values.
197
 *
198
 * @param pkt packet
199
 * @param size wanted payload size
200
 * @return 0 if OK. AVERROR_xxx otherwise.
201
 */
202
int av_new_packet(AVPacket *pkt, int size)
203
{
204
    void *data;
205
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
206
        return AVERROR_NOMEM;
207
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
208
    if (!data)
209
        return AVERROR_NOMEM;
210
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
211

    
212
    av_init_packet(pkt);
213
    pkt->data = data;
214
    pkt->size = size;
215
    pkt->destruct = av_destruct_packet;
216
    return 0;
217
}
218

    
219
/**
220
 * Allocate and read the payload of a packet and intialized its fields to default values.
221
 *
222
 * @param pkt packet
223
 * @param size wanted payload size
224
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
225
 */
226
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
227
{
228
    int ret= av_new_packet(pkt, size);
229

    
230
    if(ret<0)
231
        return ret;
232

    
233
    pkt->pos= url_ftell(s);
234

    
235
    ret= get_buffer(s, pkt->data, size);
236
    if(ret<=0)
237
        av_free_packet(pkt);
238
    else
239
        pkt->size= ret;
240

    
241
    return ret;
242
}
243

    
244
/* This is a hack - the packet memory allocation stuff is broken. The
245
   packet is allocated if it was not really allocated */
246
int av_dup_packet(AVPacket *pkt)
247
{
248
    if (pkt->destruct != av_destruct_packet) {
249
        uint8_t *data;
250
        /* we duplicate the packet and don't forget to put the padding
251
           again */
252
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
253
            return AVERROR_NOMEM;
254
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
255
        if (!data) {
256
            return AVERROR_NOMEM;
257
        }
258
        memcpy(data, pkt->data, pkt->size);
259
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
260
        pkt->data = data;
261
        pkt->destruct = av_destruct_packet;
262
    }
263
    return 0;
264
}
265

    
266
/**
267
 * Allocate the payload of a packet and intialized its fields to default values.
268
 *
269
 * @param filename possible numbered sequence string
270
 * @return 1 if a valid numbered sequence string, 0 otherwise.
271
 */
272
int av_filename_number_test(const char *filename)
273
{
274
    char buf[1024];
275
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
276
}
277

    
278
/**
279
 * Guess file format.
280
 */
281
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
282
{
283
    AVInputFormat *fmt1, *fmt;
284
    int score, score_max;
285

    
286
    fmt = NULL;
287
    score_max = 0;
288
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
289
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
290
            continue;
291
        score = 0;
292
        if (fmt1->read_probe) {
293
            score = fmt1->read_probe(pd);
294
        } else if (fmt1->extensions) {
295
            if (match_ext(pd->filename, fmt1->extensions)) {
296
                score = 50;
297
            }
298
        }
299
        if (score > score_max) {
300
            score_max = score;
301
            fmt = fmt1;
302
        }
303
    }
304
    return fmt;
305
}
306

    
307
/************************************************************/
308
/* input media file */
309

    
310
/**
311
 * Open a media file from an IO stream. 'fmt' must be specified.
312
 */
313
static const char* format_to_name(void* ptr)
314
{
315
    AVFormatContext* fc = (AVFormatContext*) ptr;
316
    if(fc->iformat) return fc->iformat->name;
317
    else if(fc->oformat) return fc->oformat->name;
318
    else return "NULL";
319
}
320

    
321
#define OFFSET(x) offsetof(AVFormatContext,x)
322
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
323
//these names are too long to be readable
324
#define E AV_OPT_FLAG_ENCODING_PARAM
325
#define D AV_OPT_FLAG_DECODING_PARAM
326

    
327
static const AVOption options[]={
328
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
329
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
330
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
331
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D, "fflags"},
332
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
333
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
334
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
335
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
336
{NULL},
337
};
338

    
339
#undef E
340
#undef D
341
#undef DEFAULT
342

    
343
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
344

    
345
#if LIBAVCODEC_VERSION_INT > ((52<<16)+(0<<8)+0)
346
static
347
#endif
348
void avformat_get_context_defaults(AVFormatContext *s){
349
    memset(s, 0, sizeof(AVFormatContext));
350

    
351
    s->av_class = &av_format_context_class;
352

    
353
    av_opt_set_defaults(s);
354
}
355

    
356
AVFormatContext *av_alloc_format_context(void)
357
{
358
    AVFormatContext *ic;
359
    ic = av_malloc(sizeof(AVFormatContext));
360
    if (!ic) return ic;
361
    avformat_get_context_defaults(ic);
362
    ic->av_class = &av_format_context_class;
363
    return ic;
364
}
365

    
366
/**
367
 * Allocates all the structures needed to read an input stream.
368
 *        This does not open the needed codecs for decoding the stream[s].
369
 */
370
int av_open_input_stream(AVFormatContext **ic_ptr,
371
                         ByteIOContext *pb, const char *filename,
372
                         AVInputFormat *fmt, AVFormatParameters *ap)
373
{
374
    int err;
375
    AVFormatContext *ic;
376
    AVFormatParameters default_ap;
377

    
378
    if(!ap){
379
        ap=&default_ap;
380
        memset(ap, 0, sizeof(default_ap));
381
    }
382

    
383
    if(!ap->prealloced_context)
384
        ic = av_alloc_format_context();
385
    else
386
        ic = *ic_ptr;
387
    if (!ic) {
388
        err = AVERROR_NOMEM;
389
        goto fail;
390
    }
391
    ic->iformat = fmt;
392
    if (pb)
393
        ic->pb = *pb;
394
    ic->duration = AV_NOPTS_VALUE;
395
    ic->start_time = AV_NOPTS_VALUE;
396
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
397

    
398
    /* allocate private data */
399
    if (fmt->priv_data_size > 0) {
400
        ic->priv_data = av_mallocz(fmt->priv_data_size);
401
        if (!ic->priv_data) {
402
            err = AVERROR_NOMEM;
403
            goto fail;
404
        }
405
    } else {
406
        ic->priv_data = NULL;
407
    }
408

    
409
    err = ic->iformat->read_header(ic, ap);
410
    if (err < 0)
411
        goto fail;
412

    
413
    if (pb)
414
        ic->data_offset = url_ftell(&ic->pb);
415

    
416
    *ic_ptr = ic;
417
    return 0;
418
 fail:
419
    if (ic) {
420
        av_freep(&ic->priv_data);
421
    }
422
    av_free(ic);
423
    *ic_ptr = NULL;
424
    return err;
425
}
426

    
427
/** Size of probe buffer, for guessing file type from file contents. */
428
#define PROBE_BUF_MIN 2048
429
#define PROBE_BUF_MAX (1<<20)
430

    
431
/**
432
 * Open a media file as input. The codec are not opened. Only the file
433
 * header (if present) is read.
434
 *
435
 * @param ic_ptr the opened media file handle is put here
436
 * @param filename filename to open.
437
 * @param fmt if non NULL, force the file format to use
438
 * @param buf_size optional buffer size (zero if default is OK)
439
 * @param ap additionnal parameters needed when opening the file (NULL if default)
440
 * @return 0 if OK. AVERROR_xxx otherwise.
441
 */
442
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
443
                       AVInputFormat *fmt,
444
                       int buf_size,
445
                       AVFormatParameters *ap)
446
{
447
    int err, must_open_file, file_opened, probe_size;
448
    AVProbeData probe_data, *pd = &probe_data;
449
    ByteIOContext pb1, *pb = &pb1;
450

    
451
    file_opened = 0;
452
    pd->filename = "";
453
    if (filename)
454
        pd->filename = filename;
455
    pd->buf = NULL;
456
    pd->buf_size = 0;
457

    
458
    if (!fmt) {
459
        /* guess format if no file can be opened  */
460
        fmt = av_probe_input_format(pd, 0);
461
    }
462

    
463
    /* do not open file if the format does not need it. XXX: specific
464
       hack needed to handle RTSP/TCP */
465
    must_open_file = 1;
466
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
467
        must_open_file = 0;
468
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
469
    }
470

    
471
    if (!fmt || must_open_file) {
472
        /* if no file needed do not try to open one */
473
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
474
            err = AVERROR_IO;
475
            goto fail;
476
        }
477
        file_opened = 1;
478
        if (buf_size > 0) {
479
            url_setbufsize(pb, buf_size);
480
        }
481

    
482
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
483
            /* read probe data */
484
            pd->buf= av_realloc(pd->buf, probe_size);
485
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
486
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
487
                url_fclose(pb);
488
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
489
                    file_opened = 0;
490
                    err = AVERROR_IO;
491
                    goto fail;
492
                }
493
            }
494
            /* guess file format */
495
            fmt = av_probe_input_format(pd, 1);
496
        }
497
        av_freep(&pd->buf);
498
    }
499

    
500
    /* if still no format found, error */
501
    if (!fmt) {
502
        err = AVERROR_NOFMT;
503
        goto fail;
504
    }
505

    
506
    /* XXX: suppress this hack for redirectors */
507
#ifdef CONFIG_NETWORK
508
    if (fmt == &redir_demuxer) {
509
        err = redir_open(ic_ptr, pb);
510
        url_fclose(pb);
511
        return err;
512
    }
513
#endif
514

    
515
    /* check filename in case of an image number is expected */
516
    if (fmt->flags & AVFMT_NEEDNUMBER) {
517
        if (!av_filename_number_test(filename)) {
518
            err = AVERROR_NUMEXPECTED;
519
            goto fail;
520
        }
521
    }
522
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
523
    if (err)
524
        goto fail;
525
    return 0;
526
 fail:
527
    av_freep(&pd->buf);
528
    if (file_opened)
529
        url_fclose(pb);
530
    *ic_ptr = NULL;
531
    return err;
532

    
533
}
534

    
535
/*******************************************************/
536

    
537
/**
538
 * Read a transport packet from a media file.
539
 *
540
 * This function is absolete and should never be used.
541
 * Use av_read_frame() instead.
542
 *
543
 * @param s media file handle
544
 * @param pkt is filled
545
 * @return 0 if OK. AVERROR_xxx if error.
546
 */
547
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
548
{
549
    return s->iformat->read_packet(s, pkt);
550
}
551

    
552
/**********************************************************/
553

    
554
/**
555
 * Get the number of samples of an audio frame. Return (-1) if error.
556
 */
557
static int get_audio_frame_size(AVCodecContext *enc, int size)
558
{
559
    int frame_size;
560

    
561
    if (enc->frame_size <= 1) {
562
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
563

    
564
        if (bits_per_sample) {
565
            if (enc->channels == 0)
566
                return -1;
567
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
568
        } else {
569
            /* used for example by ADPCM codecs */
570
            if (enc->bit_rate == 0)
571
                return -1;
572
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
573
        }
574
    } else {
575
        frame_size = enc->frame_size;
576
    }
577
    return frame_size;
578
}
579

    
580

    
581
/**
582
 * Return the frame duration in seconds, return 0 if not available.
583
 */
584
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
585
                                   AVCodecParserContext *pc, AVPacket *pkt)
586
{
587
    int frame_size;
588

    
589
    *pnum = 0;
590
    *pden = 0;
591
    switch(st->codec->codec_type) {
592
    case CODEC_TYPE_VIDEO:
593
        if(st->time_base.num*1000LL > st->time_base.den){
594
            *pnum = st->time_base.num;
595
            *pden = st->time_base.den;
596
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
597
            *pnum = st->codec->time_base.num;
598
            *pden = st->codec->time_base.den;
599
            if (pc && pc->repeat_pict) {
600
                *pden *= 2;
601
                *pnum = (*pnum) * (2 + pc->repeat_pict);
602
            }
603
        }
604
        break;
605
    case CODEC_TYPE_AUDIO:
606
        frame_size = get_audio_frame_size(st->codec, pkt->size);
607
        if (frame_size < 0)
608
            break;
609
        *pnum = frame_size;
610
        *pden = st->codec->sample_rate;
611
        break;
612
    default:
613
        break;
614
    }
615
}
616

    
617
static int is_intra_only(AVCodecContext *enc){
618
    if(enc->codec_type == CODEC_TYPE_AUDIO){
619
        return 1;
620
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
621
        switch(enc->codec_id){
622
        case CODEC_ID_MJPEG:
623
        case CODEC_ID_MJPEGB:
624
        case CODEC_ID_LJPEG:
625
        case CODEC_ID_RAWVIDEO:
626
        case CODEC_ID_DVVIDEO:
627
        case CODEC_ID_HUFFYUV:
628
        case CODEC_ID_FFVHUFF:
629
        case CODEC_ID_ASV1:
630
        case CODEC_ID_ASV2:
631
        case CODEC_ID_VCR1:
632
            return 1;
633
        default: break;
634
        }
635
    }
636
    return 0;
637
}
638

    
639
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
640
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
641
    int64_t delta= last_ts - mask/2;
642
    return  ((lsb - delta)&mask) + delta;
643
}
644

    
645
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
646
                               AVCodecParserContext *pc, AVPacket *pkt)
647
{
648
    int num, den, presentation_delayed;
649
    /* handle wrapping */
650
    if(st->cur_dts != AV_NOPTS_VALUE){
651
        if(pkt->pts != AV_NOPTS_VALUE)
652
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
653
        if(pkt->dts != AV_NOPTS_VALUE)
654
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
655
    }
656

    
657
    if (pkt->duration == 0) {
658
        compute_frame_duration(&num, &den, st, pc, pkt);
659
        if (den && num) {
660
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
661
        }
662
    }
663

    
664
    if(is_intra_only(st->codec))
665
        pkt->flags |= PKT_FLAG_KEY;
666

    
667
    /* do we have a video B frame ? */
668
    presentation_delayed = 0;
669
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
670
        /* XXX: need has_b_frame, but cannot get it if the codec is
671
           not initialized */
672
        if ((   st->codec->codec_id == CODEC_ID_H264
673
             || st->codec->has_b_frames) &&
674
            pc && pc->pict_type != FF_B_TYPE)
675
            presentation_delayed = 1;
676
        /* this may be redundant, but it shouldnt hurt */
677
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
678
            presentation_delayed = 1;
679
    }
680

    
681
    if(st->cur_dts == AV_NOPTS_VALUE){
682
        if(presentation_delayed) st->cur_dts = -pkt->duration;
683
        else                     st->cur_dts = 0;
684
    }
685

    
686
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
687
    /* interpolate PTS and DTS if they are not present */
688
    if (presentation_delayed) {
689
        /* DTS = decompression time stamp */
690
        /* PTS = presentation time stamp */
691
        if (pkt->dts == AV_NOPTS_VALUE) {
692
            /* if we know the last pts, use it */
693
            if(st->last_IP_pts != AV_NOPTS_VALUE)
694
                st->cur_dts = pkt->dts = st->last_IP_pts;
695
            else
696
                pkt->dts = st->cur_dts;
697
        } else {
698
            st->cur_dts = pkt->dts;
699
        }
700
        /* this is tricky: the dts must be incremented by the duration
701
           of the frame we are displaying, i.e. the last I or P frame */
702
        if (st->last_IP_duration == 0)
703
            st->cur_dts += pkt->duration;
704
        else
705
            st->cur_dts += st->last_IP_duration;
706
        st->last_IP_duration  = pkt->duration;
707
        st->last_IP_pts= pkt->pts;
708
        /* cannot compute PTS if not present (we can compute it only
709
           by knowing the futur */
710
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
711
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
712
            int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
713
            int64_t new_diff= ABS(st->cur_dts - pkt->pts);
714
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
715
                pkt->pts += pkt->duration;
716
//                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
717
            }
718
        }
719

    
720
        /* presentation is not delayed : PTS and DTS are the same */
721
        if (pkt->pts == AV_NOPTS_VALUE) {
722
            if (pkt->dts == AV_NOPTS_VALUE) {
723
                pkt->pts = st->cur_dts;
724
                pkt->dts = st->cur_dts;
725
            }
726
            else {
727
                st->cur_dts = pkt->dts;
728
                pkt->pts = pkt->dts;
729
            }
730
        } else {
731
            st->cur_dts = pkt->pts;
732
            pkt->dts = pkt->pts;
733
        }
734
        st->cur_dts += pkt->duration;
735
    }
736
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
737

    
738
    /* update flags */
739
    if (pc) {
740
        pkt->flags = 0;
741
        /* key frame computation */
742
        switch(st->codec->codec_type) {
743
        case CODEC_TYPE_VIDEO:
744
            if (pc->pict_type == FF_I_TYPE)
745
                pkt->flags |= PKT_FLAG_KEY;
746
            break;
747
        case CODEC_TYPE_AUDIO:
748
            pkt->flags |= PKT_FLAG_KEY;
749
            break;
750
        default:
751
            break;
752
        }
753
    }
754
}
755

    
756
void av_destruct_packet_nofree(AVPacket *pkt)
757
{
758
    pkt->data = NULL; pkt->size = 0;
759
}
760

    
761
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
762
{
763
    AVStream *st;
764
    int len, ret, i;
765

    
766
    for(;;) {
767
        /* select current input stream component */
768
        st = s->cur_st;
769
        if (st) {
770
            if (!st->need_parsing || !st->parser) {
771
                /* no parsing needed: we just output the packet as is */
772
                /* raw data support */
773
                *pkt = s->cur_pkt;
774
                compute_pkt_fields(s, st, NULL, pkt);
775
                s->cur_st = NULL;
776
                break;
777
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
778
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
779
                                      s->cur_ptr, s->cur_len,
780
                                      s->cur_pkt.pts, s->cur_pkt.dts);
781
                s->cur_pkt.pts = AV_NOPTS_VALUE;
782
                s->cur_pkt.dts = AV_NOPTS_VALUE;
783
                /* increment read pointer */
784
                s->cur_ptr += len;
785
                s->cur_len -= len;
786

    
787
                /* return packet if any */
788
                if (pkt->size) {
789
                got_packet:
790
                    pkt->duration = 0;
791
                    pkt->stream_index = st->index;
792
                    pkt->pts = st->parser->pts;
793
                    pkt->dts = st->parser->dts;
794
                    pkt->destruct = av_destruct_packet_nofree;
795
                    compute_pkt_fields(s, st, st->parser, pkt);
796
                    break;
797
                }
798
            } else {
799
                /* free packet */
800
                av_free_packet(&s->cur_pkt);
801
                s->cur_st = NULL;
802
            }
803
        } else {
804
            /* read next packet */
805
            ret = av_read_packet(s, &s->cur_pkt);
806
            if (ret < 0) {
807
                if (ret == -EAGAIN)
808
                    return ret;
809
                /* return the last frames, if any */
810
                for(i = 0; i < s->nb_streams; i++) {
811
                    st = s->streams[i];
812
                    if (st->parser && st->need_parsing) {
813
                        av_parser_parse(st->parser, st->codec,
814
                                        &pkt->data, &pkt->size,
815
                                        NULL, 0,
816
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
817
                        if (pkt->size)
818
                            goto got_packet;
819
                    }
820
                }
821
                /* no more packets: really terminates parsing */
822
                return ret;
823
            }
824

    
825
            st = s->streams[s->cur_pkt.stream_index];
826
            if(st->codec->debug & FF_DEBUG_PTS)
827
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%lld, dts=%lld, size=%d\n",
828
                    s->cur_pkt.stream_index,
829
                    s->cur_pkt.pts,
830
                    s->cur_pkt.dts,
831
                    s->cur_pkt.size);
832

    
833
            s->cur_st = st;
834
            s->cur_ptr = s->cur_pkt.data;
835
            s->cur_len = s->cur_pkt.size;
836
            if (st->need_parsing && !st->parser) {
837
                st->parser = av_parser_init(st->codec->codec_id);
838
                if (!st->parser) {
839
                    /* no parser available : just output the raw packets */
840
                    st->need_parsing = 0;
841
                }else if(st->need_parsing == 2){
842
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
843
                }
844
            }
845
        }
846
    }
847
    if(st->codec->debug & FF_DEBUG_PTS)
848
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%lld, dts=%lld, size=%d\n",
849
            pkt->stream_index,
850
            pkt->pts,
851
            pkt->dts,
852
            pkt->size);
853

    
854
    return 0;
855
}
856

    
857
/**
858
 * Return the next frame of a stream.
859
 *
860
 * The returned packet is valid
861
 * until the next av_read_frame() or until av_close_input_file() and
862
 * must be freed with av_free_packet. For video, the packet contains
863
 * exactly one frame. For audio, it contains an integer number of
864
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
865
 * data). If the audio frames have a variable size (e.g. MPEG audio),
866
 * then it contains one frame.
867
 *
868
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
869
 * values in AV_TIME_BASE unit (and guessed if the format cannot
870
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
871
 * has B frames, so it is better to rely on pkt->dts if you do not
872
 * decompress the payload.
873
 *
874
 * @return 0 if OK, < 0 if error or end of file.
875
 */
876
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
877
{
878
    AVPacketList *pktl;
879
    int eof=0;
880
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
881

    
882
    for(;;){
883
        pktl = s->packet_buffer;
884
        if (pktl) {
885
            AVPacket *next_pkt= &pktl->pkt;
886

    
887
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
888
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
889
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
890
                       && next_pkt->dts < pktl->pkt.dts
891
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
892
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
893
                        next_pkt->pts= pktl->pkt.dts;
894
                    }
895
                    pktl= pktl->next;
896
                }
897
                pktl = s->packet_buffer;
898
            }
899

    
900
            if(   next_pkt->pts != AV_NOPTS_VALUE
901
               || next_pkt->dts == AV_NOPTS_VALUE
902
               || !genpts || eof){
903
                /* read packet from packet buffer, if there is data */
904
                *pkt = *next_pkt;
905
                s->packet_buffer = pktl->next;
906
                av_free(pktl);
907
                return 0;
908
            }
909
        }
910
        if(genpts){
911
            AVPacketList **plast_pktl= &s->packet_buffer;
912
            int ret= av_read_frame_internal(s, pkt);
913
            if(ret<0){
914
                if(pktl && ret != -EAGAIN){
915
                    eof=1;
916
                    continue;
917
                }else
918
                    return ret;
919
            }
920

    
921
            /* duplicate the packet */
922
            if (av_dup_packet(pkt) < 0)
923
                return AVERROR_NOMEM;
924

    
925
            while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
926

    
927
            pktl = av_mallocz(sizeof(AVPacketList));
928
            if (!pktl)
929
                return AVERROR_NOMEM;
930

    
931
            /* add the packet in the buffered packet list */
932
            *plast_pktl = pktl;
933
            pktl->pkt= *pkt;
934
        }else{
935
            assert(!s->packet_buffer);
936
            return av_read_frame_internal(s, pkt);
937
        }
938
    }
939
}
940

    
941
/* XXX: suppress the packet queue */
942
static void flush_packet_queue(AVFormatContext *s)
943
{
944
    AVPacketList *pktl;
945

    
946
    for(;;) {
947
        pktl = s->packet_buffer;
948
        if (!pktl)
949
            break;
950
        s->packet_buffer = pktl->next;
951
        av_free_packet(&pktl->pkt);
952
        av_free(pktl);
953
    }
954
}
955

    
956
/*******************************************************/
957
/* seek support */
958

    
959
int av_find_default_stream_index(AVFormatContext *s)
960
{
961
    int i;
962
    AVStream *st;
963

    
964
    if (s->nb_streams <= 0)
965
        return -1;
966
    for(i = 0; i < s->nb_streams; i++) {
967
        st = s->streams[i];
968
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
969
            return i;
970
        }
971
    }
972
    return 0;
973
}
974

    
975
/**
976
 * Flush the frame reader.
977
 */
978
static void av_read_frame_flush(AVFormatContext *s)
979
{
980
    AVStream *st;
981
    int i;
982

    
983
    flush_packet_queue(s);
984

    
985
    /* free previous packet */
986
    if (s->cur_st) {
987
        if (s->cur_st->parser)
988
            av_free_packet(&s->cur_pkt);
989
        s->cur_st = NULL;
990
    }
991
    /* fail safe */
992
    s->cur_ptr = NULL;
993
    s->cur_len = 0;
994

    
995
    /* for each stream, reset read state */
996
    for(i = 0; i < s->nb_streams; i++) {
997
        st = s->streams[i];
998

    
999
        if (st->parser) {
1000
            av_parser_close(st->parser);
1001
            st->parser = NULL;
1002
        }
1003
        st->last_IP_pts = AV_NOPTS_VALUE;
1004
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1005
    }
1006
}
1007

    
1008
/**
1009
 * Updates cur_dts of all streams based on given timestamp and AVStream.
1010
 *
1011
 * Stream ref_st unchanged, others set cur_dts in their native timebase
1012
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1013
 * @param timestamp new dts expressed in time_base of param ref_st
1014
 * @param ref_st reference stream giving time_base of param timestamp
1015
 */
1016
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1017
    int i;
1018

    
1019
    for(i = 0; i < s->nb_streams; i++) {
1020
        AVStream *st = s->streams[i];
1021

    
1022
        st->cur_dts = av_rescale(timestamp,
1023
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1024
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1025
    }
1026
}
1027

    
1028
/**
1029
 * Add a index entry into a sorted list updateing if it is already there.
1030
 *
1031
 * @param timestamp timestamp in the timebase of the given stream
1032
 */
1033
int av_add_index_entry(AVStream *st,
1034
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1035
{
1036
    AVIndexEntry *entries, *ie;
1037
    int index;
1038

    
1039
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1040
        return -1;
1041

    
1042
    entries = av_fast_realloc(st->index_entries,
1043
                              &st->index_entries_allocated_size,
1044
                              (st->nb_index_entries + 1) *
1045
                              sizeof(AVIndexEntry));
1046
    if(!entries)
1047
        return -1;
1048

    
1049
    st->index_entries= entries;
1050

    
1051
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1052

    
1053
    if(index<0){
1054
        index= st->nb_index_entries++;
1055
        ie= &entries[index];
1056
        assert(index==0 || ie[-1].timestamp < timestamp);
1057
    }else{
1058
        ie= &entries[index];
1059
        if(ie->timestamp != timestamp){
1060
            if(ie->timestamp <= timestamp)
1061
                return -1;
1062
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1063
            st->nb_index_entries++;
1064
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1065
            distance= ie->min_distance;
1066
    }
1067

    
1068
    ie->pos = pos;
1069
    ie->timestamp = timestamp;
1070
    ie->min_distance= distance;
1071
    ie->size= size;
1072
    ie->flags = flags;
1073

    
1074
    return index;
1075
}
1076

    
1077
/**
1078
 * build an index for raw streams using a parser.
1079
 */
1080
static void av_build_index_raw(AVFormatContext *s)
1081
{
1082
    AVPacket pkt1, *pkt = &pkt1;
1083
    int ret;
1084
    AVStream *st;
1085

    
1086
    st = s->streams[0];
1087
    av_read_frame_flush(s);
1088
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1089

    
1090
    for(;;) {
1091
        ret = av_read_frame(s, pkt);
1092
        if (ret < 0)
1093
            break;
1094
        if (pkt->stream_index == 0 && st->parser &&
1095
            (pkt->flags & PKT_FLAG_KEY)) {
1096
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1097
                            0, 0, AVINDEX_KEYFRAME);
1098
        }
1099
        av_free_packet(pkt);
1100
    }
1101
}
1102

    
1103
/**
1104
 * Returns TRUE if we deal with a raw stream.
1105
 *
1106
 * Raw codec data and parsing needed.
1107
 */
1108
static int is_raw_stream(AVFormatContext *s)
1109
{
1110
    AVStream *st;
1111

    
1112
    if (s->nb_streams != 1)
1113
        return 0;
1114
    st = s->streams[0];
1115
    if (!st->need_parsing)
1116
        return 0;
1117
    return 1;
1118
}
1119

    
1120
/**
1121
 * Gets the index for a specific timestamp.
1122
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1123
 *                 the timestamp which is <= the requested one, if backward is 0
1124
 *                 then it will be >=
1125
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1126
 * @return < 0 if no such timestamp could be found
1127
 */
1128
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1129
                              int flags)
1130
{
1131
    AVIndexEntry *entries= st->index_entries;
1132
    int nb_entries= st->nb_index_entries;
1133
    int a, b, m;
1134
    int64_t timestamp;
1135

    
1136
    a = - 1;
1137
    b = nb_entries;
1138

    
1139
    while (b - a > 1) {
1140
        m = (a + b) >> 1;
1141
        timestamp = entries[m].timestamp;
1142
        if(timestamp >= wanted_timestamp)
1143
            b = m;
1144
        if(timestamp <= wanted_timestamp)
1145
            a = m;
1146
    }
1147
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1148

    
1149
    if(!(flags & AVSEEK_FLAG_ANY)){
1150
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1151
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1152
        }
1153
    }
1154

    
1155
    if(m == nb_entries)
1156
        return -1;
1157
    return  m;
1158
}
1159

    
1160
#define DEBUG_SEEK
1161

    
1162
/**
1163
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1164
 * this isnt supposed to be called directly by a user application, but by demuxers
1165
 * @param target_ts target timestamp in the time base of the given stream
1166
 * @param stream_index stream number
1167
 */
1168
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1169
    AVInputFormat *avif= s->iformat;
1170
    int64_t pos_min, pos_max, pos, pos_limit;
1171
    int64_t ts_min, ts_max, ts;
1172
    int64_t start_pos, filesize;
1173
    int index, no_change;
1174
    AVStream *st;
1175

    
1176
    if (stream_index < 0)
1177
        return -1;
1178

    
1179
#ifdef DEBUG_SEEK
1180
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1181
#endif
1182

    
1183
    ts_max=
1184
    ts_min= AV_NOPTS_VALUE;
1185
    pos_limit= -1; //gcc falsely says it may be uninitalized
1186

    
1187
    st= s->streams[stream_index];
1188
    if(st->index_entries){
1189
        AVIndexEntry *e;
1190

    
1191
        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()
1192
        index= FFMAX(index, 0);
1193
        e= &st->index_entries[index];
1194

    
1195
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1196
            pos_min= e->pos;
1197
            ts_min= e->timestamp;
1198
#ifdef DEBUG_SEEK
1199
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1200
               pos_min,ts_min);
1201
#endif
1202
        }else{
1203
            assert(index==0);
1204
        }
1205

    
1206
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1207
        assert(index < st->nb_index_entries);
1208
        if(index >= 0){
1209
            e= &st->index_entries[index];
1210
            assert(e->timestamp >= target_ts);
1211
            pos_max= e->pos;
1212
            ts_max= e->timestamp;
1213
            pos_limit= pos_max - e->min_distance;
1214
#ifdef DEBUG_SEEK
1215
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1216
               pos_max,pos_limit, ts_max);
1217
#endif
1218
        }
1219
    }
1220

    
1221
    if(ts_min == AV_NOPTS_VALUE){
1222
        pos_min = s->data_offset;
1223
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1224
        if (ts_min == AV_NOPTS_VALUE)
1225
            return -1;
1226
    }
1227

    
1228
    if(ts_max == AV_NOPTS_VALUE){
1229
        int step= 1024;
1230
        filesize = url_fsize(&s->pb);
1231
        pos_max = filesize - 1;
1232
        do{
1233
            pos_max -= step;
1234
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1235
            step += step;
1236
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1237
        if (ts_max == AV_NOPTS_VALUE)
1238
            return -1;
1239

    
1240
        for(;;){
1241
            int64_t tmp_pos= pos_max + 1;
1242
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1243
            if(tmp_ts == AV_NOPTS_VALUE)
1244
                break;
1245
            ts_max= tmp_ts;
1246
            pos_max= tmp_pos;
1247
            if(tmp_pos >= filesize)
1248
                break;
1249
        }
1250
        pos_limit= pos_max;
1251
    }
1252

    
1253
    if(ts_min > ts_max){
1254
        return -1;
1255
    }else if(ts_min == ts_max){
1256
        pos_limit= pos_min;
1257
    }
1258

    
1259
    no_change=0;
1260
    while (pos_min < pos_limit) {
1261
#ifdef DEBUG_SEEK
1262
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1263
               pos_min, pos_max,
1264
               ts_min, ts_max);
1265
#endif
1266
        assert(pos_limit <= pos_max);
1267

    
1268
        if(no_change==0){
1269
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1270
            // interpolate position (better than dichotomy)
1271
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1272
                + pos_min - approximate_keyframe_distance;
1273
        }else if(no_change==1){
1274
            // bisection, if interpolation failed to change min or max pos last time
1275
            pos = (pos_min + pos_limit)>>1;
1276
        }else{
1277
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1278
            pos=pos_min;
1279
        }
1280
        if(pos <= pos_min)
1281
            pos= pos_min + 1;
1282
        else if(pos > pos_limit)
1283
            pos= pos_limit;
1284
        start_pos= pos;
1285

    
1286
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1287
        if(pos == pos_max)
1288
            no_change++;
1289
        else
1290
            no_change=0;
1291
#ifdef DEBUG_SEEK
1292
av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1293
#endif
1294
        assert(ts != AV_NOPTS_VALUE);
1295
        if (target_ts <= ts) {
1296
            pos_limit = start_pos - 1;
1297
            pos_max = pos;
1298
            ts_max = ts;
1299
        }
1300
        if (target_ts >= ts) {
1301
            pos_min = pos;
1302
            ts_min = ts;
1303
        }
1304
    }
1305

    
1306
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1307
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1308
#ifdef DEBUG_SEEK
1309
    pos_min = pos;
1310
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1311
    pos_min++;
1312
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1313
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1314
           pos, ts_min, target_ts, ts_max);
1315
#endif
1316
    /* do the seek */
1317
    url_fseek(&s->pb, pos, SEEK_SET);
1318

    
1319
    av_update_cur_dts(s, st, ts);
1320

    
1321
    return 0;
1322
}
1323

    
1324
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1325
    int64_t pos_min, pos_max;
1326
#if 0
1327
    AVStream *st;
1328

1329
    if (stream_index < 0)
1330
        return -1;
1331

1332
    st= s->streams[stream_index];
1333
#endif
1334

    
1335
    pos_min = s->data_offset;
1336
    pos_max = url_fsize(&s->pb) - 1;
1337

    
1338
    if     (pos < pos_min) pos= pos_min;
1339
    else if(pos > pos_max) pos= pos_max;
1340

    
1341
    url_fseek(&s->pb, pos, SEEK_SET);
1342

    
1343
#if 0
1344
    av_update_cur_dts(s, st, ts);
1345
#endif
1346
    return 0;
1347
}
1348

    
1349
static int av_seek_frame_generic(AVFormatContext *s,
1350
                                 int stream_index, int64_t timestamp, int flags)
1351
{
1352
    int index;
1353
    AVStream *st;
1354
    AVIndexEntry *ie;
1355

    
1356
    if (!s->index_built) {
1357
        if (is_raw_stream(s)) {
1358
            av_build_index_raw(s);
1359
        } else {
1360
            return -1;
1361
        }
1362
        s->index_built = 1;
1363
    }
1364

    
1365
    st = s->streams[stream_index];
1366
    index = av_index_search_timestamp(st, timestamp, flags);
1367
    if (index < 0)
1368
        return -1;
1369

    
1370
    /* now we have found the index, we can seek */
1371
    ie = &st->index_entries[index];
1372
    av_read_frame_flush(s);
1373
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1374

    
1375
    av_update_cur_dts(s, st, ie->timestamp);
1376

    
1377
    return 0;
1378
}
1379

    
1380
/**
1381
 * Seek to the key frame at timestamp.
1382
 * 'timestamp' in 'stream_index'.
1383
 * @param stream_index If stream_index is (-1), a default
1384
 * stream is selected, and timestamp is automatically converted
1385
 * from AV_TIME_BASE units to the stream specific time_base.
1386
 * @param timestamp timestamp in AVStream.time_base units
1387
 *        or if there is no stream specified then in AV_TIME_BASE units
1388
 * @param flags flags which select direction and seeking mode
1389
 * @return >= 0 on success
1390
 */
1391
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1392
{
1393
    int ret;
1394
    AVStream *st;
1395

    
1396
    av_read_frame_flush(s);
1397

    
1398
    if(flags & AVSEEK_FLAG_BYTE)
1399
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1400

    
1401
    if(stream_index < 0){
1402
        stream_index= av_find_default_stream_index(s);
1403
        if(stream_index < 0)
1404
            return -1;
1405

    
1406
        st= s->streams[stream_index];
1407
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1408
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1409
    }
1410
    st= s->streams[stream_index];
1411

    
1412
    /* first, we try the format specific seek */
1413
    if (s->iformat->read_seek)
1414
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1415
    else
1416
        ret = -1;
1417
    if (ret >= 0) {
1418
        return 0;
1419
    }
1420

    
1421
    if(s->iformat->read_timestamp)
1422
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1423
    else
1424
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1425
}
1426

    
1427
/*******************************************************/
1428

    
1429
/**
1430
 * Returns TRUE if the stream has accurate timings in any stream.
1431
 *
1432
 * @return TRUE if the stream has accurate timings for at least one component.
1433
 */
1434
static int av_has_timings(AVFormatContext *ic)
1435
{
1436
    int i;
1437
    AVStream *st;
1438

    
1439
    for(i = 0;i < ic->nb_streams; i++) {
1440
        st = ic->streams[i];
1441
        if (st->start_time != AV_NOPTS_VALUE &&
1442
            st->duration != AV_NOPTS_VALUE)
1443
            return 1;
1444
    }
1445
    return 0;
1446
}
1447

    
1448
/**
1449
 * Estimate the stream timings from the one of each components.
1450
 *
1451
 * Also computes the global bitrate if possible.
1452
 */
1453
static void av_update_stream_timings(AVFormatContext *ic)
1454
{
1455
    int64_t start_time, start_time1, end_time, end_time1;
1456
    int i;
1457
    AVStream *st;
1458

    
1459
    start_time = MAXINT64;
1460
    end_time = MININT64;
1461
    for(i = 0;i < ic->nb_streams; i++) {
1462
        st = ic->streams[i];
1463
        if (st->start_time != AV_NOPTS_VALUE) {
1464
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1465
            if (start_time1 < start_time)
1466
                start_time = start_time1;
1467
            if (st->duration != AV_NOPTS_VALUE) {
1468
                end_time1 = start_time1
1469
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1470
                if (end_time1 > end_time)
1471
                    end_time = end_time1;
1472
            }
1473
        }
1474
    }
1475
    if (start_time != MAXINT64) {
1476
        ic->start_time = start_time;
1477
        if (end_time != MININT64) {
1478
            ic->duration = end_time - start_time;
1479
            if (ic->file_size > 0) {
1480
                /* compute the bit rate */
1481
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1482
                    (double)ic->duration;
1483
            }
1484
        }
1485
    }
1486

    
1487
}
1488

    
1489
static void fill_all_stream_timings(AVFormatContext *ic)
1490
{
1491
    int i;
1492
    AVStream *st;
1493

    
1494
    av_update_stream_timings(ic);
1495
    for(i = 0;i < ic->nb_streams; i++) {
1496
        st = ic->streams[i];
1497
        if (st->start_time == AV_NOPTS_VALUE) {
1498
            if(ic->start_time != AV_NOPTS_VALUE)
1499
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1500
            if(ic->duration != AV_NOPTS_VALUE)
1501
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1502
        }
1503
    }
1504
}
1505

    
1506
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1507
{
1508
    int64_t filesize, duration;
1509
    int bit_rate, i;
1510
    AVStream *st;
1511

    
1512
    /* if bit_rate is already set, we believe it */
1513
    if (ic->bit_rate == 0) {
1514
        bit_rate = 0;
1515
        for(i=0;i<ic->nb_streams;i++) {
1516
            st = ic->streams[i];
1517
            bit_rate += st->codec->bit_rate;
1518
        }
1519
        ic->bit_rate = bit_rate;
1520
    }
1521

    
1522
    /* if duration is already set, we believe it */
1523
    if (ic->duration == AV_NOPTS_VALUE &&
1524
        ic->bit_rate != 0 &&
1525
        ic->file_size != 0)  {
1526
        filesize = ic->file_size;
1527
        if (filesize > 0) {
1528
            for(i = 0; i < ic->nb_streams; i++) {
1529
                st = ic->streams[i];
1530
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1531
                if (st->start_time == AV_NOPTS_VALUE ||
1532
                    st->duration == AV_NOPTS_VALUE) {
1533
                    st->start_time = 0;
1534
                    st->duration = duration;
1535
                }
1536
            }
1537
        }
1538
    }
1539
}
1540

    
1541
#define DURATION_MAX_READ_SIZE 250000
1542

    
1543
/* only usable for MPEG-PS streams */
1544
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1545
{
1546
    AVPacket pkt1, *pkt = &pkt1;
1547
    AVStream *st;
1548
    int read_size, i, ret;
1549
    int64_t end_time;
1550
    int64_t filesize, offset, duration;
1551

    
1552
    /* free previous packet */
1553
    if (ic->cur_st && ic->cur_st->parser)
1554
        av_free_packet(&ic->cur_pkt);
1555
    ic->cur_st = NULL;
1556

    
1557
    /* flush packet queue */
1558
    flush_packet_queue(ic);
1559

    
1560
    for(i=0;i<ic->nb_streams;i++) {
1561
        st = ic->streams[i];
1562
        if (st->parser) {
1563
            av_parser_close(st->parser);
1564
            st->parser= NULL;
1565
        }
1566
    }
1567

    
1568
    /* we read the first packets to get the first PTS (not fully
1569
       accurate, but it is enough now) */
1570
    url_fseek(&ic->pb, 0, SEEK_SET);
1571
    read_size = 0;
1572
    for(;;) {
1573
        if (read_size >= DURATION_MAX_READ_SIZE)
1574
            break;
1575
        /* if all info is available, we can stop */
1576
        for(i = 0;i < ic->nb_streams; i++) {
1577
            st = ic->streams[i];
1578
            if (st->start_time == AV_NOPTS_VALUE)
1579
                break;
1580
        }
1581
        if (i == ic->nb_streams)
1582
            break;
1583

    
1584
        ret = av_read_packet(ic, pkt);
1585
        if (ret != 0)
1586
            break;
1587
        read_size += pkt->size;
1588
        st = ic->streams[pkt->stream_index];
1589
        if (pkt->pts != AV_NOPTS_VALUE) {
1590
            if (st->start_time == AV_NOPTS_VALUE)
1591
                st->start_time = pkt->pts;
1592
        }
1593
        av_free_packet(pkt);
1594
    }
1595

    
1596
    /* estimate the end time (duration) */
1597
    /* XXX: may need to support wrapping */
1598
    filesize = ic->file_size;
1599
    offset = filesize - DURATION_MAX_READ_SIZE;
1600
    if (offset < 0)
1601
        offset = 0;
1602

    
1603
    url_fseek(&ic->pb, offset, SEEK_SET);
1604
    read_size = 0;
1605
    for(;;) {
1606
        if (read_size >= DURATION_MAX_READ_SIZE)
1607
            break;
1608
        /* if all info is available, we can stop */
1609
        for(i = 0;i < ic->nb_streams; i++) {
1610
            st = ic->streams[i];
1611
            if (st->duration == AV_NOPTS_VALUE)
1612
                break;
1613
        }
1614
        if (i == ic->nb_streams)
1615
            break;
1616

    
1617
        ret = av_read_packet(ic, pkt);
1618
        if (ret != 0)
1619
            break;
1620
        read_size += pkt->size;
1621
        st = ic->streams[pkt->stream_index];
1622
        if (pkt->pts != AV_NOPTS_VALUE) {
1623
            end_time = pkt->pts;
1624
            duration = end_time - st->start_time;
1625
            if (duration > 0) {
1626
                if (st->duration == AV_NOPTS_VALUE ||
1627
                    st->duration < duration)
1628
                    st->duration = duration;
1629
            }
1630
        }
1631
        av_free_packet(pkt);
1632
    }
1633

    
1634
    fill_all_stream_timings(ic);
1635

    
1636
    url_fseek(&ic->pb, 0, SEEK_SET);
1637
}
1638

    
1639
static void av_estimate_timings(AVFormatContext *ic)
1640
{
1641
    int64_t file_size;
1642

    
1643
    /* get the file size, if possible */
1644
    if (ic->iformat->flags & AVFMT_NOFILE) {
1645
        file_size = 0;
1646
    } else {
1647
        file_size = url_fsize(&ic->pb);
1648
        if (file_size < 0)
1649
            file_size = 0;
1650
    }
1651
    ic->file_size = file_size;
1652

    
1653
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1654
         !strcmp(ic->iformat->name, "mpegts")) &&
1655
        file_size && !ic->pb.is_streamed) {
1656
        /* get accurate estimate from the PTSes */
1657
        av_estimate_timings_from_pts(ic);
1658
    } else if (av_has_timings(ic)) {
1659
        /* at least one components has timings - we use them for all
1660
           the components */
1661
        fill_all_stream_timings(ic);
1662
    } else {
1663
        /* less precise: use bit rate info */
1664
        av_estimate_timings_from_bit_rate(ic);
1665
    }
1666
    av_update_stream_timings(ic);
1667

    
1668
#if 0
1669
    {
1670
        int i;
1671
        AVStream *st;
1672
        for(i = 0;i < ic->nb_streams; i++) {
1673
            st = ic->streams[i];
1674
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1675
               i, (double)st->start_time / AV_TIME_BASE,
1676
               (double)st->duration / AV_TIME_BASE);
1677
        }
1678
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1679
               (double)ic->start_time / AV_TIME_BASE,
1680
               (double)ic->duration / AV_TIME_BASE,
1681
               ic->bit_rate / 1000);
1682
    }
1683
#endif
1684
}
1685

    
1686
static int has_codec_parameters(AVCodecContext *enc)
1687
{
1688
    int val;
1689
    switch(enc->codec_type) {
1690
    case CODEC_TYPE_AUDIO:
1691
        val = enc->sample_rate;
1692
        break;
1693
    case CODEC_TYPE_VIDEO:
1694
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1695
        break;
1696
    default:
1697
        val = 1;
1698
        break;
1699
    }
1700
    return (val != 0);
1701
}
1702

    
1703
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1704
{
1705
    int16_t *samples;
1706
    AVCodec *codec;
1707
    int got_picture, ret=0;
1708
    AVFrame picture;
1709

    
1710
  if(!st->codec->codec){
1711
    codec = avcodec_find_decoder(st->codec->codec_id);
1712
    if (!codec)
1713
        return -1;
1714
    ret = avcodec_open(st->codec, codec);
1715
    if (ret < 0)
1716
        return ret;
1717
  }
1718

    
1719
  if(!has_codec_parameters(st->codec)){
1720
    switch(st->codec->codec_type) {
1721
    case CODEC_TYPE_VIDEO:
1722
        ret = avcodec_decode_video(st->codec, &picture,
1723
                                   &got_picture, (uint8_t *)data, size);
1724
        break;
1725
    case CODEC_TYPE_AUDIO:
1726
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1727
        if (!samples)
1728
            goto fail;
1729
        ret = avcodec_decode_audio(st->codec, samples,
1730
                                   &got_picture, (uint8_t *)data, size);
1731
        av_free(samples);
1732
        break;
1733
    default:
1734
        break;
1735
    }
1736
  }
1737
 fail:
1738
    return ret;
1739
}
1740

    
1741
/* absolute maximum size we read until we abort */
1742
#define MAX_READ_SIZE        5000000
1743

    
1744
/* maximum duration until we stop analysing the stream */
1745
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 3.0))
1746

    
1747
/**
1748
 * Read the beginning of a media file to get stream information. This
1749
 * is useful for file formats with no headers such as MPEG. This
1750
 * function also compute the real frame rate in case of mpeg2 repeat
1751
 * frame mode.
1752
 *
1753
 * @param ic media file handle
1754
 * @return >=0 if OK. AVERROR_xxx if error.
1755
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1756
 */
1757
int av_find_stream_info(AVFormatContext *ic)
1758
{
1759
    int i, count, ret, read_size, j;
1760
    AVStream *st;
1761
    AVPacket pkt1, *pkt;
1762
    AVPacketList *pktl=NULL, **ppktl;
1763
    int64_t last_dts[MAX_STREAMS];
1764
    int64_t duration_sum[MAX_STREAMS];
1765
    int duration_count[MAX_STREAMS]={0};
1766

    
1767
    for(i=0;i<ic->nb_streams;i++) {
1768
        st = ic->streams[i];
1769
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1770
/*            if(!st->time_base.num)
1771
                st->time_base= */
1772
            if(!st->codec->time_base.num)
1773
                st->codec->time_base= st->time_base;
1774
        }
1775
        //only for the split stuff
1776
        if (!st->parser) {
1777
            st->parser = av_parser_init(st->codec->codec_id);
1778
            if(st->need_parsing == 2 && st->parser){
1779
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1780
            }
1781
        }
1782
    }
1783

    
1784
    for(i=0;i<MAX_STREAMS;i++){
1785
        last_dts[i]= AV_NOPTS_VALUE;
1786
        duration_sum[i]= INT64_MAX;
1787
    }
1788

    
1789
    count = 0;
1790
    read_size = 0;
1791
    ppktl = &ic->packet_buffer;
1792
    for(;;) {
1793
        /* check if one codec still needs to be handled */
1794
        for(i=0;i<ic->nb_streams;i++) {
1795
            st = ic->streams[i];
1796
            if (!has_codec_parameters(st->codec))
1797
                break;
1798
            /* variable fps and no guess at the real fps */
1799
            if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1800
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1801
                break;
1802
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1803
                break;
1804
        }
1805
        if (i == ic->nb_streams) {
1806
            /* NOTE: if the format has no header, then we need to read
1807
               some packets to get most of the streams, so we cannot
1808
               stop here */
1809
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1810
                /* if we found the info for all the codecs, we can stop */
1811
                ret = count;
1812
                break;
1813
            }
1814
        }
1815
        /* we did not get all the codec info, but we read too much data */
1816
        if (read_size >= MAX_READ_SIZE) {
1817
            ret = count;
1818
            break;
1819
        }
1820

    
1821
        /* NOTE: a new stream can be added there if no header in file
1822
           (AVFMTCTX_NOHEADER) */
1823
        ret = av_read_frame_internal(ic, &pkt1);
1824
        if (ret < 0) {
1825
            /* EOF or error */
1826
            ret = -1; /* we could not have all the codec parameters before EOF */
1827
            for(i=0;i<ic->nb_streams;i++) {
1828
                st = ic->streams[i];
1829
                if (!has_codec_parameters(st->codec)){
1830
                    char buf[256];
1831
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1832
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1833
                } else {
1834
                    ret = 0;
1835
                }
1836
            }
1837
            break;
1838
        }
1839

    
1840
        pktl = av_mallocz(sizeof(AVPacketList));
1841
        if (!pktl) {
1842
            ret = AVERROR_NOMEM;
1843
            break;
1844
        }
1845

    
1846
        /* add the packet in the buffered packet list */
1847
        *ppktl = pktl;
1848
        ppktl = &pktl->next;
1849

    
1850
        pkt = &pktl->pkt;
1851
        *pkt = pkt1;
1852

    
1853
        /* duplicate the packet */
1854
        if (av_dup_packet(pkt) < 0) {
1855
                ret = AVERROR_NOMEM;
1856
                break;
1857
        }
1858

    
1859
        read_size += pkt->size;
1860

    
1861
        st = ic->streams[pkt->stream_index];
1862
        st->codec_info_duration += pkt->duration;
1863
        if (pkt->duration != 0)
1864
            st->codec_info_nb_frames++;
1865

    
1866
        {
1867
            int index= pkt->stream_index;
1868
            int64_t last= last_dts[index];
1869
            int64_t duration= pkt->dts - last;
1870

    
1871
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1872
                if(duration*duration_count[index]*10/9 < duration_sum[index]){
1873
                    duration_sum[index]= duration;
1874
                    duration_count[index]=1;
1875
                }else{
1876
                    int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1877
                    duration_sum[index] += duration;
1878
                    duration_count[index]+= factor;
1879
                }
1880
                if(st->codec_info_nb_frames == 0 && 0)
1881
                    st->codec_info_duration += duration;
1882
            }
1883
            last_dts[pkt->stream_index]= pkt->dts;
1884
        }
1885
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1886
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1887
            if(i){
1888
                st->codec->extradata_size= i;
1889
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1890
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1891
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1892
            }
1893
        }
1894

    
1895
        /* if still no information, we try to open the codec and to
1896
           decompress the frame. We try to avoid that in most cases as
1897
           it takes longer and uses more memory. For MPEG4, we need to
1898
           decompress for Quicktime. */
1899
        if (!has_codec_parameters(st->codec) /*&&
1900
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1901
             st->codec->codec_id == CODEC_ID_H264 ||
1902
             st->codec->codec_id == CODEC_ID_H263 ||
1903
             st->codec->codec_id == CODEC_ID_H261 ||
1904
             st->codec->codec_id == CODEC_ID_VORBIS ||
1905
             st->codec->codec_id == CODEC_ID_MJPEG ||
1906
             st->codec->codec_id == CODEC_ID_PNG ||
1907
             st->codec->codec_id == CODEC_ID_PAM ||
1908
             st->codec->codec_id == CODEC_ID_PGM ||
1909
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1910
             st->codec->codec_id == CODEC_ID_PBM ||
1911
             st->codec->codec_id == CODEC_ID_PPM ||
1912
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1913
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1914
            try_decode_frame(st, pkt->data, pkt->size);
1915

    
1916
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
1917
            break;
1918
        }
1919
        count++;
1920
    }
1921

    
1922
    // close codecs which where opened in try_decode_frame()
1923
    for(i=0;i<ic->nb_streams;i++) {
1924
        st = ic->streams[i];
1925
        if(st->codec->codec)
1926
            avcodec_close(st->codec);
1927
    }
1928
    for(i=0;i<ic->nb_streams;i++) {
1929
        st = ic->streams[i];
1930
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1931
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1932
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1933

    
1934
            if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
1935
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
1936
                int64_t num, den, error, best_error;
1937

    
1938
                num= st->time_base.den*duration_count[i];
1939
                den= st->time_base.num*duration_sum[i];
1940

    
1941
                best_error= INT64_MAX;
1942
                for(j=1; j<60*12; j++){
1943
                    error= ABS(1001*12*num - 1001*j*den);
1944
                    if(error < best_error){
1945
                        best_error= error;
1946
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
1947
                    }
1948
                }
1949
                for(j=24; j<=30; j+=6){
1950
                    error= ABS(1001*12*num - 1000*12*j*den);
1951
                    if(error < best_error){
1952
                        best_error= error;
1953
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
1954
                    }
1955
                }
1956
            }
1957

    
1958
            /* set real frame rate info */
1959
            /* compute the real frame rate for telecine */
1960
            if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
1961
                 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
1962
                st->codec->sub_id == 2) {
1963
                if (st->codec_info_nb_frames >= 20) {
1964
                    float coded_frame_rate, est_frame_rate;
1965
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1966
                        (double)st->codec_info_duration ;
1967
                    coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
1968
#if 0
1969
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1970
                           coded_frame_rate, est_frame_rate);
1971
#endif
1972
                    /* if we detect that it could be a telecine, we
1973
                       signal it. It would be better to do it at a
1974
                       higher level as it can change in a film */
1975
                    if (coded_frame_rate >= 24.97 &&
1976
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1977
                        st->r_frame_rate = (AVRational){24000, 1001};
1978
                    }
1979
                }
1980
            }
1981
            /* if no real frame rate, use the codec one */
1982
            if (!st->r_frame_rate.num){
1983
                st->r_frame_rate.num = st->codec->time_base.den;
1984
                st->r_frame_rate.den = st->codec->time_base.num;
1985
            }
1986
        }
1987
    }
1988

    
1989
    av_estimate_timings(ic);
1990
#if 0
1991
    /* correct DTS for b frame streams with no timestamps */
1992
    for(i=0;i<ic->nb_streams;i++) {
1993
        st = ic->streams[i];
1994
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1995
            if(b-frames){
1996
                ppktl = &ic->packet_buffer;
1997
                while(ppkt1){
1998
                    if(ppkt1->stream_index != i)
1999
                        continue;
2000
                    if(ppkt1->pkt->dts < 0)
2001
                        break;
2002
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2003
                        break;
2004
                    ppkt1->pkt->dts -= delta;
2005
                    ppkt1= ppkt1->next;
2006
                }
2007
                if(ppkt1)
2008
                    continue;
2009
                st->cur_dts -= delta;
2010
            }
2011
        }
2012
    }
2013
#endif
2014
    return ret;
2015
}
2016

    
2017
/*******************************************************/
2018

    
2019
/**
2020
 * start playing a network based stream (e.g. RTSP stream) at the
2021
 * current position
2022
 */
2023
int av_read_play(AVFormatContext *s)
2024
{
2025
    if (!s->iformat->read_play)
2026
        return AVERROR_NOTSUPP;
2027
    return s->iformat->read_play(s);
2028
}
2029

    
2030
/**
2031
 * Pause a network based stream (e.g. RTSP stream).
2032
 *
2033
 * Use av_read_play() to resume it.
2034
 */
2035
int av_read_pause(AVFormatContext *s)
2036
{
2037
    if (!s->iformat->read_pause)
2038
        return AVERROR_NOTSUPP;
2039
    return s->iformat->read_pause(s);
2040
}
2041

    
2042
/**
2043
 * Close a media file (but not its codecs).
2044
 *
2045
 * @param s media file handle
2046
 */
2047
void av_close_input_file(AVFormatContext *s)
2048
{
2049
    int i, must_open_file;
2050
    AVStream *st;
2051

    
2052
    /* free previous packet */
2053
    if (s->cur_st && s->cur_st->parser)
2054
        av_free_packet(&s->cur_pkt);
2055

    
2056
    if (s->iformat->read_close)
2057
        s->iformat->read_close(s);
2058
    for(i=0;i<s->nb_streams;i++) {
2059
        /* free all data in a stream component */
2060
        st = s->streams[i];
2061
        if (st->parser) {
2062
            av_parser_close(st->parser);
2063
        }
2064
        av_free(st->index_entries);
2065
        av_free(st->codec->extradata);
2066
        av_free(st->codec);
2067
        av_free(st);
2068
    }
2069
    flush_packet_queue(s);
2070
    must_open_file = 1;
2071
    if (s->iformat->flags & AVFMT_NOFILE) {
2072
        must_open_file = 0;
2073
    }
2074
    if (must_open_file) {
2075
        url_fclose(&s->pb);
2076
    }
2077
    av_freep(&s->priv_data);
2078
    av_free(s);
2079
}
2080

    
2081
/**
2082
 * Add a new stream to a media file.
2083
 *
2084
 * Can only be called in the read_header() function. If the flag
2085
 * AVFMTCTX_NOHEADER is in the format context, then new streams
2086
 * can be added in read_packet too.
2087
 *
2088
 * @param s media file handle
2089
 * @param id file format dependent stream id
2090
 */
2091
AVStream *av_new_stream(AVFormatContext *s, int id)
2092
{
2093
    AVStream *st;
2094
    int i;
2095

    
2096
    if (s->nb_streams >= MAX_STREAMS)
2097
        return NULL;
2098

    
2099
    st = av_mallocz(sizeof(AVStream));
2100
    if (!st)
2101
        return NULL;
2102

    
2103
    st->codec= avcodec_alloc_context();
2104
    if (s->iformat) {
2105
        /* no default bitrate if decoding */
2106
        st->codec->bit_rate = 0;
2107
    }
2108
    st->index = s->nb_streams;
2109
    st->id = id;
2110
    st->start_time = AV_NOPTS_VALUE;
2111
    st->duration = AV_NOPTS_VALUE;
2112
    st->cur_dts = AV_NOPTS_VALUE;
2113

    
2114
    /* default pts settings is MPEG like */
2115
    av_set_pts_info(st, 33, 1, 90000);
2116
    st->last_IP_pts = AV_NOPTS_VALUE;
2117
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2118
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2119

    
2120
    s->streams[s->nb_streams++] = st;
2121
    return st;
2122
}
2123

    
2124
/************************************************************/
2125
/* output media file */
2126

    
2127
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2128
{
2129
    int ret;
2130

    
2131
    if (s->oformat->priv_data_size > 0) {
2132
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2133
        if (!s->priv_data)
2134
            return AVERROR_NOMEM;
2135
    } else
2136
        s->priv_data = NULL;
2137

    
2138
    if (s->oformat->set_parameters) {
2139
        ret = s->oformat->set_parameters(s, ap);
2140
        if (ret < 0)
2141
            return ret;
2142
    }
2143
    return 0;
2144
}
2145

    
2146
/**
2147
 * allocate the stream private data and write the stream header to an
2148
 * output media file
2149
 *
2150
 * @param s media file handle
2151
 * @return 0 if OK. AVERROR_xxx if error.
2152
 */
2153
int av_write_header(AVFormatContext *s)
2154
{
2155
    int ret, i;
2156
    AVStream *st;
2157

    
2158
    // some sanity checks
2159
    for(i=0;i<s->nb_streams;i++) {
2160
        st = s->streams[i];
2161

    
2162
        switch (st->codec->codec_type) {
2163
        case CODEC_TYPE_AUDIO:
2164
            if(st->codec->sample_rate<=0){
2165
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2166
                return -1;
2167
            }
2168
            break;
2169
        case CODEC_TYPE_VIDEO:
2170
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2171
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2172
                return -1;
2173
            }
2174
            if(st->codec->width<=0 || st->codec->height<=0){
2175
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2176
                return -1;
2177
            }
2178
            break;
2179
        }
2180
    }
2181

    
2182
    if(s->oformat->write_header){
2183
        ret = s->oformat->write_header(s);
2184
        if (ret < 0)
2185
            return ret;
2186
    }
2187

    
2188
    /* init PTS generation */
2189
    for(i=0;i<s->nb_streams;i++) {
2190
        int64_t den = AV_NOPTS_VALUE;
2191
        st = s->streams[i];
2192

    
2193
        switch (st->codec->codec_type) {
2194
        case CODEC_TYPE_AUDIO:
2195
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2196
            break;
2197
        case CODEC_TYPE_VIDEO:
2198
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2199
            break;
2200
        default:
2201
            break;
2202
        }
2203
        if (den != AV_NOPTS_VALUE) {
2204
            if (den <= 0)
2205
                return AVERROR_INVALIDDATA;
2206
            av_frac_init(&st->pts, 0, 0, den);
2207
        }
2208
    }
2209
    return 0;
2210
}
2211

    
2212
//FIXME merge with compute_pkt_fields
2213
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2214
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2215
    int num, den, frame_size, i;
2216

    
2217
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2218

    
2219
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2220
        return -1;*/
2221

    
2222
    /* duration field */
2223
    if (pkt->duration == 0) {
2224
        compute_frame_duration(&num, &den, st, NULL, pkt);
2225
        if (den && num) {
2226
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2227
        }
2228
    }
2229

    
2230
    //XXX/FIXME this is a temporary hack until all encoders output pts
2231
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2232
        pkt->dts=
2233
//        pkt->pts= st->cur_dts;
2234
        pkt->pts= st->pts.val;
2235
    }
2236

    
2237
    //calculate dts from pts
2238
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2239
        st->pts_buffer[0]= pkt->pts;
2240
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2241
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2242
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2243
            SWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2244

    
2245
        pkt->dts= st->pts_buffer[0];
2246
    }
2247

    
2248
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2249
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2250
        return -1;
2251
    }
2252
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2253
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2254
        return -1;
2255
    }
2256

    
2257
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2258
    st->cur_dts= pkt->dts;
2259
    st->pts.val= pkt->dts;
2260

    
2261
    /* update pts */
2262
    switch (st->codec->codec_type) {
2263
    case CODEC_TYPE_AUDIO:
2264
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2265

    
2266
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2267
           but it would be better if we had the real timestamps from the encoder */
2268
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2269
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2270
        }
2271
        break;
2272
    case CODEC_TYPE_VIDEO:
2273
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2274
        break;
2275
    default:
2276
        break;
2277
    }
2278
    return 0;
2279
}
2280

    
2281
static void truncate_ts(AVStream *st, AVPacket *pkt){
2282
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2283

    
2284
//    if(pkt->dts < 0)
2285
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2286

    
2287
    pkt->pts &= pts_mask;
2288
    pkt->dts &= pts_mask;
2289
}
2290

    
2291
/**
2292
 * Write a packet to an output media file.
2293
 *
2294
 * The packet shall contain one audio or video frame.
2295
 *
2296
 * @param s media file handle
2297
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2298
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2299
 */
2300
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2301
{
2302
    int ret;
2303

    
2304
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2305
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2306
        return ret;
2307

    
2308
    truncate_ts(s->streams[pkt->stream_index], pkt);
2309

    
2310
    ret= s->oformat->write_packet(s, pkt);
2311
    if(!ret)
2312
        ret= url_ferror(&s->pb);
2313
    return ret;
2314
}
2315

    
2316
/**
2317
 * Interleave a packet per DTS in an output media file.
2318
 *
2319
 * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
2320
 * so they cannot be used after it, note calling av_free_packet() on them is still safe.
2321
 *
2322
 * @param s media file handle
2323
 * @param out the interleaved packet will be output here
2324
 * @param in the input packet
2325
 * @param flush 1 if no further packets are available as input and all
2326
 *              remaining packets should be output
2327
 * @return 1 if a packet was output, 0 if no packet could be output,
2328
 *         < 0 if an error occured
2329
 */
2330
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2331
    AVPacketList *pktl, **next_point, *this_pktl;
2332
    int stream_count=0;
2333
    int streams[MAX_STREAMS];
2334

    
2335
    if(pkt){
2336
        AVStream *st= s->streams[ pkt->stream_index];
2337

    
2338
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2339

    
2340
        this_pktl = av_mallocz(sizeof(AVPacketList));
2341
        this_pktl->pkt= *pkt;
2342
        if(pkt->destruct == av_destruct_packet)
2343
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2344
        else
2345
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2346

    
2347
        next_point = &s->packet_buffer;
2348
        while(*next_point){
2349
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2350
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2351
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2352
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2353
                break;
2354
            next_point= &(*next_point)->next;
2355
        }
2356
        this_pktl->next= *next_point;
2357
        *next_point= this_pktl;
2358
    }
2359

    
2360
    memset(streams, 0, sizeof(streams));
2361
    pktl= s->packet_buffer;
2362
    while(pktl){
2363
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2364
        if(streams[ pktl->pkt.stream_index ] == 0)
2365
            stream_count++;
2366
        streams[ pktl->pkt.stream_index ]++;
2367
        pktl= pktl->next;
2368
    }
2369

    
2370
    if(s->nb_streams == stream_count || (flush && stream_count)){
2371
        pktl= s->packet_buffer;
2372
        *out= pktl->pkt;
2373

    
2374
        s->packet_buffer= pktl->next;
2375
        av_freep(&pktl);
2376
        return 1;
2377
    }else{
2378
        av_init_packet(out);
2379
        return 0;
2380
    }
2381
}
2382

    
2383
/**
2384
 * Interleaves a AVPacket correctly so it can be muxed.
2385
 * @param out the interleaved packet will be output here
2386
 * @param in the input packet
2387
 * @param flush 1 if no further packets are available as input and all
2388
 *              remaining packets should be output
2389
 * @return 1 if a packet was output, 0 if no packet could be output,
2390
 *         < 0 if an error occured
2391
 */
2392
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2393
    if(s->oformat->interleave_packet)
2394
        return s->oformat->interleave_packet(s, out, in, flush);
2395
    else
2396
        return av_interleave_packet_per_dts(s, out, in, flush);
2397
}
2398

    
2399
/**
2400
 * Writes a packet to an output media file ensuring correct interleaving.
2401
 *
2402
 * The packet must contain one audio or video frame.
2403
 * If the packets are already correctly interleaved the application should
2404
 * call av_write_frame() instead as its slightly faster, its also important
2405
 * to keep in mind that completly non interleaved input will need huge amounts
2406
 * of memory to interleave with this, so its prefereable to interleave at the
2407
 * demuxer level
2408
 *
2409
 * @param s media file handle
2410
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2411
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2412
 */
2413
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2414
    AVStream *st= s->streams[ pkt->stream_index];
2415

    
2416
    //FIXME/XXX/HACK drop zero sized packets
2417
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2418
        return 0;
2419

    
2420
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2421
    if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2422
        return -1;
2423

    
2424
    if(pkt->dts == AV_NOPTS_VALUE)
2425
        return -1;
2426

    
2427
    for(;;){
2428
        AVPacket opkt;
2429
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2430
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2431
            return ret;
2432

    
2433
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2434
        ret= s->oformat->write_packet(s, &opkt);
2435

    
2436
        av_free_packet(&opkt);
2437
        pkt= NULL;
2438

    
2439
        if(ret<0)
2440
            return ret;
2441
        if(url_ferror(&s->pb))
2442
            return url_ferror(&s->pb);
2443
    }
2444
}
2445

    
2446
/**
2447
 * @brief Write the stream trailer to an output media file and
2448
 *        free the file private data.
2449
 *
2450
 * @param s media file handle
2451
 * @return 0 if OK. AVERROR_xxx if error.
2452
 */
2453
int av_write_trailer(AVFormatContext *s)
2454
{
2455
    int ret, i;
2456

    
2457
    for(;;){
2458
        AVPacket pkt;
2459
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2460
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2461
            goto fail;
2462
        if(!ret)
2463
            break;
2464

    
2465
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2466
        ret= s->oformat->write_packet(s, &pkt);
2467

    
2468
        av_free_packet(&pkt);
2469

    
2470
        if(ret<0)
2471
            goto fail;
2472
        if(url_ferror(&s->pb))
2473
            goto fail;
2474
    }
2475

    
2476
    if(s->oformat->write_trailer)
2477
        ret = s->oformat->write_trailer(s);
2478
fail:
2479
    if(ret == 0)
2480
       ret=url_ferror(&s->pb);
2481
    for(i=0;i<s->nb_streams;i++)
2482
        av_freep(&s->streams[i]->priv_data);
2483
    av_freep(&s->priv_data);
2484
    return ret;
2485
}
2486

    
2487
/* "user interface" functions */
2488

    
2489
void dump_format(AVFormatContext *ic,
2490
                 int index,
2491
                 const char *url,
2492
                 int is_output)
2493
{
2494
    int i, flags;
2495
    char buf[256];
2496

    
2497
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2498
            is_output ? "Output" : "Input",
2499
            index,
2500
            is_output ? ic->oformat->name : ic->iformat->name,
2501
            is_output ? "to" : "from", url);
2502
    if (!is_output) {
2503
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2504
        if (ic->duration != AV_NOPTS_VALUE) {
2505
            int hours, mins, secs, us;
2506
            secs = ic->duration / AV_TIME_BASE;
2507
            us = ic->duration % AV_TIME_BASE;
2508
            mins = secs / 60;
2509
            secs %= 60;
2510
            hours = mins / 60;
2511
            mins %= 60;
2512
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2513
                   (10 * us) / AV_TIME_BASE);
2514
        } else {
2515
            av_log(NULL, AV_LOG_INFO, "N/A");
2516
        }
2517
        if (ic->start_time != AV_NOPTS_VALUE) {
2518
            int secs, us;
2519
            av_log(NULL, AV_LOG_INFO, ", start: ");
2520
            secs = ic->start_time / AV_TIME_BASE;
2521
            us = ic->start_time % AV_TIME_BASE;
2522
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2523
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2524
        }
2525
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2526
        if (ic->bit_rate) {
2527
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2528
        } else {
2529
            av_log(NULL, AV_LOG_INFO, "N/A");
2530
        }
2531
        av_log(NULL, AV_LOG_INFO, "\n");
2532
    }
2533
    for(i=0;i<ic->nb_streams;i++) {
2534
        AVStream *st = ic->streams[i];
2535
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2536
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2537
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2538
        /* the pid is an important information, so we display it */
2539
        /* XXX: add a generic system */
2540
        if (is_output)
2541
            flags = ic->oformat->flags;
2542
        else
2543
            flags = ic->iformat->flags;
2544
        if (flags & AVFMT_SHOW_IDS) {
2545
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2546
        }
2547
        if (strlen(st->language) > 0) {
2548
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2549
        }
2550
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2551
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2552
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2553
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2554
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2555
/*            else if(st->time_base.den && st->time_base.num)
2556
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2557
            else
2558
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2559
        }
2560
        av_log(NULL, AV_LOG_INFO, "\n");
2561
    }
2562
}
2563

    
2564
typedef struct {
2565
    const char *abv;
2566
    int width, height;
2567
    int frame_rate, frame_rate_base;
2568
} AbvEntry;
2569

    
2570
static AbvEntry frame_abvs[] = {
2571
    { "ntsc",      720, 480, 30000, 1001 },
2572
    { "pal",       720, 576,    25,    1 },
2573
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2574
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2575
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2576
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2577
    { "film",      352, 240,    24,    1 },
2578
    { "ntsc-film", 352, 240, 24000, 1001 },
2579
    { "sqcif",     128,  96,     0,    0 },
2580
    { "qcif",      176, 144,     0,    0 },
2581
    { "cif",       352, 288,     0,    0 },
2582
    { "4cif",      704, 576,     0,    0 },
2583
};
2584

    
2585
/**
2586
 * parses width and height out of string str.
2587
 */
2588
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2589
{
2590
    int i;
2591
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2592
    const char *p;
2593
    int frame_width = 0, frame_height = 0;
2594

    
2595
    for(i=0;i<n;i++) {
2596
        if (!strcmp(frame_abvs[i].abv, str)) {
2597
            frame_width = frame_abvs[i].width;
2598
            frame_height = frame_abvs[i].height;
2599
            break;
2600
        }
2601
    }
2602
    if (i == n) {
2603
        p = str;
2604
        frame_width = strtol(p, (char **)&p, 10);
2605
        if (*p)
2606
            p++;
2607
        frame_height = strtol(p, (char **)&p, 10);
2608
    }
2609
    if (frame_width <= 0 || frame_height <= 0)
2610
        return -1;
2611
    *width_ptr = frame_width;
2612
    *height_ptr = frame_height;
2613
    return 0;
2614
}
2615

    
2616
/**
2617
 * Converts frame rate from string to a fraction.
2618
 *
2619
 * First we try to get an exact integer or fractional frame rate.
2620
 * If this fails we convert the frame rate to a double and return
2621
 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2622
 */
2623
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2624
{
2625
    int i;
2626
    char* cp;
2627

    
2628
    /* First, we check our abbreviation table */
2629
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2630
         if (!strcmp(frame_abvs[i].abv, arg)) {
2631
             *frame_rate = frame_abvs[i].frame_rate;
2632
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2633
             return 0;
2634
         }
2635

    
2636
    /* Then, we try to parse it as fraction */
2637
    cp = strchr(arg, '/');
2638
    if (!cp)
2639
        cp = strchr(arg, ':');
2640
    if (cp) {
2641
        char* cpp;
2642
        *frame_rate = strtol(arg, &cpp, 10);
2643
        if (cpp != arg || cpp == cp)
2644
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2645
        else
2646
           *frame_rate = 0;
2647
    }
2648
    else {
2649
        /* Finally we give up and parse it as double */
2650
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2651
        *frame_rate_base = time_base.den;
2652
        *frame_rate = time_base.num;
2653
    }
2654
    if (!*frame_rate || !*frame_rate_base)
2655
        return -1;
2656
    else
2657
        return 0;
2658
}
2659

    
2660
/**
2661
 * Converts date string to number of seconds since Jan 1st, 1970.
2662
 *
2663
 * @code
2664
 * Syntax:
2665
 * - If not a duration:
2666
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2667
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2668
 * Return the date in micro seconds since 1970
2669
 *
2670
 * - If a duration:
2671
 *  HH[:MM[:SS[.m...]]]
2672
 *  S+[.m...]
2673
 * @endcode
2674
 */
2675
#ifndef CONFIG_WINCE
2676
int64_t parse_date(const char *datestr, int duration)
2677
{
2678
    const char *p;
2679
    int64_t t;
2680
    struct tm dt;
2681
    int i;
2682
    static const char *date_fmt[] = {
2683
        "%Y-%m-%d",
2684
        "%Y%m%d",
2685
    };
2686
    static const char *time_fmt[] = {
2687
        "%H:%M:%S",
2688
        "%H%M%S",
2689
    };
2690
    const char *q;
2691
    int is_utc, len;
2692
    char lastch;
2693
    int negative = 0;
2694

    
2695
#undef time
2696
    time_t now = time(0);
2697

    
2698
    len = strlen(datestr);
2699
    if (len > 0)
2700
        lastch = datestr[len - 1];
2701
    else
2702
        lastch = '\0';
2703
    is_utc = (lastch == 'z' || lastch == 'Z');
2704

    
2705
    memset(&dt, 0, sizeof(dt));
2706

    
2707
    p = datestr;
2708
    q = NULL;
2709
    if (!duration) {
2710
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2711
            q = small_strptime(p, date_fmt[i], &dt);
2712
            if (q) {
2713
                break;
2714
            }
2715
        }
2716

    
2717
        if (!q) {
2718
            if (is_utc) {
2719
                dt = *gmtime(&now);
2720
            } else {
2721
                dt = *localtime(&now);
2722
            }
2723
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2724
        } else {
2725
            p = q;
2726
        }
2727

    
2728
        if (*p == 'T' || *p == 't' || *p == ' ')
2729
            p++;
2730

    
2731
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2732
            q = small_strptime(p, time_fmt[i], &dt);
2733
            if (q) {
2734
                break;
2735
            }
2736
        }
2737
    } else {
2738
        if (p[0] == '-') {
2739
            negative = 1;
2740
            ++p;
2741
        }
2742
        q = small_strptime(p, time_fmt[0], &dt);
2743
        if (!q) {
2744
            dt.tm_sec = strtol(p, (char **)&q, 10);
2745
            dt.tm_min = 0;
2746
            dt.tm_hour = 0;
2747
        }
2748
    }
2749

    
2750
    /* Now we have all the fields that we can get */
2751
    if (!q) {
2752
        if (duration)
2753
            return 0;
2754
        else
2755
            return now * int64_t_C(1000000);
2756
    }
2757

    
2758
    if (duration) {
2759
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2760
    } else {
2761
        dt.tm_isdst = -1;       /* unknown */
2762
        if (is_utc) {
2763
            t = mktimegm(&dt);
2764
        } else {
2765
            t = mktime(&dt);
2766
        }
2767
    }
2768

    
2769
    t *= 1000000;
2770

    
2771
    if (*q == '.') {
2772
        int val, n;
2773
        q++;
2774
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2775
            if (!isdigit(*q))
2776
                break;
2777
            val += n * (*q - '0');
2778
        }
2779
        t += val;
2780
    }
2781
    return negative ? -t : t;
2782
}
2783
#endif /* CONFIG_WINCE */
2784

    
2785
/**
2786
 * Attempts to find a specific tag in a URL.
2787
 *
2788
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2789
 * Return 1 if found.
2790
 */
2791
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2792
{
2793
    const char *p;
2794
    char tag[128], *q;
2795

    
2796
    p = info;
2797
    if (*p == '?')
2798
        p++;
2799
    for(;;) {
2800
        q = tag;
2801
        while (*p != '\0' && *p != '=' && *p != '&') {
2802
            if ((q - tag) < sizeof(tag) - 1)
2803
                *q++ = *p;
2804
            p++;
2805
        }
2806
        *q = '\0';
2807
        q = arg;
2808
        if (*p == '=') {
2809
            p++;
2810
            while (*p != '&' && *p != '\0') {
2811
                if ((q - arg) < arg_size - 1) {
2812
                    if (*p == '+')
2813
                        *q++ = ' ';
2814
                    else
2815
                        *q++ = *p;
2816
                }
2817
                p++;
2818
            }
2819
            *q = '\0';
2820
        }
2821
        if (!strcmp(tag, tag1))
2822
            return 1;
2823
        if (*p != '&')
2824
            break;
2825
        p++;
2826
    }
2827
    return 0;
2828
}
2829

    
2830
/**
2831
 * Returns in 'buf' the path with '%d' replaced by number.
2832

2833
 * Also handles the '%0nd' format where 'n' is the total number
2834
 * of digits and '%%'.
2835
 *
2836
 * @param buf destination buffer
2837
 * @param buf_size destination buffer size
2838
 * @param path numbered sequence string
2839
 * @number frame number
2840
 * @return 0 if OK, -1 if format error.
2841
 */
2842
int av_get_frame_filename(char *buf, int buf_size,
2843
                          const char *path, int number)
2844
{
2845
    const char *p;
2846
    char *q, buf1[20], c;
2847
    int nd, len, percentd_found;
2848

    
2849
    q = buf;
2850
    p = path;
2851
    percentd_found = 0;
2852
    for(;;) {
2853
        c = *p++;
2854
        if (c == '\0')
2855
            break;
2856
        if (c == '%') {
2857
            do {
2858
                nd = 0;
2859
                while (isdigit(*p)) {
2860
                    nd = nd * 10 + *p++ - '0';
2861
                }
2862
                c = *p++;
2863
            } while (isdigit(c));
2864

    
2865
            switch(c) {
2866
            case '%':
2867
                goto addchar;
2868
            case 'd':
2869
                if (percentd_found)
2870
                    goto fail;
2871
                percentd_found = 1;
2872
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2873
                len = strlen(buf1);
2874
                if ((q - buf + len) > buf_size - 1)
2875
                    goto fail;
2876
                memcpy(q, buf1, len);
2877
                q += len;
2878
                break;
2879
            default:
2880
                goto fail;
2881
            }
2882
        } else {
2883
        addchar:
2884
            if ((q - buf) < buf_size - 1)
2885
                *q++ = c;
2886
        }
2887
    }
2888
    if (!percentd_found)
2889
        goto fail;
2890
    *q = '\0';
2891
    return 0;
2892
 fail:
2893
    *q = '\0';
2894
    return -1;
2895
}
2896

    
2897
/**
2898
 * Print  nice hexa dump of a buffer
2899
 * @param f stream for output
2900
 * @param buf buffer
2901
 * @param size buffer size
2902
 */
2903
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2904
{
2905
    int len, i, j, c;
2906

    
2907
    for(i=0;i<size;i+=16) {
2908
        len = size - i;
2909
        if (len > 16)
2910
            len = 16;
2911
        fprintf(f, "%08x ", i);
2912
        for(j=0;j<16;j++) {
2913
            if (j < len)
2914
                fprintf(f, " %02x", buf[i+j]);
2915
            else
2916
                fprintf(f, "   ");
2917
        }
2918
        fprintf(f, " ");
2919
        for(j=0;j<len;j++) {
2920
            c = buf[i+j];
2921
            if (c < ' ' || c > '~')
2922
                c = '.';
2923
            fprintf(f, "%c", c);
2924
        }
2925
        fprintf(f, "\n");
2926
    }
2927
}
2928

    
2929
/**
2930
 * Print on 'f' a nice dump of a packet
2931
 * @param f stream for output
2932
 * @param pkt packet to dump
2933
 * @param dump_payload true if the payload must be displayed too
2934
 */
2935
 //FIXME needs to know the time_base
2936
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2937
{
2938
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2939
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2940
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2941
    /* DTS is _always_ valid after av_read_frame() */
2942
    fprintf(f, "  dts=");
2943
    if (pkt->dts == AV_NOPTS_VALUE)
2944
        fprintf(f, "N/A");
2945
    else
2946
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2947
    /* PTS may be not known if B frames are present */
2948
    fprintf(f, "  pts=");
2949
    if (pkt->pts == AV_NOPTS_VALUE)
2950
        fprintf(f, "N/A");
2951
    else
2952
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2953
    fprintf(f, "\n");
2954
    fprintf(f, "  size=%d\n", pkt->size);
2955
    if (dump_payload)
2956
        av_hex_dump(f, pkt->data, pkt->size);
2957
}
2958

    
2959
void url_split(char *proto, int proto_size,
2960
               char *authorization, int authorization_size,
2961
               char *hostname, int hostname_size,
2962
               int *port_ptr,
2963
               char *path, int path_size,
2964
               const char *url)
2965
{
2966
    const char *p;
2967
    char *q;
2968
    int port;
2969

    
2970
    port = -1;
2971

    
2972
    p = url;
2973
    q = proto;
2974
    while (*p != ':' && *p != '\0') {
2975
        if ((q - proto) < proto_size - 1)
2976
            *q++ = *p;
2977
        p++;
2978
    }
2979
    if (proto_size > 0)
2980
        *q = '\0';
2981
    if (authorization_size > 0)
2982
        authorization[0] = '\0';
2983
    if (*p == '\0') {
2984
        if (proto_size > 0)
2985
            proto[0] = '\0';
2986
        if (hostname_size > 0)
2987
            hostname[0] = '\0';
2988
        p = url;
2989
    } else {
2990
        char *at,*slash; // PETR: position of '@' character and '/' character
2991

    
2992
        p++;
2993
        if (*p == '/')
2994
            p++;
2995
        if (*p == '/')
2996
            p++;
2997
        at = strchr(p,'@'); // PETR: get the position of '@'
2998
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2999
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3000

    
3001
        q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
3002

    
3003
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3004
            if (*p == '@') {    // PETR: passed '@'
3005
              if (authorization_size > 0)
3006
                  *q = '\0';
3007
              q = hostname;
3008
              at = NULL;
3009
            } else if (!at) {   // PETR: hostname
3010
              if ((q - hostname) < hostname_size - 1)
3011
                  *q++ = *p;
3012
            } else {
3013
              if ((q - authorization) < authorization_size - 1)
3014
                *q++ = *p;
3015
            }
3016
            p++;
3017
        }
3018
        if (hostname_size > 0)
3019
            *q = '\0';
3020
        if (*p == ':') {
3021
            p++;
3022
            port = strtoul(p, (char **)&p, 10);
3023
        }
3024
    }
3025
    if (port_ptr)
3026
        *port_ptr = port;
3027
    pstrcpy(path, path_size, p);
3028
}
3029

    
3030
/**
3031
 * Set the pts for a given stream.
3032
 *
3033
 * @param s stream
3034
 * @param pts_wrap_bits number of bits effectively used by the pts
3035
 *        (used for wrap control, 33 is the value for MPEG)
3036
 * @param pts_num numerator to convert to seconds (MPEG: 1)
3037
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3038
 */
3039
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3040
                     int pts_num, int pts_den)
3041
{
3042
    s->pts_wrap_bits = pts_wrap_bits;
3043
    s->time_base.num = pts_num;
3044
    s->time_base.den = pts_den;
3045
}
3046

    
3047
/* fraction handling */
3048

    
3049
/**
3050
 * f = val + (num / den) + 0.5.
3051
 *
3052
 * 'num' is normalized so that it is such as 0 <= num < den.
3053
 *
3054
 * @param f fractional number
3055
 * @param val integer value
3056
 * @param num must be >= 0
3057
 * @param den must be >= 1
3058
 */
3059
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3060
{
3061
    num += (den >> 1);
3062
    if (num >= den) {
3063
        val += num / den;
3064
        num = num % den;
3065
    }
3066
    f->val = val;
3067
    f->num = num;
3068
    f->den = den;
3069
}
3070

    
3071
/**
3072
 * Set f to (val + 0.5).
3073
 */
3074
static void av_frac_set(AVFrac *f, int64_t val)
3075
{
3076
    f->val = val;
3077
    f->num = f->den >> 1;
3078
}
3079

    
3080
/**
3081
 * Fractionnal addition to f: f = f + (incr / f->den).
3082
 *
3083
 * @param f fractional number
3084
 * @param incr increment, can be positive or negative
3085
 */
3086
static void av_frac_add(AVFrac *f, int64_t incr)
3087
{
3088
    int64_t num, den;
3089

    
3090
    num = f->num + incr;
3091
    den = f->den;
3092
    if (num < 0) {
3093
        f->val += num / den;
3094
        num = num % den;
3095
        if (num < 0) {
3096
            num += den;
3097
            f->val--;
3098
        }
3099
    } else if (num >= den) {
3100
        f->val += num / den;
3101
        num = num % den;
3102
    }
3103
    f->num = num;
3104
}
3105

    
3106
/**
3107
 * register a new image format
3108
 * @param img_fmt Image format descriptor
3109
 */
3110
void av_register_image_format(AVImageFormat *img_fmt)
3111
{
3112
    AVImageFormat **p;
3113

    
3114
    p = &first_image_format;
3115
    while (*p != NULL) p = &(*p)->next;
3116
    *p = img_fmt;
3117
    img_fmt->next = NULL;
3118
}
3119

    
3120
/**
3121
 * Guesses image format based on data in the image.
3122
 */
3123
AVImageFormat *av_probe_image_format(AVProbeData *pd)
3124
{
3125
    AVImageFormat *fmt1, *fmt;
3126
    int score, score_max;
3127

    
3128
    fmt = NULL;
3129
    score_max = 0;
3130
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3131
        if (fmt1->img_probe) {
3132
            score = fmt1->img_probe(pd);
3133
            if (score > score_max) {
3134
                score_max = score;
3135
                fmt = fmt1;
3136
            }
3137
        }
3138
    }
3139
    return fmt;
3140
}
3141

    
3142
/**
3143
 * Guesses image format based on file name extensions.
3144
 */
3145
AVImageFormat *guess_image_format(const char *filename)
3146
{
3147
    AVImageFormat *fmt1;
3148

    
3149
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3150
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3151
            return fmt1;
3152
    }
3153
    return NULL;
3154
}
3155

    
3156
/**
3157
 * Read an image from a stream.
3158
 * @param gb byte stream containing the image
3159
 * @param fmt image format, NULL if probing is required
3160
 */
3161
int av_read_image(ByteIOContext *pb, const char *filename,
3162
                  AVImageFormat *fmt,
3163
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3164
{
3165
    uint8_t buf[PROBE_BUF_MIN];
3166
    AVProbeData probe_data, *pd = &probe_data;
3167
    offset_t pos;
3168
    int ret;
3169

    
3170
    if (!fmt) {
3171
        pd->filename = filename;
3172
        pd->buf = buf;
3173
        pos = url_ftell(pb);
3174
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3175
        url_fseek(pb, pos, SEEK_SET);
3176
        fmt = av_probe_image_format(pd);
3177
    }
3178
    if (!fmt)
3179
        return AVERROR_NOFMT;
3180
    ret = fmt->img_read(pb, alloc_cb, opaque);
3181
    return ret;
3182
}
3183

    
3184
/**
3185
 * Write an image to a stream.
3186
 * @param pb byte stream for the image output
3187
 * @param fmt image format
3188
 * @param img image data and informations
3189
 */
3190
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3191
{
3192
    return fmt->img_write(pb, img);
3193
}
3194