Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ c04c3282

History | View | Annotate | Download (94.2 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
    AVFormatParameters default_ap;
469

    
470
    if(!ap){
471
        ap=&default_ap;
472
        memset(ap, 0, sizeof(default_ap));
473
    }
474

    
475
    ic = av_alloc_format_context();
476
    if (!ic) {
477
        err = AVERROR_NOMEM;
478
        goto fail;
479
    }
480
    ic->iformat = fmt;
481
    if (pb)
482
        ic->pb = *pb;
483
    ic->duration = AV_NOPTS_VALUE;
484
    ic->start_time = AV_NOPTS_VALUE;
485
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
486

    
487
    /* allocate private data */
488
    if (fmt->priv_data_size > 0) {
489
        ic->priv_data = av_mallocz(fmt->priv_data_size);
490
        if (!ic->priv_data) {
491
            err = AVERROR_NOMEM;
492
            goto fail;
493
        }
494
    } else {
495
        ic->priv_data = NULL;
496
    }
497

    
498
    err = ic->iformat->read_header(ic, ap);
499
    if (err < 0)
500
        goto fail;
501

    
502
    if (pb)
503
        ic->data_offset = url_ftell(&ic->pb);
504

    
505
    *ic_ptr = ic;
506
    return 0;
507
 fail:
508
    if (ic) {
509
        av_freep(&ic->priv_data);
510
    }
511
    av_free(ic);
512
    *ic_ptr = NULL;
513
    return err;
514
}
515

    
516
/** Size of probe buffer, for guessing file type from file contents. */
517
#define PROBE_BUF_MIN 2048
518
#define PROBE_BUF_MAX 131072
519

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

    
540
    file_opened = 0;
541
    pd->filename = "";
542
    if (filename)
543
        pd->filename = filename;
544
    pd->buf = NULL;
545
    pd->buf_size = 0;
546

    
547
    if (!fmt) {
548
        /* guess format if no file can be opened  */
549
        fmt = av_probe_input_format(pd, 0);
550
    }
551

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

    
560
    if (!fmt || must_open_file) {
561
        /* if no file needed do not try to open one */
562
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
563
            err = AVERROR_IO;
564
            goto fail;
565
        }
566
        file_opened = 1;
567
        if (buf_size > 0) {
568
            url_setbufsize(pb, buf_size);
569
        }
570

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

    
589
    /* if still no format found, error */
590
    if (!fmt) {
591
        err = AVERROR_NOFMT;
592
        goto fail;
593
    }
594

    
595
    /* XXX: suppress this hack for redirectors */
596
#ifdef CONFIG_NETWORK
597
    if (fmt == &redir_demux) {
598
        err = redir_open(ic_ptr, pb);
599
        url_fclose(pb);
600
        return err;
601
    }
602
#endif
603

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

    
622
}
623

    
624
/*******************************************************/
625

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

    
641
/**********************************************************/
642

    
643
/**
644
 * Get the number of samples of an audio frame. Return (-1) if error.
645
 */
646
static int get_audio_frame_size(AVCodecContext *enc, int size)
647
{
648
    int frame_size;
649

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

    
700

    
701
/**
702
 * Return the frame duration in seconds, return 0 if not available.
703
 */
704
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
705
                                   AVCodecParserContext *pc, AVPacket *pkt)
706
{
707
    int frame_size;
708

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

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

    
759
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
760
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
761
    int64_t delta= last_ts - mask/2;
762
    return  ((lsb - delta)&mask) + delta;
763
}
764

    
765
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
766
                               AVCodecParserContext *pc, AVPacket *pkt)
767
{
768
    int num, den, presentation_delayed;
769
    /* handle wrapping */
770
    if(st->cur_dts != AV_NOPTS_VALUE){
771
        if(pkt->pts != AV_NOPTS_VALUE)
772
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
773
        if(pkt->dts != AV_NOPTS_VALUE)
774
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
775
    }
776

    
777
    if (pkt->duration == 0) {
778
        compute_frame_duration(&num, &den, st, pc, pkt);
779
        if (den && num) {
780
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
781
        }
782
    }
783

    
784
    if(is_intra_only(st->codec))
785
        pkt->flags |= PKT_FLAG_KEY;
786

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

    
801
    if(st->cur_dts == AV_NOPTS_VALUE){
802
        if(presentation_delayed) st->cur_dts = -pkt->duration;
803
        else                     st->cur_dts = 0;
804
    }
805

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

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

    
858
    /* update flags */
859
    if (pc) {
860
        pkt->flags = 0;
861
        /* key frame computation */
862
        switch(st->codec->codec_type) {
863
        case CODEC_TYPE_VIDEO:
864
            if (pc->pict_type == FF_I_TYPE)
865
                pkt->flags |= PKT_FLAG_KEY;
866
            break;
867
        case CODEC_TYPE_AUDIO:
868
            pkt->flags |= PKT_FLAG_KEY;
869
            break;
870
        default:
871
            break;
872
        }
873
    }
874
}
875

    
876
void av_destruct_packet_nofree(AVPacket *pkt)
877
{
878
    pkt->data = NULL; pkt->size = 0;
879
}
880

    
881
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
882
{
883
    AVStream *st;
884
    int len, ret, i;
885

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

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

    
945
            st = s->streams[s->cur_pkt.stream_index];
946

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

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

    
988
    for(;;){
989
        pktl = s->packet_buffer;
990
        if (pktl) {
991
            AVPacket *next_pkt= &pktl->pkt;
992

    
993
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
994
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
995
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
996
                       && next_pkt->dts < pktl->pkt.dts
997
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
998
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
999
                        next_pkt->pts= pktl->pkt.dts;
1000
                    }
1001
                    pktl= pktl->next;
1002
                }
1003
                pktl = s->packet_buffer;
1004
            }
