Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 576ae256

History | View | Annotate | Download (79.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
#include "avformat.h"
20

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

    
24
AVInputFormat *first_iformat = NULL;
25
AVOutputFormat *first_oformat = NULL;
26
AVImageFormat *first_image_format = NULL;
27

    
28
void av_register_input_format(AVInputFormat *format)
29
{
30
    AVInputFormat **p;
31
    p = &first_iformat;
32
    while (*p != NULL) p = &(*p)->next;
33
    *p = format;
34
    format->next = NULL;
35
}
36

    
37
void av_register_output_format(AVOutputFormat *format)
38
{
39
    AVOutputFormat **p;
40
    p = &first_oformat;
41
    while (*p != NULL) p = &(*p)->next;
42
    *p = format;
43
    format->next = NULL;
44
}
45

    
46
int match_ext(const char *filename, const char *extensions)
47
{
48
    const char *ext, *p;
49
    char ext1[32], *q;
50

    
51
    if(!filename)
52
        return 0;
53
    
54
    ext = strrchr(filename, '.');
55
    if (ext) {
56
        ext++;
57
        p = extensions;
58
        for(;;) {
59
            q = ext1;
60
            while (*p != '\0' && *p != ',') 
61
                *q++ = *p++;
62
            *q = '\0';
63
            if (!strcasecmp(ext1, ext)) 
64
                return 1;
65
            if (*p == '\0') 
66
                break;
67
            p++;
68
        }
69
    }
70
    return 0;
71
}
72

    
73
AVOutputFormat *guess_format(const char *short_name, const char *filename, 
74
                             const char *mime_type)
75
{
76
    AVOutputFormat *fmt, *fmt_found;
77
    int score_max, score;
78

    
79
    /* specific test for image sequences */
80
    if (!short_name && filename && 
81
        filename_number_test(filename) >= 0 &&
82
        guess_image_format(filename)) {
83
        return guess_format("image", NULL, NULL);
84
    }
85

    
86
    /* find the proper file type */
87
    fmt_found = NULL;
88
    score_max = 0;
89
    fmt = first_oformat;
90
    while (fmt != NULL) {
91
        score = 0;
92
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
93
            score += 100;
94
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
95
            score += 10;
96
        if (filename && fmt->extensions && 
97
            match_ext(filename, fmt->extensions)) {
98
            score += 5;
99
        }
100
        if (score > score_max) {
101
            score_max = score;
102
            fmt_found = fmt;
103
        }
104
        fmt = fmt->next;
105
    }
106
    return fmt_found;
107
}   
108

    
109
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename, 
110
                             const char *mime_type)
111
{
112
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
113

    
114
    if (fmt) {
115
        AVOutputFormat *stream_fmt;
116
        char stream_format_name[64];
117

    
118
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
119
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
120

    
121
        if (stream_fmt)
122
            fmt = stream_fmt;
123
    }
124

    
125
    return fmt;
126
}
127

    
128
AVInputFormat *av_find_input_format(const char *short_name)
129
{
130
    AVInputFormat *fmt;
131
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
132
        if (!strcmp(fmt->name, short_name))
133
            return fmt;
134
    }
135
    return NULL;
136
}
137

    
138
/* memory handling */
139

    
140
/**
141
 * Default packet destructor 
142
 */
143
static void av_destruct_packet(AVPacket *pkt)
144
{
145
    av_free(pkt->data);
146
    pkt->data = NULL; pkt->size = 0;
147
}
148

    
149
/**
150
 * Allocate the payload of a packet and intialized its fields to default values.
151
 *
152
 * @param pkt packet
153
 * @param size wanted payload size
154
 * @return 0 if OK. AVERROR_xxx otherwise.
155
 */
156
int av_new_packet(AVPacket *pkt, int size)
157
{
158
    void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
159
    if (!data)
160
        return AVERROR_NOMEM;
161
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
162

    
163
    av_init_packet(pkt);
164
    pkt->data = data; 
165
    pkt->size = size;
166
    pkt->destruct = av_destruct_packet;
167
    return 0;
168
}
169

    
170
/* This is a hack - the packet memory allocation stuff is broken. The
171
   packet is allocated if it was not really allocated */
172
int av_dup_packet(AVPacket *pkt)
173
{
174
    if (pkt->destruct != av_destruct_packet) {
175
        uint8_t *data;
176
        /* we duplicate the packet and don't forget to put the padding
177
           again */
178
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
179
        if (!data) {
180
            return AVERROR_NOMEM;
181
        }
182
        memcpy(data, pkt->data, pkt->size);
183
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
184
        pkt->data = data;
185
        pkt->destruct = av_destruct_packet;
186
    }
187
    return 0;
188
}
189

    
190
/* fifo handling */
191

    
192
int fifo_init(FifoBuffer *f, int size)
193
{
194
    f->buffer = av_malloc(size);
195
    if (!f->buffer)
196
        return -1;
197
    f->end = f->buffer + size;
198
    f->wptr = f->rptr = f->buffer;
199
    return 0;
200
}
201

    
202
void fifo_free(FifoBuffer *f)
203
{
204
    av_free(f->buffer);
205
}
206

    
207
int fifo_size(FifoBuffer *f, uint8_t *rptr)
208
{
209
    int size;
210

    
211
    if (f->wptr >= rptr) {
212
        size = f->wptr - rptr;
213
    } else {
214
        size = (f->end - rptr) + (f->wptr - f->buffer);
215
    }
216
    return size;
217
}
218

    
219
/* get data from the fifo (return -1 if not enough data) */
220
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
221
{
222
    uint8_t *rptr = *rptr_ptr;
223
    int size, len;
224

    
225
    if (f->wptr >= rptr) {
226
        size = f->wptr - rptr;
227
    } else {
228
        size = (f->end - rptr) + (f->wptr - f->buffer);
229
    }
230
    
231
    if (size < buf_size)
232
        return -1;
233
    while (buf_size > 0) {
234
        len = f->end - rptr;
235
        if (len > buf_size)
236
            len = buf_size;
237
        memcpy(buf, rptr, len);
238
        buf += len;
239
        rptr += len;
240
        if (rptr >= f->end)
241
            rptr = f->buffer;
242
        buf_size -= len;
243
    }
244
    *rptr_ptr = rptr;
245
    return 0;
246
}
247

    
248
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
249
{
250
    int len;
251
    uint8_t *wptr;
252
    wptr = *wptr_ptr;
253
    while (size > 0) {
254
        len = f->end - wptr;
255
        if (len > size)
256
            len = size;
257
        memcpy(wptr, buf, len);
258
        wptr += len;
259
        if (wptr >= f->end)
260
            wptr = f->buffer;
261
        buf += len;
262
        size -= len;
263
    }
264
    *wptr_ptr = wptr;
265
}
266

    
267
/* get data from the fifo (return -1 if not enough data) */
268
int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
269
{
270
    uint8_t *rptr = *rptr_ptr;
271
    int size, len;
272

    
273
    if (f->wptr >= rptr) {
274
        size = f->wptr - rptr;
275
    } else {
276
        size = (f->end - rptr) + (f->wptr - f->buffer);
277
    }
278
    
279
    if (size < buf_size)
280
        return -1;
281
    while (buf_size > 0) {
282
        len = f->end - rptr;
283
        if (len > buf_size)
284
            len = buf_size;
285
        put_buffer(pb, rptr, len);
286
        rptr += len;
287
        if (rptr >= f->end)
288
            rptr = f->buffer;
289
        buf_size -= len;
290
    }
291
    *rptr_ptr = rptr;
292
    return 0;
293
}
294

    
295
int filename_number_test(const char *filename)
296
{
297
    char buf[1024];
298
    if(!filename)
299
        return -1;
300
    return get_frame_filename(buf, sizeof(buf), filename, 1);
301
}
302

    
303
/* guess file format */
304
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
305
{
306
    AVInputFormat *fmt1, *fmt;
307
    int score, score_max;
308

    
309
    fmt = NULL;
310
    score_max = 0;
311
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
312
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
313
            continue;
314
        score = 0;
315
        if (fmt1->read_probe) {
316
            score = fmt1->read_probe(pd);
317
        } else if (fmt1->extensions) {
318
            if (match_ext(pd->filename, fmt1->extensions)) {
319
                score = 50;
320
            }
321
        } 
322
        if (score > score_max) {
323
            score_max = score;
324
            fmt = fmt1;
325
        }
326
    }
327
    return fmt;
328
}
329

    
330
/************************************************************/
331
/* input media file */
332

    
333
/**
334
 * open a media file from an IO stream. 'fmt' must be specified.
335
 */
336

    
337
static const char* format_to_name(void* ptr)
338
{
339
    AVFormatContext* fc = (AVFormatContext*) ptr;
340
    if(fc->iformat) return fc->iformat->name;
341
    else if(fc->oformat) return fc->oformat->name;
342
    else return "NULL";
343
}
344

    
345
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
346

    
347
AVFormatContext *av_alloc_format_context(void)
348
{
349
    AVFormatContext *ic;
350
    ic = av_mallocz(sizeof(AVFormatContext));
351
    if (!ic) return ic;
352
    ic->av_class = &av_format_context_class;
353
    return ic;
354
}
355

    
356
int av_open_input_stream(AVFormatContext **ic_ptr, 
357
                         ByteIOContext *pb, const char *filename, 
358
                         AVInputFormat *fmt, AVFormatParameters *ap)
359
{
360
    int err;
361
    AVFormatContext *ic;
362

    
363
    ic = av_alloc_format_context();
364
    if (!ic) {
365
        err = AVERROR_NOMEM;
366
        goto fail;
367
    }
368
    ic->iformat = fmt;
369
    if (pb)
370
        ic->pb = *pb;
371
    ic->duration = AV_NOPTS_VALUE;
372
    ic->start_time = AV_NOPTS_VALUE;
373
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
374

    
375
    /* allocate private data */
376
    if (fmt->priv_data_size > 0) {
377
        ic->priv_data = av_mallocz(fmt->priv_data_size);
378
        if (!ic->priv_data) {
379
            err = AVERROR_NOMEM;
380
            goto fail;
381
        }
382
    } else {
383
        ic->priv_data = NULL;
384
    }
385

    
386
    err = ic->iformat->read_header(ic, ap);
387
    if (err < 0)
388
        goto fail;
389

    
390
    if (pb)
391
        ic->data_offset = url_ftell(&ic->pb);
392

    
393
    *ic_ptr = ic;
394
    return 0;
395
 fail:
396
    if (ic) {
397
        av_freep(&ic->priv_data);
398
    }
399
    av_free(ic);
400
    *ic_ptr = NULL;
401
    return err;
402
}
403

    
404
#define PROBE_BUF_SIZE 2048
405

    
406
/**
407
 * Open a media file as input. The codec are not opened. Only the file
408
 * header (if present) is read.
409
 *
410
 * @param ic_ptr the opened media file handle is put here
411
 * @param filename filename to open.
412
 * @param fmt if non NULL, force the file format to use
413
 * @param buf_size optional buffer size (zero if default is OK)
414
 * @param ap additionnal parameters needed when opening the file (NULL if default)
415
 * @return 0 if OK. AVERROR_xxx otherwise.
416
 */
