Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 4b65d88f

History | View | Annotate | Download (93.9 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

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

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

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

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

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

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

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

    
64
    if(!filename)
65
        return 0;
66

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

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

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

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

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

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

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

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

    
145
    return fmt;
146
}
147

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

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

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

    
183
/* memory handling */
184

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

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

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

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

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

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

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

    
240
    return ret;
241
}
242

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

    
265
/* fifo handling */
266

    
267
int fifo_init(FifoBuffer *f, int size)
268
{
269
    f->buffer = av_malloc(size);
270
    if (!f->buffer)
271
        return -1;
272
    f->end = f->buffer + size;
273
    f->wptr = f->rptr = f->buffer;
274
    return 0;
275
}
276

    
277
void fifo_free(FifoBuffer *f)
278
{
279
    av_free(f->buffer);
280
}
281

    
282
int fifo_size(FifoBuffer *f, uint8_t *rptr)
283
{
284
    int size;
285

    
286
    if(!rptr)
287
        rptr= f->rptr;
288

    
289
    if (f->wptr >= rptr) {
290
        size = f->wptr - rptr;
291
    } else {
292
        size = (f->end - rptr) + (f->wptr - f->buffer);
293
    }
294
    return size;
295
}
296

    
297
/**
298
 * Get data from the fifo (returns -1 if not enough data).
299
 */
300
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
301
{
302
    uint8_t *rptr;
303
    int size, len;
304

    
305
    if(!rptr_ptr)
306
        rptr_ptr= &f->rptr;
307
    rptr = *rptr_ptr;
308

    
309
    if (f->wptr >= rptr) {
310
        size = f->wptr - rptr;
311
    } else {
312
        size = (f->end - rptr) + (f->wptr - f->buffer);
313
    }
314

    
315
    if (size < buf_size)
316
        return -1;
317
    while (buf_size > 0) {
318
        len = f->end - rptr;
319
        if (len > buf_size)
320
            len = buf_size;
321
        memcpy(buf, rptr, len);
322
        buf += len;
323
        rptr += len;
324
        if (rptr >= f->end)
325
            rptr = f->buffer;
326
        buf_size -= len;
327
    }
328
    *rptr_ptr = rptr;
329
    return 0;
330
}
331

    
332
/**
333
 * Resizes a FIFO.
334
 */
335
void fifo_realloc(FifoBuffer *f, unsigned int new_size){
336
    unsigned int old_size= f->end - f->buffer;
337

    
338
    if(old_size < new_size){
339
        uint8_t *old= f->buffer;
340

    
341
        f->buffer= av_realloc(f->buffer, new_size);
342

    
343
        f->rptr += f->buffer - old;
344
        f->wptr += f->buffer - old;
345

    
346
        if(f->wptr < f->rptr){
347
            memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
348
            f->rptr += new_size - old_size;
349
        }
350
        f->end= f->buffer + new_size;
351
    }
352
}
353

    
354
void fifo_write(FifoBuffer *f, const uint8_t *buf, int size, uint8_t **wptr_ptr)
355
{
356
    int len;
357
    uint8_t *wptr;
358

    
359
    if(!wptr_ptr)
360
        wptr_ptr= &f->wptr;
361
    wptr = *wptr_ptr;
362

    
363
    while (size > 0) {
364
        len = f->end - wptr;
365
        if (len > size)
366
            len = size;
367
        memcpy(wptr, buf, len);
368
        wptr += len;
369
        if (wptr >= f->end)
370
            wptr = f->buffer;
371
        buf += len;
372
        size -= len;
373
    }
374
    *wptr_ptr = wptr;
375
}
376

    
377
/* get data from the fifo (return -1 if not enough data) */
378
int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
379
{
380
    uint8_t *rptr = *rptr_ptr;
381
    int size, len;
382

    
383
    if (f->wptr >= rptr) {
384
        size = f->wptr - rptr;
385
    } else {
386
        size = (f->end - rptr) + (f->wptr - f->buffer);
387
    }
388

    
389
    if (size < buf_size)
390
        return -1;
391
    while (buf_size > 0) {
392
        len = f->end - rptr;
393
        if (len > buf_size)
394
            len = buf_size;
395
        put_buffer(pb, rptr, len);
396
        rptr += len;
397
        if (rptr >= f->end)
398
            rptr = f->buffer;
399
        buf_size -= len;
400
    }
401
    *rptr_ptr = rptr;
402
    return 0;
403
}
404

    
405
int filename_number_test(const char *filename)
406
{
407
    char buf[1024];
408
    if(!filename)
409
        return -1;
410
    return get_frame_filename(buf, sizeof(buf), filename, 1);
411
}
412

    
413
/**
414
 * Guess file format.
415
 */
416
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
417
{
418
    AVInputFormat *fmt1, *fmt;
419
    int score, score_max;
420

    
421
    fmt = NULL;
422
    score_max = 0;
423
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
424
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
425
            continue;
426
        score = 0;
427
        if (fmt1->read_probe) {
428
            score = fmt1->read_probe(pd);
429
        } else if (fmt1->extensions) {
430
            if (match_ext(pd->filename, fmt1->extensions)) {
431
                score = 50;
432
            }
433
        }
434
        if (score > score_max) {
435
            score_max = score;
436
            fmt = fmt1;
437
        }
438
    }
439
    return fmt;
440
}
441

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

    
445
/**
446
 * Open a media file from an IO stream. 'fmt' must be specified.
447
 */
448
static const char* format_to_name(void* ptr)
449
{
450
    AVFormatContext* fc = (AVFormatContext*) ptr;
451
    if(fc->iformat) return fc->iformat->name;
452
    else if(fc->oformat) return fc->oformat->name;
453
    else return "NULL";
454
}
455

    
456
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
457

    
458
AVFormatContext *av_alloc_format_context(void)
459
{
460
    AVFormatContext *ic;
461
    ic = av_mallocz(sizeof(AVFormatContext));
462
    if (!ic) return ic;
463
    ic->av_class = &av_format_context_class;
464
    return ic;
465
}
466

    
467
/**
468
 * Allocates all the structures needed to read an input stream.
469
 *        This does not open the needed codecs for decoding the stream[s].
470
 */
471
int av_open_input_stream(AVFormatContext **ic_ptr,
472
                         ByteIOContext *pb, const char *filename,
473
                         AVInputFormat *fmt, AVFormatParameters *ap)
474
{
475
    int err;
476
    AVFormatContext *ic;
477
    AVFormatParameters default_ap;
478

    
479
    if(!ap){
480
        ap=&default_ap;
481
        memset(ap, 0, sizeof(default_ap));
482
    }
483

    
484
    ic = av_alloc_format_context();
485
    if (!ic) {
486
        err = AVERROR_NOMEM;
487
        goto fail;
488
    }
489
    ic->iformat = fmt;
490
    if (pb)
491
        ic->pb = *pb;
492
    ic->duration = AV_NOPTS_VALUE;
493
    ic->start_time = AV_NOPTS_VALUE;
494
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
495

    
496
    /* allocate private data */
497
    if (fmt->priv_data_size > 0) {
498
        ic->priv_data = av_mallocz(fmt->priv_data_size);
499
        if (!ic->priv_data) {
500
            err = AVERROR_NOMEM;
501
            goto fail;
502
        }
503
    } else {
504
        ic->priv_data = NULL;
505
    }
506

    
507
    err = ic->iformat->read_header(ic, ap);
508
    if (err < 0)
509
        goto fail;
510

    
511
    if (pb)
512
        ic->data_offset = url_ftell(&ic->pb);
513

    
514
    *ic_ptr = ic;
515
    return 0;
516
 fail:
517
    if (ic) {
518
        av_freep(&ic->priv_data);
519
    }
520
    av_free(ic);
521
    *ic_ptr = NULL;
522
    return err;
523
}
524

    
525
/** Size of probe buffer, for guessing file type from file contents. */
526
#define PROBE_BUF_MIN 2048
527
#define PROBE_BUF_MAX (1<<20)
528

    
529
/**
530
 * Open a media file as input. The codec are not opened. Only the file
531
 * header (if present) is read.
532
 *
533
 * @param ic_ptr the opened media file handle is put here
534
 * @param filename filename to open.
535
 * @param fmt if non NULL, force the file format to use
536
 * @param buf_size optional buffer size (zero if default is OK)
537
 * @param ap additionnal parameters needed when opening the file (NULL if default)
538
 * @return 0 if OK. AVERROR_xxx otherwise.
539
 */
540
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
541
                       AVInputFormat *fmt,
542
                       int buf_size,
543
                       AVFormatParameters *ap)
544
{
545
    int err, must_open_file, file_opened, probe_size;
546
    AVProbeData probe_data, *pd = &probe_data;
547
    ByteIOContext pb1, *pb = &pb1;
548

    
549
    file_opened = 0;
550
    pd->filename = "";
551
    if (filename)
552
        pd->filename = filename;
553
    pd->buf = NULL;
554
    pd->buf_size = 0;
555

    
556
    if (!fmt) {
557
        /* guess format if no file can be opened  */
558
        fmt = av_probe_input_format(pd, 0);
559
    }
560

    
561
    /* do not open file if the format does not need it. XXX: specific
562
       hack needed to handle RTSP/TCP */
563
    must_open_file = 1;
564
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
565
        must_open_file = 0;
566
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
567
    }
568

    
569
    if (!fmt || must_open_file) {
570
        /* if no file needed do not try to open one */
571
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
572
            err = AVERROR_IO;
573
            goto fail;
574
        }
575
        file_opened = 1;
576
        if (buf_size > 0) {
577
            url_setbufsize(pb, buf_size);
578
        }
579

    
580
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
581
            /* read probe data */
582
            pd->buf= av_realloc(pd->buf, probe_size);
583
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
584
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
585
                url_fclose(pb);
586
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
587
                    file_opened = 0;
588
                    err = AVERROR_IO;
589
                    goto fail;
590
                }
591
            }
592
            /* guess file format */
593
            fmt = av_probe_input_format(pd, 1);
594
        }
595
        av_freep(&pd->buf);
596
    }
597

    
598
    /* if still no format found, error */
599
    if (!fmt) {
600
        err = AVERROR_NOFMT;
601
        goto fail;
602
    }
603

    
604
    /* XXX: suppress this hack for redirectors */
605
#ifdef CONFIG_NETWORK
606
    if (fmt == &redir_demuxer) {
607
        err = redir_open(ic_ptr, pb);
608
        url_fclose(pb);
609
        return err;
610
    }
611
#endif
612

    
613
    /* check filename in case of an image number is expected */
614
    if (fmt->flags & AVFMT_NEEDNUMBER) {
615
        if (filename_number_test(filename) < 0) {
616
            err = AVERROR_NUMEXPECTED;
617
            goto fail;
618
        }
619
    }
620
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
621
    if (err)
622
        goto fail;
623
    return 0;
624
 fail:
625
    av_freep(&pd->buf);
626
    if (file_opened)
627
        url_fclose(pb);
628
    *ic_ptr = NULL;
629
    return err;
630

    
631
}
632

    
633
/*******************************************************/
634

    
635
/**
636
 * Read a transport packet from a media file.
637
 *
638
 * This function is absolete and should never be used.
639
 * Use av_read_frame() instead.
640
 *
641
 * @param s media file handle
642
 * @param pkt is filled
643
 * @return 0 if OK. AVERROR_xxx if error.
644
 */
645
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
646
{
647
    return s->iformat->read_packet(s, pkt);
648
}
649

    
650
/**********************************************************/
651

    
652
/**
653
 * Get the number of samples of an audio frame. Return (-1) if error.
654
 */
