Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 30a43f2d

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

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

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

    
29
/** head of registered input format linked list. */
30
AVInputFormat *first_iformat = NULL;
31
/** head of registered output format linked list. */
32
AVOutputFormat *first_oformat = NULL;
33
/** head of registered image format linked list. */
34
AVImageFormat *first_image_format = NULL;
35

    
36
void av_register_input_format(AVInputFormat *format)
37
{
38
    AVInputFormat **p;
39
    p = &first_iformat;
40
    while (*p != NULL) p = &(*p)->next;
41
    *p = format;
42
    format->next = NULL;
43
}
44

    
45
void av_register_output_format(AVOutputFormat *format)
46
{
47
    AVOutputFormat **p;
48
    p = &first_oformat;
49
    while (*p != NULL) p = &(*p)->next;
50
    *p = format;
51
    format->next = NULL;
52
}
53

    
54
int match_ext(const char *filename, const char *extensions)
55
{
56
    const char *ext, *p;
57
    char ext1[32], *q;
58

    
59
    if(!filename)
60
        return 0;
61

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

    
81
AVOutputFormat *guess_format(const char *short_name, const char *filename,
82
                             const char *mime_type)
83
{
84
    AVOutputFormat *fmt, *fmt_found;
85
    int score_max, score;
86

    
87
    /* specific test for image sequences */
88
    if (!short_name && filename &&
89
        filename_number_test(filename) >= 0 &&
90
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
91
        return guess_format("image2", NULL, NULL);
92
    }
93
    if (!short_name && filename &&
94
        filename_number_test(filename) >= 0 &&
95
        guess_image_format(filename)) {
96
        return guess_format("image", NULL, NULL);
97
    }
98

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

    
122
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
123
                             const char *mime_type)
124
{
125
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
126

    
127
    if (fmt) {
128
        AVOutputFormat *stream_fmt;
129
        char stream_format_name[64];
130

    
131
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
132
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
133

    
134
        if (stream_fmt)
135
            fmt = stream_fmt;
136
    }
137

    
138
    return fmt;
139
}
140

    
141
/**
142
 * Guesses the codec id based upon muxer and filename.
143
 */
144
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
145
                            const char *filename, const char *mime_type, enum CodecType type){
146
    if(type == CODEC_TYPE_VIDEO){
147
        enum CodecID codec_id= CODEC_ID_NONE;
148

    
149
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
150
            codec_id= av_guess_image2_codec(filename);
151
        }
152
        if(codec_id == CODEC_ID_NONE)
153
            codec_id= fmt->video_codec;
154
        return codec_id;
155
    }else if(type == CODEC_TYPE_AUDIO)
156
        return fmt->audio_codec;
157
    else
158
        return CODEC_ID_NONE;
159
}
160

    
161
/**
162
 * finds AVInputFormat based on input format's short name.
163
 */
164
AVInputFormat *av_find_input_format(const char *short_name)
165
{
166
    AVInputFormat *fmt;
167
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
168
        if (!strcmp(fmt->name, short_name))
169
            return fmt;
170
    }
171
    return NULL;
172
}
173

    
174
/* memory handling */
175

    
176
/**
177
 * Default packet destructor.
178
 */
179
void av_destruct_packet(AVPacket *pkt)
180
{
181
    av_free(pkt->data);
182
    pkt->data = NULL; pkt->size = 0;
183
}
184

    
185
/**
186
 * Allocate the payload of a packet and intialized its fields to default values.
187
 *
188
 * @param pkt packet
189
 * @param size wanted payload size
190
 * @return 0 if OK. AVERROR_xxx otherwise.
191
 */
192
int av_new_packet(AVPacket *pkt, int size)
193
{
194
    void *data;
195
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
196
        return AVERROR_NOMEM;
197
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198
    if (!data)
199
        return AVERROR_NOMEM;
200
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
201

    
202
    av_init_packet(pkt);
203
    pkt->data = data;
204
    pkt->size = size;
205
    pkt->destruct = av_destruct_packet;
206
    return 0;
207
}
208

    
209
/**
210
 * Allocate and read the payload of a packet and intialized its fields to default values.
211
 *
212
 * @param pkt packet
213
 * @param size wanted payload size
214
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
215
 */
216
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
217
{
218
    int ret= av_new_packet(pkt, size);
219

    
220
    if(ret<0)
221
        return ret;
222

    
223
    pkt->pos= url_ftell(s);
224

    
225
    ret= get_buffer(s, pkt->data, size);
226
    if(ret<=0)
227
        av_free_packet(pkt);
228
    else
229
        pkt->size= ret;
230

    
231
    return ret;
232
}
233

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

    
256
/* fifo handling */
257

    
258
int fifo_init(FifoBuffer *f, int size)
259
{
260
    f->buffer = av_malloc(size);
261
    if (!f->buffer)
262
        return -1;
263
    f->end = f->buffer + size;
264
    f->wptr = f->rptr = f->buffer;
265
    return 0;
266
}
267

    
268
void fifo_free(FifoBuffer *f)
269
{
270
    av_free(f->buffer);
271
}
272

    
273
int fifo_size(FifoBuffer *f, uint8_t *rptr)
274
{
275
    int size;
276

    
277
    if(!rptr)
278
        rptr= f->rptr;
279

    
280
    if (f->wptr >= rptr) {
281
        size = f->wptr - rptr;
282
    } else {
283
        size = (f->end - rptr) + (f->wptr - f->buffer);
284
    }
285
    return size;
286
}
287

    
288
/**
289
 * Get data from the fifo (returns -1 if not enough data).
290
 */
291
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
292
{
293
    uint8_t *rptr;
294
    int size, len;
295

    
296
    if(!rptr_ptr)
297
        rptr_ptr= &f->rptr;
298
    rptr = *rptr_ptr;
299

    
300
    if (f->wptr >= rptr) {
301
        size = f->wptr - rptr;
302
    } else {
303
        size = (f->end - rptr) + (f->wptr - f->buffer);
304
    }
305

    
306
    if (size < buf_size)
307
        return -1;
308
    while (buf_size > 0) {
309
        len = f->end - rptr;
310
        if (len > buf_size)
311
            len = buf_size;
312
        memcpy(buf, rptr, len);
313
        buf += len;
314
        rptr += len;
315
        if (rptr >= f->end)
316
            rptr = f->buffer;
317
        buf_size -= len;
318
    }
319
    *rptr_ptr = rptr;
320
    return 0;
321
}
322

    
323
/**
324
 * Resizes a FIFO.
325
 */
326
void fifo_realloc(FifoBuffer *f, unsigned int new_size){
327
    unsigned int old_size= f->end - f->buffer;
328

    
329
    if(old_size < new_size){
330
        uint8_t *old= f->buffer;
331

    
332
        f->buffer= av_realloc(f->buffer, new_size);
333

    
334
        f->rptr += f->buffer - old;
335
        f->wptr += f->buffer - old;
336

    
337
        if(f->wptr < f->rptr){
338
            memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
339
            f->rptr += new_size - old_size;
340
        }
341
        f->end= f->buffer + new_size;
342
    }
343
}
344

    
345
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
346
{
347
    int len;
348
    uint8_t *wptr;
349

    
350
    if(!wptr_ptr)
351
        wptr_ptr= &f->wptr;
352
    wptr = *wptr_ptr;
353

    
354
    while (size > 0) {
355
        len = f->end - wptr;
356
        if (len > size)
357
            len = size;
358
        memcpy(wptr, buf, len);
359
        wptr += len;
360
        if (wptr >= f->end)
361
            wptr = f->buffer;
362
        buf += len;
363
        size -= len;
364
    }
365
    *wptr_ptr = wptr;
366
}
367

    
368
/* get data from the fifo (return -1 if not enough data) */
369
int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
370
{
371
    uint8_t *rptr = *rptr_ptr;
372
    int size, len;
373

    
374
    if (f->wptr >= rptr) {
375
        size = f->wptr - rptr;
376
    } else {
377
        size = (f->end - rptr) + (f->wptr - f->buffer);
378
    }
379

    
380
    if (size < buf_size)
381
        return -1;
382
    while (buf_size > 0) {
383
        len = f->end - rptr;
384
        if (len > buf_size)
385
            len = buf_size;
386
        put_buffer(pb, rptr, len);
387
        rptr += len;
388
        if (rptr >= f->end)
389
            rptr = f->buffer;
390
        buf_size -= len;
391
    }
392
    *rptr_ptr = rptr;
393
    return 0;
394
}
395

    
396
int filename_number_test(const char *filename)
397
{
398
    char buf[1024];
399
    if(!filename)
400
        return -1;
401
    return get_frame_filename(buf, sizeof(buf), filename, 1);
402
}
403

    
404
/**
405
 * Guess file format.
406
 */
407
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
408
{
409
    AVInputFormat *fmt1, *fmt;
410
    int score, score_max;
411

    
412
    fmt = NULL;
413
    score_max = 0;
414
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
415
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
416
            continue;
417
        score = 0;
418
        if (fmt1->read_probe) {
419
            score = fmt1->read_probe(pd);
420
        } else if (fmt1->extensions) {
421
            if (match_ext(pd->filename, fmt1->extensions)) {
422
                score = 50;
423
            }
424
        }
425
        if (score > score_max) {
426
            score_max = score;
427
            fmt = fmt1;
428
        }
429
    }
430
    return fmt;
431
}
432

    
433
/************************************************************/
434
/* input media file */
435

    
436
/**
437
 * Open a media file from an IO stream. 'fmt' must be specified.
438
 */
439
static const char* format_to_name(void* ptr)
440
{
441
    AVFormatContext* fc = (AVFormatContext*) ptr;
442
    if(fc->iformat) return fc->iformat->name;
443
    else if(fc->oformat) return fc->oformat->name;
444
    else return "NULL";
445
}
446

    
447
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
448

    
449
AVFormatContext *av_alloc_format_context(void)
450
{
451
    AVFormatContext *ic;
452
    ic = av_mallocz(sizeof(AVFormatContext));
453
    if (!ic) return ic;
454
    ic->av_class = &av_format_context_class;
455
    return ic;
456
}
457

    
458
/**
459
 * Allocates all the structures needed to read an input stream.
460
 *        This does not open the needed codecs for decoding the stream[s].
461
 */
462
int av_open_input_stream(AVFormatContext **ic_ptr,
463
                         ByteIOContext *pb, const char *filename,
464
                         AVInputFormat *fmt, AVFormatParameters *ap)