417
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, 
418
                       AVInputFormat *fmt,
419
                       int buf_size,
420
                       AVFormatParameters *ap)
421
{
422
    int err, must_open_file, file_opened;
423
    uint8_t buf[PROBE_BUF_SIZE];
424
    AVProbeData probe_data, *pd = &probe_data;
425
    ByteIOContext pb1, *pb = &pb1;
426
    
427
    file_opened = 0;
428
    pd->filename = "";
429
    if (filename)
430
        pd->filename = filename;
431
    pd->buf = buf;
432
    pd->buf_size = 0;
433

    
434
    if (!fmt) {
435
        /* guess format if no file can be opened  */
436
        fmt = av_probe_input_format(pd, 0);
437
    }
438

    
439
    /* do not open file if the format does not need it. XXX: specific
440
       hack needed to handle RTSP/TCP */
441
    must_open_file = 1;
442
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
443
        must_open_file = 0;
444
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
445
    }
446

    
447
    if (!fmt || must_open_file) {
448
        /* if no file needed do not try to open one */
449
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
450
            err = AVERROR_IO;
451
            goto fail;
452
        }
453
        file_opened = 1;
454
        if (buf_size > 0) {
455
            url_setbufsize(pb, buf_size);
456
        }
457
        if (!fmt) {
458
            /* read probe data */
459
            pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
460
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
461
                url_fclose(pb);
462
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
463
                    err = AVERROR_IO;
464
                    goto fail;
465
                }
466
            }
467
        }
468
    }
469
    
470
    /* guess file format */
471
    if (!fmt) {
472
        fmt = av_probe_input_format(pd, 1);
473
    }
474

    
475
    /* if still no format found, error */
476
    if (!fmt) {
477
        err = AVERROR_NOFMT;
478
        goto fail;
479
    }
480
        
481
    /* XXX: suppress this hack for redirectors */
482
#ifdef CONFIG_NETWORK
483
    if (fmt == &redir_demux) {
484
        err = redir_open(ic_ptr, pb);
485
        url_fclose(pb);
486
        return err;
487
    }
488
#endif
489

    
490
    /* check filename in case of an image number is expected */
491
    if (fmt->flags & AVFMT_NEEDNUMBER) {
492
        if (filename_number_test(filename) < 0) { 
493
            err = AVERROR_NUMEXPECTED;
494
            goto fail;
495
        }
496
    }
497
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
498
    if (err)
499
        goto fail;
500
    return 0;
501
 fail:
502
    if (file_opened)
503
        url_fclose(pb);
504
    *ic_ptr = NULL;
505
    return err;
506
    
507
}
508

    
509
/*******************************************************/
510

    
511
/**
512
 * Read a transport packet from a media file. This function is
513
 * absolete and should never be used. Use av_read_frame() instead.
514
 * 
515
 * @param s media file handle
516
 * @param pkt is filled 
517
 * @return 0 if OK. AVERROR_xxx if error.  
518
 */
519
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
520
{
521
    return s->iformat->read_packet(s, pkt);
522
}
523

    
524
/**********************************************************/
525

    
526
/* get the number of samples of an audio frame. Return (-1) if error */
527
static int get_audio_frame_size(AVCodecContext *enc, int size)
528
{
529
    int frame_size;
530

    
531
    if (enc->frame_size <= 1) {
532
        /* specific hack for pcm codecs because no frame size is
533
           provided */
534
        switch(enc->codec_id) {
535
        case CODEC_ID_PCM_S16LE:
536
        case CODEC_ID_PCM_S16BE:
537
        case CODEC_ID_PCM_U16LE:
538
        case CODEC_ID_PCM_U16BE:
539
            if (enc->channels == 0)
540
                return -1;
541
            frame_size = size / (2 * enc->channels);
542
            break;
543
        case CODEC_ID_PCM_S8:
544
        case CODEC_ID_PCM_U8:
545
        case CODEC_ID_PCM_MULAW:
546
        case CODEC_ID_PCM_ALAW:
547
            if (enc->channels == 0)
548
                return -1;
549
            frame_size = size / (enc->channels);
550
            break;
551
        default:
552
            /* used for example by ADPCM codecs */
553
            if (enc->bit_rate == 0)
554
                return -1;
555
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
556
            break;
557
        }
558
    } else {
559
        frame_size = enc->frame_size;
560
    }
561
    return frame_size;
562
}
563

    
564

    
565
/* return the frame duration in seconds, return 0 if not available */
566
static void compute_frame_duration(int *pnum, int *pden, AVStream *st, 
567
                                   AVCodecParserContext *pc, AVPacket *pkt)
568
{
569
    int frame_size;
570

    
571
    *pnum = 0;
572
    *pden = 0;
573
    switch(st->codec.codec_type) {
574
    case CODEC_TYPE_VIDEO:
575
        *pnum = st->codec.frame_rate_base;
576
        *pden = st->codec.frame_rate;
577
        if (pc && pc->repeat_pict) {
578
            *pden *= 2;
579
            *pnum = (*pnum) * (2 + pc->repeat_pict);
580
        }
581
        break;
582
    case CODEC_TYPE_AUDIO:
583
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
584
        if (frame_size < 0)
585
            break;
586
        *pnum = frame_size;
587
        *pden = st->codec.sample_rate;
588
        break;
589
    default:
590
        break;
591
    }
592
}
593

    
594
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
595
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
596
    int64_t delta= last_ts - mask/2;
597
    return  ((lsb - delta)&mask) + delta;
598
}
599

    
600
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
601
                               AVCodecParserContext *pc, AVPacket *pkt)
602
{
603
    int num, den, presentation_delayed;
604

    
605
    /* handle wrapping */
606
    if(st->cur_dts != AV_NOPTS_VALUE){
607
        if(pkt->pts != AV_NOPTS_VALUE)
608
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
609
        if(pkt->dts != AV_NOPTS_VALUE)
610
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
611
    }
612
    
613
    if (pkt->duration == 0) {
614
        compute_frame_duration(&num, &den, st, pc, pkt);
615
        if (den && num) {
616
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
617
        }
618
    }
619

    
620
    /* do we have a video B frame ? */
621
    presentation_delayed = 0;
622
    if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
623
        /* XXX: need has_b_frame, but cannot get it if the codec is
624
           not initialized */
625
        if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
626
             st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
627
             st->codec.codec_id == CODEC_ID_MPEG4 ||
628
             st->codec.codec_id == CODEC_ID_H264) && 
629
            pc && pc->pict_type != FF_B_TYPE)
630
            presentation_delayed = 1;
631
        /* this may be redundant, but it shouldnt hurt */
632
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
633
            presentation_delayed = 1;
634
    }
635
    
636
    if(st->cur_dts == AV_NOPTS_VALUE){
637
        if(presentation_delayed) st->cur_dts = -pkt->duration;
638
        else                     st->cur_dts = 0;
639
    }
640

    
641
//    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);
642
    /* interpolate PTS and DTS if they are not present */
643
    if (presentation_delayed) {
644
        /* DTS = decompression time stamp */
645
        /* PTS = presentation time stamp */
646
        if (pkt->dts == AV_NOPTS_VALUE) {
647
            /* if we know the last pts, use it */
648
            if(st->last_IP_pts != AV_NOPTS_VALUE)
649
                st->cur_dts = pkt->dts = st->last_IP_pts;
650
            else
651
                pkt->dts = st->cur_dts;
652
        } else {
653
            st->cur_dts = pkt->dts;
654
        }
655
        /* this is tricky: the dts must be incremented by the duration
656
           of the frame we are displaying, i.e. the last I or P frame */
657
        if (st->last_IP_duration == 0)
658
            st->cur_dts += pkt->duration;
659
        else
660
            st->cur_dts += st->last_IP_duration;
661
        st->last_IP_duration  = pkt->duration;
662
        st->last_IP_pts= pkt->pts;
663
        /* cannot compute PTS if not present (we can compute it only
664
           by knowing the futur */
665
    } else {
666
        /* presentation is not delayed : PTS and DTS are the same */
667
        if (pkt->pts == AV_NOPTS_VALUE) {
668
            if (pkt->dts == AV_NOPTS_VALUE) {
669
                pkt->pts = st->cur_dts;
670
                pkt->dts = st->cur_dts;
671
            }
672
            else {
673
                st->cur_dts = pkt->dts;
674
                pkt->pts = pkt->dts;
675
            }
676
        } else {
677
            st->cur_dts = pkt->pts;
678
            pkt->dts = pkt->pts;
679
        }
680
        st->cur_dts += pkt->duration;
681
    }
682
//    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);
683
    
684
    /* update flags */
685
    if (pc) {
686
        pkt->flags = 0;
687
        /* key frame computation */
688
        switch(st->codec.codec_type) {
689
        case CODEC_TYPE_VIDEO:
690
            if (pc->pict_type == FF_I_TYPE)
691
                pkt->flags |= PKT_FLAG_KEY;
692
            break;
693
        case CODEC_TYPE_AUDIO:
694
            pkt->flags |= PKT_FLAG_KEY;
695
            break;
696
        default:
697
            break;
698
        }
699
    }
700

    
701
    /* convert the packet time stamp units */
702
    if(pkt->pts != AV_NOPTS_VALUE)
