Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ a5e9102b

History | View | Annotate | Download (94.5 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 (1<<20)
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
                    char buf[256];
1936
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1937
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1938
                    break;
1939
                }
1940
            }
1941
            if (i == ic->nb_streams)
1942
                ret = 0;
1943
            break;
1944
        }
1945

    
1946
        pktl = av_mallocz(sizeof(AVPacketList));
1947
        if (!pktl) {
1948
            ret = AVERROR_NOMEM;
1949
            break;
1950
        }
1951

    
1952
        /* add the packet in the buffered packet list */
1953
        *ppktl = pktl;
1954
        ppktl = &pktl->next;
1955

    
1956
        pkt = &pktl->pkt;
1957
        *pkt = pkt1;
1958

    
1959
        /* duplicate the packet */
1960
        if (av_dup_packet(pkt) < 0) {
1961
                ret = AVERROR_NOMEM;
1962
                break;
1963
        }
1964

    
1965
        read_size += pkt->size;
1966

    
1967
        st = ic->streams[pkt->stream_index];
1968
        st->codec_info_duration += pkt->duration;
1969
        if (pkt->duration != 0)
1970
            st->codec_info_nb_frames++;
1971

    
1972
        {
1973
            int index= pkt->stream_index;
1974
            int64_t last= last_dts[index];
1975
            int64_t duration= pkt->dts - last;
1976

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

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

    
2021
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2022
            break;
2023
        }
2024
        count++;
2025
    }
2026

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

    
2039
            if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2040
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2041
                int64_t num, den, error, best_error;
2042

    
2043
                num= st->time_base.den*duration_count[i];
2044
                den= st->time_base.num*duration_sum[i];
2045

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

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

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

    
2122
/*******************************************************/
2123

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

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

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

    
2157
    /* free previous packet */
2158
    if (s->cur_st && s->cur_st->parser)
2159
        av_free_packet(&s->cur_pkt);
2160

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

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

    
2200
    if (s->nb_streams >= MAX_STREAMS)
2201
        return NULL;
2202

    
2203
    st = av_mallocz(sizeof(AVStream));
2204
    if (!st)
2205
        return NULL;
2206

    
2207
    st->codec= avcodec_alloc_context();
2208
    if (s->iformat) {
2209
        /* no default bitrate if decoding */
2210
        st->codec->bit_rate = 0;
2211
    }
2212
    st->index = s->nb_streams;
2213
    st->id = id;
2214
    st->start_time = AV_NOPTS_VALUE;
2215
    st->duration = AV_NOPTS_VALUE;
2216
    st->cur_dts = AV_NOPTS_VALUE;
2217

    
2218
    /* default pts settings is MPEG like */
2219
    av_set_pts_info(st, 33, 1, 90000);
2220
    st->last_IP_pts = AV_NOPTS_VALUE;
2221

    
2222
    s->streams[s->nb_streams++] = st;
2223
    return st;
2224
}
2225

    
2226
/************************************************************/
2227
/* output media file */
2228

    
2229
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2230
{
2231
    int ret;
2232

    
2233
    if (s->oformat->priv_data_size > 0) {
2234
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2235
        if (!s->priv_data)
2236
            return AVERROR_NOMEM;
2237
    } else
2238
        s->priv_data = NULL;
2239

    
2240
    if (s->oformat->set_parameters) {
2241
        ret = s->oformat->set_parameters(s, ap);
2242
        if (ret < 0)
2243
            return ret;
2244
    }
2245
    return 0;
2246
}
2247

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

    
2260
    // some sanity checks
2261
    for(i=0;i<s->nb_streams;i++) {
2262
        st = s->streams[i];
2263

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

    
2284
    if(s->oformat->write_header){
2285
        ret = s->oformat->write_header(s);
2286
        if (ret < 0)
2287
            return ret;
2288
    }
2289

    
2290
    /* init PTS generation */
2291
    for(i=0;i<s->nb_streams;i++) {
2292
        int64_t den = AV_NOPTS_VALUE;
2293
        st = s->streams[i];
2294

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

    
2314
//FIXME merge with compute_pkt_fields
2315
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2316
    int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2317
    int num, den, frame_size;
2318

    
2319
//    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);
2320

    
2321
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2322
        return -1;*/
2323

    
2324
    /* duration field */
2325
    if (pkt->duration == 0) {
2326
        compute_frame_duration(&num, &den, st, NULL, pkt);
2327
        if (den && num) {
2328
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2329
        }
2330
    }
2331

    
2332
    //XXX/FIXME this is a temporary hack until all encoders output pts
2333
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2334
        pkt->dts=
2335
//        pkt->pts= st->cur_dts;
2336
        pkt->pts= st->pts.val;
2337
    }
2338

    
2339
    //calculate dts from pts
2340
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2341
        if(b_frames){
2342
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2343
                st->last_IP_pts= -pkt->duration;
2344
            }
2345
            if(st->last_IP_pts < pkt->pts){
2346
                pkt->dts= st->last_IP_pts;
2347
                st->last_IP_pts= pkt->pts;
2348
            }else
2349
                pkt->dts= pkt->pts;
2350
        }else
