Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ f5a478f6

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
        } else {
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

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

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

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

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

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

    
1860
        read_size += pkt->size;
1861

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

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

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

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

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

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

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

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

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

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

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

    
2018
/*******************************************************/
2019

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

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

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

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

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

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

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

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

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

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

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

    
2125
/************************************************************/
2126
/* output media file */
2127

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

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

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

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

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

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

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

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

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

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

    
2218
//    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);
2219

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2469
        av_free_packet(&pkt);
2470

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

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

    
2488
/* "user interface" functions */
2489

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2770
    t *= 1000000;
2771

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

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

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

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

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

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

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

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

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

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

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

    
2971
    port = -1;
2972

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

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

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

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

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

    
3048
/* fraction handling */
3049

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

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

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

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

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

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

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

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

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

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

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

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

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