← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gstreamer0.10-ffmpeg/edgy

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavformat/utils.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20060401161343-n621cgjlujio0otg
Tags: upstream-0.10.1
Import upstream version 0.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavformat/utils.c
14
14
 *
15
15
 * You should have received a copy of the GNU Lesser General Public
16
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
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 */
19
19
#include "avformat.h"
20
20
 
58
58
 
59
59
    if(!filename)
60
60
        return 0;
61
 
    
 
61
 
62
62
    ext = strrchr(filename, '.');
63
63
    if (ext) {
64
64
        ext++;
65
65
        p = extensions;
66
66
        for(;;) {
67
67
            q = ext1;
68
 
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1) 
 
68
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
69
69
                *q++ = *p++;
70
70
            *q = '\0';
71
 
            if (!strcasecmp(ext1, ext)) 
 
71
            if (!strcasecmp(ext1, ext))
72
72
                return 1;
73
 
            if (*p == '\0') 
 
73
            if (*p == '\0')
74
74
                break;
75
75
            p++;
76
76
        }
78
78
    return 0;
79
79
}
80
80
 
81
 
AVOutputFormat *guess_format(const char *short_name, const char *filename, 
 
81
AVOutputFormat *guess_format(const char *short_name, const char *filename,
82
82
                             const char *mime_type)
83
83
{
84
84
    AVOutputFormat *fmt, *fmt_found;
85
85
    int score_max, score;
86
86
 
87
87
    /* specific test for image sequences */
88
 
    if (!short_name && filename && 
 
88
    if (!short_name && filename &&
89
89
        filename_number_test(filename) >= 0 &&
90
90
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
91
91
        return guess_format("image2", NULL, NULL);
92
92
    }
93
 
    if (!short_name && filename && 
 
93
    if (!short_name && filename &&
94
94
        filename_number_test(filename) >= 0 &&
95
95
        guess_image_format(filename)) {
96
96
        return guess_format("image", NULL, NULL);
106
106
            score += 100;
107
107
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
108
108
            score += 10;
109
 
        if (filename && fmt->extensions && 
 
109
        if (filename && fmt->extensions &&
110
110
            match_ext(filename, fmt->extensions)) {
111
111
            score += 5;
112
112
        }
117
117
        fmt = fmt->next;
118
118
    }
119
119
    return fmt_found;
120
 
}   
 
120
}
121
121
 
122
 
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename, 
 
122
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
123
123
                             const char *mime_type)
124
124
{
125
125
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
141
141
/**
142
142
 * Guesses the codec id based upon muxer and filename.
143
143
 */
144
 
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, 
 
144
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
145
145
                            const char *filename, const char *mime_type, enum CodecType type){
146
146
    if(type == CODEC_TYPE_VIDEO){
147
147
        enum CodecID codec_id= CODEC_ID_NONE;
193
193
{
194
194
    void *data;
195
195
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
196
 
        return AVERROR_NOMEM;        
 
196
        return AVERROR_NOMEM;
197
197
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198
198
    if (!data)
199
199
        return AVERROR_NOMEM;
200
200
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
201
201
 
202
202
    av_init_packet(pkt);
203
 
    pkt->data = data; 
 
203
    pkt->data = data;
204
204
    pkt->size = size;
205
205
    pkt->destruct = av_destruct_packet;
206
206
    return 0;
240
240
        /* we duplicate the packet and don't forget to put the padding
241
241
           again */
242
242
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
243
 
            return AVERROR_NOMEM;        
 
243
            return AVERROR_NOMEM;
244
244
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
245
245
        if (!data) {
246
246
            return AVERROR_NOMEM;
273
273
int fifo_size(FifoBuffer *f, uint8_t *rptr)
274
274
{
275
275
    int size;
276
 
    
 
276
 
277
277
    if(!rptr)
278
278
        rptr= f->rptr;
279
279
 
302
302
    } else {
303
303
        size = (f->end - rptr) + (f->wptr - f->buffer);
304
304
    }
305
 
    
 
305
 
306
306
    if (size < buf_size)
307
307
        return -1;
308
308
    while (buf_size > 0) {
325
325
 */
326
326
void fifo_realloc(FifoBuffer *f, unsigned int new_size){
327
327
    unsigned int old_size= f->end - f->buffer;
328
 
    
 
328
 
329
329
    if(old_size < new_size){
330
330
        uint8_t *old= f->buffer;
331
331
 
376
376
    } else {
377
377
        size = (f->end - rptr) + (f->wptr - f->buffer);
378
378
    }
379
 
    
 
379
 
380
380
    if (size < buf_size)
381
381
        return -1;
382
382
    while (buf_size > 0) {
421
421
            if (match_ext(pd->filename, fmt1->extensions)) {
422
422
                score = 50;
423
423
            }
424
 
        } 
 
424
        }
425
425
        if (score > score_max) {
426
426
            score_max = score;
427
427
            fmt = fmt1;
459
459
 * Allocates all the structures needed to read an input stream.
460
460
 *        This does not open the needed codecs for decoding the stream[s].
461
461
 */
462
 
int av_open_input_stream(AVFormatContext **ic_ptr, 
463
 
                         ByteIOContext *pb, const char *filename, 
 
462
int av_open_input_stream(AVFormatContext **ic_ptr,
 
463
                         ByteIOContext *pb, const char *filename,
464
464
                         AVInputFormat *fmt, AVFormatParameters *ap)
465
465
{
466
466
    int err;
508
508
}
509
509
 
510
510
/** Size of probe buffer, for guessing file type from file contents. */
511
 
#define PROBE_BUF_SIZE 2048
 
511
#define PROBE_BUF_MIN 2048
 
512
#define PROBE_BUF_MAX 131072
512
513
 
513
514
/**
514
515
 * Open a media file as input. The codec are not opened. Only the file
521
522
 * @param ap additionnal parameters needed when opening the file (NULL if default)
522
523
 * @return 0 if OK. AVERROR_xxx otherwise.
523
524
 */
524
 
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, 
 
525
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
525
526
                       AVInputFormat *fmt,
526
527
                       int buf_size,
527
528
                       AVFormatParameters *ap)
528
529
{
529
 
    int err, must_open_file, file_opened;
530
 
    uint8_t buf[PROBE_BUF_SIZE];
 
530
    int err, must_open_file, file_opened, probe_size;
531
531
    AVProbeData probe_data, *pd = &probe_data;
532
532
    ByteIOContext pb1, *pb = &pb1;
533
 
    
 
533
 
534
534
    file_opened = 0;
535
535
    pd->filename = "";
536
536
    if (filename)
537
537
        pd->filename = filename;
538
 
    pd->buf = buf;
 
538
    pd->buf = NULL;
539
539
    pd->buf_size = 0;
540
540
 
541
541
    if (!fmt) {
561
561
        if (buf_size > 0) {
562
562
            url_setbufsize(pb, buf_size);
563
563
        }
564
 
        if (!fmt) {
 
564
 
 
565
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
565
566
            /* read probe data */
566
 
            pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
 
567
            pd->buf= av_realloc(pd->buf, probe_size);
 
568
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
567
569
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
568
570
                url_fclose(pb);
569
571
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
 
572
                    file_opened = 0;
570
573
                    err = AVERROR_IO;
571
574
                    goto fail;
572
575
                }
573
576
            }
 
577
            /* guess file format */
 
578
            fmt = av_probe_input_format(pd, 1);
574
579
        }
575
 
    }
576
 
    
577
 
    /* guess file format */
578
 
    if (!fmt) {
579
 
        fmt = av_probe_input_format(pd, 1);
 
580
        av_freep(&pd->buf);
580
581
    }
581
582
 
582
583
    /* if still no format found, error */
584
585
        err = AVERROR_NOFMT;
585
586
        goto fail;
586
587
    }
587
 
        
 
588
 
588
589
    /* XXX: suppress this hack for redirectors */
589
590
#ifdef CONFIG_NETWORK
590
591
    if (fmt == &redir_demux) {
596
597
 
597
598
    /* check filename in case of an image number is expected */
598
599
    if (fmt->flags & AVFMT_NEEDNUMBER) {
599
 
        if (filename_number_test(filename) < 0) { 
 
600
        if (filename_number_test(filename) < 0) {
600
601
            err = AVERROR_NUMEXPECTED;
601
602
            goto fail;
602
603
        }
606
607
        goto fail;
607
608
    return 0;
608
609
 fail:
 
610
    av_freep(&pd->buf);
609
611
    if (file_opened)
610
612
        url_fclose(pb);
611
613
    *ic_ptr = NULL;
612
614
    return err;
613
 
    
 
615
 
614
616
}
615
617
 
616
618
/*******************************************************/
620
622
 *
621
623
 * This function is absolete and should never be used.
622
624
 * Use av_read_frame() instead.
623
 
 * 
 
625
 *
624
626
 * @param s media file handle
625
 
 * @param pkt is filled 
626
 
 * @return 0 if OK. AVERROR_xxx if error.  
 
627
 * @param pkt is filled
 
628
 * @return 0 if OK. AVERROR_xxx if error.
627
629
 */
628
630
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
629
631
{
693
695
/**
694
696
 * Return the frame duration in seconds, return 0 if not available.
695
697
 */
696
 
static void compute_frame_duration(int *pnum, int *pden, AVStream *st, 
 
698
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
697
699
                                   AVCodecParserContext *pc, AVPacket *pkt)
698
700
{
699
701
    int frame_size;
754
756
    return  ((lsb - delta)&mask) + delta;
755
757
}
756
758
 
757
 
static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
 
759
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
758
760
                               AVCodecParserContext *pc, AVPacket *pkt)
759
761
{
760
762
    int num, den, presentation_delayed;
765
767
        if(pkt->dts != AV_NOPTS_VALUE)
766
768
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
767
769
    }
768
 
    
 
770
 
769
771
    if (pkt->duration == 0) {
770
772
        compute_frame_duration(&num, &den, st, pc, pkt);
771
773
        if (den && num) {
781
783
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
782
784
        /* XXX: need has_b_frame, but cannot get it if the codec is
783
785
           not initialized */
784
 
        if ((   st->codec->codec_id == CODEC_ID_H264 
785
 
             || st->codec->has_b_frames) && 
 
786
        if ((   st->codec->codec_id == CODEC_ID_H264
 
787
             || st->codec->has_b_frames) &&
786
788
            pc && pc->pict_type != FF_B_TYPE)
787
789
            presentation_delayed = 1;
788
790
        /* this may be redundant, but it shouldnt hurt */
789
791
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
790
792
            presentation_delayed = 1;
791
793
    }
792
 
    
 
794
 
793
795
    if(st->cur_dts == AV_NOPTS_VALUE){
794
796
        if(presentation_delayed) st->cur_dts = -pkt->duration;
795
797
        else                     st->cur_dts = 0;
828
830
//                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
829
831
            }
830
832
        }
831
 
    
 
833
 
832
834
        /* presentation is not delayed : PTS and DTS are the same */
833
835
        if (pkt->pts == AV_NOPTS_VALUE) {
834
836
            if (pkt->dts == AV_NOPTS_VALUE) {
846
848
        st->cur_dts += pkt->duration;
847
849
    }
848
850
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
849
 
    
 
851
 
850
852
    /* update flags */
851
853
    if (pc) {
852
854
        pkt->flags = 0;
887
889
                s->cur_st = NULL;
888
890
                return 0;
889
891
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
890
 
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size, 
 
892
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
891
893
                                      s->cur_ptr, s->cur_len,
892
894
                                      s->cur_pkt.pts, s->cur_pkt.dts);
893
895
                s->cur_pkt.pts = AV_NOPTS_VALUE;
895
897
                /* increment read pointer */
896
898
                s->cur_ptr += len;
897
899
                s->cur_len -= len;
898
 
                
 
900
 
899
901
                /* return packet if any */
900
902
                if (pkt->size) {
901
903
                got_packet:
909
911
                }
910
912
            } else {
911
913
                /* free packet */
912
 
                av_free_packet(&s->cur_pkt); 
 
914
                av_free_packet(&s->cur_pkt);
913
915
                s->cur_st = NULL;
914
916
            }
915
917
        } else {
922
924
                for(i = 0; i < s->nb_streams; i++) {
923
925
                    st = s->streams[i];
924
926
                    if (st->parser && st->need_parsing) {
925
 
                        av_parser_parse(st->parser, st->codec, 
926
 
                                        &pkt->data, &pkt->size, 
927
 
                                        NULL, 0, 
 
927
                        av_parser_parse(st->parser, st->codec,
 
928
                                        &pkt->data, &pkt->size,
 
929
                                        NULL, 0,
928
930
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
929
931
                        if (pkt->size)
930
932
                            goto got_packet;
933
935
                /* no more packets: really terminates parsing */
934
936
                return ret;
935
937
            }
936
 
            
 
938
 
937
939
            st = s->streams[s->cur_pkt.stream_index];
938
940
 
939
941
            s->cur_st = st;
962
964
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
963
965
 * data). If the audio frames have a variable size (e.g. MPEG audio),
964
966
 * then it contains one frame.
965
 
 * 
 
967
 *
966
968
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
967
969
 * values in AV_TIME_BASE unit (and guessed if the format cannot
968
970
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
969
971
 * has B frames, so it is better to rely on pkt->dts if you do not
970
972
 * decompress the payload.
971
 
 * 
 
973
 *
972
974
 * @return 0 if OK, < 0 if error or end of file.
973
975
 */
974
976
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
984
986
 
985
987
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
986
988
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
987
 
                    if(   pktl->pkt.stream_index == next_pkt->stream_index 
 
989
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
988
990
                       && next_pkt->dts < pktl->pkt.dts
989
991
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
990
992
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
994
996
                }
995
997
                pktl = s->packet_buffer;
996
998
            }
997
 
            
998
 
            if(   next_pkt->pts != AV_NOPTS_VALUE 
999
 
               || next_pkt->dts == AV_NOPTS_VALUE 
 
999
 
 
1000
            if(   next_pkt->pts != AV_NOPTS_VALUE
 
1001
               || next_pkt->dts == AV_NOPTS_VALUE
1000
1002
               || !genpts || eof){
1001
1003
                /* read packet from packet buffer, if there is data */
1002
1004
                *pkt = *next_pkt;
1015
1017
                }else
1016
1018
                    return ret;
1017
1019
            }
1018
 
            
 
1020
 
1019
1021
            /* duplicate the packet */
1020
1022
            if (av_dup_packet(pkt) < 0)
1021
1023
                return AVERROR_NOMEM;
1022
1024
 
1023
1025
            while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
1024
 
            
 
1026
 
1025
1027
            pktl = av_mallocz(sizeof(AVPacketList));
1026
1028
            if (!pktl)
1027
1029
                return AVERROR_NOMEM;
1028
 
    
 
1030
 
1029
1031
            /* add the packet in the buffered packet list */
1030
1032
            *plast_pktl = pktl;
1031
 
            pktl->pkt= *pkt;            
 
1033
            pktl->pkt= *pkt;
1032
1034
        }else{
1033
1035
            assert(!s->packet_buffer);
1034
1036
            return av_read_frame_internal(s, pkt);
1043
1045
 
1044
1046
    for(;;) {
1045
1047
        pktl = s->packet_buffer;
1046
 
        if (!pktl) 
 
1048
        if (!pktl)
1047
1049
            break;
1048
1050
        s->packet_buffer = pktl->next;
1049
1051
        av_free_packet(&pktl->pkt);
1089
1091
    /* fail safe */
1090
1092
    s->cur_ptr = NULL;
1091
1093
    s->cur_len = 0;
1092
 
    
 
1094
 
1093
1095
    /* for each stream, reset read state */
1094
1096
    for(i = 0; i < s->nb_streams; i++) {
1095
1097
        st = s->streams[i];
1096
 
        
 
1098
 
1097
1099
        if (st->parser) {
1098
1100
            av_parser_close(st->parser);
1099
1101
            st->parser = NULL;
1117
1119
    for(i = 0; i < s->nb_streams; i++) {
1118
1120
        AVStream *st = s->streams[i];
1119
1121
 
1120
 
        st->cur_dts = av_rescale(timestamp, 
 
1122
        st->cur_dts = av_rescale(timestamp,
1121
1123
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1122
1124
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1123
1125
    }
1133
1135
{
1134
1136
    AVIndexEntry *entries, *ie;
1135
1137
    int index;
1136
 
    
 
1138
 
1137
1139
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1138
1140
        return -1;
1139
 
    
 
1141
 
1140
1142
    entries = av_fast_realloc(st->index_entries,
1141
1143
                              &st->index_entries_allocated_size,
1142
 
                              (st->nb_index_entries + 1) * 
 
1144
                              (st->nb_index_entries + 1) *
1143
1145
                              sizeof(AVIndexEntry));
1144
1146
    if(!entries)
1145
1147
        return -1;
1167
1169
    ie->timestamp = timestamp;
1168
1170
    ie->min_distance= distance;
1169
1171
    ie->flags = flags;
1170
 
    
 
1172
 
1171
1173
    return index;
1172
1174
}
1173
1175
 
1190
1192
            break;
1191
1193
        if (pkt->stream_index == 0 && st->parser &&
1192
1194
            (pkt->flags & PKT_FLAG_KEY)) {
1193
 
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts, 
 
1195
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1194
1196
                            0, AVINDEX_KEYFRAME);
1195
1197
        }
1196
1198
        av_free_packet(pkt);
1216
1218
 
1217
1219
/**
1218
1220
 * Gets the index for a specific timestamp.
1219
 
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to 
1220
 
 *                 the timestamp which is <= the requested one, if backward is 0 
 
1221
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
 
1222
 *                 the timestamp which is <= the requested one, if backward is 0
1221
1223
 *                 then it will be >=
1222
1224
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1223
1225
 * @return < 0 if no such timestamp could be found
1242
1244
            a = m;
1243
1245
    }
1244
1246
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1245
 
    
 
1247
 
1246
1248
    if(!(flags & AVSEEK_FLAG_ANY)){
1247
1249
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1248
1250
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1249
1251
        }
1250
1252
    }
1251
1253
 
1252
 
    if(m == nb_entries) 
 
1254
    if(m == nb_entries)
1253
1255
        return -1;
1254
1256
    return  m;
1255
1257
}
1272
1274
 
1273
1275
    if (stream_index < 0)
1274
1276
        return -1;
1275
 
    
 
1277
 
1276
1278
#ifdef DEBUG_SEEK
1277
 
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
 
1279
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1278
1280
#endif
1279
1281
 
1280
1282
    ts_max=
1293
1295
            pos_min= e->pos;
1294
1296
            ts_min= e->timestamp;
1295
1297
#ifdef DEBUG_SEEK
1296
 
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n", 
 
1298
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1297
1299
               pos_min,ts_min);
1298
1300
#endif
1299
1301
        }else{
1300
1302
            assert(index==0);
1301
1303
        }
1302
 
        
1303
 
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD); 
 
1304
 
 
1305
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1304
1306
        assert(index < st->nb_index_entries);
1305
1307
        if(index >= 0){
1306
1308
            e= &st->index_entries[index];
1309
1311
            ts_max= e->timestamp;
1310
1312
            pos_limit= pos_max - e->min_distance;
1311
1313
#ifdef DEBUG_SEEK
1312
 
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n", 
 
1314
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1313
1315
               pos_max,pos_limit, ts_max);
1314
1316
#endif
1315
1317
        }
1333
1335
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1334
1336
        if (ts_max == AV_NOPTS_VALUE)
1335
1337
            return -1;
1336
 
        
 
1338
 
1337
1339
        for(;;){
1338
1340
            int64_t tmp_pos= pos_max + 1;
1339
1341
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1347
1349
        pos_limit= pos_max;
1348
1350
    }
1349
1351
 
 
1352
    if(ts_min > ts_max){
 
1353
        return -1;
 
1354
    }else if(ts_min == ts_max){
 
1355
        pos_limit= pos_min;
 
1356
    }
 
1357
 
1350
1358
    no_change=0;
1351
1359
    while (pos_min < pos_limit) {
1352
1360
#ifdef DEBUG_SEEK
1353
 
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
 
1361
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1354
1362
               pos_min, pos_max,
1355
1363
               ts_min, ts_max);
1356
1364
#endif
1380
1388
        else
1381
1389
            no_change=0;
1382
1390
#ifdef DEBUG_SEEK
1383
 
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);
 
1391
av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1384
1392
#endif
1385
1393
        assert(ts != AV_NOPTS_VALUE);
1386
1394
        if (target_ts <= ts) {
1393
1401
            ts_min = ts;
1394
1402
        }
1395
1403
    }
1396
 
    
 
1404
 
1397
1405
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1398
1406
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1399
1407
#ifdef DEBUG_SEEK
1401
1409
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1402
1410
    pos_min++;
1403
1411
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1404
 
    av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
 
1412
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1405
1413
           pos, ts_min, target_ts, ts_max);
1406
1414
#endif
1407
1415
    /* do the seek */
1437
1445
    return 0;
1438
1446
}
1439
1447
 
1440
 
static int av_seek_frame_generic(AVFormatContext *s, 
 
1448
static int av_seek_frame_generic(AVFormatContext *s,
1441
1449
                                 int stream_index, int64_t timestamp, int flags)
1442
1450
{
1443
1451
    int index;
1472
1480
 * Seek to the key frame at timestamp.
1473
1481
 * 'timestamp' in 'stream_index'.
1474
1482
 * @param stream_index If stream_index is (-1), a default
1475
 
 * stream is selected, and timestamp is automatically converted 
 
1483
 * stream is selected, and timestamp is automatically converted
1476
1484
 * from AV_TIME_BASE units to the stream specific time_base.
1477
1485
 * @param timestamp timestamp in AVStream.time_base units
1478
1486
 *        or if there is no stream specified then in AV_TIME_BASE units
1483
1491
{
1484
1492
    int ret;
1485
1493
    AVStream *st;
1486
 
    
 
1494
 
1487
1495
    av_read_frame_flush(s);
1488
 
    
 
1496
 
1489
1497
    if(flags & AVSEEK_FLAG_BYTE)
1490
1498
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1491
 
    
 
1499
 
1492
1500
    if(stream_index < 0){
1493
1501
        stream_index= av_find_default_stream_index(s);
1494
1502
        if(stream_index < 0)
1495
1503
            return -1;
1496
 
            
 
1504
 
1497
1505
        st= s->streams[stream_index];
1498
1506
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1499
1507
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1569
1577
            ic->duration = end_time - start_time;
1570
1578
            if (ic->file_size > 0) {
1571
1579
                /* compute the bit rate */
1572
 
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
 
1580
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1573
1581
                    (double)ic->duration;
1574
1582
            }
1575
1583
        }
1611
1619
    }
1612
1620
 
1613
1621
    /* if duration is already set, we believe it */
1614
 
    if (ic->duration == AV_NOPTS_VALUE && 
1615
 
        ic->bit_rate != 0 && 
 
1622
    if (ic->duration == AV_NOPTS_VALUE &&
 
1623
        ic->bit_rate != 0 &&
1616
1624
        ic->file_size != 0)  {
1617
1625
        filesize = ic->file_size;
1618
1626
        if (filesize > 0) {
1639
1647
    int read_size, i, ret;
1640
1648
    int64_t end_time;
1641
1649
    int64_t filesize, offset, duration;
1642
 
    
 
1650
 
1643
1651
    /* free previous packet */
1644
1652
    if (ic->cur_st && ic->cur_st->parser)
1645
 
        av_free_packet(&ic->cur_pkt); 
 
1653
        av_free_packet(&ic->cur_pkt);
1646
1654
    ic->cur_st = NULL;
1647
1655
 
1648
1656
    /* flush packet queue */
1655
1663
            st->parser= NULL;
1656
1664
        }
1657
1665
    }
1658
 
    
 
1666
 
1659
1667
    /* we read the first packets to get the first PTS (not fully
1660
1668
       accurate, but it is enough now) */
1661
1669
    url_fseek(&ic->pb, 0, SEEK_SET);
1704
1712
        }
1705
1713
        if (i == ic->nb_streams)
1706
1714
            break;
1707
 
        
 
1715
 
1708
1716
        ret = av_read_packet(ic, pkt);
1709
1717
        if (ret != 0)
1710
1718
            break;
1721
1729
        }
1722
1730
        av_free_packet(pkt);
1723
1731
    }
1724
 
    
 
1732
 
1725
1733
    fill_all_stream_timings(ic);
1726
1734
 
1727
1735
    url_fseek(&ic->pb, 0, SEEK_SET);
1760
1768
        AVStream *st;
1761
1769
        for(i = 0;i < ic->nb_streams; i++) {
1762
1770
            st = ic->streams[i];
1763
 
        printf("%d: start_time: %0.3f duration: %0.3f\n", 
1764
 
               i, (double)st->start_time / AV_TIME_BASE, 
 
1771
        printf("%d: start_time: %0.3f duration: %0.3f\n",
 
1772
               i, (double)st->start_time / AV_TIME_BASE,
1765
1773
               (double)st->duration / AV_TIME_BASE);
1766
1774
        }
1767
 
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1768
 
               (double)ic->start_time / AV_TIME_BASE, 
 
1775
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
 
1776
               (double)ic->start_time / AV_TIME_BASE,
1769
1777
               (double)ic->duration / AV_TIME_BASE,
1770
1778
               ic->bit_rate / 1000);
1771
1779
    }
1795
1803
    AVCodec *codec;
1796
1804
    int got_picture, ret=0;
1797
1805
    AVFrame picture;
1798
 
    
 
1806
 
1799
1807
  if(!st->codec->codec){
1800
1808
    codec = avcodec_find_decoder(st->codec->codec_id);
1801
1809
    if (!codec)
1808
1816
  if(!has_codec_parameters(st->codec)){
1809
1817
    switch(st->codec->codec_type) {
1810
1818
    case CODEC_TYPE_VIDEO:
1811
 
        ret = avcodec_decode_video(st->codec, &picture, 
 
1819
        ret = avcodec_decode_video(st->codec, &picture,
1812
1820
                                   &got_picture, (uint8_t *)data, size);
1813
1821
        break;
1814
1822
    case CODEC_TYPE_AUDIO:
1815
1823
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1816
1824
        if (!samples)
1817
1825
            goto fail;
1818
 
        ret = avcodec_decode_audio(st->codec, samples, 
 
1826
        ret = avcodec_decode_audio(st->codec, samples,
1819
1827
                                   &got_picture, (uint8_t *)data, size);
1820
1828
        av_free(samples);
1821
1829
        break;
1840
1848
 * frame mode.
1841
1849
 *
1842
1850
 * @param ic media file handle
1843
 
 * @return >=0 if OK. AVERROR_xxx if error.  
 
1851
 * @return >=0 if OK. AVERROR_xxx if error.
1844
1852
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1845
1853
 */
1846
1854
int av_find_stream_info(AVFormatContext *ic)
1847
1855
{
1848
 
    int i, count, ret, read_size;
 
1856
    int i, count, ret, read_size, j;
1849
1857
    AVStream *st;
1850
1858
    AVPacket pkt1, *pkt;
1851
1859
    AVPacketList *pktl=NULL, **ppktl;
1874
1882
        last_dts[i]= AV_NOPTS_VALUE;
1875
1883
        duration_sum[i]= INT64_MAX;
1876
1884
    }
1877
 
    
 
1885
 
1878
1886
    count = 0;
1879
1887
    read_size = 0;
1880
1888
    ppktl = &ic->packet_buffer;
1885
1893
            if (!has_codec_parameters(st->codec))
1886
1894
                break;
1887
1895
            /* variable fps and no guess at the real fps */
1888
 
            if(   st->codec->time_base.den >= 1000LL*st->codec->time_base.num
 
1896
            if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1889
1897
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1890
1898
                break;
1891
1899
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1936
1944
 
1937
1945
        pkt = &pktl->pkt;
1938
1946
        *pkt = pkt1;
1939
 
        
 
1947
 
1940
1948
        /* duplicate the packet */
1941
1949
        if (av_dup_packet(pkt) < 0) {
1942
1950
                ret = AVERROR_NOMEM;
1977
1985
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1978
1986
            }
1979
1987
        }
1980
 
        
 
1988
 
1981
1989
        /* if still no information, we try to open the codec and to
1982
1990
           decompress the frame. We try to avoid that in most cases as
1983
1991
           it takes longer and uses more memory. For MPEG4, we need to
1998
2006
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1999
2007
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2000
2008
            try_decode_frame(st, pkt->data, pkt->size);
2001
 
        
 
2009
 
2002
2010
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2003
2011
            break;
2004
2012
        }
2017
2025
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2018
2026
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2019
2027
 
2020
 
            if(duration_count[i] && st->codec->time_base.num*1000LL <= st->codec->time_base.den &&
2021
 
               st->time_base.num*duration_sum[i]/duration_count[i]*1000LL > st->time_base.den){
2022
 
                AVRational fps1;
2023
 
                int64_t num, den;
 
2028
            if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
 
2029
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
 
2030
                int64_t num, den, error, best_error;
2024
2031
 
2025
2032
                num= st->time_base.den*duration_count[i];
2026
2033
                den= st->time_base.num*duration_sum[i];
2027
 
                
2028
 
                av_reduce(&fps1.num, &fps1.den, num*1001, den*1000, FFMAX(st->time_base.den, st->time_base.num)/4);
2029
 
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, den, FFMAX(st->time_base.den, st->time_base.num)/4);
2030
 
                if(fps1.num < st->r_frame_rate.num && fps1.den == 1 && (fps1.num==24 || fps1.num==30)){ //FIXME better decission
2031
 
                    st->r_frame_rate.num= fps1.num*1000;
2032
 
                    st->r_frame_rate.den= fps1.den*1001;
 
2034
 
 
2035
                best_error= INT64_MAX;
 
2036
                for(j=1; j<60*12; j++){
 
2037
                    error= ABS(1001*12*num - 1001*j*den);
 
2038
                    if(error < best_error){
 
2039
                        best_error= error;
 
2040
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
 
2041
                    }
 
2042
                }
 
2043
                for(j=24; j<=30; j+=6){
 
2044
                    error= ABS(1001*12*num - 1000*12*j*den);
 
2045
                    if(error < best_error){
 
2046
                        best_error= error;
 
2047
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
 
2048
                    }
2033
2049
                }
2034
2050
            }
2035
2051
 
2040
2056
                st->codec->sub_id == 2) {
2041
2057
                if (st->codec_info_nb_frames >= 20) {
2042
2058
                    float coded_frame_rate, est_frame_rate;
2043
 
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
 
2059
                    est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2044
2060
                        (double)st->codec_info_duration ;
2045
2061
                    coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2046
2062
#if 0
2047
 
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
 
2063
                    printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2048
2064
                           coded_frame_rate, est_frame_rate);
2049
2065
#endif
2050
2066
                    /* if we detect that it could be a telecine, we
2051
2067
                       signal it. It would be better to do it at a
2052
2068
                       higher level as it can change in a film */
2053
 
                    if (coded_frame_rate >= 24.97 && 
 
2069
                    if (coded_frame_rate >= 24.97 &&
2054
2070
                        (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2055
2071
                        st->r_frame_rate = (AVRational){24000, 1001};
2056
2072
                    }
2096
2112
 
2097
2113
/**
2098
2114
 * start playing a network based stream (e.g. RTSP stream) at the
2099
 
 * current position 
 
2115
 * current position
2100
2116
 */
2101
2117
int av_read_play(AVFormatContext *s)
2102
2118
{
2129
2145
 
2130
2146
    /* free previous packet */
2131
2147
    if (s->cur_st && s->cur_st->parser)
2132
 
        av_free_packet(&s->cur_pkt); 
 
2148
        av_free_packet(&s->cur_pkt);
2133
2149
 
2134
2150
    if (s->iformat->read_close)
2135
2151
        s->iformat->read_close(s);
2163
2179
 * can be added in read_packet too.
2164
2180
 *
2165
2181
 * @param s media file handle
2166
 
 * @param id file format dependent stream id 
 
2182
 * @param id file format dependent stream id
2167
2183
 */
2168
2184
AVStream *av_new_stream(AVFormatContext *s, int id)
2169
2185
{
2175
2191
    st = av_mallocz(sizeof(AVStream));
2176
2192
    if (!st)
2177
2193
        return NULL;
2178
 
    
 
2194
 
2179
2195
    st->codec= avcodec_alloc_context();
2180
2196
    if (s->iformat) {
2181
2197
        /* no default bitrate if decoding */
2201
2217
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2202
2218
{
2203
2219
    int ret;
2204
 
    
 
2220
 
2205
2221
    if (s->oformat->priv_data_size > 0) {
2206
2222
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2207
2223
        if (!s->priv_data)
2208
2224
            return AVERROR_NOMEM;
2209
2225
    } else
2210
2226
        s->priv_data = NULL;
2211
 
        
 
2227
 
2212
2228
    if (s->oformat->set_parameters) {
2213
2229
        ret = s->oformat->set_parameters(s, ap);
2214
2230
        if (ret < 0)
2222
2238
 * output media file
2223
2239
 *
2224
2240
 * @param s media file handle
2225
 
 * @return 0 if OK. AVERROR_xxx if error.  
 
2241
 * @return 0 if OK. AVERROR_xxx if error.
2226
2242
 */
2227
2243
int av_write_header(AVFormatContext *s)
2228
2244
{
2253
2269
        }
2254
2270
    }
2255
2271
 
2256
 
    ret = s->oformat->write_header(s);
2257
 
    if (ret < 0)
2258
 
        return ret;
 
2272
    if(s->oformat->write_header){
 
2273
        ret = s->oformat->write_header(s);
 
2274
        if (ret < 0)
 
2275
            return ret;
 
2276
    }
2259
2277
 
2260
2278
    /* init PTS generation */
2261
2279
    for(i=0;i<s->nb_streams;i++) {
2287
2305
    int num, den, frame_size;
2288
2306
 
2289
2307
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
2290
 
    
 
2308
 
2291
2309
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2292
2310
        return -1;*/
2293
 
            
 
2311
 
2294
2312
    /* duration field */
2295
2313
    if (pkt->duration == 0) {
2296
2314
        compute_frame_duration(&num, &den, st, NULL, pkt);
2306
2324
        pkt->pts= st->pts.val;
2307
2325
    }
2308
2326
 
2309
 
    //calculate dts from pts    
 
2327
    //calculate dts from pts
2310
2328
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2311
2329
        if(b_frames){
2312
2330
            if(st->last_IP_pts == AV_NOPTS_VALUE){
2320
2338
        }else
2321
2339
            pkt->dts= pkt->pts;
2322
2340
    }
2323
 
    
 
2341
 
2324
2342
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2325
 
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %Ld >= %Ld\n", st->cur_dts, pkt->dts);
 
2343
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2326
2344
        return -1;
2327
2345
    }
2328
2346
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2356
2374
 
2357
2375
static void truncate_ts(AVStream *st, AVPacket *pkt){
2358
2376
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2359
 
    
 
2377
 
2360
2378
//    if(pkt->dts < 0)
2361
2379
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2362
 
    
 
2380
 
2363
2381
    pkt->pts &= pts_mask;
2364
2382
    pkt->dts &= pts_mask;
2365
2383
}
2380
2398
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2381
2399
    if(ret<0)
2382
2400
        return ret;
2383
 
    
 
2401
 
2384
2402
    truncate_ts(s->streams[pkt->stream_index], pkt);
2385
2403
 
2386
2404
    ret= s->oformat->write_packet(s, pkt);
2391
2409
 
2392
2410
/**
2393
2411
 * interleave_packet implementation which will interleave per DTS.
2394
 
 * packets with pkt->destruct == av_destruct_packet will be freed inside this function. 
 
2412
 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2395
2413
 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2396
2414
 */
2397
2415
static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2423
2441
        this_pktl->next= *next_point;
2424
2442
        *next_point= this_pktl;
2425
2443
    }
2426
 
    
 
2444
 
2427
2445
    memset(streams, 0, sizeof(streams));
2428
2446
    pktl= s->packet_buffer;
2429
2447
    while(pktl){
2433
2451
        streams[ pktl->pkt.stream_index ]++;
2434
2452
        pktl= pktl->next;
2435
2453
    }
2436
 
    
 
2454
 
2437
2455
    if(s->nb_streams == stream_count || (flush && stream_count)){
2438
2456
        pktl= s->packet_buffer;
2439
2457
        *out= pktl->pkt;
2440
 
        
2441
 
        s->packet_buffer= pktl->next;        
 
2458
 
 
2459
        s->packet_buffer= pktl->next;
2442
2460
        av_freep(&pktl);
2443
2461
        return 1;
2444
2462
    }else{
2453
2471
 * @param in the input packet
2454
2472
 * @param flush 1 if no further packets are available as input and all
2455
2473
 *              remaining packets should be output
2456
 
 * @return 1 if a packet was output, 0 if no packet could be output, 
 
2474
 * @return 1 if a packet was output, 0 if no packet could be output,
2457
2475
 *         < 0 if an error occured
2458
2476
 */
2459
2477
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2487
2505
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2488
2506
    if(compute_pkt_fields2(st, pkt) < 0)
2489
2507
        return -1;
2490
 
    
 
2508
 
2491
2509
    if(pkt->dts == AV_NOPTS_VALUE)
2492
2510
        return -1;
2493
2511
 
2496
2514
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2497
2515
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2498
2516
            return ret;
2499
 
        
 
2517
 
2500
2518
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2501
2519
        ret= s->oformat->write_packet(s, &opkt);
2502
 
        
 
2520
 
2503
2521
        av_free_packet(&opkt);
2504
2522
        pkt= NULL;
2505
 
        
 
2523
 
2506
2524
        if(ret<0)
2507
2525
            return ret;
2508
2526
        if(url_ferror(&s->pb))
2520
2538
int av_write_trailer(AVFormatContext *s)
2521
2539
{
2522
2540
    int ret, i;
2523
 
    
 
2541
 
2524
2542
    for(;;){
2525
2543
        AVPacket pkt;
2526
2544
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2528
2546
            goto fail;
2529
2547
        if(!ret)
2530
2548
            break;
2531
 
        
 
2549
 
2532
2550
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2533
2551
        ret= s->oformat->write_packet(s, &pkt);
2534
 
        
 
2552
 
2535
2553
        av_free_packet(&pkt);
2536
 
        
 
2554
 
2537
2555
        if(ret<0)
2538
2556
            goto fail;
2539
2557
        if(url_ferror(&s->pb))
2540
2558
            goto fail;
2541
2559
    }
2542
2560
 
2543
 
    ret = s->oformat->write_trailer(s);
 
2561
    if(s->oformat->write_trailer)
 
2562
        ret = s->oformat->write_trailer(s);
2544
2563
fail:
2545
2564
    if(ret == 0)
2546
2565
       ret=url_ferror(&s->pb);
2553
2572
/* "user interface" functions */
2554
2573
 
2555
2574
void dump_format(AVFormatContext *ic,
2556
 
                 int index, 
 
2575
                 int index,
2557
2576
                 const char *url,
2558
2577
                 int is_output)
2559
2578
{
2560
2579
    int i, flags;
2561
2580
    char buf[256];
2562
2581
 
2563
 
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n", 
 
2582
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2564
2583
            is_output ? "Output" : "Input",
2565
 
            index, 
2566
 
            is_output ? ic->oformat->name : ic->iformat->name, 
 
2584
            index,
 
2585
            is_output ? ic->oformat->name : ic->iformat->name,
2567
2586
            is_output ? "to" : "from", url);
2568
2587
    if (!is_output) {
2569
2588
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2575
2594
            secs %= 60;
2576
2595
            hours = mins / 60;
2577
2596
            mins %= 60;
2578
 
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs, 
 
2597
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2579
2598
                   (10 * us) / AV_TIME_BASE);
2580
2599
        } else {
2581
2600
            av_log(NULL, AV_LOG_INFO, "N/A");
2615
2634
        }
2616
2635
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2617
2636
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2618
 
            av_log(NULL, AV_LOG_INFO, ", %5.2f fps", av_q2d(st->r_frame_rate));
 
2637
            if(st->r_frame_rate.den && st->r_frame_rate.num)
 
2638
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
 
2639
/*            else if(st->time_base.den && st->time_base.num)
 
2640
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
 
2641
            else
 
2642
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2619
2643
        }
2620
2644
        av_log(NULL, AV_LOG_INFO, ": %s\n", buf);
2621
2645
    }
2684
2708
{
2685
2709
    int i;
2686
2710
    char* cp;
2687
 
   
 
2711
 
2688
2712
    /* First, we check our abbreviation table */
2689
2713
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2690
2714
         if (!strcmp(frame_abvs[i].abv, arg)) {
2691
 
             *frame_rate = frame_abvs[i].frame_rate;
2692
 
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2693
 
             return 0;
2694
 
         }
 
2715
             *frame_rate = frame_abvs[i].frame_rate;
 
2716
             *frame_rate_base = frame_abvs[i].frame_rate_base;
 
2717
             return 0;
 
2718
         }
2695
2719
 
2696
2720
    /* Then, we try to parse it as fraction */
2697
2721
    cp = strchr(arg, '/');
2699
2723
        cp = strchr(arg, ':');
2700
2724
    if (cp) {
2701
2725
        char* cpp;
2702
 
        *frame_rate = strtol(arg, &cpp, 10);
2703
 
        if (cpp != arg || cpp == cp) 
2704
 
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2705
 
        else
2706
 
           *frame_rate = 0;
2707
 
    } 
 
2726
        *frame_rate = strtol(arg, &cpp, 10);
 
2727
        if (cpp != arg || cpp == cp)
 
2728
            *frame_rate_base = strtol(cp+1, &cpp, 10);
 
2729
        else
 
2730
           *frame_rate = 0;
 
2731
    }
2708
2732
    else {
2709
2733
        /* Finally we give up and parse it as double */
2710
2734
        *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2724
2748
 * - If not a duration:
2725
2749
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2726
2750
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2727
 
 * Return the date in micro seconds since 1970 
 
2751
 * Return the date in micro seconds since 1970
2728
2752
 *
2729
2753
 * - If a duration:
2730
2754
 *  HH[:MM[:SS[.m...]]]
2731
2755
 *  S+[.m...]
2732
2756
 * @endcode
2733
2757
 */
 
2758
#ifndef CONFIG_WINCE
2734
2759
int64_t parse_date(const char *datestr, int duration)
2735
2760
{
2736
2761
    const char *p;
2793
2818
            }
2794
2819
        }
2795
2820
    } else {
2796
 
        if (p[0] == '-') {
2797
 
            negative = 1;
2798
 
            ++p;
2799
 
        }
 
2821
        if (p[0] == '-') {
 
2822
            negative = 1;
 
2823
            ++p;
 
2824
        }
2800
2825
        q = small_strptime(p, time_fmt[0], &dt);
2801
2826
        if (!q) {
2802
2827
            dt.tm_sec = strtol(p, (char **)&q, 10);
2830
2855
        int val, n;
2831
2856
        q++;
2832
2857
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2833
 
            if (!isdigit(*q)) 
 
2858
            if (!isdigit(*q))
2834
2859
                break;
2835
2860
            val += n * (*q - '0');
2836
2861
        }
2838
2863
    }
2839
2864
    return negative ? -t : t;
2840
2865
}
 
2866
#endif /* CONFIG_WINCE */
2841
2867
 
2842
2868
/**
2843
2869
 * Attempts to find a specific tag in a URL.
2875
2901
            }
2876
2902
            *q = '\0';
2877
2903
        }
2878
 
        if (!strcmp(tag, tag1)) 
 
2904
        if (!strcmp(tag, tag1))
2879
2905
            return 1;
2880
2906
        if (*p != '&')
2881
2907
            break;
3081
3107
/**
3082
3108
 * Set the pts for a given stream.
3083
3109
 *
3084
 
 * @param s stream 
 
3110
 * @param s stream
3085
3111
 * @param pts_wrap_bits number of bits effectively used by the pts
3086
 
 *        (used for wrap control, 33 is the value for MPEG) 
3087
 
 * @param pts_num numerator to convert to seconds (MPEG: 1) 
 
3112
 *        (used for wrap control, 33 is the value for MPEG)
 
3113
 * @param pts_num numerator to convert to seconds (MPEG: 1)
3088
3114
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3089
3115
 */
3090
3116
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3105
3131
 * @param f fractional number
3106
3132
 * @param val integer value
3107
3133
 * @param num must be >= 0
3108
 
 * @param den must be >= 1 
 
3134
 * @param den must be >= 1
3109
3135
 */
3110
3136
void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3111
3137
{
3205
3231
}
3206
3232
 
3207
3233
/**
3208
 
 * Read an image from a stream. 
 
3234
 * Read an image from a stream.
3209
3235
 * @param gb byte stream containing the image
3210
3236
 * @param fmt image format, NULL if probing is required
3211
3237
 */
3213
3239
                  AVImageFormat *fmt,
3214
3240
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3215
3241
{
3216
 
    char buf[PROBE_BUF_SIZE];
 
3242
    uint8_t buf[PROBE_BUF_MIN];
3217
3243
    AVProbeData probe_data, *pd = &probe_data;
3218
3244
    offset_t pos;
3219
3245
    int ret;
3222
3248
        pd->filename = filename;
3223
3249
        pd->buf = buf;
3224
3250
        pos = url_ftell(pb);
3225
 
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
 
3251
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3226
3252
        url_fseek(pb, pos, SEEK_SET);
3227
3253
        fmt = av_probe_image_format(pd);
3228
3254
    }