2351
            pkt->dts= pkt->pts;
2352
    }
2353

    
2354
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2355
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2356
        return -1;
2357
    }
2358
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2359
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2360
        return -1;
2361
    }
2362

    
2363
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2364
    st->cur_dts= pkt->dts;
2365
    st->pts.val= pkt->dts;
2366

    
2367
    /* update pts */
2368
    switch (st->codec->codec_type) {
2369
    case CODEC_TYPE_AUDIO:
2370
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2371

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

    
2387
static void truncate_ts(AVStream *st, AVPacket *pkt){
2388
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2389

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

    
2393
    pkt->pts &= pts_mask;
2394
    pkt->dts &= pts_mask;
2395
}
2396

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

    
2410
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2411
    if(ret<0)
2412
        return ret;
2413

    
2414
    truncate_ts(s->streams[pkt->stream_index], pkt);
2415

    
2416
    ret= s->oformat->write_packet(s, pkt);
2417
    if(!ret)
2418
        ret= url_ferror(&s->pb);
2419
    return ret;
2420
}
2421

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

    
2432
    if(pkt){
2433
        AVStream *st= s->streams[ pkt->stream_index];
2434

    
2435
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2436

    
2437
        this_pktl = av_mallocz(sizeof(AVPacketList));
2438
        this_pktl->pkt= *pkt;
2439
        if(pkt->destruct == av_destruct_packet)
2440
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2441
        else
2442
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2443

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

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

    
2467
    if(s->nb_streams == stream_count || (flush && stream_count)){
2468
        pktl= s->packet_buffer;
2469
        *out= pktl->pkt;
2470

    
2471
        s->packet_buffer= pktl->next;
2472
        av_freep(&pktl);
2473
        return 1;
2474
    }else{
2475
        av_init_packet(out);
2476
        return 0;
2477
    }
2478
}
2479

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

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

    
2513
    //FIXME/XXX/HACK drop zero sized packets
2514
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2515
        return 0;
2516

    
2517
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2518
    if(compute_pkt_fields2(st, pkt) < 0)
2519
        return -1;
2520

    
2521
    if(pkt->dts == AV_NOPTS_VALUE)
2522
        return -1;
2523

    
2524
    for(;;){
2525
        AVPacket opkt;
2526
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2527
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2528
            return ret;
2529

    
2530
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2531
        ret= s->oformat->write_packet(s, &opkt);
2532

    
2533
        av_free_packet(&opkt);
2534
        pkt= NULL;
2535

    
2536
        if(ret<0)
2537
            return ret;
2538
        if(url_ferror(&s->pb))
2539
            return url_ferror(&s->pb);
2540
    }
2541
}
2542

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

    
2554
    for(;;){
2555
        AVPacket pkt;
2556
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2557
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2558
            goto fail;
2559
        if(!ret)
2560
            break;
2561

    
2562
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2563
        ret= s->oformat->write_packet(s, &pkt);
2564

    
2565
        av_free_packet(&pkt);
2566

    
2567
        if(ret<0)
2568
            goto fail;
2569
        if(url_ferror(&s->pb))
2570
            goto fail;
2571
    }
2572

    
2573
    if(s->oformat->write_trailer)
2574
        ret = s->oformat->write_trailer(s);
2575
fail:
2576
    if(ret == 0)
2577
       ret=url_ferror(&s->pb);
2578
    for(i=0;i<s->nb_streams;i++)
2579
        av_freep(&s->streams[i]->priv_data);
2580
    av_freep(&s->priv_data);
2581
    return ret;
2582
}
2583

    
2584
/* "user interface" functions */
2585

    
2586
void dump_format(AVFormatContext *ic,
2587
                 int index,
2588
                 const char *url,
2589
                 int is_output)
