← Back to branch summary

~ubuntu-branches/ubuntu/lucid/ffmpeg/lucid-updates

« back to all changes in this revision

Viewing changes to libavformat/raw.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2009-03-13 09:18:28 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090313091828-n4ktby5eca487uhv
Tags: 3:0.svn20090303-1ubuntu1+unstripped1
merge from ubuntu.jaunty branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavformat/raw.c
29
29
#include "id3v2.h"
30
30
 
31
31
/* simple formats */
32
 
#if CONFIG_FLAC_MUXER
33
 
static int flac_write_header(struct AVFormatContext *s)
34
 
{
35
 
    static const uint8_t header[8] = {
36
 
        0x66, 0x4C, 0x61, 0x43, 0x80, 0x00, 0x00, 0x22
37
 
    };
38
 
    uint8_t *streaminfo = s->streams[0]->codec->extradata;
39
 
    int len = s->streams[0]->codec->extradata_size;
40
 
    if(streaminfo != NULL && len > 0) {
41
 
        put_buffer(s->pb, header, 8);
42
 
        put_buffer(s->pb, streaminfo, len);
43
 
    }
44
 
    return 0;
45
 
}
46
 
 
47
 
static int flac_write_trailer(struct AVFormatContext *s)
48
 
{
49
 
    ByteIOContext *pb = s->pb;
50
 
    uint8_t *streaminfo = s->streams[0]->codec->extradata;
51
 
    int len = s->streams[0]->codec->extradata_size;
52
 
    int64_t file_size;
53
 
 
54
 
    if (streaminfo && len > 0 && !url_is_streamed(s->pb)) {
55
 
        file_size = url_ftell(pb);
56
 
        url_fseek(pb, 8, SEEK_SET);
57
 
        put_buffer(pb, streaminfo, len);
58
 
        url_fseek(pb, file_size, SEEK_SET);
59
 
        put_flush_packet(pb);
60
 
    }
61
 
    return 0;
62
 
}
63
 
#endif
64
32
 
65
33
#if CONFIG_ROQ_MUXER
66
34
static int roq_write_header(struct AVFormatContext *s)
162
130
    return ret;
163
131
}
164
132
 
165
 
static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
 
133
int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
166
134
{
167
135
    int ret, size;
168
136
 
229
197
    unk2 = get_le16(s->pb);
230
198
    url_fskip(s->pb, 22); // ASCII timestamp
231
199
 
232
 
    av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
 
200
    av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
233
201
        size, w, h, unk1, unk2);
234
202
 
235
203
    if (av_new_packet(pkt, size) < 0)
290
258
    st->need_parsing = AVSTREAM_PARSE_FULL;
291
259
    /* the parameters will be extracted from the compressed bitstream */
292
260
 
293
 
    if(st->codec->codec_id == CODEC_ID_FLAC) {
294
 
        /* skip ID3v2 header if found */
295
 
        uint8_t buf[ID3v2_HEADER_SIZE];
296
 
        int ret = get_buffer(s->pb, buf, ID3v2_HEADER_SIZE);
297
 
        if (ret == ID3v2_HEADER_SIZE && ff_id3v2_match(buf)) {
298
 
            int len = ff_id3v2_tag_len(buf);
299
 
            url_fseek(s->pb, len - ID3v2_HEADER_SIZE, SEEK_CUR);
300
 
        } else {
301
 
            url_fseek(s->pb, 0, SEEK_SET);
302
 
        }
303
 
    }
304
261
    return 0;
305
262
}
306
263
 
321
278
    /* for MJPEG, specify frame rate */
322
279
    /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/
323
280
    if (ap->time_base.num) {
324
 
        av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
 
281
        st->codec->time_base= ap->time_base;
325
282
    } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
326
283
                st->codec->codec_id == CODEC_ID_MPEG4 ||
327
284
                st->codec->codec_id == CODEC_ID_DIRAC ||
328
285
                st->codec->codec_id == CODEC_ID_H264) {
329
 
        av_set_pts_info(st, 64, 1, 25);
 
286
        st->codec->time_base= (AVRational){1,25};
330
287
    }
 
288
    av_set_pts_info(st, 64, 1, 1200000);
331
289
 
332
290
    return 0;
333
291
}
365
323
        return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
366
324
    return 0;
367
325
}
 
326
 
 
327
#define CAVS_SEQ_START_CODE       0x000001b0
 
328
#define CAVS_PIC_I_START_CODE     0x000001b3
 