465
{
466
    int err;
467
    AVFormatContext *ic;
468

    
469
    ic = av_alloc_format_context();
470
    if (!ic) {
471
        err = AVERROR_NOMEM;
472
        goto fail;
473
    }
474
    ic->iformat = fmt;
475
    if (pb)
476
        ic->pb = *pb;
477
    ic->duration = AV_NOPTS_VALUE;
478
    ic->start_time = AV_NOPTS_VALUE;
479
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
480

    
481
    /* allocate private data */
482
    if (fmt->priv_data_size > 0) {
483
        ic->priv_data = av_mallocz(fmt->priv_data_size);
484
        if (!ic->priv_data) {
485
            err = AVERROR_NOMEM;
486
            goto fail;
487
        }
488
    } else {
489
        ic->priv_data = NULL;
490
    }
491

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

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

    
499
    *ic_ptr = ic;
500
    return 0;
501
 fail:
502
    if (ic) {
503
        av_freep(&ic->priv_data);
504
    }
505
    av_free(ic);
506
    *ic_ptr = NULL;
507
    return err;
508
}
509

    
510
/** Size of probe buffer, for guessing file type from file contents. */
511
#define PROBE_BUF_MIN 2048
512
#define PROBE_BUF_MAX 131072
513

    
514
/**
515
 * Open a media file as input. The codec are not opened. Only the file
516
 * header (if present) is read.
517
 *
518
 * @param ic_ptr the opened media file handle is put here
519
 * @param filename filename to open.
520
 * @param fmt if non NULL, force the file format to use
521
 * @param buf_size optional buffer size (zero if default is OK)
522
 * @param ap additionnal parameters needed when opening the file (NULL if default)
523
 * @return 0 if OK. AVERROR_xxx otherwise.
524
 */
525
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
526
                       AVInputFormat *fmt,
527
                       int buf_size,
528
                       AVFormatParameters *ap)
529
{
530
    int err, must_open_file, file_opened, probe_size;
531
    AVProbeData probe_data, *pd = &probe_data;
532
    ByteIOContext pb1, *pb = &pb1;
533

    
534
    file_opened = 0;
535
    pd->filename = "";
536
    if (filename)
537
        pd->filename = filename;
538
    pd->buf = NULL;
539
    pd->buf_size = 0;
540

    
541
    if (!fmt) {
542
        /* guess format if no file can be opened  */
543
        fmt = av_probe_input_format(pd, 0);
544
    }
545

    
546
    /* do not open file if the format does not need it. XXX: specific
547
       hack needed to handle RTSP/TCP */
548
    must_open_file = 1;
549
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
550
        must_open_file = 0;
551
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
552
    }
553

    
554
    if (!fmt || must_open_file) {
555
        /* if no file needed do not try to open one */
556
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
557
            err = AVERROR_IO;
558
            goto fail;
559
        }
560
        file_opened = 1;
561
        if (buf_size > 0) {
562
            url_setbufsize(pb, buf_size);
563
        }
564

    
565
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
566
            /* read probe data */
567
            pd->buf= av_realloc(pd->buf, probe_size);
568
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
569
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
570
                url_fclose(pb);
571
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
572
                    file_opened = 0;
573
                    err = AVERROR_IO;
574
                    goto fail;
575
                }
576
            }
577
            /* guess file format */
578
            fmt = av_probe_input_format(pd, 1);
579
        }
580
        av_freep(&pd->buf);
581
    }
582

    
583
    /* if still no format found, error */
584
    if (!fmt) {
585
        err = AVERROR_NOFMT;
586
        goto fail;
587
    }
588

    
589
    /* XXX: suppress this hack for redirectors */
590
#ifdef CONFIG_NETWORK
591
    if (fmt == &redir_demux) {
592
        err = redir_open(ic_ptr, pb);
593
        url_fclose(pb);
594
        return err;
595
    }
596
#endif
597

    
598
    /* check filename in case of an image number is expected */
599
    if (fmt->flags & AVFMT_NEEDNUMBER) {
600
        if (filename_number_test(filename) < 0) {
601
            err = AVERROR_NUMEXPECTED;
602
            goto fail;
603
        }
604
    }
605
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
606
    if (err)
607
        goto fail;
608
    return 0;
609
 fail:
610
    av_freep(&pd->buf);
611
    if (file_opened)
612
        url_fclose(pb);
613
    *ic_ptr = NULL;
614
    return err;
615

    
616
}
617

    
618
/*******************************************************/
619

    
620
/**
621
 * Read a transport packet from a media file.
622
 *
623
 * This function is absolete and should never be used.
624
 * Use av_read_frame() instead.
625
 *
626
 * @param s media file handle
627
 * @param pkt is filled
628
 * @return 0 if OK. AVERROR_xxx if error.
629
 */
630
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
631
{
632
    return s->iformat->read_packet(s, pkt);
633
}
634

    
635
/**********************************************************/
636

    
637
/**
638
 * Get the number of samples of an audio frame. Return (-1) if error.
639
 */
640
static int get_audio_frame_size(AVCodecContext *enc, int size)
641
{
642
    int frame_size;
643

    
644
    if (enc->frame_size <= 1) {
645
        /* specific hack for pcm codecs because no frame size is
646
           provided */
647
        switch(enc->codec_id) {
648
        case CODEC_ID_PCM_S32LE:
649
        case CODEC_ID_PCM_S32BE:
650
        case CODEC_ID_PCM_U32LE:
651
        case CODEC_ID_PCM_U32BE:
652
            if (enc->channels == 0)
653
                return -1;
654
            frame_size = size / (4 * enc->channels);
655
            break;
656
        case CODEC_ID_PCM_S24LE:
657
        case CODEC_ID_PCM_S24BE:
658
        case CODEC_ID_PCM_U24LE:
659
        case CODEC_ID_PCM_U24BE:
660
        case CODEC_ID_PCM_S24DAUD:
661
            if (enc->channels == 0)
662
                return -1;
663
            frame_size = size / (3 * enc->channels);
664
            break;
665
        case CODEC_ID_PCM_S16LE:
666
        case CODEC_ID_PCM_S16BE:
667
        case CODEC_ID_PCM_U16LE:
668
        case CODEC_ID_PCM_U16BE:
669
            if (enc->channels == 0)
670
                return -1;
671
            frame_size = size / (2 * enc->channels);
672
            break;
673
        case CODEC_ID_PCM_S8:
674
        case CODEC_ID_PCM_U8:
675
        case CODEC_ID_PCM_MULAW:
676
        case CODEC_ID_PCM_ALAW:
677
            if (enc->channels == 0)
678
                return -1;
679
            frame_size = size / (enc->channels);
680
            break;
681
        default:
682
            /* used for example by ADPCM codecs */
683
            if (enc->bit_rate == 0)
684
                return -1;
685
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
686
            break;
687
        }
688
    } else {
689
        frame_size = enc->frame_size;
690
    }
691
    return frame_size;
692
}
693

    
694

    
695
/**
696
 * Return the frame duration in seconds, return 0 if not available.
697
 */
698
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
699
                                   AVCodecParserContext *pc, AVPacket *pkt)
700
{
701
    int frame_size;
702

    
703
    *pnum = 0;
704
    *pden = 0;
705
    switch(st->codec->codec_type) {
706
    case CODEC_TYPE_VIDEO:
707
        if(st->time_base.num*1000LL > st->time_base.den){
708
            *pnum = st->time_base.num;
709
            *pden = st->time_base.den;
710
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
711
            *pnum = st->codec->time_base.num;
712
            *pden = st->codec->time_base.den;
713
            if (pc && pc->repeat_pict) {
714
                *pden *= 2;
715
                *pnum = (*pnum) * (2 + pc->repeat_pict);
716
            }
717
        }
718
        break;
719
    case CODEC_TYPE_AUDIO:
720
        frame_size = get_audio_frame_size(st->codec, pkt->size);
721
        if (frame_size < 0)
722
            break;
723
        *pnum = frame_size;
724
        *pden = st->codec->sample_rate;
725
        break;
726
    default:
727
        break;
728
    }
729
}
730

    
731
static int is_intra_only(AVCodecContext *enc){
732
    if(enc->codec_type == CODEC_TYPE_AUDIO){
733
        return 1;
734
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
735
        switch(enc->codec_id){
736
        case CODEC_ID_MJPEG:
737
        case CODEC_ID_MJPEGB:
738
        case CODEC_ID_LJPEG:
739
        case CODEC_ID_RAWVIDEO:
740
        case CODEC_ID_DVVIDEO:
741
        case CODEC_ID_HUFFYUV:
742
        case CODEC_ID_FFVHUFF:
743
        case CODEC_ID_ASV1:
744
        case CODEC_ID_ASV2:
745
        case CODEC_ID_VCR1:
746
            return 1;
747
        default: break;
748
        }
749
    }
750
    return 0;
751
}
752

    
753
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
754
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
755
    int64_t delta= last_ts - mask/2;
756
    return  ((lsb - delta)&mask) + delta;
757
}
758

    
759
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
760
                               AVCodecParserContext *pc, AVPacket *pkt)
761
{
762
    int num, den, presentation_delayed;
763
    /* handle wrapping */
764
    if(st->cur_dts != AV_NOPTS_VALUE){
765
        if(pkt->pts != AV_NOPTS_VALUE)
766
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
767
        if(pkt->dts != AV_NOPTS_VALUE)
768
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
769
    }
770

    
771
    if (pkt->duration == 0) {
772
        compute_frame_duration(&num, &den, st, pc, pkt);
773
        if (den && num) {
774
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
775
        }
776
    }
777

    
778
    if(is_intra_only(st->codec))
779
        pkt->flags |= PKT_FLAG_KEY;
780

    
781
    /* do we have a video B frame ? */
782
    presentation_delayed = 0;
783
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
784
        /* XXX: need has_b_frame, but cannot get it if the codec is
785
           not initialized */
786
        if ((   st->codec->codec_id == CODEC_ID_H264
787
             || st->codec->has_b_frames) &&
788
            pc && pc->pict_type != FF_B_TYPE)
789
            presentation_delayed = 1;
790
        /* this may be redundant, but it shouldnt hurt */
791
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
792
            presentation_delayed = 1;
793
    }
794

    
795
    if(st->cur_dts == AV_NOPTS_VALUE){
796
        if(presentation_delayed) st->cur_dts = -pkt->duration;
797
        else                     st->cur_dts = 0;
798
    }
799

    
800
//    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);
801
    /* interpolate PTS and DTS if they are not present */