1005

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

    
1027
            /* duplicate the packet */
1028
            if (av_dup_packet(pkt) < 0)
1029
                return AVERROR_NOMEM;
1030

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

    
1033
            pktl = av_mallocz(sizeof(AVPacketList));
1034
            if (!pktl)
1035
                return AVERROR_NOMEM;
1036

    
1037
            /* add the packet in the buffered packet list */
1038
            *plast_pktl = pktl;
1039
            pktl->pkt= *pkt;
1040
        }else{
1041
            assert(!s->packet_buffer);
1042
            return av_read_frame_internal(s, pkt);
1043
        }
1044
    }
1045
}
1046

    
1047
/* XXX: suppress the packet queue */
1048
static void flush_packet_queue(AVFormatContext *s)
1049
{
1050
    AVPacketList *pktl;
1051

    
1052
    for(;;) {
1053
        pktl = s->packet_buffer;
1054
        if (!pktl)
1055
            break;
1056
        s->packet_buffer = pktl->next;
1057
        av_free_packet(&pktl->pkt);
1058
        av_free(pktl);
1059
    }
1060
}
1061

    
1062
/*******************************************************/
1063
/* seek support */
1064

    
1065
int av_find_default_stream_index(AVFormatContext *s)
1066
{
1067
    int i;
1068
    AVStream *st;
1069

    
1070
    if (s->nb_streams <= 0)
1071
        return -1;
1072
    for(i = 0; i < s->nb_streams; i++) {
1073
        st = s->streams[i];
1074
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1075
            return i;
1076
        }
1077
    }
1078
    return 0;
1079
}
1080

    
1081
/**
1082
 * Flush the frame reader.
1083
 */
1084
static void av_read_frame_flush(AVFormatContext *s)
1085
{
1086
    AVStream *st;
1087
    int i;
1088

    
1089
    flush_packet_queue(s);
1090

    
1091
    /* free previous packet */
1092
    if (s->cur_st) {
1093
        if (s->cur_st->parser)
1094
            av_free_packet(&s->cur_pkt);
1095
        s->cur_st = NULL;
1096
    }
1097
    /* fail safe */
1098
    s->cur_ptr = NULL;
1099
    s->cur_len = 0;
1100

    
1101
    /* for each stream, reset read state */
1102
    for(i = 0; i < s->nb_streams; i++) {
1103
        st = s->streams[i];
1104

    
1105
        if (st->parser) {
1106
            av_parser_close(st->parser);
1107
            st->parser = NULL;
1108
        }
1109
        st->last_IP_pts = AV_NOPTS_VALUE;
1110
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1111
    }
1112
}
1113

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

    
1125
    for(i = 0; i < s->nb_streams; i++) {
1126
        AVStream *st = s->streams[i];
1127

    
1128
        st->cur_dts = av_rescale(timestamp,
1129
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1130
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1131
    }
1132
}
1133

    
1134
/**
1135
 * Add a index entry into a sorted list updateing if it is already there.
1136
 *
1137
 * @param timestamp timestamp in the timebase of the given stream
1138
 */
1139
int av_add_index_entry(AVStream *st,
1140
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1141
{
1142
    AVIndexEntry *entries, *ie;
1143
    int index;
1144

    
1145
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1146
        return -1;
1147

    
1148
    entries = av_fast_realloc(st->index_entries,
1149
                              &st->index_entries_allocated_size,
1150
                              (st->nb_index_entries + 1) *
1151
                              sizeof(AVIndexEntry));
1152
    if(!entries)
1153
        return -1;
1154

    
1155
    st->index_entries= entries;
1156

    
1157
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1158

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

    
1174
    ie->pos = pos;
1175
    ie->timestamp = timestamp;
1176
    ie->min_distance= distance;
1177
    ie->size= size;
1178
    ie->flags = flags;
1179

    
1180
    return index;
1181
}
1182

    
1183
/**
1184
 * build an index for raw streams using a parser.
1185
 */
1186
static void av_build_index_raw(AVFormatContext *s)
1187
{
1188
    AVPacket pkt1, *pkt = &pkt1;
1189
    int ret;
1190
    AVStream *st;
1191

    
1192
    st = s->streams[0];
1193
    av_read_frame_flush(s);
1194
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1195

    
1196
    for(;;) {
1197
        ret = av_read_frame(s, pkt);
1198
        if (ret < 0)
1199
            break;
1200
        if (pkt->stream_index == 0 && st->parser &&
1201
            (pkt->flags & PKT_FLAG_KEY)) {
1202
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1203
                            0, 0, AVINDEX_KEYFRAME);
1204
        }
1205
        av_free_packet(pkt);
1206
    }
1207
}
1208

    
1209
/**
1210
 * Returns TRUE if we deal with a raw stream.
1211
 *
1212
 * Raw codec data and parsing needed.
1213
 */