2590
{
2591
    int i, flags;
2592
    char buf[256];
2593

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

    
2661
typedef struct {
2662
    const char *abv;
2663
    int width, height;
2664
    int frame_rate, frame_rate_base;
2665
} AbvEntry;
2666

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

    
2682
/**
2683
 * parses width and height out of string str.
2684
 */
2685
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2686
{
2687
    int i;
2688
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2689
    const char *p;
2690
    int frame_width = 0, frame_height = 0;
2691

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

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

    
2725
    /* First, we check our abbreviation table */
2726
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2727
         if (!strcmp(frame_abvs[i].abv, arg)) {
2728
             *frame_rate = frame_abvs[i].frame_rate;
2729
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2730
             return 0;
2731
         }
2732

    
2733
    /* Then, we try to parse it as fraction */
2734
    cp = strchr(arg, '/');
2735
    if (!cp)
2736
        cp = strchr(arg, ':');
2737
    if (cp) {
2738
        char* cpp;
2739
        *frame_rate = strtol(arg, &cpp, 10);
2740
        if (cpp != arg || cpp == cp)
2741
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2742
        else
2743
           *frame_rate = 0;
2744
    }
2745
    else {
2746
        /* Finally we give up and parse it as double */
2747
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2748
        *frame_rate_base = time_base.den;
2749
        *frame_rate = time_base.num;
2750
    }
2751
    if (!*frame_rate || !*frame_rate_base)
2752
        return -1;
2753
    else
2754
        return 0;
2755
}
2756

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

    
2792
#undef time
2793
    time_t now = time(0);
2794

    
2795
    len = strlen(datestr);
2796
    if (len > 0)
2797
        lastch = datestr[len - 1];
2798
    else
2799
        lastch = '\0';
2800
    is_utc = (lastch == 'z' || lastch == 'Z');
2801

    
2802
    memset(&dt, 0, sizeof(dt));
2803

    
2804
    p = datestr;
2805
    q = NULL;
2806
    if (!duration) {
2807
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2808
            q = small_strptime(p, date_fmt[i], &dt);
2809
            if (q) {
2810
                break;
2811
            }
2812
        }
2813

    
2814
        if (!q) {
2815
            if (is_utc) {
2816
                dt = *gmtime(&now);
2817
            } else {
2818
                dt = *localtime(&now);
2819
            }
2820
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2821
        } else {
2822
            p = q;
2823
        }
2824

    
2825
        if (*p == 'T' || *p == 't' || *p == ' ')
2826
            p++;
2827

    
2828
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2829
            q = small_strptime(p, time_fmt[i], &dt);
2830
            if (q) {
2831
                break;
2832
            }
2833
        }
2834
    } else {
2835
        if (p[0] == '-') {
2836
            negative = 1;
2837
            ++p;
2838
        }
2839
        q = small_strptime(p, time_fmt[0], &dt);
2840
        if (!q) {
2841
            dt.tm_sec = strtol(p, (char **)&q, 10);
2842
            dt.tm_min = 0;
2843
            dt.tm_hour = 0;
2844
        }
2845
    }
2846

    
2847
    /* Now we have all the fields that we can get */
2848
    if (!q) {
2849
        if (duration)
2850
            return 0;
2851
        else
2852
            return now * int64_t_C(1000000);
2853
    }
2854

    
2855
    if (duration) {
2856
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2857
    } else {
2858
        dt.tm_isdst = -1;       /* unknown */
2859
        if (is_utc) {
2860
            t = mktimegm(&dt);
2861
        } else {
2862
            t = mktime(&dt);
2863
        }
2864
    }
2865

    
2866
    t *= 1000000;
2867

    
2868
    if (*q == '.') {
2869
        int val, n;
2870
        q++;
2871
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2872
            if (!isdigit(*q))
2873
                break;
2874
            val += n * (*q - '0');
2875
        }
2876
        t += val;
2877
    }
2878
    return negative ? -t : t;
2879
}
2880
#endif /* CONFIG_WINCE */
2881

    
2882
/**
2883
 * Attempts to find a specific tag in a URL.
2884
 *
2885
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2886
 * Return 1 if found.
2887
 */