802
    if (presentation_delayed) {
803
        /* DTS = decompression time stamp */
804
        /* PTS = presentation time stamp */
805
        if (pkt->dts == AV_NOPTS_VALUE) {
806
            /* if we know the last pts, use it */
807
            if(st->last_IP_pts != AV_NOPTS_VALUE)
808
                st->cur_dts = pkt->dts = st->last_IP_pts;
809
            else
810
                pkt->dts = st->cur_dts;
811
        } else {
812
            st->cur_dts = pkt->dts;
813
        }
814
        /* this is tricky: the dts must be incremented by the duration
815
           of the frame we are displaying, i.e. the last I or P frame */
816
        if (st->last_IP_duration == 0)
817
            st->cur_dts += pkt->duration;
818
        else
819
            st->cur_dts += st->last_IP_duration;
820
        st->last_IP_duration  = pkt->duration;
821
        st->last_IP_pts= pkt->pts;
822
        /* cannot compute PTS if not present (we can compute it only
823
           by knowing the futur */
824
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
825
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
826
            int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
827
            int64_t new_diff= ABS(st->cur_dts - pkt->pts);
828
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
829
                pkt->pts += pkt->duration;
830
//                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);
831
            }
832
        }
833

    
834
        /* presentation is not delayed : PTS and DTS are the same */
835
        if (pkt->pts == AV_NOPTS_VALUE) {
836
            if (pkt->dts == AV_NOPTS_VALUE) {
837
                pkt->pts = st->cur_dts;
838
                pkt->dts = st->cur_dts;
839
            }
840
            else {
841
                st->cur_dts = pkt->dts;
842
                pkt->pts = pkt->dts;
843
            }
844
        } else {
845
            st->cur_dts = pkt->pts;
846
            pkt->dts = pkt->pts;
847
        }
848
        st->cur_dts += pkt->duration;
849
    }
850
//    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);
851

    
852
    /* update flags */
853
    if (pc) {
854
        pkt->flags = 0;
855
        /* key frame computation */
856
        switch(st->codec->codec_type) {
857
        case CODEC_TYPE_VIDEO:
858
            if (pc->pict_type == FF_I_TYPE)
859
                pkt->flags |= PKT_FLAG_KEY;
860
            break;
861
        case CODEC_TYPE_AUDIO:
862
            pkt->flags |= PKT_FLAG_KEY;
863
            break;
864
        default:
865
            break;
866
        }
867
    }
868
}
869

    
870
void av_destruct_packet_nofree(AVPacket *pkt)
871
{
872
    pkt->data = NULL; pkt->size = 0;
873
}
874

    
875
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
876
{
877
    AVStream *st;
878
    int len, ret, i;
879

    
880
    for(;;) {
881
        /* select current input stream component */
882
        st = s->cur_st;
883
        if (st) {
884
            if (!st->need_parsing || !st->parser) {
885
                /* no parsing needed: we just output the packet as is */
886
                /* raw data support */
887
                *pkt = s->cur_pkt;
888
                compute_pkt_fields(s, st, NULL, pkt);
889
                s->cur_st = NULL;
890
                return 0;
891
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
892
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
893
                                      s->cur_ptr, s->cur_len,
894
                                      s->cur_pkt.pts, s->cur_pkt.dts);
895
                s->cur_pkt.pts = AV_NOPTS_VALUE;
896
                s->cur_pkt.dts = AV_NOPTS_VALUE;
897
                /* increment read pointer */
898
                s->cur_ptr += len;
899
                s->cur_len -= len;
900

    
901
                /* return packet if any */
902
                if (pkt->size) {
903
                got_packet:
904
                    pkt->duration = 0;
905
                    pkt->stream_index = st->index;
906
                    pkt->pts = st->parser->pts;
907
                    pkt->dts = st->parser->dts;
908
                    pkt->destruct = av_destruct_packet_nofree;
909
                    compute_pkt_fields(s, st, st->parser, pkt);
910
                    return 0;
911
                }
912
            } else {
913
                /* free packet */
914
                av_free_packet(&s->cur_pkt);
915
                s->cur_st = NULL;
916
            }
917
        } else {
918
            /* read next packet */
919
            ret = av_read_packet(s, &s->cur_pkt);
920
            if (ret < 0) {
921
                if (ret == -EAGAIN)
922
                    return ret;
923
                /* return the last frames, if any */
924
                for(i = 0; i < s->nb_streams; i++) {
925
                    st = s->streams[i];
926
                    if (st->parser && st->need_parsing) {
927
                        av_parser_parse(st->parser, st->codec,
928
                                        &pkt->data, &pkt->size,
929
                                        NULL, 0,
930
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
931
                        if (pkt->size)
932
                            goto got_packet;
933
                    }
934
                }
935
                /* no more packets: really terminates parsing */
936
                return ret;
937
            }
938

    
939
            st = s->streams[s->cur_pkt.stream_index];
940

    
941
            s->cur_st = st;
942
            s->cur_ptr = s->cur_pkt.data;
943
            s->cur_len = s->cur_pkt.size;
944
            if (st->need_parsing && !st->parser) {
945
                st->parser = av_parser_init(st->codec->codec_id);
946
                if (!st->parser) {
947
                    /* no parser available : just output the raw packets */
948
                    st->need_parsing = 0;
949
                }else if(st->need_parsing == 2){
950
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
951
                }
952
            }
953
        }
954
    }
955
}
956

    
957
/**
958
 * Return the next frame of a stream.
959
 *
960
 * The returned packet is valid
961
 * until the next av_read_frame() or until av_close_input_file() and
962
 * must be freed with av_free_packet. For video, the packet contains
963
 * exactly one frame. For audio, it contains an integer number of
964
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
965
 * data). If the audio frames have a variable size (e.g. MPEG audio),
966
 * then it contains one frame.
967
 *
968
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
969
 * values in AV_TIME_BASE unit (and guessed if the format cannot
970
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
971
 * has B frames, so it is better to rely on pkt->dts if you do not
972
 * decompress the payload.
973
 *
974
 * @return 0 if OK, < 0 if error or end of file.
975
 */
976
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
977
{
978
    AVPacketList *pktl;
979
    int eof=0;
980
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
981

    
982
    for(;;){
983
        pktl = s->packet_buffer;
984
        if (pktl) {
985
            AVPacket *next_pkt= &pktl->pkt;
986

    
987
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
988
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
989
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
990
                       && next_pkt->dts < pktl->pkt.dts
991
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
992
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
993
                        next_pkt->pts= pktl->pkt.dts;
994
                    }
995
                    pktl= pktl->next;
996
                }
997
                pktl = s->packet_buffer;
998
            }
999

    
1000
            if(   next_pkt->pts != AV_NOPTS_VALUE
1001
               || next_pkt->dts == AV_NOPTS_VALUE
1002
               || !genpts || eof){
1003
                /* read packet from packet buffer, if there is data */
1004
                *pkt = *next_pkt;
1005
                s->packet_buffer = pktl->next;
1006
                av_free(pktl);
1007
                return 0;
1008
            }
1009
        }
1010
        if(genpts){
1011
            AVPacketList **plast_pktl= &s->packet_buffer;
1012
            int ret= av_read_frame_internal(s, pkt);
1013
            if(ret<0){
1014
                if(pktl && ret != -EAGAIN){
1015
                    eof=1;
1016
                    continue;
1017
                }else
1018
                    return ret;
1019
            }
1020

    
1021
            /* duplicate the packet */
1022
            if (av_dup_packet(pkt) < 0)
1023
                return AVERROR_NOMEM;
1024

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

    
1027
            pktl = av_mallocz(sizeof(AVPacketList));
1028
            if (!pktl)
1029
                return AVERROR_NOMEM;
1030

    
1031
            /* add the packet in the buffered packet list */
1032
            *plast_pktl = pktl;
1033
            pktl->pkt= *pkt;
1034
        }else{
1035
            assert(!s->packet_buffer);
1036
            return av_read_frame_internal(s, pkt);
1037
        }
1038
    }
1039
}
1040

    
1041
/* XXX: suppress the packet queue */
1042
static void flush_packet_queue(AVFormatContext *s)
1043
{
1044
    AVPacketList *pktl;
1045

    
1046
    for(;;) {
1047
        pktl = s->packet_buffer;
1048
        if (!pktl)
1049
            break;
1050
        s->packet_buffer = pktl->next;
1051
        av_free_packet(&pktl->pkt);
1052
        av_free(pktl);
1053
    }
1054
}
1055

    
1056
/*******************************************************/
1057
/* seek support */
1058

    
1059
int av_find_default_stream_index(AVFormatContext *s)
1060
{
1061
    int i;
1062
    AVStream *st;
1063

    
1064
    if (s->nb_streams <= 0)
1065
        return -1;
1066
    for(i = 0; i < s->nb_streams; i++) {
1067
        st = s->streams[i];
1068
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1069
            return i;
1070
        }
1071
    }
1072
    return 0;
1073
}
1074

    
1075
/**
1076
 * Flush the frame reader.
1077
 */
1078
static void av_read_frame_flush(AVFormatContext *s)
1079
{
1080
    AVStream *st;
1081
    int i;
1082

    
1083
    flush_packet_queue(s);
1084

    
1085
    /* free previous packet */
1086
    if (s->cur_st) {
1087
        if (s->cur_st->parser)
1088
            av_free_packet(&s->cur_pkt);
1089
        s->cur_st = NULL;
1090
    }
1091
    /* fail safe */
1092
    s->cur_ptr = NULL;
1093
    s->cur_len = 0;
1094

    
1095
    /* for each stream, reset read state */
1096
    for(i = 0; i < s->nb_streams; i++) {
1097
        st = s->streams[i];
1098

    
1099
        if (st->parser) {
1100
            av_parser_close(st->parser);
1101
            st->parser = NULL;
1102
        }
1103
        st->last_IP_pts = AV_NOPTS_VALUE;
1104
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1105
    }
1106
}
1107

    
1108
/**
1109
 * Updates cur_dts of all streams based on given timestamp and AVStream.
1110
 *
1111
 * Stream ref_st unchanged, others set cur_dts in their native timebase
1112
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1113
 * @param timestamp new dts expressed in time_base of param ref_st
1114
 * @param ref_st reference stream giving time_base of param timestamp
1115
 */
1116
static void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1117
    int i;
1118

    
1119
    for(i = 0; i < s->nb_streams; i++) {
1120
        AVStream *st = s->streams[i];
1121

    
1122
        st->cur_dts = av_rescale(timestamp,
1123
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1124
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1125
    }
1126
}
1127

    
1128
/**
1129
 * Add a index entry into a sorted list updateing if it is already there.
1130
 *
1131
 * @param timestamp timestamp in the timebase of the given stream
1132
 */