655
static int get_audio_frame_size(AVCodecContext *enc, int size)
656
{
657
    int frame_size;
658

    
659
    if (enc->frame_size <= 1) {
660
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
661

    
662
        if (bits_per_sample) {
663
            if (enc->channels == 0)
664
                return -1;
665
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
666
        } else {
667
            /* used for example by ADPCM codecs */
668
            if (enc->bit_rate == 0)
669
                return -1;
670
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
671
        }
672
    } else {
673
        frame_size = enc->frame_size;
674
    }
675
    return frame_size;
676
}
677

    
678

    
679
/**
680
 * Return the frame duration in seconds, return 0 if not available.
681
 */
682
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
683
                                   AVCodecParserContext *pc, AVPacket *pkt)
684
{
685
    int frame_size;
686

    
687
    *pnum = 0;
688
    *pden = 0;
689
    switch(st->codec->codec_type) {
690
    case CODEC_TYPE_VIDEO:
691
        if(st->time_base.num*1000LL > st->time_base.den){
692
            *pnum = st->time_base.num;
693
            *pden = st->time_base.den;
694
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
695
            *pnum = st->codec->time_base.num;
696
            *pden = st->codec->time_base.den;
697
            if (pc && pc->repeat_pict) {
698
                *pden *= 2;
699
                *pnum = (*pnum) * (2 + pc->repeat_pict);
700
            }
701
        }
702
        break;
703
    case CODEC_TYPE_AUDIO:
704
        frame_size = get_audio_frame_size(st->codec, pkt->size);
705
        if (frame_size < 0)
706
            break;
707
        *pnum = frame_size;
708
        *pden = st->codec->sample_rate;
709
        break;
710
    default:
711
        break;
712
    }
713
}
714

    
715
static int is_intra_only(AVCodecContext *enc){
716
    if(enc->codec_type == CODEC_TYPE_AUDIO){
717
        return 1;
718
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
719
        switch(enc->codec_id){
720
        case CODEC_ID_MJPEG:
721
        case CODEC_ID_MJPEGB:
722
        case CODEC_ID_LJPEG:
723
        case CODEC_ID_RAWVIDEO:
724
        case CODEC_ID_DVVIDEO:
725
        case CODEC_ID_HUFFYUV:
726
        case CODEC_ID_FFVHUFF:
727
        case CODEC_ID_ASV1:
728
        case CODEC_ID_ASV2:
729
        case CODEC_ID_VCR1:
730
            return 1;
731
        default: break;
732
        }
733
    }
734
    return 0;
735
}
736

    
737
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
738
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
739
    int64_t delta= last_ts - mask/2;
740
    return  ((lsb - delta)&mask) + delta;
741
}
742

    
743
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
744
                               AVCodecParserContext *pc, AVPacket *pkt)
745
{
746
    int num, den, presentation_delayed;
747
    /* handle wrapping */
748
    if(st->cur_dts != AV_NOPTS_VALUE){
749
        if(pkt->pts != AV_NOPTS_VALUE)
750
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
751
        if(pkt->dts != AV_NOPTS_VALUE)
752
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
753
    }
754

    
755
    if (pkt->duration == 0) {
756
        compute_frame_duration(&num, &den, st, pc, pkt);
757
        if (den && num) {
758
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
759
        }
760
    }
761

    
762
    if(is_intra_only(st->codec))
763
        pkt->flags |= PKT_FLAG_KEY;
764

    
765
    /* do we have a video B frame ? */
766
    presentation_delayed = 0;
767
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
768
        /* XXX: need has_b_frame, but cannot get it if the codec is
769
           not initialized */
770
        if ((   st->codec->codec_id == CODEC_ID_H264
771
             || st->codec->has_b_frames) &&
772
            pc && pc->pict_type != FF_B_TYPE)
773
            presentation_delayed = 1;
774
        /* this may be redundant, but it shouldnt hurt */
775
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
776
            presentation_delayed = 1;
777
    }
778

    
779
    if(st->cur_dts == AV_NOPTS_VALUE){
780
        if(presentation_delayed) st->cur_dts = -pkt->duration;
781
        else                     st->cur_dts = 0;
782
    }
783

    
784
//    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);
785
    /* interpolate PTS and DTS if they are not present */
786
    if (presentation_delayed) {
787
        /* DTS = decompression time stamp */
788
        /* PTS = presentation time stamp */
789
        if (pkt->dts == AV_NOPTS_VALUE) {
790
            /* if we know the last pts, use it */
791
            if(st->last_IP_pts != AV_NOPTS_VALUE)
792
                st->cur_dts = pkt->dts = st->last_IP_pts;
793
            else
794
                pkt->dts = st->cur_dts;
795
        } else {
796
            st->cur_dts = pkt->dts;
797
        }
798
        /* this is tricky: the dts must be incremented by the duration
799
           of the frame we are displaying, i.e. the last I or P frame */
800
        if (st->last_IP_duration == 0)
801
            st->cur_dts += pkt->duration;
802
        else
803
            st->cur_dts += st->last_IP_duration;
804
        st->last_IP_duration  = pkt->duration;
805
        st->last_IP_pts= pkt->pts;
806
        /* cannot compute PTS if not present (we can compute it only
807
           by knowing the futur */
808
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
809
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
810
            int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
811
            int64_t new_diff= ABS(st->cur_dts - pkt->pts);
812
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
813
                pkt->pts += pkt->duration;
814
//                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);
815
            }
816
        }
817

    
818
        /* presentation is not delayed : PTS and DTS are the same */
819
        if (pkt->pts == AV_NOPTS_VALUE) {
820
            if (pkt->dts == AV_NOPTS_VALUE) {
821
                pkt->pts = st->cur_dts;
822
                pkt->dts = st->cur_dts;
823
            }
824
            else {
825
                st->cur_dts = pkt->dts;
826
                pkt->pts = pkt->dts;
827
            }
828
        } else {
829
            st->cur_dts = pkt->pts;
830
            pkt->dts = pkt->pts;
831
        }
832
        st->cur_dts += pkt->duration;
833
    }
834
//    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);
835

    
836
    /* update flags */
837
    if (pc) {
838
        pkt->flags = 0;
839
        /* key frame computation */
840
        switch(st->codec->codec_type) {
841
        case CODEC_TYPE_VIDEO:
842
            if (pc->pict_type == FF_I_TYPE)
843
                pkt->flags |= PKT_FLAG_KEY;
844
            break;
845
        case CODEC_TYPE_AUDIO:
846
            pkt->flags |= PKT_FLAG_KEY;
847
            break;
848
        default:
849
            break;
850
        }
851
    }
852
}
853

    
854
void av_destruct_packet_nofree(AVPacket *pkt)
855
{
856
    pkt->data = NULL; pkt->size = 0;
857
}
858

    
859
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
860
{
861
    AVStream *st;
862
    int len, ret, i;
863

    
864
    for(;;) {
865
        /* select current input stream component */
866
        st = s->cur_st;
867
        if (st) {
868
            if (!st->need_parsing || !st->parser) {
869
                /* no parsing needed: we just output the packet as is */
870
                /* raw data support */
871
                *pkt = s->cur_pkt;
872
                compute_pkt_fields(s, st, NULL, pkt);
873
                s->cur_st = NULL;
874
                return 0;
875
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
876
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
877
                                      s->cur_ptr, s->cur_len,
878
                                      s->cur_pkt.pts, s->cur_pkt.dts);
879
                s->cur_pkt.pts = AV_NOPTS_VALUE;
880
                s->cur_pkt.dts = AV_NOPTS_VALUE;
881
                /* increment read pointer */
882
                s->cur_ptr += len;
883
                s->cur_len -= len;
884

    
885
                /* return packet if any */
886
                if (pkt->size) {
887
                got_packet:
888
                    pkt->duration = 0;
889
                    pkt->stream_index = st->index;
890
                    pkt->pts = st->parser->pts;
891
                    pkt->dts = st->parser->dts;
892
                    pkt->destruct = av_destruct_packet_nofree;
893
                    compute_pkt_fields(s, st, st->parser, pkt);
894
                    return 0;
895
                }
896
            } else {
897
                /* free packet */
898
                av_free_packet(&s->cur_pkt);
899
                s->cur_st = NULL;
900
            }
901
        } else {
902
            /* read next packet */
903
            ret = av_read_packet(s, &s->cur_pkt);
904
            if (ret < 0) {
905
                if (ret == -EAGAIN)
906
                    return ret;
907
                /* return the last frames, if any */
908
                for(i = 0; i < s->nb_streams; i++) {
909
                    st = s->streams[i];
910
                    if (st->parser && st->need_parsing) {
911
                        av_parser_parse(st->parser, st->codec,
912
                                        &pkt->data, &pkt->size,
913
                                        NULL, 0,
914
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
915
                        if (pkt->size)
916
                            goto got_packet;
917
                    }
918
                }
919
                /* no more packets: really terminates parsing */
920
                return ret;
921
            }
922

    
923
            st = s->streams[s->cur_pkt.stream_index];
924

    
925
            s->cur_st = st;
926
            s->cur_ptr = s->cur_pkt.data;
927
            s->cur_len = s->cur_pkt.size;
928
            if (st->need_parsing && !st->parser) {
929
                st->parser = av_parser_init(st->codec->codec_id);
930
                if (!st->parser) {
931
                    /* no parser available : just output the raw packets */
932
                    st->need_parsing = 0;
933
                }else if(st->need_parsing == 2){
934
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
935
                }
936
            }
937
        }
938
    }
939
}
940

    
941
/**
942
 * Return the next frame of a stream.
943
 *
944
 * The returned packet is valid
945
 * until the next av_read_frame() or until av_close_input_file() and
946
 * must be freed with av_free_packet. For video, the packet contains
947
 * exactly one frame. For audio, it contains an integer number of
948
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
949
 * data). If the audio frames have a variable size (e.g. MPEG audio),
950
 * then it contains one frame.
951
 *
952
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
953
 * values in AV_TIME_BASE unit (and guessed if the format cannot
954
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
955
 * has B frames, so it is better to rely on pkt->dts if you do not
956
 * decompress the payload.
957
 *
958
 * @return 0 if OK, < 0 if error or end of file.
959
 */
960
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
961
{
962
    AVPacketList *pktl;
963
    int eof=0;
964
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
965

    
966
    for(;;){
967
        pktl = s->packet_buffer;
968
        if (pktl) {
969
            AVPacket *next_pkt= &pktl->pkt;
970

    
971
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
972
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
973
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
974
                       && next_pkt->dts < pktl->pkt.dts
975
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
976
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
977
                        next_pkt->pts= pktl->pkt.dts;
978
                    }
979
                    pktl= pktl->next;
980
                }
981
                pktl = s->packet_buffer;
982
            }
983

    
984
            if(   next_pkt->pts != AV_NOPTS_VALUE
985
               || next_pkt->dts == AV_NOPTS_VALUE
986
               || !genpts || eof){
987
                /* read packet from packet buffer, if there is data */
988
                *pkt = *next_pkt;
989
                s->packet_buffer = pktl->next;
990
                av_free(pktl);
991
                return 0;
992
            }
993
        }
994
        if(genpts){
995
            AVPacketList **plast_pktl= &s->packet_buffer;
996
            int ret= av_read_frame_internal(s, pkt);
997
            if(ret<0){
998
                if(pktl && ret != -EAGAIN){
999
                    eof=1;
1000
                    continue;
1001
                }else
1002
                    return ret;
1003
            }
1004

    
1005
            /* duplicate the packet */
1006
            if (av_dup_packet(pkt) < 0)
1007
                return AVERROR_NOMEM;
1008

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

    
1011
            pktl = av_mallocz(sizeof(AVPacketList));
1012
            if (!pktl)
1013
                return AVERROR_NOMEM;
1014

    
1015
            /* add the packet in the buffered packet list */
1016
            *plast_pktl = pktl;
1017
            pktl->pkt= *pkt;
1018
        }else{
1019
            assert(!s->packet_buffer);
1020
            return av_read_frame_internal(s, pkt);
1021
        }