1214
static int is_raw_stream(AVFormatContext *s)
1215
{
1216
    AVStream *st;
1217

    
1218
    if (s->nb_streams != 1)
1219
        return 0;
1220
    st = s->streams[0];
1221
    if (!st->need_parsing)
1222
        return 0;
1223
    return 1;
1224
}
1225

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

    
1242
    a = - 1;
1243
    b = nb_entries;
1244

    
1245
    while (b - a > 1) {
1246
        m = (a + b) >> 1;
1247
        timestamp = entries[m].timestamp;
1248
        if(timestamp >= wanted_timestamp)
1249
            b = m;
1250
        if(timestamp <= wanted_timestamp)
1251
            a = m;
1252
    }
1253
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1254

    
1255
    if(!(flags & AVSEEK_FLAG_ANY)){
1256
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1257
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1258
        }
1259
    }
1260

    
1261
    if(m == nb_entries)
1262
        return -1;
1263
    return  m;
1264
}
1265

    
1266
#define DEBUG_SEEK
1267

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

    
1282
    if (stream_index < 0)
1283
        return -1;
1284

    
1285
#ifdef DEBUG_SEEK
1286
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1287
#endif
1288

    
1289
    ts_max=
1290
    ts_min= AV_NOPTS_VALUE;
1291
    pos_limit= -1; //gcc falsely says it may be uninitalized
1292

    
1293
    st= s->streams[stream_index];
1294
    if(st->index_entries){
1295
        AVIndexEntry *e;
1296

    
1297
        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()
1298
        index= FFMAX(index, 0);
1299
        e= &st->index_entries[index];
1300

    
1301
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1302
            pos_min= e->pos;
1303
            ts_min= e->timestamp;
1304
#ifdef DEBUG_SEEK
1305
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1306
               pos_min,ts_min);
1307
#endif
1308
        }else{
1309
            assert(index==0);
1310
        }
1311

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

    
1327
    if(ts_min == AV_NOPTS_VALUE){
1328
        pos_min = s->data_offset;
1329
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1330
        if (ts_min == AV_NOPTS_VALUE)
1331
            return -1;
1332
    }
1333

    
1334
    if(ts_max == AV_NOPTS_VALUE){
1335
        int step= 1024;
1336
        filesize = url_fsize(&s->pb);
1337
        pos_max = filesize - 1;
1338
        do{
1339
            pos_max -= step;
1340
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1341
            step += step;
1342
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1343
        if (ts_max == AV_NOPTS_VALUE)
1344
            return -1;
1345

    
1346
        for(;;){
1347
            int64_t tmp_pos= pos_max + 1;
1348
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1349
            if(tmp_ts == AV_NOPTS_VALUE)
1350
                break;
1351
            ts_max= tmp_ts;
1352
            pos_max= tmp_pos;
1353
            if(tmp_pos >= filesize)
1354
                break;
1355
        }
1356
        pos_limit= pos_max;
1357
    }
1358

    
1359
    if(ts_min > ts_max){
1360
        return -1;
1361
    }else if(ts_min == ts_max){
1362
        pos_limit= pos_min;
1363
    }
1364

    
1365
    no_change=0;
1366
    while (pos_min < pos_limit) {
1367
#ifdef DEBUG_SEEK
1368
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1369
               pos_min, pos_max,
1370
               ts_min, ts_max);
1371
#endif
1372
        assert(pos_limit <= pos_max);
1373

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

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

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

    
1425
    av_update_cur_dts(s, st, ts);
1426

    
1427
    return 0;
1428
}
1429

    
1430
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1431
    int64_t pos_min, pos_max;
1432
#if 0
1433
    AVStream *st;
1434

1435
    if (stream_index < 0)
1436
        return -1;
1437

1438
    st= s->streams[stream_index];
1439
#endif
1440

    
1441
    pos_min = s->data_offset;
1442
    pos_max = url_fsize(&s->pb) - 1;
1443

    
1444
    if     (pos < pos_min) pos= pos_min;
1445
    else if(pos > pos_max) pos= pos_max;
1446

    
1447
    url_fseek(&s->pb, pos, SEEK_SET);
1448

    
1449
#if 0
1450
    av_update_cur_dts(s, st, ts);
1451
#endif
1452
    return 0;
1453
}
1454

    
1455
static int av_seek_frame_generic(AVFormatContext *s,
1456
                                 int stream_index, int64_t timestamp, int flags)
1457
{
1458
    int index;
1459
    AVStream *st;
1460
    AVIndexEntry *ie;
1461

    
1462
    if (!s->index_built) {
1463
        if (is_raw_stream(s)) {
1464
            av_build_index_raw(s);
1465
        } else {
1466
            return -1;
1467
        }
1468
        s->index_built = 1;
1469
    }
1470

    
1471
    st = s->streams[stream_index];
1472
    index = av_index_search_timestamp(st, timestamp, flags);
1473
    if (index < 0)
1474
        return -1;
1475

    
1476
    /* now we have found the index, we can seek */
1477
    ie = &st->index_entries[index];
1478
    av_read_frame_flush(s);
1479
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1480

    
1481
    av_update_cur_dts(s, st, ie->timestamp);
1482

    
1483
    return 0;
1484
}
1485

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

    
1502
    av_read_frame_flush(s);