1133
int av_add_index_entry(AVStream *st,
1134
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1135
{
1136
    AVIndexEntry *entries, *ie;
1137
    int index;
1138

    
1139
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1140
        return -1;
1141

    
1142
    entries = av_fast_realloc(st->index_entries,
1143
                              &st->index_entries_allocated_size,
1144
                              (st->nb_index_entries + 1) *
1145
                              sizeof(AVIndexEntry));
1146
    if(!entries)
1147
        return -1;
1148

    
1149
    st->index_entries= entries;
1150

    
1151
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1152

    
1153
    if(index<0){
1154
        index= st->nb_index_entries++;
1155
        ie= &entries[index];
1156
        assert(index==0 || ie[-1].timestamp < timestamp);
1157
    }else{
1158
        ie= &entries[index];
1159
        if(ie->timestamp != timestamp){
1160
            if(ie->timestamp <= timestamp)
1161
                return -1;
1162
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1163
            st->nb_index_entries++;
1164
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1165
            distance= ie->min_distance;
1166
    }
1167

    
1168
    ie->pos = pos;
1169
    ie->timestamp = timestamp;
1170
    ie->min_distance= distance;
1171
    ie->size= size;
1172
    ie->flags = flags;
1173

    
1174
    return index;
1175
}
1176

    
1177
/**
1178
 * build an index for raw streams using a parser.
1179
 */
1180
static void av_build_index_raw(AVFormatContext *s)
1181
{
1182
    AVPacket pkt1, *pkt = &pkt1;
1183
    int ret;
1184
    AVStream *st;
1185

    
1186
    st = s->streams[0];
1187
    av_read_frame_flush(s);
1188
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1189

    
1190
    for(;;) {
1191
        ret = av_read_frame(s, pkt);
1192
        if (ret < 0)
1193
            break;
1194
        if (pkt->stream_index == 0 && st->parser &&
1195
            (pkt->flags & PKT_FLAG_KEY)) {
1196
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1197
                            0, 0, AVINDEX_KEYFRAME);
1198
        }
1199
        av_free_packet(pkt);
1200
    }
1201
}
1202

    
1203
/**
1204
 * Returns TRUE if we deal with a raw stream.
1205
 *
1206
 * Raw codec data and parsing needed.
1207
 */
1208
static int is_raw_stream(AVFormatContext *s)
1209
{
1210
    AVStream *st;
1211

    
1212
    if (s->nb_streams != 1)
1213
        return 0;
1214
    st = s->streams[0];
1215
    if (!st->need_parsing)
1216
        return 0;
1217
    return 1;
1218
}
1219

    
1220
/**
1221
 * Gets the index for a specific timestamp.
1222
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1223
 *                 the timestamp which is <= the requested one, if backward is 0
1224
 *                 then it will be >=
1225
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1226
 * @return < 0 if no such timestamp could be found
1227
 */
1228
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1229
                              int flags)
1230
{
1231
    AVIndexEntry *entries= st->index_entries;
1232
    int nb_entries= st->nb_index_entries;
1233
    int a, b, m;
1234
    int64_t timestamp;
1235

    
1236
    a = - 1;
1237
    b = nb_entries;
1238

    
1239
    while (b - a > 1) {
1240
        m = (a + b) >> 1;
1241
        timestamp = entries[m].timestamp;
1242
        if(timestamp >= wanted_timestamp)
1243
            b = m;
1244
        if(timestamp <= wanted_timestamp)
1245
            a = m;
1246
    }
1247
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1248

    
1249
    if(!(flags & AVSEEK_FLAG_ANY)){
1250
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1251
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1252
        }
1253
    }
1254

    
1255
    if(m == nb_entries)
1256
        return -1;
1257
    return  m;
1258
}
1259

    
1260
#define DEBUG_SEEK
1261

    
1262
/**
1263
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1264
 * this isnt supposed to be called directly by a user application, but by demuxers
1265
 * @param target_ts target timestamp in the time base of the given stream
1266
 * @param stream_index stream number
1267
 */
1268
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1269
    AVInputFormat *avif= s->iformat;
1270
    int64_t pos_min, pos_max, pos, pos_limit;
1271
    int64_t ts_min, ts_max, ts;
1272
    int64_t start_pos, filesize;
1273
    int index, no_change;
1274
    AVStream *st;
1275

    
1276
    if (stream_index < 0)
1277
        return -1;
1278

    
1279
#ifdef DEBUG_SEEK
1280
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1281
#endif
1282

    
1283
    ts_max=
1284
    ts_min= AV_NOPTS_VALUE;
1285
    pos_limit= -1; //gcc falsely says it may be uninitalized
1286

    
1287
    st= s->streams[stream_index];
1288
    if(st->index_entries){
1289
        AVIndexEntry *e;
1290

    
1291
        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()
1292
        index= FFMAX(index, 0);
1293
        e= &st->index_entries[index];
1294

    
1295
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1296
            pos_min= e->pos;
1297
            ts_min= e->timestamp;
1298
#ifdef DEBUG_SEEK
1299
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1300
               pos_min,ts_min);
1301
#endif
1302
        }else{
1303
            assert(index==0);
1304
        }
1305

    
1306
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1307
        assert(index < st->nb_index_entries);
1308
        if(index >= 0){
1309
            e= &st->index_entries[index];
1310
            assert(e->timestamp >= target_ts);
1311
            pos_max= e->pos;
1312
            ts_max= e->timestamp;
1313
            pos_limit= pos_max - e->min_distance;
1314
#ifdef DEBUG_SEEK
1315
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1316
               pos_max,pos_limit, ts_max);
1317
#endif
1318
        }
1319
    }
1320

    
1321
    if(ts_min == AV_NOPTS_VALUE){
1322
        pos_min = s->data_offset;
1323
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1324
        if (ts_min == AV_NOPTS_VALUE)
1325
            return -1;
1326
    }
1327

    
1328
    if(ts_max == AV_NOPTS_VALUE){
1329
        int step= 1024;
1330
        filesize = url_fsize(&s->pb);
1331
        pos_max = filesize - 1;
1332
        do{
1333
            pos_max -= step;
1334
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1335
            step += step;
1336
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1337
        if (ts_max == AV_NOPTS_VALUE)
1338
            return -1;
1339

    
1340
        for(;;){
1341
            int64_t tmp_pos= pos_max + 1;
1342
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1343
            if(tmp_ts == AV_NOPTS_VALUE)
1344
                break;
1345
            ts_max= tmp_ts;
1346
            pos_max= tmp_pos;
1347
            if(tmp_pos >= filesize)
1348
                break;
1349
        }
1350
        pos_limit= pos_max;
1351
    }
1352

    
1353
    if(ts_min > ts_max){
1354
        return -1;
1355
    }else if(ts_min == ts_max){
1356
        pos_limit= pos_min;
1357
    }
1358

    
1359
    no_change=0;
1360
    while (pos_min < pos_limit) {
1361
#ifdef DEBUG_SEEK
1362
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1363
               pos_min, pos_max,
1364
               ts_min, ts_max);
1365
#endif
1366
        assert(pos_limit <= pos_max);
1367

    
1368
        if(no_change==0){
1369
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1370
            // interpolate position (better than dichotomy)
1371
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1372
                + pos_min - approximate_keyframe_distance;
1373
        }else if(no_change==1){
1374
            // bisection, if interpolation failed to change min or max pos last time
1375
            pos = (pos_min + pos_limit)>>1;
1376
        }else{
1377
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1378
            pos=pos_min;
1379
        }
1380
        if(pos <= pos_min)
1381
            pos= pos_min + 1;
1382
        else if(pos > pos_limit)
1383
            pos= pos_limit;
1384
        start_pos= pos;
1385

    
1386
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1387
        if(pos == pos_max)
1388
            no_change++;
1389
        else
1390
            no_change=0;
1391
#ifdef DEBUG_SEEK
1392
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);
1393
#endif
1394
        assert(ts != AV_NOPTS_VALUE);
1395
        if (target_ts <= ts) {
1396
            pos_limit = start_pos - 1;
1397
            pos_max = pos;
1398
            ts_max = ts;
1399
        }
1400
        if (target_ts >= ts) {
1401
            pos_min = pos;
1402
            ts_min = ts;
1403
        }
1404
    }
1405

    
1406
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1407
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1408
#ifdef DEBUG_SEEK
1409
    pos_min = pos;
1410
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1411
    pos_min++;
1412
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1413
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1414
           pos, ts_min, target_ts, ts_max);
1415
#endif
1416
    /* do the seek */
1417
    url_fseek(&s->pb, pos, SEEK_SET);
1418

    
1419
    av_update_cur_dts(s, st, ts);
1420

    
1421
    return 0;
1422
}
1423

    
1424
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1425
    int64_t pos_min, pos_max;
1426
#if 0
1427
    AVStream *st;
1428

1429
    if (stream_index < 0)
1430
        return -1;
1431

1432
    st= s->streams[stream_index];
1433
#endif
1434

    
1435
    pos_min = s->data_offset;
1436
    pos_max = url_fsize(&s->pb) - 1;
1437

    
1438
    if     (pos < pos_min) pos= pos_min;
1439
    else if(pos > pos_max) pos= pos_max;
1440

    
1441
    url_fseek(&s->pb, pos, SEEK_SET);
1442

    
1443
#if 0
1444
    av_update_cur_dts(s, st, ts);
1445
#endif
1446
    return 0;
1447
}
1448

    
1449
static int av_seek_frame_generic(AVFormatContext *s,
1450
                                 int stream_index, int64_t timestamp, int flags)
1451
{
1452
    int index;
1453
    AVStream *st;
1454
    AVIndexEntry *ie;
1455

    
1456
    if (!s->index_built) {
1457
        if (is_raw_stream(s)) {
1458
            av_build_index_raw(s);
1459
        } else {
1460
            return -1;
1461
        }
1462
        s->index_built = 1;
1463
    }
1464

    
1465
    st = s->streams[stream_index];
1466
    index = av_index_search_timestamp(st, timestamp, flags);
1467
    if (index < 0)
1468
        return -1;
1469

    
1470
    /* now we have found the index, we can seek */
1471
    ie = &st->index_entries[index];
1472
    av_read_frame_flush(s);
1473
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1474

    
1475
    av_update_cur_dts(s, st, ie->timestamp);
1476

    
1477
    return 0;
1478
}
1479

    
1480
/**
1481
 * Seek to the key frame at timestamp.
1482
 * 'timestamp' in 'stream_index'.
1483
 * @param stream_index If stream_index is (-1), a default
1484
 * stream is selected, and timestamp is automatically converted
1485
 * from AV_TIME_BASE units to the stream specific time_base.
1486
 * @param timestamp timestamp in AVStream.time_base units
1487
 *        or if there is no stream specified then in AV_TIME_BASE units
1488
 * @param flags flags which select direction and seeking mode
1489
 * @return >= 0 on success
1490
 */