1022
    }
1023
}
1024

    
1025
/* XXX: suppress the packet queue */
1026
static void flush_packet_queue(AVFormatContext *s)
1027
{
1028
    AVPacketList *pktl;
1029

    
1030
    for(;;) {
1031
        pktl = s->packet_buffer;
1032
        if (!pktl)
1033
            break;
1034
        s->packet_buffer = pktl->next;
1035
        av_free_packet(&pktl->pkt);
1036
        av_free(pktl);
1037
    }
1038
}
1039

    
1040
/*******************************************************/
1041
/* seek support */
1042

    
1043
int av_find_default_stream_index(AVFormatContext *s)
1044
{
1045
    int i;
1046
    AVStream *st;
1047

    
1048
    if (s->nb_streams <= 0)
1049
        return -1;
1050
    for(i = 0; i < s->nb_streams; i++) {
1051
        st = s->streams[i];
1052
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1053
            return i;
1054
        }
1055
    }
1056
    return 0;
1057
}
1058

    
1059
/**
1060
 * Flush the frame reader.
1061
 */
1062
static void av_read_frame_flush(AVFormatContext *s)
1063
{
1064
    AVStream *st;
1065
    int i;
1066

    
1067
    flush_packet_queue(s);
1068

    
1069
    /* free previous packet */
1070
    if (s->cur_st) {
1071
        if (s->cur_st->parser)
1072
            av_free_packet(&s->cur_pkt);
1073
        s->cur_st = NULL;
1074
    }
1075
    /* fail safe */
1076
    s->cur_ptr = NULL;
1077
    s->cur_len = 0;
1078

    
1079
    /* for each stream, reset read state */
1080
    for(i = 0; i < s->nb_streams; i++) {
1081
        st = s->streams[i];
1082

    
1083
        if (st->parser) {
1084
            av_parser_close(st->parser);
1085
            st->parser = NULL;
1086
        }
1087
        st->last_IP_pts = AV_NOPTS_VALUE;
1088
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1089
    }
1090
}
1091

    
1092
/**
1093
 * Updates cur_dts of all streams based on given timestamp and AVStream.
1094
 *
1095
 * Stream ref_st unchanged, others set cur_dts in their native timebase
1096
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1097
 * @param timestamp new dts expressed in time_base of param ref_st
1098
 * @param ref_st reference stream giving time_base of param timestamp
1099
 */
1100
static void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1101
    int i;
1102

    
1103
    for(i = 0; i < s->nb_streams; i++) {
1104
        AVStream *st = s->streams[i];
1105

    
1106
        st->cur_dts = av_rescale(timestamp,
1107
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1108
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1109
    }
1110
}
1111

    
1112
/**
1113
 * Add a index entry into a sorted list updateing if it is already there.
1114
 *
1115
 * @param timestamp timestamp in the timebase of the given stream
1116
 */
1117
int av_add_index_entry(AVStream *st,
1118
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1119
{
1120
    AVIndexEntry *entries, *ie;
1121
    int index;
1122

    
1123
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1124
        return -1;
1125

    
1126
    entries = av_fast_realloc(st->index_entries,
1127
                              &st->index_entries_allocated_size,
1128
                              (st->nb_index_entries + 1) *
1129
                              sizeof(AVIndexEntry));
1130
    if(!entries)
1131
        return -1;
1132

    
1133
    st->index_entries= entries;
1134

    
1135
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1136

    
1137
    if(index<0){
1138
        index= st->nb_index_entries++;
1139
        ie= &entries[index];
1140
        assert(index==0 || ie[-1].timestamp < timestamp);
1141
    }else{
1142
        ie= &entries[index];
1143
        if(ie->timestamp != timestamp){
1144
            if(ie->timestamp <= timestamp)
1145
                return -1;
1146
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1147
            st->nb_index_entries++;
1148
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1149
            distance= ie->min_distance;
1150
    }
1151

    
1152
    ie->pos = pos;
1153
    ie->timestamp = timestamp;
1154
    ie->min_distance= distance;
1155
    ie->size= size;
1156
    ie->flags = flags;
1157

    
1158
    return index;
1159
}
1160

    
1161
/**
1162
 * build an index for raw streams using a parser.
1163
 */
1164
static void av_build_index_raw(AVFormatContext *s)
1165
{
1166
    AVPacket pkt1, *pkt = &pkt1;
1167
    int ret;
1168
    AVStream *st;
1169

    
1170
    st = s->streams[0];
1171
    av_read_frame_flush(s);
1172
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1173

    
1174
    for(;;) {
1175
        ret = av_read_frame(s, pkt);
1176
        if (ret < 0)
1177
            break;
1178
        if (pkt->stream_index == 0 && st->parser &&
1179
            (pkt->flags & PKT_FLAG_KEY)) {
1180
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1181
                            0, 0, AVINDEX_KEYFRAME);
1182
        }
1183
        av_free_packet(pkt);
1184
    }
1185
}
1186

    
1187
/**
1188
 * Returns TRUE if we deal with a raw stream.
1189
 *
1190
 * Raw codec data and parsing needed.
1191
 */
1192
static int is_raw_stream(AVFormatContext *s)
1193
{
1194
    AVStream *st;
1195

    
1196
    if (s->nb_streams != 1)
1197
        return 0;
1198
    st = s->streams[0];
1199
    if (!st->need_parsing)
1200
        return 0;
1201
    return 1;
1202
}
1203

    
1204
/**
1205
 * Gets the index for a specific timestamp.
1206
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1207
 *                 the timestamp which is <= the requested one, if backward is 0
1208
 *                 then it will be >=
1209
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1210
 * @return < 0 if no such timestamp could be found
1211
 */
1212
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1213
                              int flags)
1214
{
1215
    AVIndexEntry *entries= st->index_entries;
1216
    int nb_entries= st->nb_index_entries;
1217
    int a, b, m;
1218
    int64_t timestamp;
1219

    
1220
    a = - 1;
1221
    b = nb_entries;
1222

    
1223
    while (b - a > 1) {
1224
        m = (a + b) >> 1;
1225
        timestamp = entries[m].timestamp;
1226
        if(timestamp >= wanted_timestamp)
1227
            b = m;
1228
        if(timestamp <= wanted_timestamp)
1229
            a = m;
1230
    }
1231
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1232

    
1233
    if(!(flags & AVSEEK_FLAG_ANY)){
1234
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1235
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1236
        }
1237
    }
1238

    
1239
    if(m == nb_entries)
1240
        return -1;
1241
    return  m;
1242
}
1243

    
1244
#define DEBUG_SEEK
1245

    
1246
/**
1247
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1248
 * this isnt supposed to be called directly by a user application, but by demuxers
1249
 * @param target_ts target timestamp in the time base of the given stream
1250
 * @param stream_index stream number
1251
 */
1252
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1253
    AVInputFormat *avif= s->iformat;
1254
    int64_t pos_min, pos_max, pos, pos_limit;
1255
    int64_t ts_min, ts_max, ts;
1256
    int64_t start_pos, filesize;
1257
    int index, no_change;
1258
    AVStream *st;
1259

    
1260
    if (stream_index < 0)
1261
        return -1;
1262

    
1263
#ifdef DEBUG_SEEK
1264
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1265
#endif
1266

    
1267
    ts_max=
1268
    ts_min= AV_NOPTS_VALUE;
1269
    pos_limit= -1; //gcc falsely says it may be uninitalized
1270

    
1271
    st= s->streams[stream_index];
1272
    if(st->index_entries){
1273
        AVIndexEntry *e;
1274

    
1275
        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()
1276
        index= FFMAX(index, 0);
1277
        e= &st->index_entries[index];
1278

    
1279
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1280
            pos_min= e->pos;
1281
            ts_min= e->timestamp;
1282
#ifdef DEBUG_SEEK
1283
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1284
               pos_min,ts_min);
1285
#endif
1286
        }else{
1287
            assert(index==0);
1288
        }
1289

    
1290
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1291
        assert(index < st->nb_index_entries);
1292
        if(index >= 0){
1293
            e= &st->index_entries[index];
1294
            assert(e->timestamp >= target_ts);
1295
            pos_max= e->pos;
1296
            ts_max= e->timestamp;
1297
            pos_limit= pos_max - e->min_distance;
1298
#ifdef DEBUG_SEEK
1299
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1300
               pos_max,pos_limit, ts_max);
1301
#endif
1302
        }
1303
    }
1304

    
1305
    if(ts_min == AV_NOPTS_VALUE){
1306
        pos_min = s->data_offset;
1307
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1308
        if (ts_min == AV_NOPTS_VALUE)
1309
            return -1;
1310
    }
1311

    
1312
    if(ts_max == AV_NOPTS_VALUE){
1313
        int step= 1024;
1314
        filesize = url_fsize(&s->pb);
1315
        pos_max = filesize - 1;
1316
        do{
1317
            pos_max -= step;
1318
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1319
            step += step;
1320
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1321
        if (ts_max == AV_NOPTS_VALUE)
1322
            return -1;
1323

    
1324
        for(;;){
1325
            int64_t tmp_pos= pos_max + 1;
1326
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1327
            if(tmp_ts == AV_NOPTS_VALUE)
1328
                break;
1329
            ts_max= tmp_ts;
1330
            pos_max= tmp_pos;
1331
            if(tmp_pos >= filesize)
1332
                break;
1333
        }
1334
        pos_limit= pos_max;
1335
    }
1336

    
1337
    if(ts_min > ts_max){
1338
        return -1;
1339
    }else if(ts_min == ts_max){
1340
        pos_limit= pos_min;
1341
    }
1342

    
1343
    no_change=0;
1344
    while (pos_min < pos_limit) {
1345
#ifdef DEBUG_SEEK
1346
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1347
               pos_min, pos_max,
1348
               ts_min, ts_max);
1349
#endif
1350
        assert(pos_limit <= pos_max);
1351

    
1352
        if(no_change==0){
1353
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1354
            // interpolate position (better than dichotomy)
1355
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1356
                + pos_min - approximate_keyframe_distance;
1357
        }else if(no_change==1){
1358
            // bisection, if interpolation failed to change min or max pos last time
1359
            pos = (pos_min + pos_limit)>>1;
1360
        }else{
1361
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1362
            pos=pos_min;
1363
        }
1364
        if(pos <= pos_min)
1365
            pos= pos_min + 1;
1366
        else if(pos > pos_limit)
1367
            pos= pos_limit;
1368
        start_pos= pos;
1369

    
1370
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1371
        if(pos == pos_max)
1372
            no_change++;
1373
        else
1374
            no_change=0;
1375
#ifdef DEBUG_SEEK
1376
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);
1377
#endif
1378
        assert(ts != AV_NOPTS_VALUE);
1379
        if (target_ts <= ts) {
1380
            pos_limit = start_pos - 1;
1381
            pos_max = pos;
1382
            ts_max = ts;
1383
        }
1384
        if (target_ts >= ts) {
1385
            pos_min = pos;
1386
            ts_min = ts;
1387
        }
1388
    }
1389

    
1390
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1391
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1392
#ifdef DEBUG_SEEK
1393
    pos_min = pos;
1394
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1395
    pos_min++;
