00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00030 #include "avformat.h"
00031
00032 #define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
00033 #define _4XMV_TAG MKTAG('4', 'X', 'M', 'V')
00034 #define LIST_TAG MKTAG('L', 'I', 'S', 'T')
00035 #define HEAD_TAG MKTAG('H', 'E', 'A', 'D')
00036 #define TRK__TAG MKTAG('T', 'R', 'K', '_')
00037 #define MOVI_TAG MKTAG('M', 'O', 'V', 'I')
00038 #define VTRK_TAG MKTAG('V', 'T', 'R', 'K')
00039 #define STRK_TAG MKTAG('S', 'T', 'R', 'K')
00040 #define std__TAG MKTAG('s', 't', 'd', '_')
00041 #define name_TAG MKTAG('n', 'a', 'm', 'e')
00042 #define vtrk_TAG MKTAG('v', 't', 'r', 'k')
00043 #define strk_TAG MKTAG('s', 't', 'r', 'k')
00044 #define ifrm_TAG MKTAG('i', 'f', 'r', 'm')
00045 #define pfrm_TAG MKTAG('p', 'f', 'r', 'm')
00046 #define cfrm_TAG MKTAG('c', 'f', 'r', 'm')
00047 #define ifr2_TAG MKTAG('i', 'f', 'r', '2')
00048 #define pfr2_TAG MKTAG('p', 'f', 'r', '2')
00049 #define cfr2_TAG MKTAG('c', 'f', 'r', '2')
00050 #define snd__TAG MKTAG('s', 'n', 'd', '_')
00051
00052 #define vtrk_SIZE 0x44
00053 #define strk_SIZE 0x28
00054
00055 #define GET_LIST_HEADER() \
00056 fourcc_tag = get_le32(pb); \
00057 size = get_le32(pb); \
00058 if (fourcc_tag != LIST_TAG) \
00059 return AVERROR_INVALIDDATA; \
00060 fourcc_tag = get_le32(pb);
00061
00062 typedef struct AudioTrack {
00063 int sample_rate;
00064 int bits;
00065 int channels;
00066 int stream_index;
00067 int adpcm;
00068 } AudioTrack;
00069
00070 typedef struct FourxmDemuxContext {
00071 int width;
00072 int height;
00073 int video_stream_index;
00074 int track_count;
00075 AudioTrack *tracks;
00076 int selected_track;
00077
00078 int64_t audio_pts;
00079 int64_t video_pts;
00080 float fps;
00081 } FourxmDemuxContext;
00082
00083 static int fourxm_probe(AVProbeData *p)
00084 {
00085 if ((AV_RL32(&p->buf[0]) != RIFF_TAG) ||
00086 (AV_RL32(&p->buf[8]) != _4XMV_TAG))
00087 return 0;
00088
00089 return AVPROBE_SCORE_MAX;
00090 }
00091
00092 static int fourxm_read_header(AVFormatContext *s,
00093 AVFormatParameters *ap)
00094 {
00095 ByteIOContext *pb = s->pb;
00096 unsigned int fourcc_tag;
00097 unsigned int size;
00098 int header_size;
00099 FourxmDemuxContext *fourxm = s->priv_data;
00100 unsigned char *header;
00101 int i;
00102 int current_track = -1;
00103 AVStream *st;
00104
00105 fourxm->track_count = 0;
00106 fourxm->tracks = NULL;
00107 fourxm->selected_track = 0;
00108 fourxm->fps = 1.0;
00109
00110
00111 url_fseek(pb, 12, SEEK_CUR);
00112
00113
00114 GET_LIST_HEADER();
00115 header_size = size - 4;
00116 if (fourcc_tag != HEAD_TAG)
00117 return AVERROR_INVALIDDATA;
00118
00119
00120 header = av_malloc(header_size);
00121 if (!header)
00122 return AVERROR(ENOMEM);
00123 if (get_buffer(pb, header, header_size) != header_size)
00124 return AVERROR(EIO);
00125
00126
00127 for (i = 0; i < header_size - 8; i++) {
00128 fourcc_tag = AV_RL32(&header[i]);
00129 size = AV_RL32(&header[i + 4]);
00130
00131 if (fourcc_tag == std__TAG) {
00132 fourxm->fps = av_int2flt(AV_RL32(&header[i + 12]));
00133 } else if (fourcc_tag == vtrk_TAG) {
00134
00135 if (size != vtrk_SIZE) {
00136 av_free(header);
00137 return AVERROR_INVALIDDATA;
00138 }
00139 fourxm->width = AV_RL32(&header[i + 36]);
00140 fourxm->height = AV_RL32(&header[i + 40]);
00141
00142
00143 st = av_new_stream(s, 0);
00144 if (!st)
00145 return AVERROR(ENOMEM);
00146 av_set_pts_info(st, 60, 1, fourxm->fps);
00147
00148 fourxm->video_stream_index = st->index;
00149
00150 st->codec->codec_type = CODEC_TYPE_VIDEO;
00151 st->codec->codec_id = CODEC_ID_4XM;
00152 st->codec->extradata_size = 4;
00153 st->codec->extradata = av_malloc(4);
00154 AV_WL32(st->codec->extradata, AV_RL32(&header[i + 16]));
00155 st->codec->width = fourxm->width;
00156 st->codec->height = fourxm->height;
00157
00158 i += 8 + size;
00159 } else if (fourcc_tag == strk_TAG) {
00160
00161 if (size != strk_SIZE) {
00162 av_free(header);
00163 return AVERROR_INVALIDDATA;
00164 }
00165 current_track = AV_RL32(&header[i + 8]);
00166 if((unsigned)current_track >= UINT_MAX / sizeof(AudioTrack) - 1) {
00167 av_log(s, AV_LOG_ERROR, "current_track too large\n");
00168 return -1;
00169 }
00170 if (current_track + 1 > fourxm->track_count) {
00171 fourxm->track_count = current_track + 1;
00172 fourxm->tracks = av_realloc(fourxm->tracks,
00173 fourxm->track_count * sizeof(AudioTrack));
00174 if (!fourxm->tracks) {
00175 av_free(header);
00176 return AVERROR(ENOMEM);
00177 }
00178 }
00179 fourxm->tracks[current_track].adpcm = AV_RL32(&header[i + 12]);
00180 fourxm->tracks[current_track].channels = AV_RL32(&header[i + 36]);
00181 fourxm->tracks[current_track].sample_rate = AV_RL32(&header[i + 40]);
00182 fourxm->tracks[current_track].bits = AV_RL32(&header[i + 44]);
00183 i += 8 + size;
00184
00185
00186 st = av_new_stream(s, current_track);
00187 if (!st)
00188 return AVERROR(ENOMEM);
00189
00190 av_set_pts_info(st, 60, 1, fourxm->tracks[current_track].sample_rate);
00191
00192 fourxm->tracks[current_track].stream_index = st->index;
00193
00194 st->codec->codec_type = CODEC_TYPE_AUDIO;
00195 st->codec->codec_tag = 0;
00196 st->codec->channels = fourxm->tracks[current_track].channels;
00197 st->codec->sample_rate = fourxm->tracks[current_track].sample_rate;
00198 st->codec->bits_per_sample = fourxm->tracks[current_track].bits;
00199 st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
00200 st->codec->bits_per_sample;
00201 st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
00202 if (fourxm->tracks[current_track].adpcm)
00203 st->codec->codec_id = CODEC_ID_ADPCM_4XM;
00204 else if (st->codec->bits_per_sample == 8)
00205 st->codec->codec_id = CODEC_ID_PCM_U8;
00206 else
00207 st->codec->codec_id = CODEC_ID_PCM_S16LE;
00208 }
00209 }
00210
00211 av_free(header);
00212
00213
00214 GET_LIST_HEADER();
00215 if (fourcc_tag != MOVI_TAG)
00216 return AVERROR_INVALIDDATA;
00217
00218
00219 fourxm->video_pts = -1;
00220 fourxm->audio_pts = 0;
00221
00222 return 0;
00223 }
00224
00225 static int fourxm_read_packet(AVFormatContext *s,
00226 AVPacket *pkt)
00227 {
00228 FourxmDemuxContext *fourxm = s->priv_data;
00229 ByteIOContext *pb = s->pb;
00230 unsigned int fourcc_tag;
00231 unsigned int size, out_size;
00232 int ret = 0;
00233 int track_number;
00234 int packet_read = 0;
00235 unsigned char header[8];
00236 int audio_frame_count;
00237
00238 while (!packet_read) {
00239
00240 if ((ret = get_buffer(s->pb, header, 8)) < 0)
00241 return ret;
00242 fourcc_tag = AV_RL32(&header[0]);
00243 size = AV_RL32(&header[4]);
00244 if (url_feof(pb))
00245 return AVERROR(EIO);
00246 switch (fourcc_tag) {
00247
00248 case LIST_TAG:
00249
00250 fourxm->video_pts ++;
00251
00252
00253 get_le32(pb);
00254 break;
00255
00256 case ifrm_TAG:
00257 case pfrm_TAG:
00258 case cfrm_TAG:
00259 case ifr2_TAG:
00260 case pfr2_TAG:
00261 case cfr2_TAG:
00262 {
00263
00264
00265
00266 if (size + 8 < size || av_new_packet(pkt, size + 8))
00267 return AVERROR(EIO);
00268 pkt->stream_index = fourxm->video_stream_index;
00269 pkt->pts = fourxm->video_pts;
00270 pkt->pos = url_ftell(s->pb);
00271 memcpy(pkt->data, header, 8);
00272 ret = get_buffer(s->pb, &pkt->data[8], size);
00273
00274 if (ret < 0)
00275 av_free_packet(pkt);
00276 else
00277 packet_read = 1;
00278 break;
00279 }
00280
00281 case snd__TAG:
00282 track_number = get_le32(pb);
00283 out_size= get_le32(pb);
00284 size-=8;
00285
00286 if (track_number == fourxm->selected_track) {
00287 ret= av_get_packet(s->pb, pkt, size);
00288 if(ret<0)
00289 return AVERROR(EIO);
00290 pkt->stream_index =
00291 fourxm->tracks[fourxm->selected_track].stream_index;
00292 pkt->pts = fourxm->audio_pts;
00293 packet_read = 1;
00294
00295
00296 audio_frame_count = size;
00297 if (fourxm->tracks[fourxm->selected_track].adpcm)
00298 audio_frame_count -=
00299 2 * (fourxm->tracks[fourxm->selected_track].channels);
00300 audio_frame_count /=
00301 fourxm->tracks[fourxm->selected_track].channels;
00302 if (fourxm->tracks[fourxm->selected_track].adpcm)
00303 audio_frame_count *= 2;
00304 else
00305 audio_frame_count /=
00306 (fourxm->tracks[fourxm->selected_track].bits / 8);
00307 fourxm->audio_pts += audio_frame_count;
00308
00309 } else {
00310 url_fseek(pb, size, SEEK_CUR);
00311 }
00312 break;
00313
00314 default:
00315 url_fseek(pb, size, SEEK_CUR);
00316 break;
00317 }
00318 }
00319 return ret;
00320 }
00321
00322 static int fourxm_read_close(AVFormatContext *s)
00323 {
00324 FourxmDemuxContext *fourxm = s->priv_data;
00325
00326 av_free(fourxm->tracks);
00327
00328 return 0;
00329 }
00330
00331 AVInputFormat fourxm_demuxer = {
00332 "4xm",
00333 "4X Technologies format",
00334 sizeof(FourxmDemuxContext),
00335 fourxm_probe,
00336 fourxm_read_header,
00337 fourxm_read_packet,
00338 fourxm_read_close,
00339 };