1491
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1492
{
1493
    int ret;
1494
    AVStream *st;
1495

    
1496
    av_read_frame_flush(s);
1497

    
1498
    if(flags & AVSEEK_FLAG_BYTE)
1499
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1500

    
1501
    if(stream_index < 0){
1502
        stream_index= av_find_default_stream_index(s);
1503
        if(stream_index < 0)
1504
            return -1;
1505

    
1506
        st= s->streams[stream_index];
1507
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1508
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1509
    }
1510
    st= s->streams[stream_index];
1511

    
1512
    /* first, we try the format specific seek */
1513
    if (s->iformat->read_seek)
1514
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1515
    else
1516
        ret = -1;
1517
    if (ret >= 0) {
1518
        return 0;
1519
    }
1520

    
1521
    if(s->iformat->read_timestamp)
1522
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1523
    else
1524
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1525
}
1526

    
1527
/*******************************************************/
1528

    
1529
/**
1530
 * Returns TRUE if the stream has accurate timings in any stream.
1531
 *
1532
 * @return TRUE if the stream has accurate timings for at least one component.
1533
 */
1534
static int av_has_timings(AVFormatContext *ic)
1535
{
1536
    int i;
1537
    AVStream *st;
1538

    
1539
    for(i = 0;i < ic->nb_streams; i++) {
1540
        st = ic->streams[i];
1541
        if (st->start_time != AV_NOPTS_VALUE &&
1542
            st->duration != AV_NOPTS_VALUE)
1543
            return 1;
1544
    }
1545
    return 0;
1546
}
1547

    
1548
/**
1549
 * Estimate the stream timings from the one of each components.
1550
 *
1551
 * Also computes the global bitrate if possible.
1552
 */
1553
static void av_update_stream_timings(AVFormatContext *ic)
1554
{
1555
    int64_t start_time, start_time1, end_time, end_time1;
1556
    int i;
1557
    AVStream *st;
1558

    
1559
    start_time = MAXINT64;
1560
    end_time = MININT64;
1561
    for(i = 0;i < ic->nb_streams; i++) {
1562
        st = ic->streams[i];
1563
        if (st->start_time != AV_NOPTS_VALUE) {
1564
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1565
            if (start_time1 < start_time)
1566
                start_time = start_time1;
1567
            if (st->duration != AV_NOPTS_VALUE) {
1568
                end_time1 = start_time1
1569
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1570
                if (end_time1 > end_time)
1571
                    end_time = end_time1;
1572
            }
1573
        }
1574
    }
1575
    if (start_time != MAXINT64) {
1576
        ic->start_time = start_time;
1577
        if (end_time != MININT64) {
1578
            ic->duration = end_time - start_time;
1579
            if (ic->file_size > 0) {
1580
                /* compute the bit rate */
1581
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1582
                    (double)ic->duration;
1583
            }
1584
        }
1585
    }
1586

    
1587
}
1588

    
1589
static void fill_all_stream_timings(AVFormatContext *ic)
1590
{
1591
    int i;
1592
    AVStream *st;
1593

    
1594
    av_update_stream_timings(ic);
1595
    for(i = 0;i < ic->nb_streams; i++) {
1596
        st = ic->streams[i];
1597
        if (st->start_time == AV_NOPTS_VALUE) {
1598
            if(ic->start_time != AV_NOPTS_VALUE)
1599
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1600
            if(ic->duration != AV_NOPTS_VALUE)
1601
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1602
        }
1603
    }
1604
}
1605

    
1606
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1607
{
1608
    int64_t filesize, duration;
1609
    int bit_rate, i;
1610
    AVStream *st;
1611

    
1612
    /* if bit_rate is already set, we believe it */
1613
    if (ic->bit_rate == 0) {
1614
        bit_rate = 0;
1615
        for(i=0;i<ic->nb_streams;i++) {
1616
            st = ic->streams[i];
1617
            bit_rate += st->codec->bit_rate;
1618
        }
1619
        ic->bit_rate = bit_rate;
1620
    }
1621

    
1622
    /* if duration is already set, we believe it */
1623
    if (ic->duration == AV_NOPTS_VALUE &&
1624
        ic->bit_rate != 0 &&
1625
        ic->file_size != 0)  {
1626
        filesize = ic->file_size;
1627
        if (filesize > 0) {
1628
            for(i = 0; i < ic->nb_streams; i++) {
1629
                st = ic->streams[i];
1630
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1631
                if (st->start_time == AV_NOPTS_VALUE ||
1632
                    st->duration == AV_NOPTS_VALUE) {
1633
                    st->start_time = 0;
1634
                    st->duration = duration;
1635
                }
1636
            }
1637
        }
1638
    }
1639
}
1640

    
1641
#define DURATION_MAX_READ_SIZE 250000
1642

    
1643
/* only usable for MPEG-PS streams */
1644
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1645
{
1646
    AVPacket pkt1, *pkt = &pkt1;
1647
    AVStream *st;
1648
    int read_size, i, ret;
1649
    int64_t end_time;
1650
    int64_t filesize, offset, duration;
1651

    
1652
    /* free previous packet */
1653
    if (ic->cur_st && ic->cur_st->parser)
1654
        av_free_packet(&ic->cur_pkt);
1655
    ic->cur_st = NULL;
1656

    
1657
    /* flush packet queue */
1658
    flush_packet_queue(ic);
1659

    
1660
    for(i=0;i<ic->nb_streams;i++) {
1661
        st = ic->streams[i];
1662
        if (st->parser) {
1663
            av_parser_close(st->parser);
1664
            st->parser= NULL;
1665
        }
1666
    }
1667

    
1668
    /* we read the first packets to get the first PTS (not fully
1669
       accurate, but it is enough now) */
1670
    url_fseek(&ic->pb, 0, SEEK_SET);
1671
    read_size = 0;
1672
    for(;;) {
1673
        if (read_size >= DURATION_MAX_READ_SIZE)
1674
            break;
1675
        /* if all info is available, we can stop */
1676
        for(i = 0;i < ic->nb_streams; i++) {
1677
            st = ic->streams[i];
1678
            if (st->start_time == AV_NOPTS_VALUE)
1679
                break;
1680
        }
1681
        if (i == ic->nb_streams)
1682
            break;
1683

    
1684
        ret = av_read_packet(ic, pkt);
1685
        if (ret != 0)
1686
            break;
1687
        read_size += pkt->size;
1688
        st = ic->streams[pkt->stream_index];
1689
        if (pkt->pts != AV_NOPTS_VALUE) {
1690
            if (st->start_time == AV_NOPTS_VALUE)
1691
                st->start_time = pkt->pts;
1692
        }
1693
        av_free_packet(pkt);
1694
    }
1695

    
1696
    /* estimate the end time (duration) */
1697
    /* XXX: may need to support wrapping */
1698
    filesize = ic->file_size;
1699
    offset = filesize - DURATION_MAX_READ_SIZE;
1700
    if (offset < 0)
1701
        offset = 0;
1702

    
1703
    url_fseek(&ic->pb, offset, SEEK_SET);
1704
    read_size = 0;
1705
    for(;;) {
1706
        if (read_size >= DURATION_MAX_READ_SIZE)
1707
            break;
1708
        /* if all info is available, we can stop */
1709
        for(i = 0;i < ic->nb_streams; i++) {
1710
            st = ic->streams[i];
1711
            if (st->duration == AV_NOPTS_VALUE)
1712
                break;
1713
        }
1714
        if (i == ic->nb_streams)
1715
            break;
1716

    
1717
        ret = av_read_packet(ic, pkt);
1718
        if (ret != 0)
1719
            break;
1720
        read_size += pkt->size;
1721
        st = ic->streams[pkt->stream_index];
1722
        if (pkt->pts != AV_NOPTS_VALUE) {
1723
            end_time = pkt->pts;
1724
            duration = end_time - st->start_time;
1725
            if (duration > 0) {
1726
                if (st->duration == AV_NOPTS_VALUE ||
1727
                    st->duration < duration)
1728
                    st->duration = duration;
1729
            }
1730
        }
1731
        av_free_packet(pkt);
1732
    }
1733

    
1734
    fill_all_stream_timings(ic);
1735

    
1736
    url_fseek(&ic->pb, 0, SEEK_SET);
1737
}
1738

    
1739
static void av_estimate_timings(AVFormatContext *ic)
1740
{
1741
    int64_t file_size;
1742

    
1743
    /* get the file size, if possible */
1744
    if (ic->iformat->flags & AVFMT_NOFILE) {
1745
        file_size = 0;
1746
    } else {
1747
        file_size = url_fsize(&ic->pb);
1748
        if (file_size < 0)
1749
            file_size = 0;
1750
    }
1751
    ic->file_size = file_size;
1752

    
1753
    if ((ic->iformat == &mpegps_demux || ic->iformat == &mpegts_demux) && file_size && !ic->pb.is_streamed) {
1754
        /* get accurate estimate from the PTSes */
1755
        av_estimate_timings_from_pts(ic);
1756
    } else if (av_has_timings(ic)) {
1757
        /* at least one components has timings - we use them for all
1758
           the components */
1759
        fill_all_stream_timings(ic);
1760
    } else {
1761
        /* less precise: use bit rate info */
1762
        av_estimate_timings_from_bit_rate(ic);
1763
    }
1764
    av_update_stream_timings(ic);
1765

    
1766
#if 0
1767
    {
1768
        int i;
1769
        AVStream *st;
1770
        for(i = 0;i < ic->nb_streams; i++) {
1771
            st = ic->streams[i];
1772
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1773
               i, (double)st->start_time / AV_TIME_BASE,
1774
               (double)st->duration / AV_TIME_BASE);
1775
        }
1776
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1777
               (double)ic->start_time / AV_TIME_BASE,
1778
               (double)ic->duration / AV_TIME_BASE,
1779
               ic->bit_rate / 1000);
1780
    }
1781
#endif
1782
}
1783

    
1784
static int has_codec_parameters(AVCodecContext *enc)
1785
{
1786
    int val;
1787
    switch(enc->codec_type) {
1788
    case CODEC_TYPE_AUDIO:
1789
        val = enc->sample_rate;
1790
        break;
1791
    case CODEC_TYPE_VIDEO:
1792
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1793
        break;
1794
    default:
1795
        val = 1;
1796
        break;
1797
    }
1798
    return (val != 0);
1799
}
1800

    
1801
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1802
{
1803
    int16_t *samples;
1804
    AVCodec *codec;
1805
    int got_picture, ret=0;
1806
    AVFrame picture;
1807

    
1808
  if(!st->codec->codec){
1809
    codec = avcodec_find_decoder(st->codec->codec_id);
1810
    if (!codec)
1811
        return -1;
1812
    ret = avcodec_open(st->codec, codec);
1813
    if (ret < 0)
1814
        return ret;
1815
  }
1816

    
1817
  if(!has_codec_parameters(st->codec)){
1818
    switch(st->codec->codec_type) {
1819
    case CODEC_TYPE_VIDEO:
1820
        ret = avcodec_decode_video(st->codec, &picture,
1821
                                   &got_picture, (uint8_t *)data, size);
1822
        break;
1823
    case CODEC_TYPE_AUDIO:
1824
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1825
        if (!samples)
1826
            goto fail;
1827
        ret = avcodec_decode_audio(st->codec, samples,
1828
                                   &got_picture, (uint8_t *)data, size);
1829
        av_free(samples);
1830
        break;
1831
    default:
1832
        break;
1833
    }
1834
  }
1835
 fail:
1836
    return ret;
1837
}
1838

    
1839
/* absolute maximum size we read until we abort */
1840
#define MAX_READ_SIZE        5000000
1841

    
1842
/* maximum duration until we stop analysing the stream */
1843
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 2.0))
1844

    
1845
/**
1846
 * Read the beginning of a media file to get stream information. This
1847
 * is useful for file formats with no headers such as MPEG. This
1848
 * function also compute the real frame rate in case of mpeg2 repeat
1849
 * frame mode.
1850
 *
1851
 * @param ic media file handle
1852
 * @return >=0 if OK. AVERROR_xxx if error.
1853
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1854
 */