1396
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1397
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1398
           pos, ts_min, target_ts, ts_max);
1399
#endif
1400
    /* do the seek */
1401
    url_fseek(&s->pb, pos, SEEK_SET);
1402

    
1403
    av_update_cur_dts(s, st, ts);
1404

    
1405
    return 0;
1406
}
1407

    
1408
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1409
    int64_t pos_min, pos_max;
1410
#if 0
1411
    AVStream *st;
1412

1413
    if (stream_index < 0)
1414
        return -1;
1415

1416
    st= s->streams[stream_index];
1417
#endif
1418

    
1419
    pos_min = s->data_offset;
1420
    pos_max = url_fsize(&s->pb) - 1;
1421

    
1422
    if     (pos < pos_min) pos= pos_min;
1423
    else if(pos > pos_max) pos= pos_max;
1424

    
1425
    url_fseek(&s->pb, pos, SEEK_SET);
1426

    
1427
#if 0
1428
    av_update_cur_dts(s, st, ts);
1429
#endif
1430
    return 0;
1431
}
1432

    
1433
static int av_seek_frame_generic(AVFormatContext *s,
1434
                                 int stream_index, int64_t timestamp, int flags)
1435
{
1436
    int index;
1437
    AVStream *st;
1438
    AVIndexEntry *ie;
1439

    
1440
    if (!s->index_built) {
1441
        if (is_raw_stream(s)) {
1442
            av_build_index_raw(s);
1443
        } else {
1444
            return -1;
1445
        }
1446
        s->index_built = 1;
1447
    }
1448

    
1449
    st = s->streams[stream_index];
1450
    index = av_index_search_timestamp(st, timestamp, flags);
1451
    if (index < 0)
1452
        return -1;
1453

    
1454
    /* now we have found the index, we can seek */
1455
    ie = &st->index_entries[index];
1456
    av_read_frame_flush(s);
1457
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1458

    
1459
    av_update_cur_dts(s, st, ie->timestamp);
1460

    
1461
    return 0;
1462
}
1463

    
1464
/**
1465
 * Seek to the key frame at timestamp.
1466
 * 'timestamp' in 'stream_index'.
1467
 * @param stream_index If stream_index is (-1), a default
1468
 * stream is selected, and timestamp is automatically converted
1469
 * from AV_TIME_BASE units to the stream specific time_base.
1470
 * @param timestamp timestamp in AVStream.time_base units
1471
 *        or if there is no stream specified then in AV_TIME_BASE units
1472
 * @param flags flags which select direction and seeking mode
1473
 * @return >= 0 on success
1474
 */
1475
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1476
{
1477
    int ret;
1478
    AVStream *st;
1479

    
1480
    av_read_frame_flush(s);
1481

    
1482
    if(flags & AVSEEK_FLAG_BYTE)
1483
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1484

    
1485
    if(stream_index < 0){
1486
        stream_index= av_find_default_stream_index(s);
1487
        if(stream_index < 0)
1488
            return -1;
1489

    
1490
        st= s->streams[stream_index];
1491
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1492
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1493
    }
1494
    st= s->streams[stream_index];
1495

    
1496
    /* first, we try the format specific seek */
1497
    if (s->iformat->read_seek)
1498
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1499
    else
1500
        ret = -1;
1501
    if (ret >= 0) {
1502
        return 0;
1503
    }
1504

    
1505
    if(s->iformat->read_timestamp)
1506
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1507
    else
1508
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1509
}
1510

    
1511
/*******************************************************/
1512

    
1513
/**
1514
 * Returns TRUE if the stream has accurate timings in any stream.
1515
 *
1516
 * @return TRUE if the stream has accurate timings for at least one component.
1517
 */
1518
static int av_has_timings(AVFormatContext *ic)
1519
{
1520
    int i;
1521
    AVStream *st;
1522

    
1523
    for(i = 0;i < ic->nb_streams; i++) {
1524
        st = ic->streams[i];
1525
        if (st->start_time != AV_NOPTS_VALUE &&
1526
            st->duration != AV_NOPTS_VALUE)
1527
            return 1;
1528
    }
1529
    return 0;
1530
}
1531

    
1532
/**
1533
 * Estimate the stream timings from the one of each components.
1534
 *
1535
 * Also computes the global bitrate if possible.
1536
 */
1537
static void av_update_stream_timings(AVFormatContext *ic)
1538
{
1539
    int64_t start_time, start_time1, end_time, end_time1;
1540
    int i;
1541
    AVStream *st;
1542

    
1543
    start_time = MAXINT64;
1544
    end_time = MININT64;
1545
    for(i = 0;i < ic->nb_streams; i++) {
1546
        st = ic->streams[i];
1547
        if (st->start_time != AV_NOPTS_VALUE) {
1548
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1549
            if (start_time1 < start_time)
1550
                start_time = start_time1;
1551
            if (st->duration != AV_NOPTS_VALUE) {
1552
                end_time1 = start_time1
1553
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1554
                if (end_time1 > end_time)
1555
                    end_time = end_time1;
1556
            }
1557
        }
1558
    }
1559
    if (start_time != MAXINT64) {
1560
        ic->start_time = start_time;
1561
        if (end_time != MININT64) {
1562
            ic->duration = end_time - start_time;
1563
            if (ic->file_size > 0) {
1564
                /* compute the bit rate */
1565
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1566
                    (double)ic->duration;
1567
            }
1568
        }
1569
    }
1570

    
1571
}
1572

    
1573
static void fill_all_stream_timings(AVFormatContext *ic)
1574
{
1575
    int i;
1576
    AVStream *st;
1577

    
1578
    av_update_stream_timings(ic);
1579
    for(i = 0;i < ic->nb_streams; i++) {
1580
        st = ic->streams[i];
1581
        if (st->start_time == AV_NOPTS_VALUE) {
1582
            if(ic->start_time != AV_NOPTS_VALUE)
1583
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1584
            if(ic->duration != AV_NOPTS_VALUE)
1585
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1586
        }
1587
    }
1588
}
1589

    
1590
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1591
{
1592
    int64_t filesize, duration;
1593
    int bit_rate, i;
1594
    AVStream *st;
1595

    
1596
    /* if bit_rate is already set, we believe it */
1597
    if (ic->bit_rate == 0) {
1598
        bit_rate = 0;
1599
        for(i=0;i<ic->nb_streams;i++) {
1600
            st = ic->streams[i];
1601
            bit_rate += st->codec->bit_rate;
1602
        }
1603
        ic->bit_rate = bit_rate;
1604
    }
1605

    
1606
    /* if duration is already set, we believe it */
1607
    if (ic->duration == AV_NOPTS_VALUE &&
1608
        ic->bit_rate != 0 &&
1609
        ic->file_size != 0)  {
1610
        filesize = ic->file_size;
1611
        if (filesize > 0) {
1612
            for(i = 0; i < ic->nb_streams; i++) {
1613
                st = ic->streams[i];
1614
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1615
                if (st->start_time == AV_NOPTS_VALUE ||
1616
                    st->duration == AV_NOPTS_VALUE) {
1617
                    st->start_time = 0;
1618
                    st->duration = duration;
1619
                }
1620
            }
1621
        }
1622
    }
1623
}
1624

    
1625
#define DURATION_MAX_READ_SIZE 250000
1626

    
1627
/* only usable for MPEG-PS streams */
1628
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1629
{
1630
    AVPacket pkt1, *pkt = &pkt1;
1631
    AVStream *st;
1632
    int read_size, i, ret;
1633
    int64_t end_time;
1634
    int64_t filesize, offset, duration;
1635

    
1636
    /* free previous packet */
1637
    if (ic->cur_st && ic->cur_st->parser)
1638
        av_free_packet(&ic->cur_pkt);
1639
    ic->cur_st = NULL;
1640

    
1641
    /* flush packet queue */
1642
    flush_packet_queue(ic);
1643

    
1644
    for(i=0;i<ic->nb_streams;i++) {
1645
        st = ic->streams[i];
1646
        if (st->parser) {
1647
            av_parser_close(st->parser);
1648
            st->parser= NULL;
1649
        }
1650
    }
1651

    
1652
    /* we read the first packets to get the first PTS (not fully
1653
       accurate, but it is enough now) */
1654
    url_fseek(&ic->pb, 0, SEEK_SET);
1655
    read_size = 0;
1656
    for(;;) {
1657
        if (read_size >= DURATION_MAX_READ_SIZE)
1658
            break;
1659
        /* if all info is available, we can stop */
1660
        for(i = 0;i < ic->nb_streams; i++) {
1661
            st = ic->streams[i];
1662
            if (st->start_time == AV_NOPTS_VALUE)
1663
                break;
1664
        }
1665
        if (i == ic->nb_streams)
1666
            break;
1667

    
1668
        ret = av_read_packet(ic, pkt);
1669
        if (ret != 0)
1670
            break;
1671
        read_size += pkt->size;
1672
        st = ic->streams[pkt->stream_index];
1673
        if (pkt->pts != AV_NOPTS_VALUE) {
1674
            if (st->start_time == AV_NOPTS_VALUE)
1675
                st->start_time = pkt->pts;
1676
        }
1677
        av_free_packet(pkt);
1678
    }
1679

    
1680
    /* estimate the end time (duration) */
1681
    /* XXX: may need to support wrapping */
1682
    filesize = ic->file_size;
1683
    offset = filesize - DURATION_MAX_READ_SIZE;
1684
    if (offset < 0)
1685
        offset = 0;
1686

    
1687
    url_fseek(&ic->pb, offset, SEEK_SET);
1688
    read_size = 0;
1689
    for(;;) {
1690
        if (read_size >= DURATION_MAX_READ_SIZE)
1691
            break;
1692
        /* if all info is available, we can stop */
1693
        for(i = 0;i < ic->nb_streams; i++) {
1694
            st = ic->streams[i];
1695
            if (st->duration == AV_NOPTS_VALUE)
1696
                break;
1697
        }
1698
        if (i == ic->nb_streams)
1699
            break;
1700

    
1701
        ret = av_read_packet(ic, pkt);
1702
        if (ret != 0)
1703
            break;
1704
        read_size += pkt->size;
1705
        st = ic->streams[pkt->stream_index];
1706
        if (pkt->pts != AV_NOPTS_VALUE) {
1707
            end_time = pkt->pts;
1708
            duration = end_time - st->start_time;
1709
            if (duration > 0) {
1710
                if (st->duration == AV_NOPTS_VALUE ||
1711
                    st->duration < duration)
1712
                    st->duration = duration;
1713
            }
1714
        }
1715
        av_free_packet(pkt);
1716
    }
1717

    
1718
    fill_all_stream_timings(ic);
1719

    
1720
    url_fseek(&ic->pb, 0, SEEK_SET);
1721
}
1722

    
1723
static void av_estimate_timings(AVFormatContext *ic)
1724
{
1725
    int64_t file_size;
1726

    
1727
    /* get the file size, if possible */
1728
    if (ic->iformat->flags & AVFMT_NOFILE) {
1729
        file_size = 0;
1730
    } else {
1731
        file_size = url_fsize(&ic->pb);
1732
        if (file_size < 0)
1733
            file_size = 0;
1734
    }
1735
    ic->file_size = file_size;
1736

    
1737
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1738
         !strcmp(ic->iformat->name, "mpegts")) &&
1739
        file_size && !ic->pb.is_streamed) {
1740
        /* get accurate estimate from the PTSes */
1741
        av_estimate_timings_from_pts(ic);
1742
    } else if (av_has_timings(ic)) {
1743
        /* at least one components has timings - we use them for all
1744
           the components */
1745
        fill_all_stream_timings(ic);
1746
    } else {
1747
        /* less precise: use bit rate info */
1748
        av_estimate_timings_from_bit_rate(ic);
1749
    }