1503

    
1504
    if(flags & AVSEEK_FLAG_BYTE)
1505
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1506

    
1507
    if(stream_index < 0){
1508
        stream_index= av_find_default_stream_index(s);
1509
        if(stream_index < 0)
1510
            return -1;
1511

    
1512
        st= s->streams[stream_index];
1513
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1514
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1515
    }
1516
    st= s->streams[stream_index];
1517

    
1518
    /* first, we try the format specific seek */
1519
    if (s->iformat->read_seek)
1520
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1521
    else
1522
        ret = -1;
1523
    if (ret >= 0) {
1524
        return 0;
1525
    }
1526

    
1527
    if(s->iformat->read_timestamp)
1528
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1529
    else
1530
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1531
}
1532

    
1533
/*******************************************************/
1534

    
1535
/**
1536
 * Returns TRUE if the stream has accurate timings in any stream.
1537
 *
1538
 * @return TRUE if the stream has accurate timings for at least one component.
1539
 */
1540
static int av_has_timings(AVFormatContext *ic)
1541
{
1542
    int i;
1543
    AVStream *st;
1544

    
1545
    for(i = 0;i < ic->nb_streams; i++) {
1546
        st = ic->streams[i];
1547
        if (st->start_time != AV_NOPTS_VALUE &&
1548
            st->duration != AV_NOPTS_VALUE)
1549
            return 1;
1550
    }
1551
    return 0;
1552
}
1553

    
1554
/**
1555
 * Estimate the stream timings from the one of each components.
1556
 *
1557
 * Also computes the global bitrate if possible.
1558
 */
1559
static void av_update_stream_timings(AVFormatContext *ic)
1560
{
1561
    int64_t start_time, start_time1, end_time, end_time1;
1562
    int i;
1563
    AVStream *st;
1564

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

    
1593
}
1594

    
1595
static void fill_all_stream_timings(AVFormatContext *ic)
1596
{
1597
    int i;
1598
    AVStream *st;
1599

    
1600
    av_update_stream_timings(ic);
1601
    for(i = 0;i < ic->nb_streams; i++) {
1602
        st = ic->streams[i];
1603
        if (st->start_time == AV_NOPTS_VALUE) {
1604
            if(ic->start_time != AV_NOPTS_VALUE)
1605
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1606
            if(ic->duration != AV_NOPTS_VALUE)
1607
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1608
        }
1609
    }
1610
}
1611

    
1612
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1613
{
1614
    int64_t filesize, duration;
1615
    int bit_rate, i;
1616
    AVStream *st;
1617

    
1618
    /* if bit_rate is already set, we believe it */
1619
    if (ic->bit_rate == 0) {
1620
        bit_rate = 0;
1621
        for(i=0;i<ic->nb_streams;i++) {
1622
            st = ic->streams[i];
1623
            bit_rate += st->codec->bit_rate;
1624
        }
1625
        ic->bit_rate = bit_rate;
1626
    }
1627

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

    
1647
#define DURATION_MAX_READ_SIZE 250000
1648

    
1649
/* only usable for MPEG-PS streams */
1650
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1651
{
1652
    AVPacket pkt1, *pkt = &pkt1;
1653
    AVStream *st;
1654
    int read_size, i, ret;
1655
    int64_t end_time;
1656
    int64_t filesize, offset, duration;
1657

    
1658
    /* free previous packet */
1659
    if (ic->cur_st && ic->cur_st->parser)
1660
        av_free_packet(&ic->cur_pkt);
1661
    ic->cur_st = NULL;
1662

    
1663
    /* flush packet queue */
1664
    flush_packet_queue(ic);
1665

    
1666
    for(i=0;i<ic->nb_streams;i++) {
1667
        st = ic->streams[i];
1668
        if (st->parser) {
1669
            av_parser_close(st->parser);
1670
            st->parser= NULL;
1671
        }
1672
    }
1673

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

    
1690
        ret = av_read_packet(ic, pkt);
1691
        if (ret != 0)
1692
            break;
1693
        read_size += pkt->size;
1694
        st = ic->streams[pkt->stream_index];
1695
        if (pkt->pts != AV_NOPTS_VALUE) {
1696
            if (st->start_time == AV_NOPTS_VALUE)
1697
                st->start_time = pkt->pts;
1698
        }
1699
        av_free_packet(pkt);
1700
    }
1701

    
1702
    /* estimate the end time (duration) */
1703
    /* XXX: may need to support wrapping */
1704
    filesize = ic->file_size;
1705
    offset = filesize - DURATION_MAX_READ_SIZE;
1706
    if (offset < 0)
1707
        offset = 0;
1708

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

    
1723
        ret = av_read_packet(ic, pkt);
1724
        if (ret != 0)
1725
            break;
1726
        read_size += pkt->size;
1727
        st = ic->streams[pkt->stream_index];
1728
        if (pkt->pts != AV_NOPTS_VALUE) {
1729
            end_time = pkt->pts;
1730
            duration = end_time - st->start_time;
1731
            if (duration > 0) {
1732
                if (st->duration == AV_NOPTS_VALUE ||
1733
                    st->duration < duration)
1734
                    st->duration = duration;
1735
            }
1736
        }
1737
        av_free_packet(pkt);
1738
    }