1855
int av_find_stream_info(AVFormatContext *ic)
1856
{
1857
    int i, count, ret, read_size, j;
1858
    AVStream *st;
1859
    AVPacket pkt1, *pkt;
1860
    AVPacketList *pktl=NULL, **ppktl;
1861
    int64_t last_dts[MAX_STREAMS];
1862
    int64_t duration_sum[MAX_STREAMS];
1863
    int duration_count[MAX_STREAMS]={0};
1864

    
1865
    for(i=0;i<ic->nb_streams;i++) {
1866
        st = ic->streams[i];
1867
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1868
/*            if(!st->time_base.num)
1869
                st->time_base= */
1870
            if(!st->codec->time_base.num)
1871
                st->codec->time_base= st->time_base;
1872
        }
1873
        //only for the split stuff
1874
        if (!st->parser) {
1875
            st->parser = av_parser_init(st->codec->codec_id);
1876
            if(st->need_parsing == 2 && st->parser){
1877
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1878
            }
1879
        }
1880
    }
1881

    
1882
    for(i=0;i<MAX_STREAMS;i++){
1883
        last_dts[i]= AV_NOPTS_VALUE;
1884
        duration_sum[i]= INT64_MAX;
1885
    }
1886

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

    
1920
        /* NOTE: a new stream can be added there if no header in file
1921
           (AVFMTCTX_NOHEADER) */
1922
        ret = av_read_frame_internal(ic, &pkt1);
1923
        if (ret < 0) {
1924
            /* EOF or error */
1925
            ret = -1; /* we could not have all the codec parameters before EOF */
1926
            for(i=0;i<ic->nb_streams;i++) {
1927
                st = ic->streams[i];
1928
                if (!has_codec_parameters(st->codec))
1929
                    break;
1930
            }
1931
            if (i == ic->nb_streams)
1932
                ret = 0;
1933
            break;
1934
        }
1935

    
1936
        pktl = av_mallocz(sizeof(AVPacketList));
1937
        if (!pktl) {
1938
            ret = AVERROR_NOMEM;
1939
            break;
1940
        }
1941

    
1942
        /* add the packet in the buffered packet list */
1943
        *ppktl = pktl;
1944
        ppktl = &pktl->next;
1945

    
1946
        pkt = &pktl->pkt;
1947
        *pkt = pkt1;
1948

    
1949
        /* duplicate the packet */
1950
        if (av_dup_packet(pkt) < 0) {
1951
                ret = AVERROR_NOMEM;
1952
                break;
1953
        }
1954

    
1955
        read_size += pkt->size;
1956

    
1957
        st = ic->streams[pkt->stream_index];
1958
        st->codec_info_duration += pkt->duration;
1959
        if (pkt->duration != 0)
1960
            st->codec_info_nb_frames++;
1961

    
1962
        {
1963
            int index= pkt->stream_index;
1964
            int64_t last= last_dts[index];
1965
            int64_t duration= pkt->dts - last;
1966

    
1967
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1968
                if(duration*duration_count[index]*10/9 < duration_sum[index]){
1969
                    duration_sum[index]= duration;
1970
                    duration_count[index]=1;
1971
                }else{
1972
                    int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1973
                    duration_sum[index] += duration;
1974
                    duration_count[index]+= factor;
1975
                }
1976
                if(st->codec_info_nb_frames == 0 && 0)
1977
                    st->codec_info_duration += duration;
1978
            }
1979
            last_dts[pkt->stream_index]= pkt->dts;
1980
        }
1981
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1982
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1983
            if(i){
1984
                st->codec->extradata_size= i;
1985
                st->codec->extradata= av_malloc(st->codec->extradata_size);
1986
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1987
            }
1988
        }
1989

    
1990
        /* if still no information, we try to open the codec and to
1991
           decompress the frame. We try to avoid that in most cases as
1992
           it takes longer and uses more memory. For MPEG4, we need to
1993
           decompress for Quicktime. */
1994
        if (!has_codec_parameters(st->codec) /*&&
1995
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1996
             st->codec->codec_id == CODEC_ID_H264 ||
1997
             st->codec->codec_id == CODEC_ID_H263 ||
1998
             st->codec->codec_id == CODEC_ID_H261 ||
1999
             st->codec->codec_id == CODEC_ID_VORBIS ||
2000
             st->codec->codec_id == CODEC_ID_MJPEG ||
2001
             st->codec->codec_id == CODEC_ID_PNG ||
2002
             st->codec->codec_id == CODEC_ID_PAM ||
2003
             st->codec->codec_id == CODEC_ID_PGM ||
2004
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2005
             st->codec->codec_id == CODEC_ID_PBM ||
2006
             st->codec->codec_id == CODEC_ID_PPM ||
2007
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2008
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2009
            try_decode_frame(st, pkt->data, pkt->size);
2010

    
2011
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2012
            break;
2013
        }
2014
        count++;
2015
    }
2016

    
2017
    // close codecs which where opened in try_decode_frame()
2018
    for(i=0;i<ic->nb_streams;i++) {
2019
        st = ic->streams[i];
2020
        if(st->codec->codec)
2021
            avcodec_close(st->codec);
2022
    }
2023
    for(i=0;i<ic->nb_streams;i++) {
2024
        st = ic->streams[i];
2025
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2026
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2027
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2028

    
2029
            if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2030
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2031
                int64_t num, den, error, best_error;
2032

    
2033
                num= st->time_base.den*duration_count[i];
2034
                den= st->time_base.num*duration_sum[i];
2035

    
2036
                best_error= INT64_MAX;
2037
                for(j=1; j<60*12; j++){
2038
                    error= ABS(1001*12*num - 1001*j*den);
2039
                    if(error < best_error){
2040
                        best_error= error;
2041
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2042
                    }
2043
                }
2044
                for(j=24; j<=30; j+=6){
2045
                    error= ABS(1001*12*num - 1000*12*j*den);
2046
                    if(error < best_error){
2047
                        best_error= error;
2048
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2049
                    }
2050
                }
2051
            }
2052

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

    
2084
    av_estimate_timings(ic);
2085
#if 0
2086
    /* correct DTS for b frame streams with no timestamps */
2087
    for(i=0;i<ic->nb_streams;i++) {
2088
        st = ic->streams[i];
2089
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2090
            if(b-frames){
2091
                ppktl = &ic->packet_buffer;
2092
                while(ppkt1){
2093
                    if(ppkt1->stream_index != i)
2094
                        continue;
2095
                    if(ppkt1->pkt->dts < 0)
2096
                        break;
2097
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2098
                        break;
2099
                    ppkt1->pkt->dts -= delta;
2100
                    ppkt1= ppkt1->next;
2101
                }
2102
                if(ppkt1)
2103
                    continue;
2104
                st->cur_dts -= delta;
2105
            }
2106
        }
2107
    }
2108
#endif
2109
    return ret;
2110
}
2111

    
2112
/*******************************************************/
2113

    
2114
/**
2115
 * start playing a network based stream (e.g. RTSP stream) at the
2116
 * current position
2117
 */
2118
int av_read_play(AVFormatContext *s)
2119
{
2120
    if (!s->iformat->read_play)
2121
        return AVERROR_NOTSUPP;
2122
    return s->iformat->read_play(s);
2123
}
2124

    
2125
/**
2126
 * Pause a network based stream (e.g. RTSP stream).
2127
 *
2128
 * Use av_read_play() to resume it.
2129
 */
2130
int av_read_pause(AVFormatContext *s)
2131
{
2132
    if (!s->iformat->read_pause)
2133
        return AVERROR_NOTSUPP;
2134
    return s->iformat->read_pause(s);
2135
}
2136

    
2137
/**
2138
 * Close a media file (but not its codecs).
2139
 *
2140
 * @param s media file handle
2141
 */
2142
void av_close_input_file(AVFormatContext *s)
2143
{
2144
    int i, must_open_file;
2145
    AVStream *st;
2146

    
2147
    /* free previous packet */
2148
    if (s->cur_st && s->cur_st->parser)
2149
        av_free_packet(&s->cur_pkt);
2150

    
2151
    if (s->iformat->read_close)
2152
        s->iformat->read_close(s);
2153
    for(i=0;i<s->nb_streams;i++) {
2154
        /* free all data in a stream component */
2155
        st = s->streams[i];
2156
        if (st->parser) {
2157
            av_parser_close(st->parser);
2158
        }
2159
        av_free(st->index_entries);
2160
        av_free(st->codec);
2161
        av_free(st);
2162
    }
2163
    flush_packet_queue(s);
2164
    must_open_file = 1;
2165
    if (s->iformat->flags & AVFMT_NOFILE) {
2166
        must_open_file = 0;
2167
    }
2168
    if (must_open_file) {
2169
        url_fclose(&s->pb);
2170
    }
2171
    av_freep(&s->priv_data);
2172
    av_free(s);
2173
}
2174

    
2175
/**
2176
 * Add a new stream to a media file.
2177
 *
2178
 * Can only be called in the read_header() function. If the flag
2179
 * AVFMTCTX_NOHEADER is in the format context, then new streams
2180
 * can be added in read_packet too.
2181
 *
2182
 * @param s media file handle
2183
 * @param id file format dependent stream id
2184
 */