703
        pkt->pts = av_rescale(pkt->pts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
704
    if(pkt->dts != AV_NOPTS_VALUE)
705
        pkt->dts = av_rescale(pkt->dts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
706

    
707
    /* duration field */
708
    pkt->duration = av_rescale(pkt->duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
709
}
710

    
711
void av_destruct_packet_nofree(AVPacket *pkt)
712
{
713
    pkt->data = NULL; pkt->size = 0;
714
}
715

    
716
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
717
{
718
    AVStream *st;
719
    int len, ret, i;
720

    
721
    for(;;) {
722
        /* select current input stream component */
723
        st = s->cur_st;
724
        if (st) {
725
            if (!st->parser) {
726
                /* no parsing needed: we just output the packet as is */
727
                /* raw data support */
728
                *pkt = s->cur_pkt;
729
                compute_pkt_fields(s, st, NULL, pkt);
730
                s->cur_st = NULL;
731
                return 0;
732
            } else if (s->cur_len > 0) {
733
                len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size, 
734
                                      s->cur_ptr, s->cur_len,
735
                                      s->cur_pkt.pts, s->cur_pkt.dts);
736
                s->cur_pkt.pts = AV_NOPTS_VALUE;
737
                s->cur_pkt.dts = AV_NOPTS_VALUE;
738
                /* increment read pointer */
739
                s->cur_ptr += len;
740
                s->cur_len -= len;
741
                
742
                /* return packet if any */
743
                if (pkt->size) {
744
                got_packet:
745
                    pkt->duration = 0;
746
                    pkt->stream_index = st->index;
747
                    pkt->pts = st->parser->pts;
748
                    pkt->dts = st->parser->dts;
749
                    pkt->destruct = av_destruct_packet_nofree;
750
                    compute_pkt_fields(s, st, st->parser, pkt);
751
                    return 0;
752
                }
753
            } else {
754
                /* free packet */
755
                av_free_packet(&s->cur_pkt); 
756
                s->cur_st = NULL;
757
            }
758
        } else {
759
            /* read next packet */
760
            ret = av_read_packet(s, &s->cur_pkt);
761
            if (ret < 0) {
762
                if (ret == -EAGAIN)
763
                    return ret;
764
                /* return the last frames, if any */
765
                for(i = 0; i < s->nb_streams; i++) {
766
                    st = s->streams[i];
767
                    if (st->parser) {
768
                        av_parser_parse(st->parser, &st->codec, 
769
                                        &pkt->data, &pkt->size, 
770
                                        NULL, 0, 
771
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
772
                        if (pkt->size)
773
                            goto got_packet;
774
                    }
775
                }
776
                /* no more packets: really terminates parsing */
777
                return ret;
778
            }
779
            
780
            st = s->streams[s->cur_pkt.stream_index];
781

    
782
            s->cur_st = st;
783
            s->cur_ptr = s->cur_pkt.data;
784
            s->cur_len = s->cur_pkt.size;
785
            if (st->need_parsing && !st->parser) {
786
                st->parser = av_parser_init(st->codec.codec_id);
787
                if (!st->parser) {
788
                    /* no parser available : just output the raw packets */
789
                    st->need_parsing = 0;
790
                }
791
            }
792
        }
793
    }
794
}
795

    
796
/**
797
 * Return the next frame of a stream. The returned packet is valid
798
 * until the next av_read_frame() or until av_close_input_file() and
799
 * must be freed with av_free_packet. For video, the packet contains
800
 * exactly one frame. For audio, it contains an integer number of
801
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
802
 * data). If the audio frames have a variable size (e.g. MPEG audio),
803
 * then it contains one frame.
804
 * 
805
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
806
 * values in AV_TIME_BASE unit (and guessed if the format cannot
807
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
808
 * has B frames, so it is better to rely on pkt->dts if you do not
809
 * decompress the payload.
810
 * 
811
 * Return 0 if OK, < 0 if error or end of file.  
812
 */
813
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
814
{
815
    AVPacketList *pktl;
816

    
817
    pktl = s->packet_buffer;
818
    if (pktl) {
819
        /* read packet from packet buffer, if there is data */
820
        *pkt = pktl->pkt;
821
        s->packet_buffer = pktl->next;
822
        av_free(pktl);
823
        return 0;
824
    } else {
825
        return av_read_frame_internal(s, pkt);
826
    }
827
}
828

    
829
/* XXX: suppress the packet queue */
830
static void flush_packet_queue(AVFormatContext *s)
831
{
832
    AVPacketList *pktl;
833

    
834
    for(;;) {
835
        pktl = s->packet_buffer;
836
        if (!pktl) 
837
            break;
838
        s->packet_buffer = pktl->next;
839
        av_free_packet(&pktl->pkt);
840
        av_free(pktl);
841
    }
842
}
843

    
844
/*******************************************************/
845
/* seek support */
846

    
847
int av_find_default_stream_index(AVFormatContext *s)
848
{
849
    int i;
850
    AVStream *st;
851

    
852
    if (s->nb_streams <= 0)
853
        return -1;
854
    for(i = 0; i < s->nb_streams; i++) {
855
        st = s->streams[i];
856
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
857
            return i;
858
        }
859
    }
860
    return 0;
861
}
862

    
863
/* flush the frame reader */
864
static void av_read_frame_flush(AVFormatContext *s)
865
{
866
    AVStream *st;
867
    int i;
868

    
869
    flush_packet_queue(s);
870

    
871
    /* free previous packet */
872
    if (s->cur_st) {
873
        if (s->cur_st->parser)
874
            av_free_packet(&s->cur_pkt);
875
        s->cur_st = NULL;
876
    }
877
    /* fail safe */
878
    s->cur_ptr = NULL;
879
    s->cur_len = 0;
880
    
881
    /* for each stream, reset read state */
882
    for(i = 0; i < s->nb_streams; i++) {
883
        st = s->streams[i];
884
        
885
        if (st->parser) {
886
            av_parser_close(st->parser);
887
            st->parser = NULL;
888
        }
889
        st->last_IP_pts = AV_NOPTS_VALUE;
890
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
891
    }
892
}
893

    
894
/**
895
 * add a index entry into a sorted list updateing if it is already there.
896
 * @param timestamp timestamp in the timebase of the given stream
897
 */
898
int av_add_index_entry(AVStream *st,
899
                            int64_t pos, int64_t timestamp, int distance, int flags)
900
{
901
    AVIndexEntry *entries, *ie;
902
    int index;
903
    
904
    entries = av_fast_realloc(st->index_entries,
905
                              &st->index_entries_allocated_size,
906
                              (st->nb_index_entries + 1) * 
907
                              sizeof(AVIndexEntry));
908
    st->index_entries= entries;
909

    
910
    if(st->nb_index_entries){
911
        index= av_index_search_timestamp(st, timestamp);
912
        ie= &entries[index];
913

    
914
        if(ie->timestamp != timestamp){
915
            if(ie->timestamp < timestamp){
916
                index++; //index points to next instead of previous entry, maybe nonexistant
917
                ie= &st->index_entries[index];
918
            }else
919
                assert(index==0);
920
                
921
            if(index != st->nb_index_entries){
922
                assert(index < st->nb_index_entries);
923
                memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
924
            }
925
            st->nb_index_entries++;
926
        }else{
927
            if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
928
                distance= ie->min_distance;
929
        }
930
    }else{
931
        index= st->nb_index_entries++;
932
        ie= &entries[index];
933
    }
934
    
935
    ie->pos = pos;
936
    ie->timestamp = timestamp;
937
    ie->min_distance= distance;
938
    ie->flags = flags;
939
    
940
    return index;
941
}
942

    
943
/* build an index for raw streams using a parser */
944
static void av_build_index_raw(AVFormatContext *s)
945
{
946
    AVPacket pkt1, *pkt = &pkt1;
947
    int ret;
948
    AVStream *st;
949

    
950
    st = s->streams[0];
951
    av_read_frame_flush(s);
952
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
953

    
954
    for(;;) {
955
        ret = av_read_frame(s, pkt);
956
        if (ret < 0)
957
            break;
958
        if (pkt->stream_index == 0 && st->parser &&
959
            (pkt->flags & PKT_FLAG_KEY)) {
960
            int64_t dts= av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
961
            av_add_index_entry(st, st->parser->frame_offset, dts, 
962
                            0, AVINDEX_KEYFRAME);
963
        }
964
        av_free_packet(pkt);
965
    }
966
}
967

    
968
/* return TRUE if we deal with a raw stream (raw codec data and
969
   parsing needed) */
970
static int is_raw_stream(AVFormatContext *s)
971
{
972
    AVStream *st;
973

    
974
    if (s->nb_streams != 1)
975
        return 0;
976
    st = s->streams[0];
977
    if (!st->need_parsing)
978
        return 0;
979
    return 1;
980
}
981

    
982
/* return the largest index entry whose timestamp is <=
983
   wanted_timestamp */
984
int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
985
{
986
    AVIndexEntry *entries= st->index_entries;
987
    int nb_entries= st->nb_index_entries;
988
    int a, b, m;
989
    int64_t timestamp;
990

    
991
    if (nb_entries <= 0)
992
        return -1;
993
    
994
    a = 0;
995
    b = nb_entries - 1;
996

    
997
    while (a < b) {
998
        m = (a + b + 1) >> 1;
999
        timestamp = entries[m].timestamp;
1000
        if (timestamp > wanted_timestamp) {
1001
            b = m - 1;
1002
        } else {
1003
            a = m;
1004
        }
1005
    }
1006
    return a;
1007
}
1008

    
1009
#define DEBUG_SEEK
1010

    
1011
/**
1012
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1013
 * this isnt supposed to be called directly by a user application, but by demuxers
1014
 * @param target_ts target timestamp in the time base of the given stream
1015
 * @param stream_index stream number
1016
 */
1017
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts){
1018
    AVInputFormat *avif= s->iformat;
1019
    int64_t pos_min, pos_max, pos, pos_limit;
1020
    int64_t ts_min, ts_max, ts;
1021
    int64_t start_pos;
1022
    int index, no_change, i;
1023
    AVStream *st;
1024

    
1025
    if (stream_index < 0)
1026
        return -1;
1027
    
1028
#ifdef DEBUG_SEEK
1029
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1030
#endif
1031

    
1032
    ts_max=
1033
    ts_min= AV_NOPTS_VALUE;
1034
    pos_limit= -1; //gcc falsely says it may be uninitalized
1035

    
1036
    st= s->streams[stream_index];
1037
    if(st->index_entries){
1038
        AVIndexEntry *e;
1039

    
1040
        index= av_index_search_timestamp(st, target_ts);
1041
        e= &st->index_entries[index];
1042

    
1043
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1044
            pos_min= e->pos;
1045
            ts_min= e->timestamp;
1046
#ifdef DEBUG_SEEK
1047
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n", 
1048
               pos_min,ts_min);
1049
#endif
1050
        }else{
1051
            assert(index==0);
1052
        }
1053
        index++;
1054
        if(index < st->nb_index_entries){
1055
            e= &st->index_entries[index];
1056
            assert(e->timestamp >= target_ts);
1057
            pos_max= e->pos;
1058
            ts_max= e->timestamp;
1059
            pos_limit= pos_max - e->min_distance;
1060
#ifdef DEBUG_SEEK
1061
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n", 
1062
               pos_max,pos_limit, ts_max);
1063
#endif
1064
        }
1065
    }
1066

    
1067
    if(ts_min == AV_NOPTS_VALUE){
1068
        pos_min = s->data_offset;
1069
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1070
        if (ts_min == AV_NOPTS_VALUE)
1071
            return -1;
1072
    }