1750
    av_update_stream_timings(ic);
1751

    
1752
#if 0
1753
    {
1754
        int i;
1755
        AVStream *st;
1756
        for(i = 0;i < ic->nb_streams; i++) {
1757
            st = ic->streams[i];
1758
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1759
               i, (double)st->start_time / AV_TIME_BASE,
1760
               (double)st->duration / AV_TIME_BASE);
1761
        }
1762
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1763
               (double)ic->start_time / AV_TIME_BASE,
1764
               (double)ic->duration / AV_TIME_BASE,
1765
               ic->bit_rate / 1000);
1766
    }
1767
#endif
1768
}
1769

    
1770
static int has_codec_parameters(AVCodecContext *enc)
1771
{
1772
    int val;
1773
    switch(enc->codec_type) {
1774
    case CODEC_TYPE_AUDIO:
1775
        val = enc->sample_rate;
1776
        break;
1777
    case CODEC_TYPE_VIDEO:
1778
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1779
        break;
1780
    default:
1781
        val = 1;
1782
        break;
1783
    }
1784
    return (val != 0);
1785
}
1786

    
1787
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1788
{
1789
    int16_t *samples;
1790
    AVCodec *codec;
1791
    int got_picture, ret=0;
1792
    AVFrame picture;
1793

    
1794
  if(!st->codec->codec){
1795
    codec = avcodec_find_decoder(st->codec->codec_id);
1796
    if (!codec)
1797
        return -1;
1798
    ret = avcodec_open(st->codec, codec);
1799
    if (ret < 0)
1800
        return ret;
1801
  }
1802

    
1803
  if(!has_codec_parameters(st->codec)){
1804
    switch(st->codec->codec_type) {
1805
    case CODEC_TYPE_VIDEO:
1806
        ret = avcodec_decode_video(st->codec, &picture,
1807
                                   &got_picture, (uint8_t *)data, size);
1808
        break;
1809
    case CODEC_TYPE_AUDIO:
1810
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1811
        if (!samples)
1812
            goto fail;
1813
        ret = avcodec_decode_audio(st->codec, samples,
1814
                                   &got_picture, (uint8_t *)data, size);
1815
        av_free(samples);
1816
        break;
1817
    default:
1818
        break;
1819
    }
1820
  }
1821
 fail:
1822
    return ret;
1823
}
1824

    
1825
/* absolute maximum size we read until we abort */
1826
#define MAX_READ_SIZE        5000000
1827

    
1828
/* maximum duration until we stop analysing the stream */
1829
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 3.0))
1830

    
1831
/**
1832
 * Read the beginning of a media file to get stream information. This
1833
 * is useful for file formats with no headers such as MPEG. This
1834
 * function also compute the real frame rate in case of mpeg2 repeat
1835
 * frame mode.
1836
 *
1837
 * @param ic media file handle
1838
 * @return >=0 if OK. AVERROR_xxx if error.
1839
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1840
 */
1841
int av_find_stream_info(AVFormatContext *ic)
1842
{
1843
    int i, count, ret, read_size, j;
1844
    AVStream *st;
1845
    AVPacket pkt1, *pkt;
1846
    AVPacketList *pktl=NULL, **ppktl;
1847
    int64_t last_dts[MAX_STREAMS];
1848
    int64_t duration_sum[MAX_STREAMS];
1849
    int duration_count[MAX_STREAMS]={0};
1850

    
1851
    for(i=0;i<ic->nb_streams;i++) {
1852
        st = ic->streams[i];
1853
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1854
/*            if(!st->time_base.num)
1855
                st->time_base= */
1856
            if(!st->codec->time_base.num)
1857
                st->codec->time_base= st->time_base;
1858
        }
1859
        //only for the split stuff
1860
        if (!st->parser) {
1861
            st->parser = av_parser_init(st->codec->codec_id);
1862
            if(st->need_parsing == 2 && st->parser){
1863
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1864
            }
1865
        }
1866
    }
1867

    
1868
    for(i=0;i<MAX_STREAMS;i++){
1869
        last_dts[i]= AV_NOPTS_VALUE;
1870
        duration_sum[i]= INT64_MAX;
1871
    }
1872

    
1873
    count = 0;
1874
    read_size = 0;
1875
    ppktl = &ic->packet_buffer;
1876
    for(;;) {
1877
        /* check if one codec still needs to be handled */
1878
        for(i=0;i<ic->nb_streams;i++) {
1879
            st = ic->streams[i];
1880
            if (!has_codec_parameters(st->codec))
1881
                break;
1882
            /* variable fps and no guess at the real fps */
1883
            if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1884
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1885
                break;
1886
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1887
                break;
1888
        }
1889
        if (i == ic->nb_streams) {
1890
            /* NOTE: if the format has no header, then we need to read
1891
               some packets to get most of the streams, so we cannot
1892
               stop here */
1893
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1894
                /* if we found the info for all the codecs, we can stop */
1895
                ret = count;
1896
                break;
1897
            }
1898
        } else {
1899
            /* we did not get all the codec info, but we read too much data */
1900
            if (read_size >= MAX_READ_SIZE) {
1901
                ret = count;
1902
                break;
1903
            }
1904
        }
1905

    
1906
        /* NOTE: a new stream can be added there if no header in file
1907
           (AVFMTCTX_NOHEADER) */
1908
        ret = av_read_frame_internal(ic, &pkt1);
1909
        if (ret < 0) {
1910
            /* EOF or error */
1911
            ret = -1; /* we could not have all the codec parameters before EOF */
1912
            for(i=0;i<ic->nb_streams;i++) {
1913
                st = ic->streams[i];
1914
                if (!has_codec_parameters(st->codec)){
1915
                    char buf[256];
1916
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1917
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1918
                } else {
1919
                    ret = 0;
1920
                }
1921
            }
1922
            break;
1923
        }
1924

    
1925
        pktl = av_mallocz(sizeof(AVPacketList));
1926
        if (!pktl) {
1927
            ret = AVERROR_NOMEM;
1928
            break;
1929
        }
1930

    
1931
        /* add the packet in the buffered packet list */
1932
        *ppktl = pktl;
1933
        ppktl = &pktl->next;
1934

    
1935
        pkt = &pktl->pkt;
1936
        *pkt = pkt1;
1937

    
1938
        /* duplicate the packet */
1939
        if (av_dup_packet(pkt) < 0) {
1940
                ret = AVERROR_NOMEM;
1941
                break;
1942
        }
1943

    
1944
        read_size += pkt->size;
1945

    
1946
        st = ic->streams[pkt->stream_index];
1947
        st->codec_info_duration += pkt->duration;
1948
        if (pkt->duration != 0)
1949
            st->codec_info_nb_frames++;
1950

    
1951
        {
1952
            int index= pkt->stream_index;
1953
            int64_t last= last_dts[index];
1954
            int64_t duration= pkt->dts - last;
1955

    
1956
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1957
                if(duration*duration_count[index]*10/9 < duration_sum[index]){
1958
                    duration_sum[index]= duration;
1959
                    duration_count[index]=1;
1960
                }else{
1961
                    int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1962
                    duration_sum[index] += duration;
1963
                    duration_count[index]+= factor;
1964
                }
1965
                if(st->codec_info_nb_frames == 0 && 0)
1966
                    st->codec_info_duration += duration;
1967
            }
1968
            last_dts[pkt->stream_index]= pkt->dts;
1969
        }
1970
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1971
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1972
            if(i){
1973
                st->codec->extradata_size= i;
1974
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1975
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1976
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1977
            }
1978
        }
1979

    
1980
        /* if still no information, we try to open the codec and to
1981
           decompress the frame. We try to avoid that in most cases as
1982
           it takes longer and uses more memory. For MPEG4, we need to
1983
           decompress for Quicktime. */
1984
        if (!has_codec_parameters(st->codec) /*&&
1985
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1986
             st->codec->codec_id == CODEC_ID_H264 ||
1987
             st->codec->codec_id == CODEC_ID_H263 ||
1988
             st->codec->codec_id == CODEC_ID_H261 ||
1989
             st->codec->codec_id == CODEC_ID_VORBIS ||
1990
             st->codec->codec_id == CODEC_ID_MJPEG ||
1991
             st->codec->codec_id == CODEC_ID_PNG ||
1992
             st->codec->codec_id == CODEC_ID_PAM ||
1993
             st->codec->codec_id == CODEC_ID_PGM ||
1994
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1995
             st->codec->codec_id == CODEC_ID_PBM ||
1996
             st->codec->codec_id == CODEC_ID_PPM ||
1997
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1998
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1999
            try_decode_frame(st, pkt->data, pkt->size);
2000

    
2001
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2002
            break;
2003
        }
2004
        count++;
2005
    }
2006

    
2007
    // close codecs which where opened in try_decode_frame()
2008
    for(i=0;i<ic->nb_streams;i++) {
2009
        st = ic->streams[i];
2010
        if(st->codec->codec)
2011
            avcodec_close(st->codec);
2012
    }
2013
    for(i=0;i<ic->nb_streams;i++) {
2014
        st = ic->streams[i];
2015
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2016
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2017
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2018

    
2019
            if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2020
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2021
                int64_t num, den, error, best_error;
2022

    
2023
                num= st->time_base.den*duration_count[i];
2024
                den= st->time_base.num*duration_sum[i];
2025

    
2026
                best_error= INT64_MAX;
2027
                for(j=1; j<60*12; j++){
2028
                    error= ABS(1001*12*num - 1001*j*den);
2029
                    if(error < best_error){
2030
                        best_error= error;
2031
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2032
                    }
2033
                }
2034
                for(j=24; j<=30; j+=6){
2035
                    error= ABS(1001*12*num - 1000*12*j*den);
2036
                    if(error < best_error){
2037
                        best_error= error;
2038
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2039
                    }
2040
                }
2041
            }
2042

    
2043
            /* set real frame rate info */
2044
            /* compute the real frame rate for telecine */
2045
            if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
2046
                 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
2047
                st->codec->sub_id == 2) {
2048
                if (st->codec_info_nb_frames >= 20) {
2049
                    float coded_frame_rate, est_frame_rate;
2050
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2051
                        (double)st->codec_info_duration ;
2052
                    coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2053
#if 0
2054
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2055
                           coded_frame_rate, est_frame_rate);
2056
#endif
2057
                    /* if we detect that it could be a telecine, we
2058
                       signal it. It would be better to do it at a
2059
                       higher level as it can change in a film */
2060
                    if (coded_frame_rate >= 24.97 &&
2061
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2062
                        st->r_frame_rate = (AVRational){24000, 1001};
2063
                    }
2064
                }
2065
            }
2066
            /* if no real frame rate, use the codec one */
2067
            if (!st->r_frame_rate.num){
2068
                st->r_frame_rate.num = st->codec->time_base.den;
2069
                st->r_frame_rate.den = st->codec->time_base.num;
2070
            }
2071
        }
2072
    }
2073

    
2074
    av_estimate_timings(ic);
2075
#if 0
2076
    /* correct DTS for b frame streams with no timestamps */
2077
    for(i=0;i<ic->nb_streams;i++) {
2078
        st = ic->streams[i];
2079
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2080
            if(b-frames){
2081
                ppktl = &ic->packet_buffer;
2082
                while(ppkt1){
2083
                    if(ppkt1->stream_index != i)
2084
                        continue;
2085
                    if(ppkt1->pkt->dts < 0)
2086
                        break;
2087
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2088
                        break;
2089
                    ppkt1->pkt->dts -= delta;
2090
                    ppkt1= ppkt1->next;
2091
                }
2092
                if(ppkt1)
2093
                    continue;
2094
                st->cur_dts -= delta;
2095
            }
2096
        }