329
#define CAVS_UNDEF_START_CODE     0x000001b4
 
330
#define CAVS_PIC_PB_START_CODE    0x000001b6
 
331
#define CAVS_VIDEO_EDIT_CODE      0x000001b7
 
332
#define CAVS_PROFILE_JIZHUN       0x20
 
333
 
 
334
static int cavsvideo_probe(AVProbeData *p)
 
335
{
 
336
    uint32_t code= -1;
 
337
    int pic=0, seq=0, slice_pos = 0;
 
338
    int i;
 
339
 
 
340
    for(i=0; i<p->buf_size; i++){
 
341
        code = (code<<8) + p->buf[i];
 
342
        if ((code & 0xffffff00) == 0x100) {
 
343
            if(code < CAVS_SEQ_START_CODE) {
 
344
                /* slices have to be consecutive */
 
345
                if(code < slice_pos)
 
346
                    return 0;
 
347
                slice_pos = code;
 
348
            } else {
 
349
                slice_pos = 0;
 
350
            }
 
351
            if (code == CAVS_SEQ_START_CODE) {
 
352
                seq++;
 
353
                /* check for the only currently supported profile */
 
354
                if(p->buf[i+1] != CAVS_PROFILE_JIZHUN)
 
355
                    return 0;
 
356
            } else if ((code == CAVS_PIC_I_START_CODE) ||
 
357
                       (code == CAVS_PIC_PB_START_CODE)) {
 
358
                pic++;
 
359
            } else if ((code == CAVS_UNDEF_START_CODE) ||
 
360
                       (code >  CAVS_VIDEO_EDIT_CODE)) {
 
361
                return 0;
 
362
            }
 
363
        }
 
364
    }
 
365
    if(seq && seq*9<=pic*10)
 
366
        return AVPROBE_SCORE_MAX/2;
 
367
    return 0;
 
368
}
368
369
#endif
369
370
 
370
371
#if CONFIG_M4V_DEMUXER
582
583
}
583
584
#endif
584
585
 
585
 
#if CONFIG_FLAC_DEMUXER
586
 
static int flac_probe(AVProbeData *p)
587
 
{
588
 
    uint8_t *bufptr = p->buf;
589
 
    uint8_t *end    = p->buf + p->buf_size;
590
 
 
591
 
    if(ff_id3v2_match(bufptr))
592
 
        bufptr += ff_id3v2_tag_len(bufptr);
593
 
 
594
 
    if(bufptr > end-4 || memcmp(bufptr, "fLaC", 4)) return 0;
595
 
    else                                            return AVPROBE_SCORE_MAX/2;
596
 
}
597
 
#endif
598
 
 
599
586
#if CONFIG_AAC_DEMUXER
600
587
static int adts_aac_probe(AVProbeData *p)
601
588
{
640
627
#if CONFIG_AAC_DEMUXER
641
628
AVInputFormat aac_demuxer = {
642
629
    "aac",
643
 
    NULL_IF_CONFIG_SMALL("ADTS AAC"),
 
630
    NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
644
631
    0,
645
632
    adts_aac_probe,
646
633
    audio_read_header,
647
 
    raw_read_partial_packet,
 
634
    ff_raw_read_partial_packet,
648
635
    .flags= AVFMT_GENERIC_INDEX,
649
636
    .extensions = "aac",
650
637
    .value = CODEC_ID_AAC,
658
645
    0,
659
646
    ac3_probe,
660
647
    audio_read_header,
661
 
    raw_read_partial_packet,
 
648
    ff_raw_read_partial_packet,
662
649
    .flags= AVFMT_GENERIC_INDEX,
663
650
    .extensions = "ac3",
664
651
    .value = CODEC_ID_AC3,
687
674
    0,
688
675
    dirac_probe,
689
676
    video_read_header,
690
 
    raw_read_partial_packet,
 
677
    ff_raw_read_partial_packet,
691
678
    .flags= AVFMT_GENERIC_INDEX,
692
679
    .value = CODEC_ID_DIRAC,
693
680
};
715
702
    0,
716
703
    dnxhd_probe,
717
704
    video_read_header,
718
 
    raw_read_partial_packet,
 
705
    ff_raw_read_partial_packet,
719
706
    .flags= AVFMT_GENERIC_INDEX,
720
707
    .value = CODEC_ID_DNXHD,
721
708
};
743
730
    0,
744
731
    dts_probe,
745
732
    audio_read_header,
746
 
    raw_read_partial_packet,
 
733
    ff_raw_read_partial_packet,