1739

    
1740
    fill_all_stream_timings(ic);
1741

    
1742
    url_fseek(&ic->pb, 0, SEEK_SET);
1743
}
1744

    
1745
static void av_estimate_timings(AVFormatContext *ic)
1746
{
1747
    int64_t file_size;
1748

    
1749
    /* get the file size, if possible */
1750
    if (ic->iformat->flags & AVFMT_NOFILE) {
1751
        file_size = 0;
1752
    } else {
1753
        file_size = url_fsize(&ic->pb);
1754
        if (file_size < 0)
1755
            file_size = 0;
1756
    }
1757
    ic->file_size = file_size;
1758

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

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

    
1790
static int has_codec_parameters(AVCodecContext *enc)
1791
{
1792
    int val;
1793
    switch(enc->codec_type) {
1794
    case CODEC_TYPE_AUDIO:
1795
        val = enc->sample_rate;
1796
        break;
1797
    case CODEC_TYPE_VIDEO:
1798
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1799
        break;
1800
    default:
1801
        val = 1;
1802
        break;
1803
    }
1804
    return (val != 0);
1805
}
1806

    
1807
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1808
{
1809
    int16_t *samples;
1810
    AVCodec *codec;
1811
    int got_picture, ret=0;
1812
    AVFrame picture;
1813

    
1814
  if(!st->codec->codec){
1815
    codec = avcodec_find_decoder(st->codec->codec_id);
1816
    if (!codec)
1817
        return -1;
1818
    ret = avcodec_open(st->codec, codec);
1819
    if (ret < 0)
1820
        return ret;
1821
  }
1822

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

    
1845
/* absolute maximum size we read until we abort */
1846
#define MAX_READ_SIZE        5000000
1847

    
1848
/* maximum duration until we stop analysing the stream */
1849
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 2.0))
1850

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

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

    
1888
    for(i=0;i<MAX_STREAMS;i++){
1889
        last_dts[i]= AV_NOPTS_VALUE;
1890
        duration_sum[i]= INT64_MAX;
1891
    }
1892

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

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

    
1942
        pktl = av_mallocz(sizeof(AVPacketList));
1943
        if (!pktl) {
1944
            ret = AVERROR_NOMEM;
1945
            break;
1946
        }
1947

    
1948
        /* add the packet in the buffered packet list */
1949
        *ppktl = pktl;
1950
        ppktl = &pktl->next;
1951

    
1952
        pkt = &pktl->pkt;
1953
        *pkt = pkt1;
1954

    
1955
        /* duplicate the packet */
1956
        if (av_dup_packet(pkt) < 0) {
1957
                ret = AVERROR_NOMEM;
1958
                break;
1959
        }
1960

    
1961
        read_size += pkt->size;
1962

    
1963
        st = ic->streams[pkt->stream_index];
1964
        st->codec_info_duration += pkt->duration;
1965
        if (pkt->duration != 0)
1966
            st->codec_info_nb_frames++;
1967

    
1968
        {
1969
            int index= pkt->stream_index;
1970
            int64_t last= last_dts[index];
1971
            int64_t duration= pkt->dts - last;
1972

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

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

    
2017
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2018
            break;
2019
        }
2020
        count++;
2021
    }
2022

    
2023
    // close codecs which where opened in try_decode_frame()
2024
    for(i=0;i<ic->nb_streams;i++) {
2025
        st = ic->streams[i];
2026
        if(st->codec->codec)
2027
            avcodec_close(st->codec);
2028
    }
2029
    for(i=0;i<ic->nb_streams;i++) {
2030
        st = ic->streams[i];
2031
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2032
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2033
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2034

    
2035
            if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2036
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2037
                int64_t num, den, error, best_error;
2038

    
2039
                num= st->time_base.den*duration_count[i];
2040
                den= st->time_base.num*duration_sum[i];
2041

    
2042
                best_error= INT64_MAX;
2043
                for(j=1; j<60*12; j++){
2044
                    error= ABS(1001*12*num - 1001*j*den);
2045
                    if(error < best_error){
2046
                        best_error= error;
2047
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2048
                    }
2049
                }
2050
                for(j=24; j<=30; j+=6){
2051
                    error= ABS(1001*12*num - 1000*12*j*den);
2052
                    if(error < best_error){
2053
                        best_error= error;
2054
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2055
                    }
2056
                }
2057
            }
2058

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

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

    
2118
/*******************************************************/
2119

    
2120
/**
2121
 * start playing a network based stream (e.g. RTSP stream) at the
2122
 * current position
2123
 */
2124
int av_read_play(AVFormatContext *s)
2125
{
2126
    if (!s->iformat->read_play)
2127
        return AVERROR_NOTSUPP;
2128
    return s->iformat->read_play(s);
2129
}
2130

    
2131
/**
2132
 * Pause a network based stream (e.g. RTSP stream).
2133
 *
2134
 * Use av_read_play() to resume it.
2135
 */
2136
int av_read_pause(AVFormatContext *s)
2137
{
2138
    if (!s->iformat->read_pause)
2139
        return AVERROR_NOTSUPP;
2140
    return s->iformat->read_pause(s);
2141
}
2142

    
2143
/**
2144
 * Close a media file (but not its codecs).
2145
 *
2146
 * @param s media file handle
2147
 */