2097
    }
2098
#endif
2099
    return ret;
2100
}
2101

    
2102
/*******************************************************/
2103

    
2104
/**
2105
 * start playing a network based stream (e.g. RTSP stream) at the
2106
 * current position
2107
 */
2108
int av_read_play(AVFormatContext *s)
2109
{
2110
    if (!s->iformat->read_play)
2111
        return AVERROR_NOTSUPP;
2112
    return s->iformat->read_play(s);
2113
}
2114

    
2115
/**
2116
 * Pause a network based stream (e.g. RTSP stream).
2117
 *
2118
 * Use av_read_play() to resume it.
2119
 */
2120
int av_read_pause(AVFormatContext *s)
2121
{
2122
    if (!s->iformat->read_pause)
2123
        return AVERROR_NOTSUPP;
2124
    return s->iformat->read_pause(s);
2125
}
2126

    
2127
/**
2128
 * Close a media file (but not its codecs).
2129
 *
2130
 * @param s media file handle
2131
 */
2132
void av_close_input_file(AVFormatContext *s)
2133
{
2134
    int i, must_open_file;
2135
    AVStream *st;
2136

    
2137
    /* free previous packet */
2138
    if (s->cur_st && s->cur_st->parser)
2139
        av_free_packet(&s->cur_pkt);
2140

    
2141
    if (s->iformat->read_close)
2142
        s->iformat->read_close(s);
2143
    for(i=0;i<s->nb_streams;i++) {
2144
        /* free all data in a stream component */
2145
        st = s->streams[i];
2146
        if (st->parser) {
2147
            av_parser_close(st->parser);
2148
        }
2149
        av_free(st->index_entries);
2150
        av_free(st->codec->extradata);
2151
        av_free(st->codec);
2152
        av_free(st);
2153
    }
2154
    flush_packet_queue(s);
2155
    must_open_file = 1;
2156
    if (s->iformat->flags & AVFMT_NOFILE) {
2157
        must_open_file = 0;
2158
    }
2159
    if (must_open_file) {
2160
        url_fclose(&s->pb);
2161
    }
2162
    av_freep(&s->priv_data);
2163
    av_free(s);
2164
}
2165

    
2166
/**
2167
 * Add a new stream to a media file.
2168
 *
2169
 * Can only be called in the read_header() function. If the flag
2170
 * AVFMTCTX_NOHEADER is in the format context, then new streams
2171
 * can be added in read_packet too.
2172
 *
2173
 * @param s media file handle
2174
 * @param id file format dependent stream id
2175
 */
2176
AVStream *av_new_stream(AVFormatContext *s, int id)
2177
{
2178
    AVStream *st;
2179

    
2180
    if (s->nb_streams >= MAX_STREAMS)
2181
        return NULL;
2182

    
2183
    st = av_mallocz(sizeof(AVStream));
2184
    if (!st)
2185
        return NULL;
2186

    
2187
    st->codec= avcodec_alloc_context();
2188
    if (s->iformat) {
2189
        /* no default bitrate if decoding */
2190
        st->codec->bit_rate = 0;
2191
    }
2192
    st->index = s->nb_streams;
2193
    st->id = id;
2194
    st->start_time = AV_NOPTS_VALUE;
2195
    st->duration = AV_NOPTS_VALUE;
2196
    st->cur_dts = AV_NOPTS_VALUE;
2197

    
2198
    /* default pts settings is MPEG like */
2199
    av_set_pts_info(st, 33, 1, 90000);
2200
    st->last_IP_pts = AV_NOPTS_VALUE;
2201

    
2202
    s->streams[s->nb_streams++] = st;
2203
    return st;
2204
}
2205

    
2206
/************************************************************/
2207
/* output media file */
2208

    
2209
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2210
{
2211
    int ret;
2212

    
2213
    if (s->oformat->priv_data_size > 0) {
2214
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2215
        if (!s->priv_data)
2216
            return AVERROR_NOMEM;
2217
    } else
2218
        s->priv_data = NULL;
2219

    
2220
    if (s->oformat->set_parameters) {
2221
        ret = s->oformat->set_parameters(s, ap);
2222
        if (ret < 0)
2223
            return ret;
2224
    }
2225
    return 0;
2226
}
2227

    
2228
/**
2229
 * allocate the stream private data and write the stream header to an
2230
 * output media file
2231
 *
2232
 * @param s media file handle
2233
 * @return 0 if OK. AVERROR_xxx if error.
2234
 */
2235
int av_write_header(AVFormatContext *s)
2236
{
2237
    int ret, i;
2238
    AVStream *st;
2239

    
2240
    // some sanity checks
2241
    for(i=0;i<s->nb_streams;i++) {
2242
        st = s->streams[i];
2243

    
2244
        switch (st->codec->codec_type) {
2245
        case CODEC_TYPE_AUDIO:
2246
            if(st->codec->sample_rate<=0){
2247
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2248
                return -1;
2249
            }
2250
            break;
2251
        case CODEC_TYPE_VIDEO:
2252
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2253
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2254
                return -1;
2255
            }
2256
            if(st->codec->width<=0 || st->codec->height<=0){
2257
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2258
                return -1;
2259
            }
2260
            break;
2261
        }
2262
    }
2263

    
2264
    if(s->oformat->write_header){
2265
        ret = s->oformat->write_header(s);
2266
        if (ret < 0)
2267
            return ret;
2268
    }
2269

    
2270
    /* init PTS generation */
2271
    for(i=0;i<s->nb_streams;i++) {
2272
        int64_t den = AV_NOPTS_VALUE;
2273
        st = s->streams[i];
2274

    
2275
        switch (st->codec->codec_type) {
2276
        case CODEC_TYPE_AUDIO:
2277
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2278
            break;
2279
        case CODEC_TYPE_VIDEO:
2280
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2281
            break;
2282
        default:
2283
            break;
2284
        }
2285
        if (den != AV_NOPTS_VALUE) {
2286
            if (den <= 0)
2287
                return AVERROR_INVALIDDATA;
2288
            av_frac_init(&st->pts, 0, 0, den);
2289
        }
2290
    }
2291
    return 0;
2292
}
2293

    
2294
//FIXME merge with compute_pkt_fields
2295
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2296
    int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2297
    int num, den, frame_size;
2298

    
2299
//    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, b_frames, pkt->size, pkt->stream_index);
2300

    
2301
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2302
        return -1;*/
2303

    
2304
    /* duration field */
2305
    if (pkt->duration == 0) {
2306
        compute_frame_duration(&num, &den, st, NULL, pkt);
2307
        if (den && num) {
2308
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2309
        }
2310
    }
2311

    
2312
    //XXX/FIXME this is a temporary hack until all encoders output pts
2313
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2314
        pkt->dts=
2315
//        pkt->pts= st->cur_dts;
2316
        pkt->pts= st->pts.val;
2317
    }
2318

    
2319
    //calculate dts from pts
2320
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2321
        if(b_frames){
2322
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2323
                st->last_IP_pts= -pkt->duration;
2324
            }
2325
            if(st->last_IP_pts < pkt->pts){
2326
                pkt->dts= st->last_IP_pts;
2327
                st->last_IP_pts= pkt->pts;
2328
            }else
2329
                pkt->dts= pkt->pts;
2330
        }else
2331
            pkt->dts= pkt->pts;
2332
    }
2333

    
2334
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2335
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2336
        return -1;
2337
    }
2338
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2339
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2340
        return -1;
2341
    }
2342

    
2343
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2344
    st->cur_dts= pkt->dts;
2345
    st->pts.val= pkt->dts;
2346

    
2347
    /* update pts */
2348
    switch (st->codec->codec_type) {
2349
    case CODEC_TYPE_AUDIO:
2350
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2351

    
2352
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2353
           but it would be better if we had the real timestamps from the encoder */
2354
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2355
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2356
        }
2357
        break;
2358
    case CODEC_TYPE_VIDEO:
2359
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2360
        break;
2361
    default:
2362
        break;
2363
    }
2364
    return 0;
2365
}
2366

    
2367
static void truncate_ts(AVStream *st, AVPacket *pkt){
2368
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2369

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

    
2373
    pkt->pts &= pts_mask;
2374
    pkt->dts &= pts_mask;
2375
}
2376

    
2377
/**
2378
 * Write a packet to an output media file.
2379
 *
2380
 * The packet shall contain one audio or video frame.
2381
 *
2382
 * @param s media file handle
2383
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2384
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2385
 */
2386
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2387
{
2388
    int ret;
2389

    
2390
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2391
    if(ret<0)
2392
        return ret;
2393

    
2394
    truncate_ts(s->streams[pkt->stream_index], pkt);
2395

    
2396
    ret= s->oformat->write_packet(s, pkt);
2397
    if(!ret)
2398
        ret= url_ferror(&s->pb);
2399
    return ret;
2400
}
2401

    
2402
/**
2403
 * interleave_packet implementation which will interleave per DTS.
2404
 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2405
 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2406
 */
2407
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2408
    AVPacketList *pktl, **next_point, *this_pktl;
2409
    int stream_count=0;
2410
    int streams[MAX_STREAMS];
2411

    
2412
    if(pkt){
2413
        AVStream *st= s->streams[ pkt->stream_index];
2414

    
2415
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2416

    
2417
        this_pktl = av_mallocz(sizeof(AVPacketList));
2418
        this_pktl->pkt= *pkt;
2419
        if(pkt->destruct == av_destruct_packet)
2420
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2421
        else
2422
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2423

    
2424
        next_point = &s->packet_buffer;
2425
        while(*next_point){
2426
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2427
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2428
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2429
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2430
                break;
2431
            next_point= &(*next_point)->next;
2432
        }
2433
        this_pktl->next= *next_point;
2434
        *next_point= this_pktl;
2435
    }
2436

    
2437
    memset(streams, 0, sizeof(streams));
2438
    pktl= s->packet_buffer;
2439
    while(pktl){
2440
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2441
        if(streams[ pktl->pkt.stream_index ] == 0)
2442
            stream_count++;
2443
        streams[ pktl->pkt.stream_index ]++;
2444
        pktl= pktl->next;
2445
    }
2446

    
2447
    if(s->nb_streams == stream_count || (flush && stream_count)){
2448
        pktl= s->packet_buffer;
2449
        *out= pktl->pkt;
2450

    
2451
        s->packet_buffer= pktl->next;
2452
        av_freep(&pktl);
2453
        return 1;
2454
    }else{
2455
        av_init_packet(out);
2456
        return 0;
2457
    }
2458
}
2459

    
2460
/**
2461
 * Interleaves a AVPacket correctly so it can be muxed.
2462
 * @param out the interleaved packet will be output here
2463
 * @param in the input packet
2464
 * @param flush 1 if no further packets are available as input and all
2465
 *              remaining packets should be output
2466
 * @return 1 if a packet was output, 0 if no packet could be output,
2467
 *         < 0 if an error occured
2468
 */
2469
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2470
    if(s->oformat->interleave_packet)
2471
        return s->oformat->interleave_packet(s, out, in, flush);
2472
    else
2473
        return av_interleave_packet_per_dts(s, out, in, flush);