2185
AVStream *av_new_stream(AVFormatContext *s, int id)
2186
{
2187
    AVStream *st;
2188

    
2189
    if (s->nb_streams >= MAX_STREAMS)
2190
        return NULL;
2191

    
2192
    st = av_mallocz(sizeof(AVStream));
2193
    if (!st)
2194
        return NULL;
2195

    
2196
    st->codec= avcodec_alloc_context();
2197
    if (s->iformat) {
2198
        /* no default bitrate if decoding */
2199
        st->codec->bit_rate = 0;
2200
    }
2201
    st->index = s->nb_streams;
2202
    st->id = id;
2203
    st->start_time = AV_NOPTS_VALUE;
2204
    st->duration = AV_NOPTS_VALUE;
2205
    st->cur_dts = AV_NOPTS_VALUE;
2206

    
2207
    /* default pts settings is MPEG like */
2208
    av_set_pts_info(st, 33, 1, 90000);
2209
    st->last_IP_pts = AV_NOPTS_VALUE;
2210

    
2211
    s->streams[s->nb_streams++] = st;
2212
    return st;
2213
}
2214

    
2215
/************************************************************/
2216
/* output media file */
2217

    
2218
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2219
{
2220
    int ret;
2221

    
2222
    if (s->oformat->priv_data_size > 0) {
2223
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2224
        if (!s->priv_data)
2225
            return AVERROR_NOMEM;
2226
    } else
2227
        s->priv_data = NULL;
2228

    
2229
    if (s->oformat->set_parameters) {
2230
        ret = s->oformat->set_parameters(s, ap);
2231
        if (ret < 0)
2232
            return ret;
2233
    }
2234
    return 0;
2235
}
2236

    
2237
/**
2238
 * allocate the stream private data and write the stream header to an
2239
 * output media file
2240
 *
2241
 * @param s media file handle
2242
 * @return 0 if OK. AVERROR_xxx if error.
2243
 */
2244
int av_write_header(AVFormatContext *s)
2245
{
2246
    int ret, i;
2247
    AVStream *st;
2248

    
2249
    // some sanity checks
2250
    for(i=0;i<s->nb_streams;i++) {
2251
        st = s->streams[i];
2252

    
2253
        switch (st->codec->codec_type) {
2254
        case CODEC_TYPE_AUDIO:
2255
            if(st->codec->sample_rate<=0){
2256
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2257
                return -1;
2258
            }
2259
            break;
2260
        case CODEC_TYPE_VIDEO:
2261
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2262
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2263
                return -1;
2264
            }
2265
            if(st->codec->width<=0 || st->codec->height<=0){
2266
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2267
                return -1;
2268
            }
2269
            break;
2270
        }
2271
    }
2272

    
2273
    if(s->oformat->write_header){
2274
        ret = s->oformat->write_header(s);
2275
        if (ret < 0)
2276
            return ret;
2277
    }
2278

    
2279
    /* init PTS generation */
2280
    for(i=0;i<s->nb_streams;i++) {
2281
        int64_t den = AV_NOPTS_VALUE;
2282
        st = s->streams[i];
2283

    
2284
        switch (st->codec->codec_type) {
2285
        case CODEC_TYPE_AUDIO:
2286
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2287
            break;
2288
        case CODEC_TYPE_VIDEO:
2289
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2290
            break;
2291
        default:
2292
            break;
2293
        }
2294
        if (den != AV_NOPTS_VALUE) {
2295
            if (den <= 0)
2296
                return AVERROR_INVALIDDATA;
2297
            av_frac_init(&st->pts, 0, 0, den);
2298
        }
2299
    }
2300
    return 0;
2301
}
2302

    
2303
//FIXME merge with compute_pkt_fields
2304
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2305
    int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2306
    int num, den, frame_size;
2307

    
2308
//    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);
2309

    
2310
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2311
        return -1;*/
2312

    
2313
    /* duration field */
2314
    if (pkt->duration == 0) {
2315
        compute_frame_duration(&num, &den, st, NULL, pkt);
2316
        if (den && num) {
2317
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2318
        }
2319
    }
2320

    
2321
    //XXX/FIXME this is a temporary hack until all encoders output pts
2322
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2323
        pkt->dts=
2324
//        pkt->pts= st->cur_dts;
2325
        pkt->pts= st->pts.val;
2326
    }
2327

    
2328
    //calculate dts from pts
2329
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2330
        if(b_frames){
2331
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2332
                st->last_IP_pts= -pkt->duration;
2333
            }
2334
            if(st->last_IP_pts < pkt->pts){
2335
                pkt->dts= st->last_IP_pts;
2336
                st->last_IP_pts= pkt->pts;
2337
            }else
2338
                pkt->dts= pkt->pts;
2339
        }else
2340
            pkt->dts= pkt->pts;
2341
    }
2342

    
2343
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2344
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2345
        return -1;
2346
    }
2347
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2348
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2349
        return -1;
2350
    }
2351

    
2352
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2353
    st->cur_dts= pkt->dts;
2354
    st->pts.val= pkt->dts;
2355

    
2356
    /* update pts */
2357
    switch (st->codec->codec_type) {
2358
    case CODEC_TYPE_AUDIO:
2359
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2360

    
2361
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2362
           but it would be better if we had the real timestamps from the encoder */
2363
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2364
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2365
        }
2366
        break;
2367
    case CODEC_TYPE_VIDEO:
2368
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2369
        break;
2370
    default:
2371
        break;
2372
    }
2373
    return 0;
2374
}
2375

    
2376
static void truncate_ts(AVStream *st, AVPacket *pkt){
2377
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2378

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

    
2382
    pkt->pts &= pts_mask;
2383
    pkt->dts &= pts_mask;
2384
}
2385

    
2386
/**
2387
 * Write a packet to an output media file.
2388
 *
2389
 * The packet shall contain one audio or video frame.
2390
 *
2391
 * @param s media file handle
2392
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2393
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2394
 */
2395
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2396
{
2397
    int ret;
2398

    
2399
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2400
    if(ret<0)
2401
        return ret;
2402

    
2403
    truncate_ts(s->streams[pkt->stream_index], pkt);
2404

    
2405
    ret= s->oformat->write_packet(s, pkt);
2406
    if(!ret)
2407
        ret= url_ferror(&s->pb);
2408
    return ret;
2409
}
2410

    
2411
/**
2412
 * interleave_packet implementation which will interleave per DTS.
2413
 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2414
 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2415
 */
2416
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2417
    AVPacketList *pktl, **next_point, *this_pktl;
2418
    int stream_count=0;
2419
    int streams[MAX_STREAMS];
2420

    
2421
    if(pkt){
2422
        AVStream *st= s->streams[ pkt->stream_index];
2423

    
2424
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2425

    
2426
        this_pktl = av_mallocz(sizeof(AVPacketList));
2427
        this_pktl->pkt= *pkt;
2428
        if(pkt->destruct == av_destruct_packet)
2429
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2430
        else
2431
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2432

    
2433
        next_point = &s->packet_buffer;
2434
        while(*next_point){
2435
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2436
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2437
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2438
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2439
                break;
2440
            next_point= &(*next_point)->next;
2441
        }
2442
        this_pktl->next= *next_point;
2443
        *next_point= this_pktl;
2444
    }
2445

    
2446
    memset(streams, 0, sizeof(streams));
2447
    pktl= s->packet_buffer;
2448
    while(pktl){
2449
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2450
        if(streams[ pktl->pkt.stream_index ] == 0)
2451
            stream_count++;
2452
        streams[ pktl->pkt.stream_index ]++;
2453
        pktl= pktl->next;
2454
    }
2455

    
2456
    if(s->nb_streams == stream_count || (flush && stream_count)){
2457
        pktl= s->packet_buffer;
2458
        *out= pktl->pkt;
2459

    
2460
        s->packet_buffer= pktl->next;
2461
        av_freep(&pktl);
2462
        return 1;
2463
    }else{
2464
        av_init_packet(out);
2465
        return 0;
2466
    }
2467
}
2468

    
2469
/**
2470
 * Interleaves a AVPacket correctly so it can be muxed.
2471
 * @param out the interleaved packet will be output here
2472
 * @param in the input packet
2473
 * @param flush 1 if no further packets are available as input and all
2474
 *              remaining packets should be output
2475
 * @return 1 if a packet was output, 0 if no packet could be output,
2476
 *         < 0 if an error occured
2477
 */
2478
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2479
    if(s->oformat->interleave_packet)
2480
        return s->oformat->interleave_packet(s, out, in, flush);
2481
    else
2482
        return av_interleave_packet_per_dts(s, out, in, flush);
2483
}
2484

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

    
2502
    //FIXME/XXX/HACK drop zero sized packets
2503
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2504
        return 0;
2505

    
2506
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2507
    if(compute_pkt_fields2(st, pkt) < 0)
2508
        return -1;
2509

    
2510
    if(pkt->dts == AV_NOPTS_VALUE)
2511
        return -1;
2512

    
2513
    for(;;){
2514
        AVPacket opkt;
2515
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2516
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2517
            return ret;
2518

    
2519
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2520
        ret= s->oformat->write_packet(s, &opkt);
2521

    
2522
        av_free_packet(&opkt);
2523
        pkt= NULL;
2524

    
2525
        if(ret<0)
2526
            return ret;
2527
        if(url_ferror(&s->pb))
2528
            return url_ferror(&s->pb);
2529
    }
2530
}
2531

    
2532
/**
2533
 * @brief Write the stream trailer to an output media file and
2534
 *        free the file private data.
2535
 *
2536
 * @param s media file handle
2537
 * @return 0 if OK. AVERROR_xxx if error.
2538
 */
2539
int av_write_trailer(AVFormatContext *s)
2540
{
2541
    int ret, i;
2542

    
2543
    for(;;){
2544
        AVPacket pkt;
2545
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2546
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2547
            goto fail;
2548
        if(!ret)
2549
            break;
2550

    
2551
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2552
        ret= s->oformat->write_packet(s, &pkt);
2553

    
2554
        av_free_packet(&pkt);
2555

    
2556
        if(ret<0)
2557
            goto fail;
2558
        if(url_ferror(&s->pb))
2559
            goto fail;
2560
    }
2561

    
2562
    if(s->oformat->write_trailer)
2563
        ret = s->oformat->write_trailer(s);
2564
fail:
2565
    if(ret == 0)
2566
       ret=url_ferror(&s->pb);
2567
    for(i=0;i<s->nb_streams;i++)
2568
        av_freep(&s->streams[i]->priv_data);
2569
    av_freep(&s->priv_data);
2570
    return ret;
2571
}
2572

    
2573
/* "user interface" functions */
2574

    
2575
void dump_format(AVFormatContext *ic,
2576
                 int index,
2577
                 const char *url,
2578
                 int is_output)