1073

    
1074
    if(ts_max == AV_NOPTS_VALUE){
1075
        int step= 1024;
1076
        pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1077
        do{
1078
            pos_max -= step;
1079
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1080
            step += step;
1081
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1082
        if (ts_max == AV_NOPTS_VALUE)
1083
            return -1;
1084
        
1085
        for(;;){
1086
            int64_t tmp_pos= pos_max + 1;
1087
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1088
            if(tmp_ts == AV_NOPTS_VALUE)
1089
                break;
1090
            ts_max= tmp_ts;
1091
            pos_max= tmp_pos;
1092
        }
1093
        pos_limit= pos_max;
1094
    }
1095

    
1096
    no_change=0;
1097
    while (pos_min < pos_limit) {
1098
#ifdef DEBUG_SEEK
1099
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
1100
               pos_min, pos_max,
1101
               ts_min, ts_max);
1102
#endif
1103
        assert(pos_limit <= pos_max);
1104

    
1105
        if(no_change==0){
1106
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1107
            // interpolate position (better than dichotomy)
1108
            pos = (int64_t)((double)(pos_max - pos_min) *
1109
                            (double)(target_ts - ts_min) /
1110
                            (double)(ts_max - ts_min)) + pos_min - approximate_keyframe_distance;
1111
        }else if(no_change==1){
1112
            // bisection, if interpolation failed to change min or max pos last time
1113
            pos = (pos_min + pos_limit)>>1;
1114
        }else{
1115
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1116
            pos=pos_min;
1117
        }
1118
        if(pos <= pos_min)
1119
            pos= pos_min + 1;
1120
        else if(pos > pos_limit)
1121
            pos= pos_limit;
1122
        start_pos= pos;
1123

    
1124
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1125
        if(pos == pos_max)
1126
            no_change++;
1127
        else
1128
            no_change=0;
1129
#ifdef DEBUG_SEEK
1130
av_log(s, AV_LOG_DEBUG, "%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1131
#endif
1132
        assert(ts != AV_NOPTS_VALUE);
1133
        if (target_ts < ts) {
1134
            pos_limit = start_pos - 1;
1135
            pos_max = pos;
1136
            ts_max = ts;
1137
        } else {
1138
            pos_min = pos;
1139
            ts_min = ts;
1140
            /* check if we are lucky */
1141
            if (target_ts == ts)
1142
                break;
1143
        }
1144
    }
1145
    
1146
    pos = pos_min;
1147
#ifdef DEBUG_SEEK
1148
    pos_min = pos;
1149
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1150
    pos_min++;
1151
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1152
    av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
1153
           pos, ts_min, target_ts, ts_max);
1154
#endif
1155
    /* do the seek */
1156
    url_fseek(&s->pb, pos, SEEK_SET);
1157

    
1158
    ts= av_rescale(ts_min, AV_TIME_BASE*(int64_t)st->time_base.num, st->time_base.den);
1159
    for(i = 0; i < s->nb_streams; i++) {
1160
        st = s->streams[i];
1161

    
1162
        st->cur_dts = av_rescale(ts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
1163
    }
1164

    
1165
    return 0;
1166
}
1167

    
1168
static int av_seek_frame_generic(AVFormatContext *s, 
1169
                                 int stream_index, int64_t timestamp)
1170
{
1171
    int index, i;
1172
    AVStream *st;
1173
    AVIndexEntry *ie;
1174

    
1175
    if (!s->index_built) {
1176
        if (is_raw_stream(s)) {
1177
            av_build_index_raw(s);
1178
        } else {
1179
            return -1;
1180
        }
1181
        s->index_built = 1;
1182
    }
1183

    
1184
    st = s->streams[stream_index];
1185
    index = av_index_search_timestamp(st, timestamp);
1186
    if (index < 0)
1187
        return -1;
1188

    
1189
    /* now we have found the index, we can seek */
1190
    ie = &st->index_entries[index];
1191
    av_read_frame_flush(s);
1192
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1193
    
1194
    timestamp= av_rescale(ie->timestamp, AV_TIME_BASE*(int64_t)st->time_base.num, st->time_base.den);
1195
    for(i = 0; i < s->nb_streams; i++) {
1196
        st = s->streams[i];
1197

    
1198
        st->cur_dts = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
1199
    }
1200

    
1201
    return 0;
1202
}
1203

    
1204
/**
1205
 * Seek to the key frame just before the frame at timestamp
1206
 * 'timestamp' in 'stream_index'.
1207
 * @param stream_index If stream_index is (-1), a default
1208
 * stream is selected
1209
 * @param timestamp timestamp in AV_TIME_BASE units
1210
 * @return >= 0 on success
1211
 */
1212
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1213
{
1214
    int ret;
1215
    AVStream *st;
1216
    
1217
    av_read_frame_flush(s);
1218
    
1219
    if(stream_index < 0){
1220
        stream_index= av_find_default_stream_index(s);
1221
        if(stream_index < 0)
1222
            return -1;
1223
    }
1224
    st= s->streams[stream_index];
1225

    
1226
    timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1227

    
1228
    /* first, we try the format specific seek */
1229
    if (s->iformat->read_seek)
1230
        ret = s->iformat->read_seek(s, stream_index, timestamp);
1231
    else
1232
        ret = -1;
1233
    if (ret >= 0) {
1234
        return 0;
1235
    }
1236

    
1237
    if(s->iformat->read_timestamp)
1238
        return av_seek_frame_binary(s, stream_index, timestamp);
1239
    else
1240
        return av_seek_frame_generic(s, stream_index, timestamp);
1241
}
1242

    
1243
/*******************************************************/
1244

    
1245
/* return TRUE if the stream has accurate timings for at least one component */
1246
static int av_has_timings(AVFormatContext *ic)
1247
{
1248
    int i;
1249
    AVStream *st;
1250

    
1251
    for(i = 0;i < ic->nb_streams; i++) {
1252
        st = ic->streams[i];
1253
        if (st->start_time != AV_NOPTS_VALUE &&
1254
            st->duration != AV_NOPTS_VALUE)
1255
            return 1;
1256
    }
1257
    return 0;
1258
}
1259

    
1260
/* estimate the stream timings from the one of each components. Also
1261
   compute the global bitrate if possible */
1262
static void av_update_stream_timings(AVFormatContext *ic)
1263
{
1264
    int64_t start_time, end_time, end_time1;
1265
    int i;
1266
    AVStream *st;
1267

    
1268
    start_time = MAXINT64;
1269
    end_time = MININT64;
1270
    for(i = 0;i < ic->nb_streams; i++) {
1271
        st = ic->streams[i];
1272
        if (st->start_time != AV_NOPTS_VALUE) {
1273
            if (st->start_time < start_time)
1274
                start_time = st->start_time;
1275
            if (st->duration != AV_NOPTS_VALUE) {
1276
                end_time1 = st->start_time + st->duration;
1277
                if (end_time1 > end_time)
1278
                    end_time = end_time1;
1279
            }
1280
        }
1281
    }
1282
    if (start_time != MAXINT64) {
1283
        ic->start_time = start_time;
1284
        if (end_time != MAXINT64) {
1285
            ic->duration = end_time - start_time;
1286
            if (ic->file_size > 0) {
1287
                /* compute the bit rate */
1288
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1289
                    (double)ic->duration;
1290
            }
1291
        }
1292
    }
1293

    
1294
}
1295

    
1296
static void fill_all_stream_timings(AVFormatContext *ic)
1297
{
1298
    int i;
1299
    AVStream *st;
1300

    
1301
    av_update_stream_timings(ic);
1302
    for(i = 0;i < ic->nb_streams; i++) {
1303
        st = ic->streams[i];
1304
        if (st->start_time == AV_NOPTS_VALUE) {
1305
            st->start_time = ic->start_time;
1306
            st->duration = ic->duration;
1307
        }
1308
    }
1309
}
1310

    
1311
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1312
{
1313
    int64_t filesize, duration;
1314
    int bit_rate, i;
1315
    AVStream *st;
1316

    
1317
    /* if bit_rate is already set, we believe it */
1318
    if (ic->bit_rate == 0) {
1319
        bit_rate = 0;
1320
        for(i=0;i<ic->nb_streams;i++) {
1321
            st = ic->streams[i];
1322
            bit_rate += st->codec.bit_rate;
1323
        }
1324
        ic->bit_rate = bit_rate;
1325
    }
1326

    
1327
    /* if duration is already set, we believe it */
1328
    if (ic->duration == AV_NOPTS_VALUE && 
1329
        ic->bit_rate != 0 && 
1330
        ic->file_size != 0)  {
1331
        filesize = ic->file_size;
1332
        if (filesize > 0) {
1333
            duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1334
            for(i = 0; i < ic->nb_streams; i++) {
1335
                st = ic->streams[i];
1336
                if (st->start_time == AV_NOPTS_VALUE ||
1337
                    st->duration == AV_NOPTS_VALUE) {
1338
                    st->start_time = 0;
1339
                    st->duration = duration;
1340
                }
1341
            }
1342
        }
1343
    }
1344
}
1345

    
1346
#define DURATION_MAX_READ_SIZE 250000
1347

    
1348
/* only usable for MPEG-PS streams */
1349
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1350
{
1351
    AVPacket pkt1, *pkt = &pkt1;
1352
    AVStream *st;
1353
    int read_size, i, ret;
1354
    int64_t start_time, end_time, end_time1;
1355
    int64_t filesize, offset, duration;
1356
    
1357
    /* free previous packet */
1358
    if (ic->cur_st && ic->cur_st->parser)
1359
        av_free_packet(&ic->cur_pkt); 
1360
    ic->cur_st = NULL;
1361

    
1362
    /* flush packet queue */
1363
    flush_packet_queue(ic);
1364

    
1365
    for(i=0;i<ic->nb_streams;i++) {
1366
        st = ic->streams[i];
1367
        if (st->parser) {
1368
            av_parser_close(st->parser);
1369
            st->parser= NULL;
1370
        }
1371
    }
1372
    
1373
    /* we read the first packets to get the first PTS (not fully
1374
       accurate, but it is enough now) */
1375
    url_fseek(&ic->pb, 0, SEEK_SET);
1376
    read_size = 0;
1377
    for(;;) {
1378
        if (read_size >= DURATION_MAX_READ_SIZE)
1379
            break;
1380
        /* if all info is available, we can stop */
1381
        for(i = 0;i < ic->nb_streams; i++) {
1382
            st = ic->streams[i];
1383
            if (st->start_time == AV_NOPTS_VALUE)
1384
                break;
1385
        }
1386
        if (i == ic->nb_streams)
1387
            break;
1388

    
1389
        ret = av_read_packet(ic, pkt);
1390
        if (ret != 0)
1391
            break;
1392
        read_size += pkt->size;
1393
        st = ic->streams[pkt->stream_index];
1394
        if (pkt->pts != AV_NOPTS_VALUE) {
1395
            if (st->start_time == AV_NOPTS_VALUE)
1396
                st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1397
        }
1398
        av_free_packet(pkt);
1399
    }
1400

    
1401
    /* we compute the minimum start_time and use it as default */
1402
    start_time = MAXINT64;
1403
    for(i = 0; i < ic->nb_streams; i++) {
1404
        st = ic->streams[i];
1405
        if (st->start_time != AV_NOPTS_VALUE &&
1406
            st->start_time < start_time)
1407
            start_time = st->start_time;
1408
    }
1409
    if (start_time != MAXINT64)
1410
        ic->start_time = start_time;
1411
    
1412
    /* estimate the end time (duration) */
1413
    /* XXX: may need to support wrapping */
1414
    filesize = ic->file_size;
1415
    offset = filesize - DURATION_MAX_READ_SIZE;
1416
    if (offset < 0)
1417
        offset = 0;
1418

    
1419
    url_fseek(&ic->pb, offset, SEEK_SET);
1420
    read_size = 0;
1421
    for(;;) {
1422
        if (read_size >= DURATION_MAX_READ_SIZE)
1423
            break;
1424
        /* if all info is available, we can stop */
1425
        for(i = 0;i < ic->nb_streams; i++) {
1426
            st = ic->streams[i];
1427
            if (st->duration == AV_NOPTS_VALUE)
1428
                break;
1429
        }
1430
        if (i == ic->nb_streams)
1431
            break;
1432
        
1433
        ret = av_read_packet(ic, pkt);
1434
        if (ret != 0)
1435
            break;
1436
        read_size += pkt->size;
1437
        st = ic->streams[pkt->stream_index];
1438
        if (pkt->pts != AV_NOPTS_VALUE) {
1439
            end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1440
            duration = end_time - st->start_time;
1441
            if (duration > 0) {
1442
                if (st->duration == AV_NOPTS_VALUE ||
1443
                    st->duration < duration)
1444
                    st->duration = duration;
1445
            }
1446
        }
1447
        av_free_packet(pkt);
1448
    }
1449
    
1450
    /* estimate total duration */
1451
    end_time = MININT64;
1452
    for(i = 0;i < ic->nb_streams; i++) {
1453
        st = ic->streams[i];
1454
        if (st->duration != AV_NOPTS_VALUE) {
1455
            end_time1 = st->start_time + st->duration;
1456
            if (end_time1 > end_time)
1457
                end_time = end_time1;
1458
        }
1459
    }
1460
    
1461
    /* update start_time (new stream may have been created, so we do
1462
       it at the end */
1463
    if (ic->start_time != AV_NOPTS_VALUE) {
1464
        for(i = 0; i < ic->nb_streams; i++) {
1465
            st = ic->streams[i];
1466
            if (st->start_time == AV_NOPTS_VALUE)
1467
                st->start_time = ic->start_time;
1468
        }
1469
    }
1470

    
1471
    if (end_time != MININT64) {
1472
        /* put dummy values for duration if needed */
1473
        for(i = 0;i < ic->nb_streams; i++) {
1474
            st = ic->streams[i];
1475
            if (st->duration == AV_NOPTS_VALUE && 
1476
                st->start_time != AV_NOPTS_VALUE)
1477
                st->duration = end_time - st->start_time;
1478
        }
1479
        ic->duration = end_time - ic->start_time;
1480
    }
1481

    
1482
    url_fseek(&ic->pb, 0, SEEK_SET);
1483
}
1484

    
1485
static void av_estimate_timings(AVFormatContext *ic)
1486
{
1487
    URLContext *h;
1488
    int64_t file_size;
1489

    
1490
    /* get the file size, if possible */
1491
    if (ic->iformat->flags & AVFMT_NOFILE) {
1492
        file_size = 0;
1493
    } else {
1494
        h = url_fileno(&ic->pb);
1495
        file_size = url_filesize(h);
1496
        if (file_size < 0)
1497
            file_size = 0;
1498
    }
1499
    ic->file_size = file_size;
1500

    
1501
    if (ic->iformat == &mpegps_demux) {
1502
        /* get accurate estimate from the PTSes */
1503
        av_estimate_timings_from_pts(ic);
1504
    } else if (av_has_timings(ic)) {
1505
        /* at least one components has timings - we use them for all
1506
           the components */
1507
        fill_all_stream_timings(ic);
1508
    } else {
1509
        /* less precise: use bit rate info */
1510
        av_estimate_timings_from_bit_rate(ic);
1511
    }
1512
    av_update_stream_timings(ic);
1513

    
1514
#if 0
1515
    {
1516
        int i;
1517
        AVStream *st;
1518
        for(i = 0;i < ic->nb_streams; i++) {
1519
            st = ic->streams[i];
1520
        printf("%d: start_time: %0.3f duration: %0.3f\n", 
1521
               i, (double)st->start_time / AV_TIME_BASE, 
1522
               (double)st->duration / AV_TIME_BASE);
1523
        }
1524
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1525
               (double)ic->start_time / AV_TIME_BASE, 
1526
               (double)ic->duration / AV_TIME_BASE,
1527
               ic->bit_rate / 1000);
1528
    }