2474
}
2475

    
2476
/**
2477
 * Writes a packet to an output media file ensuring correct interleaving.
2478
 *
2479
 * The packet must contain one audio or video frame.
2480
 * If the packets are already correctly interleaved the application should
2481
 * call av_write_frame() instead as its slightly faster, its also important
2482
 * to keep in mind that completly non interleaved input will need huge amounts
2483
 * of memory to interleave with this, so its prefereable to interleave at the
2484
 * demuxer level
2485
 *
2486
 * @param s media file handle
2487
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2488
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2489
 */
2490
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2491
    AVStream *st= s->streams[ pkt->stream_index];
2492

    
2493
    //FIXME/XXX/HACK drop zero sized packets
2494
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2495
        return 0;
2496

    
2497
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2498
    if(compute_pkt_fields2(st, pkt) < 0)
2499
        return -1;
2500

    
2501
    if(pkt->dts == AV_NOPTS_VALUE)
2502
        return -1;
2503

    
2504
    for(;;){
2505
        AVPacket opkt;
2506
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2507
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2508
            return ret;
2509

    
2510
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2511
        ret= s->oformat->write_packet(s, &opkt);
2512

    
2513
        av_free_packet(&opkt);
2514
        pkt= NULL;
2515

    
2516
        if(ret<0)
2517
            return ret;
2518
        if(url_ferror(&s->pb))
2519
            return url_ferror(&s->pb);
2520
    }
2521
}
2522

    
2523
/**
2524
 * @brief Write the stream trailer to an output media file and
2525
 *        free the file private data.
2526
 *
2527
 * @param s media file handle
2528
 * @return 0 if OK. AVERROR_xxx if error.
2529
 */
2530
int av_write_trailer(AVFormatContext *s)
2531
{
2532
    int ret, i;
2533

    
2534
    for(;;){
2535
        AVPacket pkt;
2536
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2537
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2538
            goto fail;
2539
        if(!ret)
2540
            break;
2541

    
2542
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2543
        ret= s->oformat->write_packet(s, &pkt);
2544

    
2545
        av_free_packet(&pkt);
2546

    
2547
        if(ret<0)
2548
            goto fail;
2549
        if(url_ferror(&s->pb))
2550
            goto fail;
2551
    }
2552

    
2553
    if(s->oformat->write_trailer)
2554
        ret = s->oformat->write_trailer(s);
2555
fail:
2556
    if(ret == 0)
2557
       ret=url_ferror(&s->pb);
2558
    for(i=0;i<s->nb_streams;i++)
2559
        av_freep(&s->streams[i]->priv_data);
2560
    av_freep(&s->priv_data);
2561
    return ret;
2562
}
2563

    
2564
/* "user interface" functions */
2565

    
2566
void dump_format(AVFormatContext *ic,
2567
                 int index,
2568
                 const char *url,
2569
                 int is_output)
2570
{
2571
    int i, flags;
2572
    char buf[256];
2573

    
2574
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2575
            is_output ? "Output" : "Input",
2576
            index,
2577
            is_output ? ic->oformat->name : ic->iformat->name,
2578
            is_output ? "to" : "from", url);
2579
    if (!is_output) {
2580
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2581
        if (ic->duration != AV_NOPTS_VALUE) {
2582
            int hours, mins, secs, us;
2583
            secs = ic->duration / AV_TIME_BASE;
2584
            us = ic->duration % AV_TIME_BASE;
2585
            mins = secs / 60;
2586
            secs %= 60;
2587
            hours = mins / 60;
2588
            mins %= 60;
2589
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2590
                   (10 * us) / AV_TIME_BASE);
2591
        } else {
2592
            av_log(NULL, AV_LOG_INFO, "N/A");
2593
        }
2594
        if (ic->start_time != AV_NOPTS_VALUE) {
2595
            int secs, us;
2596
            av_log(NULL, AV_LOG_INFO, ", start: ");
2597
            secs = ic->start_time / AV_TIME_BASE;
2598
            us = ic->start_time % AV_TIME_BASE;
2599
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2600
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2601
        }
2602
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2603
        if (ic->bit_rate) {
2604
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2605
        } else {
2606
            av_log(NULL, AV_LOG_INFO, "N/A");
2607
        }
2608
        av_log(NULL, AV_LOG_INFO, "\n");
2609
    }
2610
    for(i=0;i<ic->nb_streams;i++) {
2611
        AVStream *st = ic->streams[i];
2612
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2613
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2614
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2615
        /* the pid is an important information, so we display it */
2616
        /* XXX: add a generic system */
2617
        if (is_output)
2618
            flags = ic->oformat->flags;
2619
        else
2620
            flags = ic->iformat->flags;
2621
        if (flags & AVFMT_SHOW_IDS) {
2622
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2623
        }
2624
        if (strlen(st->language) > 0) {
2625
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2626
        }
2627
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2628
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2629
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2630
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2631
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2632
/*            else if(st->time_base.den && st->time_base.num)
2633
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2634
            else
2635
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2636
        }
2637
        av_log(NULL, AV_LOG_INFO, "\n");
2638
    }
2639
}
2640

    
2641
typedef struct {
2642
    const char *abv;
2643
    int width, height;
2644
    int frame_rate, frame_rate_base;
2645
} AbvEntry;
2646

    
2647
static AbvEntry frame_abvs[] = {
2648
    { "ntsc",      720, 480, 30000, 1001 },
2649
    { "pal",       720, 576,    25,    1 },
2650
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2651
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2652
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2653
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2654
    { "film",      352, 240,    24,    1 },
2655
    { "ntsc-film", 352, 240, 24000, 1001 },
2656
    { "sqcif",     128,  96,     0,    0 },
2657
    { "qcif",      176, 144,     0,    0 },
2658
    { "cif",       352, 288,     0,    0 },
2659
    { "4cif",      704, 576,     0,    0 },
2660
};
2661

    
2662
/**
2663
 * parses width and height out of string str.
2664
 */
2665
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2666
{
2667
    int i;
2668
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2669
    const char *p;
2670
    int frame_width = 0, frame_height = 0;
2671

    
2672
    for(i=0;i<n;i++) {
2673
        if (!strcmp(frame_abvs[i].abv, str)) {
2674
            frame_width = frame_abvs[i].width;
2675
            frame_height = frame_abvs[i].height;
2676
            break;
2677
        }
2678
    }
2679
    if (i == n) {
2680
        p = str;
2681
        frame_width = strtol(p, (char **)&p, 10);
2682
        if (*p)
2683
            p++;
2684
        frame_height = strtol(p, (char **)&p, 10);
2685
    }
2686
    if (frame_width <= 0 || frame_height <= 0)
2687
        return -1;
2688
    *width_ptr = frame_width;
2689
    *height_ptr = frame_height;
2690
    return 0;
2691
}
2692

    
2693
/**
2694
 * Converts frame rate from string to a fraction.
2695
 *
2696
 * First we try to get an exact integer or fractional frame rate.
2697
 * If this fails we convert the frame rate to a double and return
2698
 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2699
 */
2700
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2701
{
2702
    int i;
2703
    char* cp;
2704

    
2705
    /* First, we check our abbreviation table */
2706
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2707
         if (!strcmp(frame_abvs[i].abv, arg)) {
2708
             *frame_rate = frame_abvs[i].frame_rate;
2709
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2710
             return 0;
2711
         }
2712

    
2713
    /* Then, we try to parse it as fraction */
2714
    cp = strchr(arg, '/');
2715
    if (!cp)
2716
        cp = strchr(arg, ':');
2717
    if (cp) {
2718
        char* cpp;
2719
        *frame_rate = strtol(arg, &cpp, 10);
2720
        if (cpp != arg || cpp == cp)
2721
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2722
        else
2723
           *frame_rate = 0;
2724
    }
2725
    else {
2726
        /* Finally we give up and parse it as double */
2727
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2728
        *frame_rate_base = time_base.den;
2729
        *frame_rate = time_base.num;
2730
    }
2731
    if (!*frame_rate || !*frame_rate_base)
2732
        return -1;
2733
    else
2734
        return 0;
2735
}
2736

    
2737
/**
2738
 * Converts date string to number of seconds since Jan 1st, 1970.
2739
 *
2740
 * @code
2741
 * Syntax:
2742
 * - If not a duration:
2743
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2744
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2745
 * Return the date in micro seconds since 1970
2746
 *
2747
 * - If a duration:
2748
 *  HH[:MM[:SS[.m...]]]
2749
 *  S+[.m...]
2750
 * @endcode
2751
 */
2752
#ifndef CONFIG_WINCE
2753
int64_t parse_date(const char *datestr, int duration)
2754
{
2755
    const char *p;
2756
    int64_t t;
2757
    struct tm dt;
2758
    int i;
2759
    static const char *date_fmt[] = {
2760
        "%Y-%m-%d",
2761
        "%Y%m%d",
2762
    };
2763
    static const char *time_fmt[] = {
2764
        "%H:%M:%S",
2765
        "%H%M%S",
2766
    };
2767
    const char *q;
2768
    int is_utc, len;
2769
    char lastch;
2770
    int negative = 0;
2771

    
2772
#undef time
2773
    time_t now = time(0);
2774

    
2775
    len = strlen(datestr);
2776
    if (len > 0)
2777
        lastch = datestr[len - 1];
2778
    else
2779
        lastch = '\0';
2780
    is_utc = (lastch == 'z' || lastch == 'Z');
2781

    
2782
    memset(&dt, 0, sizeof(dt));
2783

    
2784
    p = datestr;
2785
    q = NULL;
2786
    if (!duration) {
2787
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2788
            q = small_strptime(p, date_fmt[i], &dt);
2789
            if (q) {
2790
                break;
2791
            }
2792
        }
2793

    
2794
        if (!q) {
2795
            if (is_utc) {
2796
                dt = *gmtime(&now);
2797
            } else {
2798
                dt = *localtime(&now);
2799
            }
2800
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2801
        } else {
2802
            p = q;
2803
        }
2804

    
2805
        if (*p == 'T' || *p == 't' || *p == ' ')
2806
            p++;
2807

    
2808
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2809
            q = small_strptime(p, time_fmt[i], &dt);
2810
            if (q) {
2811
                break;
2812
            }
2813
        }
2814
    } else {
2815
        if (p[0] == '-') {
2816
            negative = 1;
2817
            ++p;
2818
        }
2819
        q = small_strptime(p, time_fmt[0], &dt);
2820
        if (!q) {
2821
            dt.tm_sec = strtol(p, (char **)&q, 10);
2822
            dt.tm_min = 0;
2823
            dt.tm_hour = 0;
2824
        }
2825
    }
2826

    
2827
    /* Now we have all the fields that we can get */
2828
    if (!q) {
2829
        if (duration)
2830
            return 0;
2831
        else
2832
            return now * int64_t_C(1000000);
2833
    }
2834

    
2835
    if (duration) {
2836
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2837
    } else {
2838
        dt.tm_isdst = -1;       /* unknown */
2839
        if (is_utc) {
2840
            t = mktimegm(&dt);
2841
        } else {
2842
            t = mktime(&dt);
2843
        }
2844
    }
2845

    
2846
    t *= 1000000;
2847

    
2848
    if (*q == '.') {
2849
        int val, n;
2850
        q++;
2851
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2852
            if (!isdigit(*q))
2853
                break;
2854
            val += n * (*q - '0');
2855
        }
2856
        t += val;
2857
    }
2858
    return negative ? -t : t;
2859
}
2860
#endif /* CONFIG_WINCE */
2861

    
2862
/**
2863
 * Attempts to find a specific tag in a URL.
2864
 *
2865
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2866
 * Return 1 if found.
2867
 */