747
734
    .flags= AVFMT_GENERIC_INDEX,
748
735
    .extensions = "dts",
749
736
    .value = CODEC_ID_DTS,
772
759
    0,
773
760
    eac3_probe,
774
761
    audio_read_header,
775
 
    raw_read_partial_packet,
 
762
    ff_raw_read_partial_packet,
776
763
    .flags= AVFMT_GENERIC_INDEX,
777
764
    .extensions = "eac3",
778
765
    .value = CODEC_ID_EAC3,
794
781
};
795
782
#endif
796
783
 
797
 
#if CONFIG_FLAC_DEMUXER
798
 
AVInputFormat flac_demuxer = {
799
 
    "flac",
800
 
    NULL_IF_CONFIG_SMALL("raw FLAC"),
801
 
    0,
802
 
    flac_probe,
803
 
    audio_read_header,
804
 
    raw_read_partial_packet,
805
 
    .flags= AVFMT_GENERIC_INDEX,
806
 
    .extensions = "flac",
807
 
    .value = CODEC_ID_FLAC,
808
 
};
809
 
#endif
810
 
 
811
 
#if CONFIG_FLAC_MUXER
812
 
AVOutputFormat flac_muxer = {
813
 
    "flac",
814
 
    NULL_IF_CONFIG_SMALL("raw FLAC"),
815
 
    "audio/x-flac",
816
 
    "flac",
817
 
    0,
818
 
    CODEC_ID_FLAC,
819
 
    CODEC_ID_NONE,
820
 
    flac_write_header,
821
 
    raw_write_packet,
822
 
    flac_write_trailer,
823
 
    .flags= AVFMT_NOTIMESTAMPS,
824
 
};
825
 