2888
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2889
{
2890
    const char *p;
2891
    char tag[128], *q;
2892

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

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

    
2940
    q = buf;
2941
    p = path;
2942
    percentd_found = 0;
2943
    for(;;) {
2944
        c = *p++;
2945
        if (c == '\0')
2946
            break;
2947
        if (c == '%') {
2948
            do {
2949
                nd = 0;
2950
                while (isdigit(*p)) {
2951
                    nd = nd * 10 + *p++ - '0';
2952
                }
2953
                c = *p++;
2954
            } while (isdigit(c));
2955

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

    
2988
/**
2989
 * Print  nice hexa dump of a buffer
2990
 * @param f stream for output
2991
 * @param buf buffer
2992
 * @param size buffer size
2993
 */
2994
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2995
{
2996
    int len, i, j, c;
2997

    
2998
    for(i=0;i<size;i+=16) {
2999
        len = size - i;
3000
        if (len > 16)
3001
            len = 16;
3002
        fprintf(f, "%08x ", i);
3003
        for(j=0;j<16;j++) {
3004
            if (j < len)
3005
                fprintf(f, " %02x", buf[i+j]);
3006
            else
3007
                fprintf(f, "   ");
3008
        }
3009
        fprintf(f, " ");
3010
        for(j=0;j<len;j++) {
3011
            c = buf[i+j];
3012
            if (c < ' ' || c > '~')
3013
                c = '.';
3014
            fprintf(f, "%c", c);
3015
        }
3016
        fprintf(f, "\n");
3017
    }
3018
}
3019

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

    
3050
void url_split(char *proto, int proto_size,
3051
               char *authorization, int authorization_size,
3052
               char *hostname, int hostname_size,
3053
               int *port_ptr,
3054
               char *path, int path_size,
3055
               const char *url)
3056
{
3057
    const char *p;
3058
    char *q;
3059
    int port;
3060

    
3061
    port = -1;
3062

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

    
3083
        p++;
3084
        if (*p == '/')
3085
            p++;
3086
        if (*p == '/')
3087
            p++;
3088
        at = strchr(p,'@'); // PETR: get the position of '@'
3089
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
3090
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3091

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

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

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

    
3138
/* fraction handling */
3139

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

    
3162
/**
3163
 * Set f to (val + 0.5).
3164
 */
3165
void av_frac_set(AVFrac *f, int64_t val)
3166
{
3167
    f->val = val;
3168
    f->num = f->den >> 1;
3169
}
3170

    
3171
/**
3172
 * Fractionnal addition to f: f = f + (incr / f->den).
3173
 *
3174
 * @param f fractional number
3175
 * @param incr increment, can be positive or negative
3176
 */
3177
void av_frac_add(AVFrac *f, int64_t incr)
3178
{
3179
    int64_t num, den;
3180

    
3181
    num = f->num + incr;
3182
    den = f->den;
3183
    if (num < 0) {
3184
        f->val += num / den;
3185
        num = num % den;
3186
        if (num < 0) {
3187
            num += den;
3188
            f->val--;
3189
        }
3190
    } else if (num >= den) {
3191
        f->val += num / den;
3192
        num = num % den;
3193
    }
3194
    f->num = num;
3195
}
3196

    
3197
/**
3198
 * register a new image format
3199
 * @param img_fmt Image format descriptor
3200
 */
3201
void av_register_image_format(AVImageFormat *img_fmt)
3202
{
3203
    AVImageFormat **p;
3204

    
3205
    p = &first_image_format;
3206
    while (*p != NULL) p = &(*p)->next;
3207
    *p = img_fmt;
3208
    img_fmt->next = NULL;
3209
}
3210

    
3211
/**
3212
 * Guesses image format based on data in the image.
3213
 */
3214
AVImageFormat *av_probe_image_format(AVProbeData *pd)
3215
{
3216
    AVImageFormat *fmt1, *fmt;
3217
    int score, score_max;
3218

    
3219
    fmt = NULL;
3220
    score_max = 0;
3221
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3222
        if (fmt1->img_probe) {
3223
            score = fmt1->img_probe(pd);
3224
            if (score > score_max) {
3225
                score_max = score;
3226
                fmt = fmt1;
3227
            }
3228
        }
3229
    }
3230
    return fmt;
3231
}
3232

    
3233
/**
3234
 * Guesses image format based on file name extensions.
3235
 */
3236
AVImageFormat *guess_image_format(const char *filename)
3237
{
3238
    AVImageFormat *fmt1;
3239

    
3240
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3241
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3242
            return fmt1;
3243
    }
3244
    return NULL;
3245
}
3246

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

    
3261
    if (!fmt) {
3262
        pd->filename = filename;
3263
        pd->buf = buf;
3264
        pos = url_ftell(pb);
3265
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3266
        url_fseek(pb, pos, SEEK_SET);
3267
        fmt = av_probe_image_format(pd);
3268
    }
3269
    if (!fmt)
3270
        return AVERROR_NOFMT;
3271
    ret = fmt->img_read(pb, alloc_cb, opaque);
3272
    return ret;
3273
}
3274

    
3275
/**
3276
 * Write an image to a stream.
3277
 * @param pb byte stream for the image output
3278
 * @param fmt image format
3279
 * @param img image data and informations
3280
 */
3281
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3282
{
3283
    return fmt->img_write(pb, img);
3284
}
3285