2868
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2869
{
2870
    const char *p;
2871
    char tag[128], *q;
2872

    
2873
    p = info;
2874
    if (*p == '?')
2875
        p++;
2876
    for(;;) {
2877
        q = tag;
2878
        while (*p != '\0' && *p != '=' && *p != '&') {
2879
            if ((q - tag) < sizeof(tag) - 1)
2880
                *q++ = *p;
2881
            p++;
2882
        }
2883
        *q = '\0';
2884
        q = arg;
2885
        if (*p == '=') {
2886
            p++;
2887
            while (*p != '&' && *p != '\0') {
2888
                if ((q - arg) < arg_size - 1) {
2889
                    if (*p == '+')
2890
                        *q++ = ' ';
2891
                    else
2892
                        *q++ = *p;
2893
                }
2894
                p++;
2895
            }
2896
            *q = '\0';
2897
        }
2898
        if (!strcmp(tag, tag1))
2899
            return 1;
2900
        if (*p != '&')
2901
            break;
2902
        p++;
2903
    }
2904
    return 0;
2905
}
2906

    
2907
/**
2908
 * Returns in 'buf' the path with '%d' replaced by number.
2909
 *
2910
 * Also handles the '%0nd' format where 'n' is the total number
2911
 * of digits and '%%'. Return 0 if OK, and -1 if format error.
2912
 */
2913
int get_frame_filename(char *buf, int buf_size,
2914
                       const char *path, int number)
2915
{
2916
    const char *p;
2917
    char *q, buf1[20], c;
2918
    int nd, len, percentd_found;
2919

    
2920
    q = buf;
2921
    p = path;
2922
    percentd_found = 0;
2923
    for(;;) {
2924
        c = *p++;
2925
        if (c == '\0')
2926
            break;
2927
        if (c == '%') {
2928
            do {
2929
                nd = 0;
2930
                while (isdigit(*p)) {
2931
                    nd = nd * 10 + *p++ - '0';
2932
                }
2933
                c = *p++;
2934
            } while (isdigit(c));
2935

    
2936
            switch(c) {
2937
            case '%':
2938
                goto addchar;
2939
            case 'd':
2940
                if (percentd_found)
2941
                    goto fail;
2942
                percentd_found = 1;
2943
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2944
                len = strlen(buf1);
2945
                if ((q - buf + len) > buf_size - 1)
2946
                    goto fail;
2947
                memcpy(q, buf1, len);
2948
                q += len;
2949
                break;
2950
            default:
2951
                goto fail;
2952
            }
2953
        } else {
2954
        addchar:
2955
            if ((q - buf) < buf_size - 1)
2956
                *q++ = c;
2957
        }
2958
    }
2959
    if (!percentd_found)
2960
        goto fail;
2961
    *q = '\0';
2962
    return 0;
2963
 fail:
2964
    *q = '\0';
2965
    return -1;
2966
}
2967

    
2968
/**
2969
 * Print  nice hexa dump of a buffer
2970
 * @param f stream for output
2971
 * @param buf buffer
2972
 * @param size buffer size
2973
 */
2974
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2975
{
2976
    int len, i, j, c;
2977

    
2978
    for(i=0;i<size;i+=16) {
2979
        len = size - i;
2980
        if (len > 16)
2981
            len = 16;
2982
        fprintf(f, "%08x ", i);
2983
        for(j=0;j<16;j++) {
2984
            if (j < len)
2985
                fprintf(f, " %02x", buf[i+j]);
2986
            else
2987
                fprintf(f, "   ");
2988
        }
2989
        fprintf(f, " ");
2990
        for(j=0;j<len;j++) {
2991
            c = buf[i+j];
2992
            if (c < ' ' || c > '~')
2993
                c = '.';
2994
            fprintf(f, "%c", c);
2995
        }
2996
        fprintf(f, "\n");
2997
    }
2998
}
2999

    
3000
/**
3001
 * Print on 'f' a nice dump of a packet
3002
 * @param f stream for output
3003
 * @param pkt packet to dump
3004
 * @param dump_payload true if the payload must be displayed too
3005
 */
3006
 //FIXME needs to know the time_base
3007
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3008
{
3009
    fprintf(f, "stream #%d:\n", pkt->stream_index);
3010
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3011
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3012
    /* DTS is _always_ valid after av_read_frame() */
3013
    fprintf(f, "  dts=");
3014
    if (pkt->dts == AV_NOPTS_VALUE)
3015
        fprintf(f, "N/A");
3016
    else
3017
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3018
    /* PTS may be not known if B frames are present */
3019
    fprintf(f, "  pts=");
3020
    if (pkt->pts == AV_NOPTS_VALUE)
3021
        fprintf(f, "N/A");
3022
    else
3023
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3024
    fprintf(f, "\n");
3025
    fprintf(f, "  size=%d\n", pkt->size);
3026
    if (dump_payload)
3027
        av_hex_dump(f, pkt->data, pkt->size);
3028
}
3029

    
3030
void url_split(char *proto, int proto_size,
3031
               char *authorization, int authorization_size,
3032
               char *hostname, int hostname_size,
3033
               int *port_ptr,
3034
               char *path, int path_size,
3035
               const char *url)
3036
{
3037
    const char *p;
3038
    char *q;
3039
    int port;
3040

    
3041
    port = -1;
3042

    
3043
    p = url;
3044
    q = proto;
3045
    while (*p != ':' && *p != '\0') {
3046
        if ((q - proto) < proto_size - 1)
3047
            *q++ = *p;
3048
        p++;
3049
    }
3050
    if (proto_size > 0)
3051
        *q = '\0';
3052
    if (authorization_size > 0)
3053
        authorization[0] = '\0';
3054
    if (*p == '\0') {
3055
        if (proto_size > 0)
3056
            proto[0] = '\0';
3057
        if (hostname_size > 0)
3058
            hostname[0] = '\0';
3059
        p = url;
3060
    } else {
3061
        char *at,*slash; // PETR: position of '@' character and '/' character
3062

    
3063
        p++;
3064
        if (*p == '/')
3065
            p++;
3066
        if (*p == '/')
3067
            p++;
3068
        at = strchr(p,'@'); // PETR: get the position of '@'
3069
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
3070
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3071

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

    
3074
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3075
            if (*p == '@') {    // PETR: passed '@'
3076
              if (authorization_size > 0)
3077
                  *q = '\0';
3078
              q = hostname;
3079
              at = NULL;
3080
            } else if (!at) {   // PETR: hostname
3081
              if ((q - hostname) < hostname_size - 1)
3082
                  *q++ = *p;
3083
            } else {
3084
              if ((q - authorization) < authorization_size - 1)
3085
                *q++ = *p;
3086
            }
3087
            p++;
3088
        }
3089
        if (hostname_size > 0)
3090
            *q = '\0';
3091
        if (*p == ':') {
3092
            p++;
3093
            port = strtoul(p, (char **)&p, 10);
3094
        }
3095
    }
3096
    if (port_ptr)
3097
        *port_ptr = port;
3098
    pstrcpy(path, path_size, p);
3099
}
3100

    
3101
/**
3102
 * Set the pts for a given stream.
3103
 *
3104
 * @param s stream
3105
 * @param pts_wrap_bits number of bits effectively used by the pts
3106
 *        (used for wrap control, 33 is the value for MPEG)
3107
 * @param pts_num numerator to convert to seconds (MPEG: 1)
3108
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3109
 */
3110
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3111
                     int pts_num, int pts_den)
3112
{
3113
    s->pts_wrap_bits = pts_wrap_bits;
3114
    s->time_base.num = pts_num;
3115
    s->time_base.den = pts_den;
3116
}
3117

    
3118
/* fraction handling */
3119

    
3120
/**
3121
 * f = val + (num / den) + 0.5.
3122
 *
3123
 * 'num' is normalized so that it is such as 0 <= num < den.
3124
 *
3125
 * @param f fractional number
3126
 * @param val integer value
3127
 * @param num must be >= 0
3128
 * @param den must be >= 1
3129
 */
3130
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3131
{
3132
    num += (den >> 1);
3133
    if (num >= den) {
3134
        val += num / den;
3135
        num = num % den;
3136
    }
3137
    f->val = val;
3138
    f->num = num;
3139
    f->den = den;
3140
}
3141

    
3142
/**
3143
 * Set f to (val + 0.5).
3144
 */
3145
static void av_frac_set(AVFrac *f, int64_t val)
3146
{
3147
    f->val = val;
3148
    f->num = f->den >> 1;
3149
}
3150

    
3151
/**
3152
 * Fractionnal addition to f: f = f + (incr / f->den).
3153
 *
3154
 * @param f fractional number
3155
 * @param incr increment, can be positive or negative
3156
 */
3157
static void av_frac_add(AVFrac *f, int64_t incr)
3158
{
3159
    int64_t num, den;
3160

    
3161
    num = f->num + incr;
3162
    den = f->den;
3163
    if (num < 0) {
3164
        f->val += num / den;
3165
        num = num % den;
3166
        if (num < 0) {
3167
            num += den;
3168
            f->val--;
3169
        }
3170
    } else if (num >= den) {
3171
        f->val += num / den;
3172
        num = num % den;
3173
    }
3174
    f->num = num;
3175
}
3176

    
3177
/**
3178
 * register a new image format
3179
 * @param img_fmt Image format descriptor
3180
 */
3181
void av_register_image_format(AVImageFormat *img_fmt)
3182
{
3183
    AVImageFormat **p;
3184

    
3185
    p = &first_image_format;
3186
    while (*p != NULL) p = &(*p)->next;
3187
    *p = img_fmt;
3188
    img_fmt->next = NULL;
3189
}
3190

    
3191
/**
3192
 * Guesses image format based on data in the image.
3193
 */
3194
AVImageFormat *av_probe_image_format(AVProbeData *pd)
3195
{
3196
    AVImageFormat *fmt1, *fmt;
3197
    int score, score_max;
3198

    
3199
    fmt = NULL;
3200
    score_max = 0;
3201
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3202
        if (fmt1->img_probe) {
3203
            score = fmt1->img_probe(pd);
3204
            if (score > score_max) {
3205
                score_max = score;
3206
                fmt = fmt1;
3207
            }
3208
        }
3209
    }
3210
    return fmt;
3211
}
3212

    
3213
/**
3214
 * Guesses image format based on file name extensions.
3215
 */
3216
AVImageFormat *guess_image_format(const char *filename)
3217
{
3218
    AVImageFormat *fmt1;
3219

    
3220
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3221
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3222
            return fmt1;
3223
    }
3224
    return NULL;
3225
}
3226

    
3227
/**
3228
 * Read an image from a stream.
3229
 * @param gb byte stream containing the image
3230
 * @param fmt image format, NULL if probing is required
3231
 */
3232
int av_read_image(ByteIOContext *pb, const char *filename,
3233
                  AVImageFormat *fmt,
3234
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3235
{
3236
    uint8_t buf[PROBE_BUF_MIN];
3237
    AVProbeData probe_data, *pd = &probe_data;
3238
    offset_t pos;
3239
    int ret;
3240

    
3241
    if (!fmt) {
3242
        pd->filename = filename;
3243
        pd->buf = buf;
3244
        pos = url_ftell(pb);
3245
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3246
        url_fseek(pb, pos, SEEK_SET);
3247
        fmt = av_probe_image_format(pd);
3248
    }
3249
    if (!fmt)
3250
        return AVERROR_NOFMT;
3251
    ret = fmt->img_read(pb, alloc_cb, opaque);
3252
    return ret;
3253
}
3254

    
3255
/**
3256
 * Write an image to a stream.
3257
 * @param pb byte stream for the image output
3258
 * @param fmt image format
3259
 * @param img image data and informations
3260
 */
3261
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3262
{
3263
    return fmt->img_write(pb, img);
3264
}
3265