2579
{
2580
    int i, flags;
2581
    char buf[256];
2582

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

    
2649
typedef struct {
2650
    const char *abv;
2651
    int width, height;
2652
    int frame_rate, frame_rate_base;
2653
} AbvEntry;
2654

    
2655
static AbvEntry frame_abvs[] = {
2656
    { "ntsc",      720, 480, 30000, 1001 },
2657
    { "pal",       720, 576,    25,    1 },
2658
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2659
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2660
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2661
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2662
    { "film",      352, 240,    24,    1 },
2663
    { "ntsc-film", 352, 240, 24000, 1001 },
2664
    { "sqcif",     128,  96,     0,    0 },
2665
    { "qcif",      176, 144,     0,    0 },
2666
    { "cif",       352, 288,     0,    0 },
2667
    { "4cif",      704, 576,     0,    0 },
2668
};
2669

    
2670
/**
2671
 * parses width and height out of string str.
2672
 */
2673
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2674
{
2675
    int i;
2676
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2677
    const char *p;
2678
    int frame_width = 0, frame_height = 0;
2679

    
2680
    for(i=0;i<n;i++) {
2681
        if (!strcmp(frame_abvs[i].abv, str)) {
2682
            frame_width = frame_abvs[i].width;
2683
            frame_height = frame_abvs[i].height;
2684
            break;
2685
        }
2686
    }
2687
    if (i == n) {
2688
        p = str;
2689
        frame_width = strtol(p, (char **)&p, 10);
2690
        if (*p)
2691
            p++;
2692
        frame_height = strtol(p, (char **)&p, 10);
2693
    }
2694
    if (frame_width <= 0 || frame_height <= 0)
2695
        return -1;
2696
    *width_ptr = frame_width;
2697
    *height_ptr = frame_height;
2698
    return 0;
2699
}
2700

    
2701
/**
2702
 * Converts frame rate from string to a fraction.
2703
 *
2704
 * First we try to get an exact integer or fractional frame rate.
2705
 * If this fails we convert the frame rate to a double and return
2706
 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2707
 */
2708
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2709
{
2710
    int i;
2711
    char* cp;
2712

    
2713
    /* First, we check our abbreviation table */
2714
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2715
         if (!strcmp(frame_abvs[i].abv, arg)) {
2716
             *frame_rate = frame_abvs[i].frame_rate;
2717
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2718
             return 0;
2719
         }
2720

    
2721
    /* Then, we try to parse it as fraction */
2722
    cp = strchr(arg, '/');
2723
    if (!cp)
2724
        cp = strchr(arg, ':');
2725
    if (cp) {
2726
        char* cpp;
2727
        *frame_rate = strtol(arg, &cpp, 10);
2728
        if (cpp != arg || cpp == cp)
2729
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2730
        else
2731
           *frame_rate = 0;
2732
    }
2733
    else {
2734
        /* Finally we give up and parse it as double */
2735
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2736
        *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2737
    }
2738
    if (!*frame_rate || !*frame_rate_base)
2739
        return -1;
2740
    else
2741
        return 0;
2742
}
2743

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

    
2779
#undef time
2780
    time_t now = time(0);
2781

    
2782
    len = strlen(datestr);
2783
    if (len > 0)
2784
        lastch = datestr[len - 1];
2785
    else
2786
        lastch = '\0';
2787
    is_utc = (lastch == 'z' || lastch == 'Z');
2788

    
2789
    memset(&dt, 0, sizeof(dt));
2790

    
2791
    p = datestr;
2792
    q = NULL;
2793
    if (!duration) {
2794
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2795
            q = small_strptime(p, date_fmt[i], &dt);
2796
            if (q) {
2797
                break;
2798
            }
2799
        }
2800

    
2801
        if (!q) {
2802
            if (is_utc) {
2803
                dt = *gmtime(&now);
2804
            } else {
2805
                dt = *localtime(&now);
2806
            }
2807
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2808
        } else {
2809
            p = q;
2810
        }
2811

    
2812
        if (*p == 'T' || *p == 't' || *p == ' ')
2813
            p++;
2814

    
2815
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2816
            q = small_strptime(p, time_fmt[i], &dt);
2817
            if (q) {
2818
                break;
2819
            }
2820
        }
2821
    } else {
2822
        if (p[0] == '-') {
2823
            negative = 1;
2824
            ++p;
2825
        }
2826
        q = small_strptime(p, time_fmt[0], &dt);
2827
        if (!q) {
2828
            dt.tm_sec = strtol(p, (char **)&q, 10);
2829
            dt.tm_min = 0;
2830
            dt.tm_hour = 0;
2831
        }
2832
    }
2833

    
2834
    /* Now we have all the fields that we can get */
2835
    if (!q) {
2836
        if (duration)
2837
            return 0;
2838
        else
2839
            return now * int64_t_C(1000000);
2840
    }
2841

    
2842
    if (duration) {
2843
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2844
    } else {
2845
        dt.tm_isdst = -1;       /* unknown */
2846
        if (is_utc) {
2847
            t = mktimegm(&dt);
2848
        } else {
2849
            t = mktime(&dt);
2850
        }
2851
    }
2852

    
2853
    t *= 1000000;
2854

    
2855
    if (*q == '.') {
2856
        int val, n;
2857
        q++;
2858
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2859
            if (!isdigit(*q))
2860
                break;
2861
            val += n * (*q - '0');
2862
        }
2863
        t += val;
2864
    }
2865
    return negative ? -t : t;
2866
}
2867
#endif /* CONFIG_WINCE */
2868

    
2869
/**
2870
 * Attempts to find a specific tag in a URL.
2871
 *
2872
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2873
 * Return 1 if found.
2874
 */
2875
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2876
{
2877
    const char *p;
2878
    char tag[128], *q;
2879

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

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

    
2927
    q = buf;
2928
    p = path;
2929
    percentd_found = 0;
2930
    for(;;) {
2931
        c = *p++;
2932
        if (c == '\0')
2933
            break;
2934
        if (c == '%') {
2935
            do {
2936
                nd = 0;
2937
                while (isdigit(*p)) {
2938
                    nd = nd * 10 + *p++ - '0';
2939
                }
2940
                c = *p++;
2941
            } while (isdigit(c));
2942

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

    
2975
/**
2976
 * Print  nice hexa dump of a buffer
2977
 * @param f stream for output
2978
 * @param buf buffer
2979
 * @param size buffer size
2980
 */
2981
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2982
{
2983
    int len, i, j, c;
2984

    
2985
    for(i=0;i<size;i+=16) {
2986
        len = size - i;
2987
        if (len > 16)
2988
            len = 16;
2989
        fprintf(f, "%08x ", i);
2990
        for(j=0;j<16;j++) {
2991
            if (j < len)
2992
                fprintf(f, " %02x", buf[i+j]);
2993
            else
2994
                fprintf(f, "   ");
2995
        }
2996
        fprintf(f, " ");
2997
        for(j=0;j<len;j++) {
2998
            c = buf[i+j];
2999
            if (c < ' ' || c > '~')
3000
                c = '.';
3001
            fprintf(f, "%c", c);
3002
        }
3003
        fprintf(f, "\n");
3004
    }
3005
}
3006

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

    
3037
void url_split(char *proto, int proto_size,
3038
               char *authorization, int authorization_size,
3039
               char *hostname, int hostname_size,
3040
               int *port_ptr,
3041
               char *path, int path_size,
3042
               const char *url)
3043
{
3044
    const char *p;
3045
    char *q;
3046
    int port;
3047

    
3048
    port = -1;
3049

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

    
3070
        p++;
3071
        if (*p == '/')
3072
            p++;
3073
        if (*p == '/')
3074
            p++;
3075
        at = strchr(p,'@'); // PETR: get the position of '@'
3076
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
3077
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3078

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

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

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

    
3125
/* fraction handling */
3126

    
3127
/**
3128
 * f = val + (num / den) + 0.5.
3129
 *
3130
 * 'num' is normalized so that it is such as 0 <= num < den.
3131
 *
3132
 * @param f fractional number
3133
 * @param val integer value
3134
 * @param num must be >= 0
3135
 * @param den must be >= 1
3136
 */
3137
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3138
{
3139
    num += (den >> 1);
3140
    if (num >= den) {
3141
        val += num / den;
3142
        num = num % den;
3143
    }
3144
    f->val = val;
3145
    f->num = num;
3146
    f->den = den;
3147
}
3148

    
3149
/**
3150
 * Set f to (val + 0.5).
3151
 */
3152
void av_frac_set(AVFrac *f, int64_t val)
3153
{
3154
    f->val = val;
3155
    f->num = f->den >> 1;
3156
}
3157

    
3158
/**
3159
 * Fractionnal addition to f: f = f + (incr / f->den).
3160
 *
3161
 * @param f fractional number
3162
 * @param incr increment, can be positive or negative
3163
 */
3164
void av_frac_add(AVFrac *f, int64_t incr)
3165
{
3166
    int64_t num, den;
3167

    
3168
    num = f->num + incr;
3169
    den = f->den;
3170
    if (num < 0) {
3171
        f->val += num / den;
3172
        num = num % den;
3173
        if (num < 0) {
3174
            num += den;
3175
            f->val--;
3176
        }
3177
    } else if (num >= den) {
3178
        f->val += num / den;
3179
        num = num % den;
3180
    }
3181
    f->num = num;
3182
}
3183

    
3184
/**
3185
 * register a new image format
3186
 * @param img_fmt Image format descriptor
3187
 */
3188
void av_register_image_format(AVImageFormat *img_fmt)
3189
{
3190
    AVImageFormat **p;
3191

    
3192
    p = &first_image_format;
3193
    while (*p != NULL) p = &(*p)->next;
3194
    *p = img_fmt;
3195
    img_fmt->next = NULL;
3196
}
3197

    
3198
/**
3199
 * Guesses image format based on data in the image.
3200
 */
3201
AVImageFormat *av_probe_image_format(AVProbeData *pd)
3202
{
3203
    AVImageFormat *fmt1, *fmt;
3204
    int score, score_max;
3205

    
3206
    fmt = NULL;
3207
    score_max = 0;
3208
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3209
        if (fmt1->img_probe) {
3210
            score = fmt1->img_probe(pd);
3211
            if (score > score_max) {
3212
                score_max = score;
3213
                fmt = fmt1;
3214
            }
3215
        }
3216
    }
3217
    return fmt;
3218
}
3219

    
3220
/**
3221
 * Guesses image format based on file name extensions.
3222
 */
3223
AVImageFormat *guess_image_format(const char *filename)
3224
{
3225
    AVImageFormat *fmt1;
3226

    
3227
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3228
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3229
            return fmt1;
3230
    }
3231
    return NULL;
3232
}
3233

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

    
3248
    if (!fmt) {
3249
        pd->filename = filename;
3250
        pd->buf = buf;
3251
        pos = url_ftell(pb);
3252
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3253
        url_fseek(pb, pos, SEEK_SET);
3254
        fmt = av_probe_image_format(pd);
3255
    }
3256
    if (!fmt)
3257
        return AVERROR_NOFMT;
3258
    ret = fmt->img_read(pb, alloc_cb, opaque);
3259
    return ret;
3260
}
3261

    
3262
/**
3263
 * Write an image to a stream.
3264
 * @param pb byte stream for the image output
3265
 * @param fmt image format
3266
 * @param img image data and informations
3267
 */
3268
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3269
{
3270
    return fmt->img_write(pb, img);
3271
}
3272