1529
#endif
1530
}
1531

    
1532
static int has_codec_parameters(AVCodecContext *enc)
1533
{
1534
    int val;
1535
    switch(enc->codec_type) {
1536
    case CODEC_TYPE_AUDIO:
1537
        val = enc->sample_rate;
1538
        break;
1539
    case CODEC_TYPE_VIDEO:
1540
        val = enc->width;
1541
        break;
1542
    default:
1543
        val = 1;
1544
        break;
1545
    }
1546
    return (val != 0);
1547
}
1548

    
1549
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1550
{
1551
    int16_t *samples;
1552
    AVCodec *codec;
1553
    int got_picture, ret;
1554
    AVFrame picture;
1555
    
1556
    codec = avcodec_find_decoder(st->codec.codec_id);
1557
    if (!codec)
1558
        return -1;
1559
    ret = avcodec_open(&st->codec, codec);
1560
    if (ret < 0)
1561
        return ret;
1562
    switch(st->codec.codec_type) {
1563
    case CODEC_TYPE_VIDEO:
1564
        ret = avcodec_decode_video(&st->codec, &picture, 
1565
                                   &got_picture, (uint8_t *)data, size);
1566
        break;
1567
    case CODEC_TYPE_AUDIO:
1568
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1569
        if (!samples)
1570
            goto fail;
1571
        ret = avcodec_decode_audio(&st->codec, samples, 
1572
                                   &got_picture, (uint8_t *)data, size);
1573
        av_free(samples);
1574
        break;
1575
    default:
1576
        break;
1577
    }
1578
 fail:
1579
    avcodec_close(&st->codec);
1580
    return ret;
1581
}
1582

    
1583
/* absolute maximum size we read until we abort */
1584
#define MAX_READ_SIZE        5000000
1585

    
1586
/* maximum duration until we stop analysing the stream */
1587
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1588

    
1589
/**
1590
 * Read the beginning of a media file to get stream information. This
1591
 * is useful for file formats with no headers such as MPEG. This
1592
 * function also compute the real frame rate in case of mpeg2 repeat
1593
 * frame mode.
1594
 *
1595
 * @param ic media file handle
1596
 * @return >=0 if OK. AVERROR_xxx if error.  
1597
 */
1598
int av_find_stream_info(AVFormatContext *ic)
1599
{
1600
    int i, count, ret, read_size;
1601
    AVStream *st;
1602
    AVPacket pkt1, *pkt;
1603
    AVPacketList *pktl=NULL, **ppktl;
1604

    
1605
    count = 0;
1606
    read_size = 0;
1607
    ppktl = &ic->packet_buffer;
1608
    for(;;) {
1609
        /* check if one codec still needs to be handled */
1610
        for(i=0;i<ic->nb_streams;i++) {
1611
            st = ic->streams[i];
1612
            if (!has_codec_parameters(&st->codec))
1613
                break;
1614
        }
1615
        if (i == ic->nb_streams) {
1616
            /* NOTE: if the format has no header, then we need to read
1617
               some packets to get most of the streams, so we cannot
1618
               stop here */
1619
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1620
                /* if we found the info for all the codecs, we can stop */
1621
                ret = count;
1622
                break;
1623
            }
1624
        } else {
1625
            /* we did not get all the codec info, but we read too much data */
1626
            if (read_size >= MAX_READ_SIZE) {
1627
                ret = count;
1628
                break;
1629
            }
1630
        }
1631

    
1632
        /* NOTE: a new stream can be added there if no header in file
1633
           (AVFMTCTX_NOHEADER) */
1634
        ret = av_read_frame_internal(ic, &pkt1);
1635
        if (ret < 0) {
1636
            /* EOF or error */
1637
            ret = -1; /* we could not have all the codec parameters before EOF */
1638
            if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1639
                i == ic->nb_streams)
1640
                ret = 0;
1641
            break;
1642
        }
1643

    
1644
        pktl = av_mallocz(sizeof(AVPacketList));
1645
        if (!pktl) {
1646
            ret = AVERROR_NOMEM;
1647
            break;
1648
        }
1649

    
1650
        /* add the packet in the buffered packet list */
1651
        *ppktl = pktl;
1652
        ppktl = &pktl->next;
1653

    
1654
        pkt = &pktl->pkt;
1655
        *pkt = pkt1;
1656
        
1657
        /* duplicate the packet */
1658
        if (av_dup_packet(pkt) < 0) {
1659
                ret = AVERROR_NOMEM;
1660
                break;
1661
        }
1662

    
1663
        read_size += pkt->size;
1664

    
1665
        st = ic->streams[pkt->stream_index];
1666
        st->codec_info_duration += pkt->duration;
1667
        if (pkt->duration != 0)
1668
            st->codec_info_nb_frames++;
1669

    
1670
        /* if still no information, we try to open the codec and to
1671
           decompress the frame. We try to avoid that in most cases as
1672
           it takes longer and uses more memory. For MPEG4, we need to
1673
           decompress for Quicktime. */
1674
        if (!has_codec_parameters(&st->codec) &&
1675
            (st->codec.codec_id == CODEC_ID_FLV1 ||
1676
             st->codec.codec_id == CODEC_ID_H264 ||
1677
             st->codec.codec_id == CODEC_ID_H263 ||
1678
             st->codec.codec_id == CODEC_ID_VORBIS ||
1679
             st->codec.codec_id == CODEC_ID_MJPEG ||
1680
             (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1681
            try_decode_frame(st, pkt->data, pkt->size);
1682
        
1683
        if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1684
            break;
1685
        }
1686
        count++;
1687
    }
1688

    
1689
    /* set real frame rate info */
1690
    for(i=0;i<ic->nb_streams;i++) {
1691
        st = ic->streams[i];
1692
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1693
            /* compute the real frame rate for telecine */
1694
            if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1695
                 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1696
                st->codec.sub_id == 2) {
1697
                if (st->codec_info_nb_frames >= 20) {
1698
                    float coded_frame_rate, est_frame_rate;
1699
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1700
                        (double)st->codec_info_duration ;
1701
                    coded_frame_rate = (double)st->codec.frame_rate /
1702
                        (double)st->codec.frame_rate_base;
1703
#if 0
1704
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1705
                           coded_frame_rate, est_frame_rate);
1706
#endif
1707
                    /* if we detect that it could be a telecine, we
1708
                       signal it. It would be better to do it at a
1709
                       higher level as it can change in a film */
1710
                    if (coded_frame_rate >= 24.97 && 
1711
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1712
                        st->r_frame_rate = 24024;
1713
                        st->r_frame_rate_base = 1001;
1714
                    }
1715
                }
1716
            }
1717
            /* if no real frame rate, use the codec one */