2148
void av_close_input_file(AVFormatContext *s)
2149
{
2150
    int i, must_open_file;
2151
    AVStream *st;
2152

    
2153
    /* free previous packet */
2154
    if (s->cur_st && s->cur_st->parser)
2155
        av_free_packet(&s->cur_pkt);
2156

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

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

    
2195
    if (s->nb_streams >= MAX_STREAMS)
2196
        return NULL;
2197

    
2198
    st = av_mallocz(sizeof(AVStream));
2199
    if (!st)
2200
        return NULL;
2201

    
2202
    st->codec= avcodec_alloc_context();
2203
    if (s->iformat) {
2204
        /* no default bitrate if decoding */
2205
        st->codec->bit_rate = 0;
2206
    }
2207
    st->index = s->nb_streams;
2208
    st->id = id;
2209
    st->start_time = AV_NOPTS_VALUE;
2210
    st->duration = AV_NOPTS_VALUE;
2211
    st->cur_dts = AV_NOPTS_VALUE;
2212

    
2213
    /* default pts settings is MPEG like */
2214
    av_set_pts_info(st, 33, 1, 90000);
2215
    st->last_IP_pts = AV_NOPTS_VALUE;
2216

    
2217
    s->streams[s->nb_streams++] = st;
2218
    return st;
2219
}
2220

    
2221
/************************************************************/
2222
/* output media file */
2223

    
2224
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2225
{
2226
    int ret;
2227

    
2228
    if (s->oformat->priv_data_size > 0) {
2229
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2230
        if (!s->priv_data)
2231
            return AVERROR_NOMEM;
2232
    } else
2233
        s->priv_data = NULL;
2234

    
2235
    if (s->oformat->set_parameters) {
2236
        ret = s->oformat->set_parameters(s, ap);
2237
        if (ret < 0)
2238
            return ret;
2239
    }
2240
    return 0;
2241
}
2242

    
2243
/**
2244
 * allocate the stream private data and write the stream header to an
2245
 * output media file
2246
 *
2247
 * @param s media file handle
2248
 * @return 0 if OK. AVERROR_xxx if error.
2249
 */
2250
int av_write_header(AVFormatContext *s)
2251
{
2252
    int ret, i;
2253
    AVStream *st;
2254

    
2255
    // some sanity checks
2256
    for(i=0;i<s->nb_streams;i++) {
2257
        st = s->streams[i];
2258

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

    
2279
    if(s->oformat->write_header){
2280
        ret = s->oformat->write_header(s);
2281
        if (ret < 0)
2282
            return ret;
2283
    }
2284

    
2285
    /* init PTS generation */
2286
    for(i=0;i<s->nb_streams;i++) {
2287
        int64_t den = AV_NOPTS_VALUE;
2288
        st = s->streams[i];
2289

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

    
2309
//FIXME merge with compute_pkt_fields
2310
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2311
    int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2312
    int num, den, frame_size;
2313

    
2314
//    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);
2315

    
2316
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2317
        return -1;*/
2318

    
2319
    /* duration field */
2320
    if (pkt->duration == 0) {
2321
        compute_frame_duration(&num, &den, st, NULL, pkt);
2322
        if (den && num) {
2323
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2324
        }
2325
    }
2326

    
2327
    //XXX/FIXME this is a temporary hack until all encoders output pts
2328
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2329
        pkt->dts=
2330
//        pkt->pts= st->cur_dts;
2331
        pkt->pts= st->pts.val;
2332
    }
2333

    
2334
    //calculate dts from pts
2335
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2336
        if(b_frames){
2337
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2338
                st->last_IP_pts= -pkt->duration;
2339
            }
2340
            if(st->last_IP_pts < pkt->pts){
2341
                pkt->dts= st->last_IP_pts;
2342
                st->last_IP_pts= pkt->pts;
2343
            }else
2344
                pkt->dts= pkt->pts;
2345
        }else
2346
            pkt->dts= pkt->pts;
2347
    }
2348

    
2349
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2350
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2351
        return -1;
2352
    }
2353
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2354
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2355
        return -1;
2356
    }
2357

    
2358
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2359
    st->cur_dts= pkt->dts;
2360
    st->pts.val= pkt->dts;
2361

    
2362
    /* update pts */
2363
    switch (st->codec->codec_type) {
2364
    case CODEC_TYPE_AUDIO:
2365
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2366

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

    
2382
static void truncate_ts(AVStream *st, AVPacket *pkt){
2383
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2384

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

    
2388
    pkt->pts &= pts_mask;
2389
    pkt->dts &= pts_mask;
2390
}
2391

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

    
2405
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2406
    if(ret<0)
2407
        return ret;
2408

    
2409
    truncate_ts(s->streams[pkt->stream_index], pkt);
2410

    
2411
    ret= s->oformat->write_packet(s, pkt);
2412
    if(!ret)
2413
        ret= url_ferror(&s->pb);
2414
    return ret;
2415
}
2416

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

    
2427
    if(pkt){
2428
        AVStream *st= s->streams[ pkt->stream_index];
2429

    
2430
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2431

    
2432
        this_pktl = av_mallocz(sizeof(AVPacketList));
2433
        this_pktl->pkt= *pkt;
2434
        if(pkt->destruct == av_destruct_packet)
2435
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2436
        else
2437
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2438

    
2439
        next_point = &s->packet_buffer;
2440
        while(*next_point){
2441
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2442
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2443
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2444
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2445
                break;
2446
            next_point= &(*next_point)->next;
2447
        }
2448
        this_pktl->next= *next_point;
2449
        *next_point= this_pktl;
2450
    }
