Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 75b5b631

History | View | Annotate | Download (94 KB)

1
/*
2
 * Various utilities for ffmpeg system
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
 */
19
#include "avformat.h"
20

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

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

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

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

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

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

    
59
    if(!filename)
60
        return 0;
61

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

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

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

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

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

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

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

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

    
138
    return fmt;
139
}
140

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

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

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

    
174
/* memory handling */
175

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

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

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

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

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

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

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

    
231
    return ret;
232
}
233

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

    
256
/* fifo handling */
257

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
616
}
617

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

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

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

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

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

    
694

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

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

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

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

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

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

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

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

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

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

    
834
        /* presentation is not delayed : PTS and DTS are the same */
835
        if (pkt->pts == AV_NOPTS_VALUE) {
836
            if (pkt->dts == AV_NOPTS_VALUE) {
837
                pkt->pts = st->cur_dts;
838
                pkt->dts = st->cur_dts;
839
            }
840
            else {
841
                st->cur_dts = pkt->dts;
842
                pkt->pts = pkt->dts;
843
            }
844
        } else {
845
            st->cur_dts = pkt->pts;
846
            pkt->dts = pkt->pts;
847
        }
848
        st->cur_dts += pkt->duration;
849
    }
850
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
851

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1083
    flush_packet_queue(s);
1084

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

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

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

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

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

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

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

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

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

    
1149
    st->index_entries= entries;
1150

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

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

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

    
1173
    return index;
1174
}
1175

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

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

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

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

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

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

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

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

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

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

    
1259
#define DEBUG_SEEK
1260

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1418
    av_update_cur_dts(s, st, ts);
1419

    
1420
    return 0;
1421
}
1422

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

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

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

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

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

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

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

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

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

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

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

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

    
1476
    return 0;
1477
}
1478

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

    
1495
    av_read_frame_flush(s);
1496

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

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

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

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

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

    
1526
/*******************************************************/
1527

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

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

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

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

    
1586
}
1587

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

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

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

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

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

    
1640
#define DURATION_MAX_READ_SIZE 250000
1641

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

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

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

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

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

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

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

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

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

    
1733
    fill_all_stream_timings(ic);
1734

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1954
        read_size += pkt->size;
1955

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

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

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

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

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

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

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

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

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

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

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

    
2111
/*******************************************************/
2112

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

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

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

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

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

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

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

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

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

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

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

    
2214
/************************************************************/
2215
/* output media file */
2216

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2553
        av_free_packet(&pkt);
2554

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

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

    
2572
/* "user interface" functions */
2573

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2852
    t *= 1000000;
2853

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

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

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

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

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

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

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

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

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

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

    
3047
    port = -1;
3048

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

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

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

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

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

    
3124
/* fraction handling */
3125

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

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

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

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

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

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

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

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

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

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

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

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

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