1718
            if (!st->r_frame_rate){
1719
                st->r_frame_rate      = st->codec.frame_rate;
1720
                st->r_frame_rate_base = st->codec.frame_rate_base;
1721
            }
1722
        }
1723
    }
1724

    
1725
    av_estimate_timings(ic);
1726
#if 0
1727
    /* correct DTS for b frame streams with no timestamps */
1728
    for(i=0;i<ic->nb_streams;i++) {
1729
        st = ic->streams[i];
1730
        if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1731
            if(b-frames){
1732
                ppktl = &ic->packet_buffer;
1733
                while(ppkt1){
1734
                    if(ppkt1->stream_index != i)
1735
                        continue;
1736
                    if(ppkt1->pkt->dts < 0)
1737
                        break;
1738
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1739
                        break;
1740
                    ppkt1->pkt->dts -= delta;
1741
                    ppkt1= ppkt1->next;
1742
                }
1743
                if(ppkt1)
1744
                    continue;
1745
                st->cur_dts -= delta;
1746
            }
1747
        }
1748
    }
1749
#endif
1750
    return ret;
1751
}
1752

    
1753
/*******************************************************/
1754

    
1755
/**
1756
 * start playing a network based stream (e.g. RTSP stream) at the
1757
 * current position 
1758
 */
1759
int av_read_play(AVFormatContext *s)
1760
{
1761
    if (!s->iformat->read_play)
1762
        return AVERROR_NOTSUPP;
1763
    return s->iformat->read_play(s);
1764
}
1765

    
1766
/**
1767
 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1768
 * to resume it.
1769
 */
1770
int av_read_pause(AVFormatContext *s)
1771
{
1772
    if (!s->iformat->read_pause)
1773
        return AVERROR_NOTSUPP;
1774
    return s->iformat->read_pause(s);
1775
}
1776

    
1777
/**
1778
 * Close a media file (but not its codecs)
1779
 *
1780
 * @param s media file handle
1781
 */
1782
void av_close_input_file(AVFormatContext *s)
1783
{
1784
    int i, must_open_file;
1785
    AVStream *st;
1786

    
1787
    /* free previous packet */
1788
    if (s->cur_st && s->cur_st->parser)
1789
        av_free_packet(&s->cur_pkt); 
1790

    
1791
    if (s->iformat->read_close)
1792
        s->iformat->read_close(s);
1793
    for(i=0;i<s->nb_streams;i++) {
1794
        /* free all data in a stream component */
1795
        st = s->streams[i];
1796
        if (st->parser) {
1797
            av_parser_close(st->parser);
1798
        }
1799
        av_free(st->index_entries);
1800
        av_free(st);
1801
    }
1802
    flush_packet_queue(s);
1803
    must_open_file = 1;
1804
    if (s->iformat->flags & AVFMT_NOFILE) {
1805
        must_open_file = 0;
1806
    }
1807
    if (must_open_file) {
1808
        url_fclose(&s->pb);
1809
    }
1810
    av_freep(&s->priv_data);
1811
    av_free(s);
1812
}
1813

    
1814
/**
1815
 * Add a new stream to a media file. Can only be called in the
1816
 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1817
 * format context, then new streams can be added in read_packet too.
1818
 *
1819
 *
1820
 * @param s media file handle
1821
 * @param id file format dependent stream id 
1822
 */
1823
AVStream *av_new_stream(AVFormatContext *s, int id)
1824
{
1825
    AVStream *st;
1826

    
1827
    if (s->nb_streams >= MAX_STREAMS)
1828
        return NULL;
1829

    
1830
    st = av_mallocz(sizeof(AVStream));
1831
    if (!st)
1832
        return NULL;
1833
    avcodec_get_context_defaults(&st->codec);
1834
    if (s->iformat) {
1835
        /* no default bitrate if decoding */
1836
        st->codec.bit_rate = 0;
1837
    }
1838
    st->index = s->nb_streams;
1839
    st->id = id;
1840
    st->start_time = AV_NOPTS_VALUE;
1841
    st->duration = AV_NOPTS_VALUE;
1842
    st->cur_dts = AV_NOPTS_VALUE;
1843

    
1844
    /* default pts settings is MPEG like */
1845
    av_set_pts_info(st, 33, 1, 90000);
1846
    st->last_IP_pts = AV_NOPTS_VALUE;
1847

    
1848
    s->streams[s->nb_streams++] = st;
1849
    return st;
1850
}
1851

    
1852
/************************************************************/
1853
/* output media file */
1854

    
1855
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1856
{
1857
    int ret;
1858
    
1859
    if (s->oformat->priv_data_size > 0) {
1860
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
1861
        if (!s->priv_data)
1862
            return AVERROR_NOMEM;
1863
    } else
1864
        s->priv_data = NULL;
1865
        
1866
    if (s->oformat->set_parameters) {
1867
        ret = s->oformat->set_parameters(s, ap);
1868
        if (ret < 0)
1869
            return ret;
1870
    }
1871
    return 0;
1872
}
1873

    
1874
/**
1875
 * allocate the stream private data and write the stream header to an
1876
 * output media file
1877
 *
1878
 * @param s media file handle
1879
 * @return 0 if OK. AVERROR_xxx if error.  
1880
 */
1881
int av_write_header(AVFormatContext *s)
1882
{
1883
    int ret, i;
1884
    AVStream *st;
1885

    
1886
    ret = s->oformat->write_header(s);
1887
    if (ret < 0)
1888
        return ret;
1889

    
1890
    /* init PTS generation */
1891
    for(i=0;i<s->nb_streams;i++) {
1892
        st = s->streams[i];
1893

    
1894
        switch (st->codec.codec_type) {
1895
        case CODEC_TYPE_AUDIO:
1896
            av_frac_init(&st->pts, 0, 0, 
1897
                         (int64_t)st->time_base.num * st->codec.sample_rate);
1898
            break;
1899
        case CODEC_TYPE_VIDEO:
1900
            av_frac_init(&st->pts, 0, 0, 
1901
                         (int64_t)st->time_base.num * st->codec.frame_rate);
1902
            break;
1903
        default:
1904
            break;
1905
        }
1906
    }
1907
    return 0;
1908
}
1909

    
1910
//FIXME merge with compute_pkt_fields
1911
static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
1912
    int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
1913
    int num, den, frame_size;
1914

    
1915
//    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);
1916
    
1917
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
1918
        return -1;*/
1919
            
1920
    if(pkt->pts != AV_NOPTS_VALUE)
1921
        pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1922
    if(pkt->dts != AV_NOPTS_VALUE)
1923
        pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1924

    
1925
    /* duration field */
1926
    pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1927
    if (pkt->duration == 0) {
1928
        compute_frame_duration(&num, &den, st, NULL, pkt);
1929
        if (den && num) {
1930
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
1931
        }
1932
    }
1933

    
1934
    //XXX/FIXME this is a temporary hack until all encoders output pts
1935
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
1936
        pkt->dts=
1937
//        pkt->pts= st->cur_dts;
1938
        pkt->pts= st->pts.val;
1939
    }
1940

    
1941
    //calculate dts from pts    
1942
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
1943
        if(b_frames){
1944
            if(st->last_IP_pts == AV_NOPTS_VALUE){
1945
                st->last_IP_pts= -pkt->duration;
1946
            }
1947
            if(st->last_IP_pts < pkt->pts){
1948
                pkt->dts= st->last_IP_pts;
1949
                st->last_IP_pts= pkt->pts;
1950
            }else
1951
                pkt->dts= pkt->pts;
1952
        }else
1953
            pkt->dts= pkt->pts;
1954
    }
1955
    
1956
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
1957
    st->cur_dts= pkt->dts;
1958
    st->pts.val= pkt->dts;
1959

    
1960
    /* update pts */
1961
    switch (st->codec.codec_type) {
1962
    case CODEC_TYPE_AUDIO:
1963
        frame_size = get_audio_frame_size(&st->codec, pkt->size);
1964

    
1965
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1966
           but it would be better if we had the real timestamps from the encoder */
1967
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
1968
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
1969
        }
1970
        break;
1971
    case CODEC_TYPE_VIDEO:
1972
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
1973
        break;
1974
    default:
1975
        break;
1976
    }
1977
}
1978

    
1979
static void truncate_ts(AVStream *st, AVPacket *pkt){
1980
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
1981
    
1982
//    if(pkt->dts < 0)
1983
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
1984
    
1985
    pkt->pts &= pts_mask;
1986
    pkt->dts &= pts_mask;
1987
}
1988

    
1989
/**
1990
 * Write a packet to an output media file. The packet shall contain
1991
 * one audio or video frame.
1992
 *
1993
 * @param s media file handle
1994
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
1995
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1996
 */
1997
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
1998
{
1999
    int ret;
2000

    
2001
    compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2002
    
2003
    truncate_ts(s->streams[pkt->stream_index], pkt);
2004

    
2005
    ret= s->oformat->write_packet(s, pkt);
2006
    if(!ret)
2007
        ret= url_ferror(&s->pb);
2008
    return ret;
2009
}
2010

    
2011
/**
2012
 * interleave_packet implementation which will interleave per DTS.
2013
 */
2014
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2015
    AVPacketList *pktl, **next_point, *this_pktl;
2016
    int stream_count=0;
2017
    int streams[MAX_STREAMS];
2018

    
2019
    if(pkt){
2020
        AVStream *st= s->streams[ pkt->stream_index];
2021

    
2022
        assert(pkt->destruct != av_destruct_packet); //FIXME
2023

    
2024
        this_pktl = av_mallocz(sizeof(AVPacketList));
2025
        this_pktl->pkt= *pkt;
2026
        av_dup_packet(&this_pktl->pkt);
2027

    
2028
        next_point = &s->packet_buffer;
2029
        while(*next_point){
2030
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2031
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2032
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2033
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2034
                break;
2035
            next_point= &(*next_point)->next;
2036
        }
2037
        this_pktl->next= *next_point;
2038
        *next_point= this_pktl;
2039
    }
2040
    
2041
    memset(streams, 0, sizeof(streams));
2042
    pktl= s->packet_buffer;
2043
    while(pktl){
2044
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2045
        if(streams[ pktl->pkt.stream_index ] == 0)
2046
            stream_count++;
2047
        streams[ pktl->pkt.stream_index ]++;
2048
        pktl= pktl->next;
2049
    }
2050
    
2051
    if(s->nb_streams == stream_count || (flush && stream_count)){
2052
        pktl= s->packet_buffer;
2053
        *out= pktl->pkt;
2054
        
2055
        s->packet_buffer= pktl->next;        
2056
        av_freep(&pktl);
2057
        return 1;
2058
    }else{
2059
        av_init_packet(out);
2060
        return 0;
2061
    }
2062
}
2063

    
2064
/**
2065
 * Interleaves a AVPacket correctly so it can be muxed.
2066
 * @param out the interleaved packet will be output here
2067
 * @param in the input packet
2068
 * @param flush 1 if no further packets are available as input and all
2069
 *              remaining packets should be output
2070
 * @return 1 if a packet was output, 0 if no packet could be output, 
2071
 *         < 0 if an error occured
2072
 */