2451

    
2452
    memset(streams, 0, sizeof(streams));
2453
    pktl= s->packet_buffer;
2454
    while(pktl){
2455
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2456
        if(streams[ pktl->pkt.stream_index ] == 0)
2457
            stream_count++;
2458
        streams[ pktl->pkt.stream_index ]++;
2459
        pktl= pktl->next;
2460
    }
2461

    
2462
    if(s->nb_streams == stream_count || (flush && stream_count)){
2463
        pktl= s->packet_buffer;
2464
        *out= pktl->pkt;
2465

    
2466
        s->packet_buffer= pktl->next;
2467
        av_freep(&pktl);
2468
        return 1;
2469
    }else{
2470
        av_init_packet(out);
2471
        return 0;
2472
    }
2473
}
2474

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

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

    
2508
    //FIXME/XXX/HACK drop zero sized packets
2509
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2510
        return 0;
2511

    
2512
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2513
    if(compute_pkt_fields2(st, pkt) < 0)
2514
        return -1;
2515

    
2516
    if(pkt->dts == AV_NOPTS_VALUE)
2517
        return -1;
2518

    
2519
    for(;;){
2520
        AVPacket opkt;
2521
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2522
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2523
            return ret;
2524

    
2525
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2526
        ret= s->oformat->write_packet(s, &opkt);
2527

    
2528
        av_free_packet(&opkt);
2529
        pkt= NULL;
2530

    
2531
        if(ret<0)
2532
            return ret;
2533
        if(url_ferror(&s->pb))
2534
            return url_ferror(&s->pb);
2535
    }
2536
}
2537

    
2538
/**
2539
 * @brief Write the stream trailer to an output media file and
2540
 *        free the file private data.
2541
 *
2542
 * @param s media file handle
2543
 * @return 0 if OK. AVERROR_xxx if error.
2544
 */
2545
int av_write_trailer(AVFormatContext *s)
2546
{
2547
    int ret, i;
2548

    
2549
    for(;;){
2550
        AVPacket pkt;
2551
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2552
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2553
            goto fail;
2554
        if(!ret)
2555
            break;
2556

    
2557
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2558
        ret= s->oformat->write_packet(s, &pkt);
2559

    
2560
        av_free_packet(&pkt);
2561

    
2562
        if(ret<0)
2563
            goto fail;
2564
        if(url_ferror(&s->pb))
2565
            goto fail;
2566
    }
2567

    
2568
    if(s->oformat->write_trailer)
2569
        ret = s->oformat->write_trailer(s);
2570
fail:
2571
    if(ret == 0)
2572
       ret=url_ferror(&s->pb);
2573
    for(i=0;i<s->nb_streams;i++)
2574
        av_freep(&s->streams[i]->priv_data);
2575
    av_freep(&s->priv_data);
2576
    return ret;
2577
}
2578

    
2579
/* "user interface" functions */
2580

    
2581
void dump_format(AVFormatContext *ic,
2582
                 int index,
2583
                 const char *url,
2584
                 int is_output)
2585
{
2586
    int i, flags;
2587
    char buf[256];
2588

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

    
2655
typedef struct {
2656
    const char *abv;
2657
    int width, height;
2658
    int frame_rate, frame_rate_base;
2659
} AbvEntry;
2660

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

    
2676
/**
2677
 * parses width and height out of string str.
2678
 */
2679
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2680
{
2681
    int i;
2682
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2683
    const char *p;
2684
    int frame_width = 0, frame_height = 0;
2685

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

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

    
2719
    /* First, we check our abbreviation table */
2720
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2721
         if (!strcmp(frame_abvs[i].abv, arg)) {
2722
             *frame_rate = frame_abvs[i].frame_rate;
2723
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2724
             return 0;
2725
         }
2726

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

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

    
2785
#undef time
2786
    time_t now = time(0);
2787

    
2788
    len = strlen(datestr);
2789
    if (len > 0)
2790
        lastch = datestr[len - 1];
2791
    else
2792
        lastch = '\0';
2793
    is_utc = (lastch == 'z' || lastch == 'Z');
2794

    
2795
    memset(&dt, 0, sizeof(dt));
2796

    
2797
    p = datestr;
2798
    q = NULL;
2799
    if (!duration) {
2800
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2801
            q = small_strptime(p, date_fmt[i], &dt);
2802
            if (q) {
2803
                break;
2804
            }
2805
        }
2806

    
2807
        if (!q) {
2808
            if (is_utc) {
2809
                dt = *gmtime(&now);
2810
            } else {
2811
                dt = *localtime(&now);
2812
            }
2813
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2814
        } else {
2815
            p = q;
2816
        }
2817

    
2818
        if (*p == 'T' || *p == 't' || *p == ' ')
2819
            p++;
2820

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

    
2840
    /* Now we have all the fields that we can get */
2841
    if (!q) {
2842
        if (duration)
2843
            return 0;
2844
        else
2845
            return now * int64_t_C(1000000);
2846
    }
2847

    
2848
    if (duration) {
2849
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2850
    } else {
2851
        dt.tm_isdst = -1;       /* unknown */
2852
        if (is_utc) {
2853
            t = mktimegm(&dt);
2854
        } else {
2855
            t = mktime(&dt);
2856
        }
2857
    }
2858

    
2859
    t *= 1000000;
2860

    
2861
    if (*q == '.') {
2862
        int val, n;
2863
        q++;
2864
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2865
            if (!isdigit(*q))
2866
                break;
2867
            val += n * (*q - '0');
2868
        }
2869
        t += val;
2870
    }
2871
    return negative ? -t : t;
2872
}
2873
#endif /* CONFIG_WINCE */
2874

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

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

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

    
2933
    q = buf;