#endif
826
 
 
827
784
#if CONFIG_GSM_DEMUXER
828
785
AVInputFormat gsm_demuxer = {
829
786
    "gsm",
830
 
    NULL_IF_CONFIG_SMALL("GSM"),
 
787
    NULL_IF_CONFIG_SMALL("raw GSM"),
831
788
    0,
832
789
    NULL,
833
790
    audio_read_header,
834
 
    raw_read_partial_packet,
 
791
    ff_raw_read_partial_packet,
835
792
    .flags= AVFMT_GENERIC_INDEX,
836
793
    .extensions = "gsm",
837
794
    .value = CODEC_ID_GSM,
845
802
    0,
846
803
    h261_probe,
847
804
    video_read_header,
848
 
    raw_read_partial_packet,
 
805
    ff_raw_read_partial_packet,
849
806
    .flags= AVFMT_GENERIC_INDEX,
850
807
    .extensions = "h261",
851
808
    .value = CODEC_ID_H261,
874
831
    0,
875
832
    h263_probe,
876
833
    video_read_header,
877
 
    raw_read_partial_packet,
 
834
    ff_raw_read_partial_packet,
878
835
    .flags= AVFMT_GENERIC_INDEX,
879
836
//    .extensions = "h263", //FIXME remove after writing mpeg4_probe
880
837
    .value = CODEC_ID_H263,
903
860
    0,
904
861
    h264_probe,
905
862
    video_read_header,
906
 
    raw_read_partial_packet,
 
863
    ff_raw_read_partial_packet,
907
864
    .flags= AVFMT_GENERIC_INDEX,
908
865
    .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
909
866
    .value = CODEC_ID_H264,
928
885
#if CONFIG_INGENIENT_DEMUXER
929
886
AVInputFormat ingenient_demuxer = {
930
887
    "ingenient",
931
 
    NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),
 
888
    NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
932
889
    0,
933
890
    NULL,
934
891
    video_read_header,
946
903
    0,
947
904
    mpeg4video_probe, /** probing for MPEG-4 data */
948
905
    video_read_header,
949
 
    raw_read_partial_packet,
 
906
    ff_raw_read_partial_packet,
950
907
    .flags= AVFMT_GENERIC_INDEX,
951
908
    .extensions = "m4v",
952
909
    .value = CODEC_ID_MPEG4,
971
928
#if CONFIG_MJPEG_DEMUXER
972
929
AVInputFormat mjpeg_demuxer = {
973
930
    "mjpeg",
974
 
    NULL_IF_CONFIG_SMALL("MJPEG video"),
 
931
    NULL_IF_CONFIG_SMALL("raw MJPEG video"),
975
932
    0,
976
933
    NULL,
977
934
    video_read_header,
978
 
    raw_read_partial_packet,
 
935
    ff_raw_read_partial_packet,
979
936
    .flags= AVFMT_GENERIC_INDEX,
980
937
    .extensions = "mjpg,mjpeg",
981
938
    .value = CODEC_ID_MJPEG,
985
942
#if CONFIG_MJPEG_MUXER
986
943
AVOutputFormat mjpeg_muxer = {
987
944
    "mjpeg",
988
 
    NULL_IF_CONFIG_SMALL("MJPEG video"),
 
945
    NULL_IF_CONFIG_SMALL("raw MJPEG video"),
989
946
    "video/x-mjpeg",
990
947
    "mjpg,mjpeg",
991
948
    0,
1004
961
    0,
1005
962
    NULL,
1006
963
    audio_read_header,
1007
 
    raw_read_partial_packet,
 
964
    ff_raw_read_partial_packet,
1008
965
    .flags= AVFMT_GENERIC_INDEX,
1009
966
    .extensions = "mlp",
1010
967
    .value = CODEC_ID_MLP,
1014
971
#if CONFIG_MPEG1VIDEO_MUXER
1015
972
AVOutputFormat mpeg1video_muxer = {
1016
973
    "mpeg1video",
1017
 
    NULL_IF_CONFIG_SMALL("MPEG video"),
 
974
    NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
1018
975
    "video/x-mpeg",
1019
976
    "mpg,mpeg,m1v",
1020
977
    0,
1029
986
#if CONFIG_MPEG2VIDEO_MUXER
1030
987
AVOutputFormat mpeg2video_muxer = {
1031
988
    "mpeg2video",
1032
 
    NULL_IF_CONFIG_SMALL("MPEG-2 video"),
 
989
    NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
1033
990
    NULL,
1034
991
    "m2v",
1035
992
    0,
1044
1001
#if CONFIG_MPEGVIDEO_DEMUXER
1045
1002
AVInputFormat mpegvideo_demuxer = {
1046
1003
    "mpegvideo",
1047
 
    NULL_IF_CONFIG_SMALL("MPEG video"),
 
1004
    NULL_IF_CONFIG_SMALL("raw MPEG video"),
1048
1005
    0,
1049
1006
    mpegvideo_probe,
1050
1007
    video_read_header,
1051
 
    raw_read_partial_packet,
 
1008
    ff_raw_read_partial_packet,
1052
1009
    .flags= AVFMT_GENERIC_INDEX,
1053
1010
    .value = CODEC_ID_MPEG1VIDEO,
1054
1011
};
1055
1012
#endif
1056
1013
 
 
1014
#if CONFIG_CAVSVIDEO_DEMUXER
 
1015
AVInputFormat cavsvideo_demuxer = {
 
1016
    "cavsvideo",
 
1017
    NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
 
1018
    0,
 
1019
    cavsvideo_probe,
 
1020
    video_read_header,
 
1021
    ff_raw_read_partial_packet,
 
1022
    .flags= AVFMT_GENERIC_INDEX,
 
1023
    .value = CODEC_ID_CAVS,
 
1024
};
 
1025
#endif
 
1026
 
1057
1027
#if CONFIG_NULL_MUXER
1058
1028
AVOutputFormat null_muxer = {
1059
1029
    "null",
1060
 
    NULL_IF_CONFIG_SMALL("null video format"),
 
1030
    NULL_IF_CONFIG_SMALL("raw null video format"),
1061
1031
    NULL,
1062
1032
    NULL,
1063
1033
    0,
1106
1076
AVOutputFormat roq_muxer =
1107
1077
{
1108
1078
    "RoQ",
1109
 
    NULL_IF_CONFIG_SMALL("id RoQ format"),
 
1079
    NULL_IF_CONFIG_SMALL("raw id RoQ format"),
1110
1080
    NULL,
1111
1081
    "roq",
1112
1082
    0,
1124
1094
    0,
1125
1095
    NULL,
1126
1096
    audio_read_header,
1127
 
    raw_read_partial_packet,
 
1097
    ff_raw_read_partial_packet,
1128
1098
    .flags= AVFMT_GENERIC_INDEX,
1129
1099
    .extensions = "shn",
1130
1100
    .value = CODEC_ID_SHORTEN,
1138
1108
    0,
1139
1109
    NULL /* vc1_probe */,
1140
1110
    video_read_header,
1141
 
    raw_read_partial_packet,
 
1111
    ff_raw_read_partial_packet,
1142
1112
    .extensions = "vc1",
1143
1113
    .value = CODEC_ID_VC1,
1144
1114
};