2073
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2074
    if(s->oformat->interleave_packet)
2075
        return s->oformat->interleave_packet(s, out, in, flush);
2076
    else
2077
        return av_interleave_packet_per_dts(s, out, in, flush);
2078
}
2079

    
2080
/**
2081
 * Writes a packet to an output media file ensuring correct interleaving. 
2082
 * The packet shall contain one audio or video frame.
2083
 * If the packets are already correctly interleaved the application should
2084
 * call av_write_frame() instead as its slightly faster, its also important
2085
 * to keep in mind that completly non interleaved input will need huge amounts
2086
 * of memory to interleave with this, so its prefereable to interleave at the
2087
 * demuxer level
2088
 *
2089
 * @param s media file handle
2090
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2091
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2092
 */
2093
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2094
    AVStream *st= s->streams[ pkt->stream_index];
2095

    
2096
    compute_pkt_fields2(st, pkt);
2097
    
2098
    //FIXME/XXX/HACK drop zero sized packets
2099
    if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2100
        return 0;
2101
    
2102
    if(pkt->dts == AV_NOPTS_VALUE)
2103
        return -1;
2104

    
2105
    for(;;){
2106
        AVPacket opkt;
2107
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2108
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2109
            return ret;
2110
        
2111
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2112
        ret= s->oformat->write_packet(s, &opkt);
2113
        
2114
        av_free_packet(&opkt);
2115
        pkt= NULL;
2116
        
2117
        if(ret<0)
2118
            return ret;
2119
        if(url_ferror(&s->pb))
2120
            return url_ferror(&s->pb);
2121
    }
2122
}
2123

    
2124
/**
2125
 * write the stream trailer to an output media file and and free the
2126
 * file private data.
2127
 *
2128
 * @param s media file handle
2129
 * @return 0 if OK. AVERROR_xxx if error.  */
2130
int av_write_trailer(AVFormatContext *s)
2131
{
2132
    int ret, i;
2133
    
2134
    for(;;){
2135
        AVPacket pkt;
2136
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2137
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2138
            goto fail;
2139
        if(!ret)
2140
            break;
2141
        
2142
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2143
        ret= s->oformat->write_packet(s, &pkt);
2144
        
2145
        av_free_packet(&pkt);
2146
        
2147
        if(ret<0)
2148
            goto fail;
2149
        if(url_ferror(&s->pb))
2150
            goto fail;
2151
    }
2152

    
2153
    ret = s->oformat->write_trailer(s);
2154
fail:
2155
    if(ret == 0)
2156
       ret=url_ferror(&s->pb);
2157
    for(i=0;i<s->nb_streams;i++)
2158
        av_freep(&s->streams[i]->priv_data);
2159
    av_freep(&s->priv_data);
2160
    return ret;
2161
}
2162

    
2163
/* "user interface" functions */
2164

    
2165
void dump_format(AVFormatContext *ic,
2166
                 int index, 
2167
                 const char *url,
2168
                 int is_output)
2169
{
2170
    int i, flags;
2171
    char buf[256];
2172

    
2173
    av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
2174
            is_output ? "Output" : "Input",
2175
            index, 
2176
            is_output ? ic->oformat->name : ic->iformat->name, 
2177
            is_output ? "to" : "from", url);
2178
    if (!is_output) {
2179
        av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
2180
        if (ic->duration != AV_NOPTS_VALUE) {
2181
            int hours, mins, secs, us;
2182
            secs = ic->duration / AV_TIME_BASE;
2183
            us = ic->duration % AV_TIME_BASE;
2184
            mins = secs / 60;
2185
            secs %= 60;
2186
            hours = mins / 60;
2187
            mins %= 60;
2188
            av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
2189
                   (10 * us) / AV_TIME_BASE);
2190
        } else {
2191
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2192
        }
2193
        av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
2194
        if (ic->bit_rate) {
2195
            av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
2196
        } else {
2197
            av_log(NULL, AV_LOG_DEBUG, "N/A");
2198
        }
2199
        av_log(NULL, AV_LOG_DEBUG, "\n");
2200
    }
2201
    for(i=0;i<ic->nb_streams;i++) {
2202
        AVStream *st = ic->streams[i];
2203
        avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2204
        av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
2205
        /* the pid is an important information, so we display it */
2206
        /* XXX: add a generic system */
2207
        if (is_output)
2208
            flags = ic->oformat->flags;
2209
        else
2210
            flags = ic->iformat->flags;
2211
        if (flags & AVFMT_SHOW_IDS) {
2212
            av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
2213
        }
2214
        av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
2215
    }
2216
}
2217

    
2218
typedef struct {
2219
    const char *abv;
2220
    int width, height;
2221
    int frame_rate, frame_rate_base;
2222
} AbvEntry;
2223

    
2224
static AbvEntry frame_abvs[] = {
2225
    { "ntsc",      720, 480, 30000, 1001 },
2226
    { "pal",       720, 576,    25,    1 },
2227
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2228
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2229
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2230
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2231
    { "film",      352, 240,    24,    1 },
2232
    { "ntsc-film", 352, 240, 24000, 1001 },
2233
    { "sqcif",     128,  96,     0,    0 },
2234
    { "qcif",      176, 144,     0,    0 },
2235
    { "cif",       352, 288,     0,    0 },
2236
    { "4cif",      704, 576,     0,    0 },
2237
};
2238

    
2239
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2240
{
2241
    int i;
2242
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2243
    const char *p;
2244
    int frame_width = 0, frame_height = 0;
2245

    
2246
    for(i=0;i<n;i++) {
2247
        if (!strcmp(frame_abvs[i].abv, str)) {
2248
            frame_width = frame_abvs[i].width;
2249
            frame_height = frame_abvs[i].height;
2250
            break;
2251
        }
2252
    }
2253
    if (i == n) {
2254
        p = str;
2255
        frame_width = strtol(p, (char **)&p, 10);
2256
        if (*p)
2257
            p++;
2258
        frame_height = strtol(p, (char **)&p, 10);
2259
    }
2260
    if (frame_width <= 0 || frame_height <= 0)
2261
        return -1;
2262
    *width_ptr = frame_width;
2263
    *height_ptr = frame_height;
2264
    return 0;
2265
}
2266

    
2267
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2268
{
2269
    int i;
2270
    char* cp;
2271
   
2272
    /* First, we check our abbreviation table */
2273
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2274
         if (!strcmp(frame_abvs[i].abv, arg)) {
2275
             *frame_rate = frame_abvs[i].frame_rate;
2276
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2277
             return 0;
2278
         }
2279

    
2280
    /* Then, we try to parse it as fraction */
2281
    cp = strchr(arg, '/');
2282
    if (cp) {
2283
        char* cpp;
2284
        *frame_rate = strtol(arg, &cpp, 10);
2285
        if (cpp != arg || cpp == cp) 
2286
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2287
        else
2288
           *frame_rate = 0;
2289
    } 
2290
    else {
2291
        /* Finally we give up and parse it as double */
2292
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2293
        *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2294
    }
2295
    if (!*frame_rate || !*frame_rate_base)
2296
        return -1;
2297
    else
2298
        return 0;
2299
}
2300

    
2301
/* Syntax:
2302
 * - If not a duration:
2303
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2304
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2305
 * Return the date in micro seconds since 1970 
2306
 * - If duration:
2307
 *  HH[:MM[:SS[.m...]]]
2308
 *  S+[.m...]
2309
 */
2310
int64_t parse_date(const char *datestr, int duration)
2311
{
2312
    const char *p;
2313
    int64_t t;
2314
    struct tm dt;
2315
    int i;
2316
    static const char *date_fmt[] = {
2317
        "%Y-%m-%d",
2318
        "%Y%m%d",
2319
    };
2320
    static const char *time_fmt[] = {
2321
        "%H:%M:%S",
2322
        "%H%M%S",
2323
    };
2324
    const char *q;
2325
    int is_utc, len;
2326
    char lastch;
2327
    int negative = 0;
2328

    
2329
#undef time
2330
    time_t now = time(0);
2331

    
2332
    len = strlen(datestr);
2333
    if (len > 0)
2334
        lastch = datestr[len - 1];
2335
    else
2336
        lastch = '\0';
2337
    is_utc = (lastch == 'z' || lastch == 'Z');
2338

    
2339
    memset(&dt, 0, sizeof(dt));
2340

    
2341
    p = datestr;
2342
    q = NULL;
2343
    if (!duration) {
2344
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2345
            q = small_strptime(p, date_fmt[i], &dt);
2346
            if (q) {
2347
                break;
2348
            }
2349
        }
2350

    
2351
        if (!q) {
2352
            if (is_utc) {
2353
                dt = *gmtime(&now);
2354
            } else {
2355
                dt = *localtime(&now);
2356
            }
2357
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2358
        } else {
2359
            p = q;
2360
        }
2361

    
2362
        if (*p == 'T' || *p == 't' || *p == ' ')
2363
            p++;
2364

    
2365
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2366
            q = small_strptime(p, time_fmt[i], &dt);
2367
            if (q) {
2368
                break;
2369
            }
2370
        }
2371
    } else {
2372
        if (p[0] == '-') {
2373
            negative = 1;
2374
            ++p;
2375
        }
2376
        q = small_strptime(p, time_fmt[0], &dt);
2377
        if (!q) {
2378
            dt.tm_sec = strtol(p, (char **)&q, 10);
2379
            dt.tm_min = 0;
2380
            dt.tm_hour = 0;
2381
        }
2382
    }
2383

    
2384
    /* Now we have all the fields that we can get */
2385
    if (!q) {
2386
        if (duration)
2387
            return 0;
2388
        else
2389
            return now * int64_t_C(1000000);
2390
    }
2391

    
2392
    if (duration) {
2393
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2394
    } else {
2395
        dt.tm_isdst = -1;       /* unknown */
2396
        if (is_utc) {
2397
            t = mktimegm(&dt);
2398
        } else {
2399
            t = mktime(&dt);
2400
        }
2401
    }
2402

    
2403
    t *= 1000000;
2404

    
2405
    if (*q == '.') {
2406
        int val, n;
2407
        q++;
2408
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2409
            if (!isdigit(*q)) 
2410
                break;
2411
            val += n * (*q - '0');
2412
        }
2413
        t += val;
2414
    }
2415
    return negative ? -t : t;
2416
}
2417

    
2418
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2419
   1 if found */