2934
    p = path;
2935
    percentd_found = 0;
2936
    for(;;) {
2937
        c = *p++;
2938
        if (c == '\0')
2939
            break;
2940
        if (c == '%') {
2941
            do {
2942
                nd = 0;
2943
                while (isdigit(*p)) {
2944
                    nd = nd * 10 + *p++ - '0';
2945
                }
2946
                c = *p++;
2947
            } while (isdigit(c));
2948

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

    
2981
/**
2982
 * Print  nice hexa dump of a buffer
2983
 * @param f stream for output
2984
 * @param buf buffer
2985
 * @param size buffer size
2986
 */
2987
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2988
{
2989
    int len, i, j, c;
2990

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

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

    
3043
void url_split(char *proto, int proto_size,
3044
               char *authorization, int authorization_size,
3045
               char *hostname, int hostname_size,
3046
               int *port_ptr,
3047
               char *path, int path_size,
3048
               const char *url)
3049
{
3050
    const char *p;
3051
    char *q;
3052
    int port;
3053

    
3054
    port = -1;
3055

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

    
3076
        p++;
3077
        if (*p == '/')
3078
            p++;
3079
        if (*p == '/')
3080
            p++;
3081
        at = strchr(p,'@'); // PETR: get the position of '@'
3082
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
3083
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3084

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

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

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

    
3131
/* fraction handling */
3132

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

    
3155
/**
3156
 * Set f to (val + 0.5).
3157
 */
3158
void av_frac_set(AVFrac *f, int64_t val)
3159
{
3160
    f->val = val;
3161
    f->num = f->den >> 1;
3162
}
3163

    
3164
/**
3165
 * Fractionnal addition to f: f = f + (incr / f->den).
3166
 *
3167
 * @param f fractional number
3168
 * @param incr increment, can be positive or negative
3169
 */
3170
void av_frac_add(AVFrac *f, int64_t incr)
3171
{
3172
    int64_t num, den;
3173

    
3174
    num = f->num + incr;
3175
    den = f->den;
3176
    if (num < 0) {
3177
        f->val += num / den;
3178
        num = num % den;
3179
        if (num < 0) {
3180
            num += den;
3181
            f->val--;
3182
        }
3183
    } else if (num >= den) {
3184
        f->val += num / den;
3185
        num = num % den;
3186
    }
3187
    f->num = num;
3188
}
3189

    
3190
/**
3191
 * register a new image format
3192
 * @param img_fmt Image format descriptor
3193
 */
3194
void av_register_image_format(AVImageFormat *img_fmt)
3195
{
3196
    AVImageFormat **p;
3197

    
3198
    p = &first_image_format;
3199
    while (*p != NULL) p = &(*p)->next;
3200
    *p = img_fmt;
3201
    img_fmt->next = NULL;
3202
}
3203

    
3204
/**
3205
 * Guesses image format based on data in the image.
3206
 */
3207
AVImageFormat *av_probe_image_format(AVProbeData *pd)
3208
{
3209
    AVImageFormat *fmt1, *fmt;
3210
    int score, score_max;
3211

    
3212
    fmt = NULL;
3213
    score_max = 0;
3214
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3215
        if (fmt1->img_probe) {
3216
            score = fmt1->img_probe(pd);
3217
            if (score > score_max) {
3218
                score_max = score;
3219
                fmt = fmt1;
3220
            }
3221
        }
3222
    }
3223
    return fmt;
3224
}
3225

    
3226
/**
3227
 * Guesses image format based on file name extensions.
3228
 */
3229
AVImageFormat *guess_image_format(const char *filename)
3230
{
3231
    AVImageFormat *fmt1;
3232

    
3233
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3234
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3235
            return fmt1;
3236
    }
3237
    return NULL;
3238
}
3239

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

    
3254
    if (!fmt) {
3255
        pd->filename = filename;
3256
        pd->buf = buf;
3257
        pos = url_ftell(pb);
3258
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3259
        url_fseek(pb, pos, SEEK_SET);
3260
        fmt = av_probe_image_format(pd);
3261
    }
3262
    if (!fmt)
3263
        return AVERROR_NOFMT;
3264
    ret = fmt->img_read(pb, alloc_cb, opaque);
3265
    return ret;
3266
}
3267

    
3268
/**
3269
 * Write an image to a stream.
3270
 * @param pb byte stream for the image output
3271
 * @param fmt image format
3272
 * @param img image data and informations
3273
 */
3274
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3275
{
3276
    return fmt->img_write(pb, img);
3277
}
3278