2420
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2421
{
2422
    const char *p;
2423
    char tag[128], *q;
2424

    
2425
    p = info;
2426
    if (*p == '?')
2427
        p++;
2428
    for(;;) {
2429
        q = tag;
2430
        while (*p != '\0' && *p != '=' && *p != '&') {
2431
            if ((q - tag) < sizeof(tag) - 1)
2432
                *q++ = *p;
2433
            p++;
2434
        }
2435
        *q = '\0';
2436
        q = arg;
2437
        if (*p == '=') {
2438
            p++;
2439
            while (*p != '&' && *p != '\0') {
2440
                if ((q - arg) < arg_size - 1) {
2441
                    if (*p == '+')
2442
                        *q++ = ' ';
2443
                    else
2444
                        *q++ = *p;
2445
                }
2446
                p++;
2447
            }
2448
            *q = '\0';
2449
        }
2450
        if (!strcmp(tag, tag1)) 
2451
            return 1;
2452
        if (*p != '&')
2453
            break;
2454
        p++;
2455
    }
2456
    return 0;
2457
}
2458

    
2459
/* Return in 'buf' the path with '%d' replaced by number. Also handles
2460
   the '%0nd' format where 'n' is the total number of digits and
2461
   '%%'. Return 0 if OK, and -1 if format error */
2462
int get_frame_filename(char *buf, int buf_size,
2463
                       const char *path, int number)
2464
{
2465
    const char *p;
2466
    char *q, buf1[20], c;
2467
    int nd, len, percentd_found;
2468

    
2469
    q = buf;
2470
    p = path;
2471
    percentd_found = 0;
2472
    for(;;) {
2473
        c = *p++;
2474
        if (c == '\0')
2475
            break;
2476
        if (c == '%') {
2477
            do {
2478
                nd = 0;
2479
                while (isdigit(*p)) {
2480
                    nd = nd * 10 + *p++ - '0';
2481
                }
2482
                c = *p++;
2483
            } while (isdigit(c));
2484

    
2485
            switch(c) {
2486
            case '%':
2487
                goto addchar;
2488
            case 'd':
2489
                if (percentd_found)
2490
                    goto fail;
2491
                percentd_found = 1;
2492
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2493
                len = strlen(buf1);
2494
                if ((q - buf + len) > buf_size - 1)
2495
                    goto fail;
2496
                memcpy(q, buf1, len);
2497
                q += len;
2498
                break;
2499
            default:
2500
                goto fail;
2501
            }
2502
        } else {
2503
        addchar:
2504
            if ((q - buf) < buf_size - 1)
2505
                *q++ = c;
2506
        }
2507
    }
2508
    if (!percentd_found)
2509
        goto fail;
2510
    *q = '\0';
2511
    return 0;
2512
 fail:
2513
    *q = '\0';
2514
    return -1;
2515
}
2516

    
2517
/**
2518
 * Print  nice hexa dump of a buffer
2519
 * @param f stream for output
2520
 * @param buf buffer
2521
 * @param size buffer size
2522
 */
2523
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2524
{
2525
    int len, i, j, c;
2526

    
2527
    for(i=0;i<size;i+=16) {
2528
        len = size - i;
2529
        if (len > 16)
2530
            len = 16;
2531
        fprintf(f, "%08x ", i);
2532
        for(j=0;j<16;j++) {
2533
            if (j < len)
2534
                fprintf(f, " %02x", buf[i+j]);
2535
            else
2536
                fprintf(f, "   ");
2537
        }
2538
        fprintf(f, " ");
2539
        for(j=0;j<len;j++) {
2540
            c = buf[i+j];
2541
            if (c < ' ' || c > '~')
2542
                c = '.';
2543
            fprintf(f, "%c", c);
2544
        }
2545
        fprintf(f, "\n");
2546
    }
2547
}
2548

    
2549
/**
2550
 * Print on 'f' a nice dump of a packet
2551
 * @param f stream for output
2552
 * @param pkt packet to dump
2553
 * @param dump_payload true if the payload must be displayed too
2554
 */
2555
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2556
{
2557
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2558
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2559
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2560
    /* DTS is _always_ valid after av_read_frame() */
2561
    fprintf(f, "  dts=");
2562
    if (pkt->dts == AV_NOPTS_VALUE)
2563
        fprintf(f, "N/A");
2564
    else
2565
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2566
    /* PTS may be not known if B frames are present */
2567
    fprintf(f, "  pts=");
2568
    if (pkt->pts == AV_NOPTS_VALUE)
2569
        fprintf(f, "N/A");
2570
    else
2571
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2572
    fprintf(f, "\n");
2573
    fprintf(f, "  size=%d\n", pkt->size);
2574
    if (dump_payload)
2575
        av_hex_dump(f, pkt->data, pkt->size);
2576
}
2577

    
2578
void url_split(char *proto, int proto_size,
2579
               char *authorization, int authorization_size,
2580
               char *hostname, int hostname_size,
2581
               int *port_ptr,
2582
               char *path, int path_size,
2583
               const char *url)
2584
{
2585
    const char *p;
2586
    char *q;
2587
    int port;
2588

    
2589
    port = -1;
2590

    
2591
    p = url;
2592
    q = proto;
2593
    while (*p != ':' && *p != '\0') {
2594
        if ((q - proto) < proto_size - 1)
2595
            *q++ = *p;
2596
        p++;
2597
    }
2598
    if (proto_size > 0)
2599
        *q = '\0';
2600
    if (authorization_size > 0)
2601
        authorization[0] = '\0';
2602
    if (*p == '\0') {
2603
        if (proto_size > 0)
2604
            proto[0] = '\0';
2605
        if (hostname_size > 0)
2606
            hostname[0] = '\0';
2607
        p = url;
2608
    } else {
2609
        char *at,*slash; // PETR: position of '@' character and '/' character
2610

    
2611
        p++;
2612
        if (*p == '/')
2613
            p++;
2614
        if (*p == '/')
2615
            p++;
2616
        at = strchr(p,'@'); // PETR: get the position of '@'
2617
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2618
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2619

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

    
2622
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2623
            if (*p == '@') {    // PETR: passed '@'
2624
              if (authorization_size > 0)
2625
                  *q = '\0';
2626
              q = hostname;
2627
              at = NULL;
2628
            } else if (!at) {   // PETR: hostname
2629
              if ((q - hostname) < hostname_size - 1)
2630
                  *q++ = *p;
2631
            } else {
2632
              if ((q - authorization) < authorization_size - 1)
2633
                *q++ = *p;
2634
            }
2635
            p++;
2636
        }
2637
        if (hostname_size > 0)
2638
            *q = '\0';
2639
        if (*p == ':') {
2640
            p++;
2641
            port = strtoul(p, (char **)&p, 10);
2642
        }
2643
    }
2644
    if (port_ptr)
2645
        *port_ptr = port;
2646
    pstrcpy(path, path_size, p);
2647
}
2648

    
2649
/**
2650
 * Set the pts for a given stream
2651
 * @param s stream 
2652
 * @param pts_wrap_bits number of bits effectively used by the pts
2653
 *        (used for wrap control, 33 is the value for MPEG) 
2654
 * @param pts_num numerator to convert to seconds (MPEG: 1) 
2655
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2656
 */
2657
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2658
                     int pts_num, int pts_den)
2659
{
2660
    s->pts_wrap_bits = pts_wrap_bits;
2661
    s->time_base.num = pts_num;
2662
    s->time_base.den = pts_den;
2663
}
2664

    
2665
/* fraction handling */
2666

    
2667
/**
2668
 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2669
 * as 0 <= num < den.
2670
 *
2671
 * @param f fractional number
2672
 * @param val integer value
2673
 * @param num must be >= 0
2674
 * @param den must be >= 1 
2675
 */
2676
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2677
{
2678
    num += (den >> 1);
2679
    if (num >= den) {
2680
        val += num / den;
2681
        num = num % den;
2682
    }
2683
    f->val = val;
2684
    f->num = num;
2685
    f->den = den;
2686
}
2687

    
2688
/* set f to (val + 0.5) */
2689
void av_frac_set(AVFrac *f, int64_t val)
2690
{
2691
    f->val = val;
2692
    f->num = f->den >> 1;
2693
}
2694

    
2695
/**
2696
 * Fractionnal addition to f: f = f + (incr / f->den)
2697
 *
2698
 * @param f fractional number
2699
 * @param incr increment, can be positive or negative
2700
 */
2701
void av_frac_add(AVFrac *f, int64_t incr)
2702
{
2703
    int64_t num, den;
2704

    
2705
    num = f->num + incr;
2706
    den = f->den;
2707
    if (num < 0) {
2708
        f->val += num / den;
2709
        num = num % den;
2710
        if (num < 0) {
2711
            num += den;
2712
            f->val--;
2713
        }
2714
    } else if (num >= den) {
2715
        f->val += num / den;
2716
        num = num % den;
2717
    }
2718
    f->num = num;
2719
}
2720

    
2721
/**
2722
 * register a new image format
2723
 * @param img_fmt Image format descriptor
2724
 */
2725
void av_register_image_format(AVImageFormat *img_fmt)
2726
{
2727
    AVImageFormat **p;
2728

    
2729
    p = &first_image_format;
2730
    while (*p != NULL) p = &(*p)->next;
2731
    *p = img_fmt;
2732
    img_fmt->next = NULL;
2733
}
2734

    
2735
/* guess image format */
2736
AVImageFormat *av_probe_image_format(AVProbeData *pd)
2737
{
2738
    AVImageFormat *fmt1, *fmt;
2739
    int score, score_max;
2740

    
2741
    fmt = NULL;
2742
    score_max = 0;
2743
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2744
        if (fmt1->img_probe) {
2745
            score = fmt1->img_probe(pd);
2746
            if (score > score_max) {
2747
                score_max = score;
2748
                fmt = fmt1;
2749
            }
2750
        }
2751
    }
2752
    return fmt;
2753
}
2754

    
2755
AVImageFormat *guess_image_format(const char *filename)
2756
{
2757
    AVImageFormat *fmt1;
2758

    
2759
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2760
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2761
            return fmt1;
2762
    }
2763
    return NULL;
2764
}
2765

    
2766
/**
2767
 * Read an image from a stream. 
2768
 * @param gb byte stream containing the image
2769
 * @param fmt image format, NULL if probing is required
2770
 */
2771
int av_read_image(ByteIOContext *pb, const char *filename,
2772
                  AVImageFormat *fmt,
2773
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2774
{
2775
    char buf[PROBE_BUF_SIZE];
2776
    AVProbeData probe_data, *pd = &probe_data;
2777
    offset_t pos;
2778
    int ret;
2779

    
2780
    if (!fmt) {
2781
        pd->filename = filename;
2782
        pd->buf = buf;
2783
        pos = url_ftell(pb);
2784
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2785
        url_fseek(pb, pos, SEEK_SET);
2786
        fmt = av_probe_image_format(pd);
2787
    }
2788
    if (!fmt)
2789
        return AVERROR_NOFMT;
2790
    ret = fmt->img_read(pb, alloc_cb, opaque);
2791
    return ret;
2792
}
2793

    
2794
/**
2795
 * Write an image to a stream.
2796
 * @param pb byte stream for the image output
2797
 * @param fmt image format
2798
 * @param img image data and informations
2799
 */
2800
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2801
{
2802
    return fmt->img_write(pb, img);
2803
}
2804