Mercurial > libavformat.hg
annotate 4xm.c @ 5639:829780403fc6 libavformat
Make sure the header value used to avoid repeating headers on seeking to the
start and to avoid initializing codecs with missing headers is set for all streams.
Fixes issue 1723.
author | reimar |
---|---|
date | Mon, 08 Feb 2010 20:25:36 +0000 |
parents | 49c1d3b27727 |
children | 536e5527c1e0 |
rev | line source |
---|---|
137 | 1 /* |
2 * 4X Technologies .4xm File Demuxer (no muxer) | |
3 * Copyright (c) 2003 The ffmpeg Project | |
4 * | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
137 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
137 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
137 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
885
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
137 | 20 */ |
21 | |
22 /** | |
4331
49c1d3b27727
Use full internal pathname in doxygen @file directives.
diego
parents:
4305
diff
changeset
|
23 * @file libavformat/4xm.c |
137 | 24 * 4X Technologies file demuxer |
25 * by Mike Melanson (melanson@pcisys.net) | |
26 * for more information on the .4xm file format, visit: | |
27 * http://www.pcisys.net/~melanson/codecs/ | |
28 */ | |
29 | |
4201
7d2f3f1b68d8
Fix build: Add intreadwrite.h and bswap.h #includes where necessary.
diego
parents:
4199
diff
changeset
|
30 #include "libavutil/intreadwrite.h" |
137 | 31 #include "avformat.h" |
32 | |
4199 | 33 #define RIFF_TAG MKTAG('R', 'I', 'F', 'F') |
4198 | 34 #define FOURXMV_TAG MKTAG('4', 'X', 'M', 'V') |
4199 | 35 #define LIST_TAG MKTAG('L', 'I', 'S', 'T') |
36 #define HEAD_TAG MKTAG('H', 'E', 'A', 'D') | |
37 #define TRK__TAG MKTAG('T', 'R', 'K', '_') | |
38 #define MOVI_TAG MKTAG('M', 'O', 'V', 'I') | |
39 #define VTRK_TAG MKTAG('V', 'T', 'R', 'K') | |
40 #define STRK_TAG MKTAG('S', 'T', 'R', 'K') | |
41 #define std__TAG MKTAG('s', 't', 'd', '_') | |
42 #define name_TAG MKTAG('n', 'a', 'm', 'e') | |
43 #define vtrk_TAG MKTAG('v', 't', 'r', 'k') | |
44 #define strk_TAG MKTAG('s', 't', 'r', 'k') | |
45 #define ifrm_TAG MKTAG('i', 'f', 'r', 'm') | |
46 #define pfrm_TAG MKTAG('p', 'f', 'r', 'm') | |
47 #define cfrm_TAG MKTAG('c', 'f', 'r', 'm') | |
48 #define ifr2_TAG MKTAG('i', 'f', 'r', '2') | |
49 #define pfr2_TAG MKTAG('p', 'f', 'r', '2') | |
50 #define cfr2_TAG MKTAG('c', 'f', 'r', '2') | |
51 #define snd__TAG MKTAG('s', 'n', 'd', '_') | |
137 | 52 |
53 #define vtrk_SIZE 0x44 | |
54 #define strk_SIZE 0x28 | |
55 | |
56 #define GET_LIST_HEADER() \ | |
143 | 57 fourcc_tag = get_le32(pb); \ |
137 | 58 size = get_le32(pb); \ |
59 if (fourcc_tag != LIST_TAG) \ | |
60 return AVERROR_INVALIDDATA; \ | |
143 | 61 fourcc_tag = get_le32(pb); |
137 | 62 |
63 typedef struct AudioTrack { | |
64 int sample_rate; | |
65 int bits; | |
66 int channels; | |
143 | 67 int stream_index; |
145 | 68 int adpcm; |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
69 int64_t audio_pts; |
137 | 70 } AudioTrack; |
71 | |
72 typedef struct FourxmDemuxContext { | |
73 int width; | |
74 int height; | |
143 | 75 int video_stream_index; |
137 | 76 int track_count; |
77 AudioTrack *tracks; | |
143 | 78 |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
79 int64_t video_pts; |
317 | 80 float fps; |
137 | 81 } FourxmDemuxContext; |
82 | |
83 static int fourxm_probe(AVProbeData *p) | |
84 { | |
1673 | 85 if ((AV_RL32(&p->buf[0]) != RIFF_TAG) || |
4198 | 86 (AV_RL32(&p->buf[8]) != FOURXMV_TAG)) |
137 | 87 return 0; |
88 | |
89 return AVPROBE_SCORE_MAX; | |
90 } | |
91 | |
92 static int fourxm_read_header(AVFormatContext *s, | |
143 | 93 AVFormatParameters *ap) |
137 | 94 { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2410
diff
changeset
|
95 ByteIOContext *pb = s->pb; |
137 | 96 unsigned int fourcc_tag; |
97 unsigned int size; | |
98 int header_size; | |
2006 | 99 FourxmDemuxContext *fourxm = s->priv_data; |
137 | 100 unsigned char *header; |
4298 | 101 int i, ret; |
137 | 102 AVStream *st; |
103 | |
104 fourxm->track_count = 0; | |
105 fourxm->tracks = NULL; | |
317 | 106 fourxm->fps = 1.0; |
137 | 107 |
108 /* skip the first 3 32-bit numbers */ | |
109 url_fseek(pb, 12, SEEK_CUR); | |
110 | |
111 /* check for LIST-HEAD */ | |
112 GET_LIST_HEADER(); | |
113 header_size = size - 4; | |
4295 | 114 if (fourcc_tag != HEAD_TAG || header_size < 0) |
137 | 115 return AVERROR_INVALIDDATA; |
116 | |
117 /* allocate space for the header and load the whole thing */ | |
118 header = av_malloc(header_size); | |
119 if (!header) | |
2273
7eb456c4ed8a
Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents:
2006
diff
changeset
|
120 return AVERROR(ENOMEM); |
4296 | 121 if (get_buffer(pb, header, header_size) != header_size){ |
122 av_free(header); | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2273
diff
changeset
|
123 return AVERROR(EIO); |
4296 | 124 } |
137 | 125 |
126 /* take the lazy approach and search for any and all vtrk and strk chunks */ | |
127 for (i = 0; i < header_size - 8; i++) { | |
1673 | 128 fourcc_tag = AV_RL32(&header[i]); |
129 size = AV_RL32(&header[i + 4]); | |
137 | 130 |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
131 if (fourcc_tag == std__TAG) { |
1673 | 132 fourxm->fps = av_int2flt(AV_RL32(&header[i + 12])); |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
133 } else if (fourcc_tag == vtrk_TAG) { |
137 | 134 /* check that there is enough data */ |
135 if (size != vtrk_SIZE) { | |
4298 | 136 ret= AVERROR_INVALIDDATA; |
137 goto fail; | |
137 | 138 } |
4297 | 139 fourxm->width = AV_RL32(&header[i + 36]); |
1673 | 140 fourxm->height = AV_RL32(&header[i + 40]); |
143 | 141 |
142 /* allocate a new AVStream */ | |
143 st = av_new_stream(s, 0); | |
4296 | 144 if (!st){ |
4298 | 145 ret= AVERROR(ENOMEM); |
146 goto fail; | |
4296 | 147 } |
740 | 148 av_set_pts_info(st, 60, 1, fourxm->fps); |
143 | 149 |
150 fourxm->video_stream_index = st->index; | |
151 | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
152 st->codec->codec_type = CODEC_TYPE_VIDEO; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
153 st->codec->codec_id = CODEC_ID_4XM; |
2410
9b58a031620e
Change 4xm demuxer and video decoder to pass the video format version in
rtogni
parents:
2379
diff
changeset
|
154 st->codec->extradata_size = 4; |
9b58a031620e
Change 4xm demuxer and video decoder to pass the video format version in
rtogni
parents:
2379
diff
changeset
|
155 st->codec->extradata = av_malloc(4); |
9b58a031620e
Change 4xm demuxer and video decoder to pass the video format version in
rtogni
parents:
2379
diff
changeset
|
156 AV_WL32(st->codec->extradata, AV_RL32(&header[i + 16])); |
4297 | 157 st->codec->width = fourxm->width; |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
158 st->codec->height = fourxm->height; |
143 | 159 |
2379 | 160 i += 8 + size; |
137 | 161 } else if (fourcc_tag == strk_TAG) { |
4299
59c385f94310
Move current_track variable closer to where it is used.
michael
parents:
4298
diff
changeset
|
162 int current_track; |
137 | 163 /* check that there is enough data */ |
164 if (size != strk_SIZE) { | |
4298 | 165 ret= AVERROR_INVALIDDATA; |
166 goto fail; | |
137 | 167 } |
1673 | 168 current_track = AV_RL32(&header[i + 8]); |
4305
3e1bf36d7c73
Fix remotely exploitable arbitrary code execution vulnerability.
michael
parents:
4303
diff
changeset
|
169 if((unsigned)current_track >= UINT_MAX / sizeof(AudioTrack) - 1){ |
3e1bf36d7c73
Fix remotely exploitable arbitrary code execution vulnerability.
michael
parents:
4303
diff
changeset
|
170 av_log(s, AV_LOG_ERROR, "current_track too large\n"); |
3e1bf36d7c73
Fix remotely exploitable arbitrary code execution vulnerability.
michael
parents:
4303
diff
changeset
|
171 ret= -1; |
3e1bf36d7c73
Fix remotely exploitable arbitrary code execution vulnerability.
michael
parents:
4303
diff
changeset
|
172 goto fail; |
3e1bf36d7c73
Fix remotely exploitable arbitrary code execution vulnerability.
michael
parents:
4303
diff
changeset
|
173 } |
137 | 174 if (current_track + 1 > fourxm->track_count) { |
141 | 175 fourxm->track_count = current_track + 1; |
885 | 176 fourxm->tracks = av_realloc(fourxm->tracks, |
141 | 177 fourxm->track_count * sizeof(AudioTrack)); |
137 | 178 if (!fourxm->tracks) { |
4298 | 179 ret= AVERROR(ENOMEM); |
180 goto fail; | |
137 | 181 } |
182 } | |
4297 | 183 fourxm->tracks[current_track].adpcm = AV_RL32(&header[i + 12]); |
184 fourxm->tracks[current_track].channels = AV_RL32(&header[i + 36]); | |
1673 | 185 fourxm->tracks[current_track].sample_rate = AV_RL32(&header[i + 40]); |
4297 | 186 fourxm->tracks[current_track].bits = AV_RL32(&header[i + 44]); |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
187 fourxm->tracks[current_track].audio_pts = 0; |
137 | 188 i += 8 + size; |
143 | 189 |
190 /* allocate a new AVStream */ | |
191 st = av_new_stream(s, current_track); | |
4296 | 192 if (!st){ |
4298 | 193 ret= AVERROR(ENOMEM); |
194 goto fail; | |
4296 | 195 } |
143 | 196 |
740 | 197 av_set_pts_info(st, 60, 1, fourxm->tracks[current_track].sample_rate); |
462
b69898ffc92a
move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents:
386
diff
changeset
|
198 |
143 | 199 fourxm->tracks[current_track].stream_index = st->index; |
200 | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
201 st->codec->codec_type = CODEC_TYPE_AUDIO; |
1450
1580c48ba4b9
Do not set audio codec_tag to 1, that would be PCM audio.
diego
parents:
1358
diff
changeset
|
202 st->codec->codec_tag = 0; |
4297 | 203 st->codec->channels = fourxm->tracks[current_track].channels; |
204 st->codec->sample_rate = fourxm->tracks[current_track].sample_rate; | |
3908
1d3d17de20ba
Bump Major version, this commit is almost just renaming bits_per_sample to
michael
parents:
3424
diff
changeset
|
205 st->codec->bits_per_coded_sample = fourxm->tracks[current_track].bits; |
4297 | 206 st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * |
3908
1d3d17de20ba
Bump Major version, this commit is almost just renaming bits_per_sample to
michael
parents:
3424
diff
changeset
|
207 st->codec->bits_per_coded_sample; |
1d3d17de20ba
Bump Major version, this commit is almost just renaming bits_per_sample to
michael
parents:
3424
diff
changeset
|
208 st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample; |
4302 | 209 if (fourxm->tracks[current_track].adpcm){ |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
210 st->codec->codec_id = CODEC_ID_ADPCM_4XM; |
4302 | 211 }else if (st->codec->bits_per_coded_sample == 8){ |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
212 st->codec->codec_id = CODEC_ID_PCM_U8; |
4302 | 213 }else |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
214 st->codec->codec_id = CODEC_ID_PCM_S16LE; |
137 | 215 } |
216 } | |
217 | |
218 /* skip over the LIST-MOVI chunk (which is where the stream should be */ | |
219 GET_LIST_HEADER(); | |
4298 | 220 if (fourcc_tag != MOVI_TAG){ |
221 ret= AVERROR_INVALIDDATA; | |
222 goto fail; | |
223 } | |
137 | 224 |
4298 | 225 av_free(header); |
143 | 226 /* initialize context members */ |
740 | 227 fourxm->video_pts = -1; /* first frame will push to 0 */ |
137 | 228 |
229 return 0; | |
4298 | 230 fail: |
231 av_freep(&fourxm->tracks); | |
232 av_free(header); | |
233 return ret; | |
137 | 234 } |
235 | |
236 static int fourxm_read_packet(AVFormatContext *s, | |
143 | 237 AVPacket *pkt) |
137 | 238 { |
239 FourxmDemuxContext *fourxm = s->priv_data; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2410
diff
changeset
|
240 ByteIOContext *pb = s->pb; |
137 | 241 unsigned int fourcc_tag; |
145 | 242 unsigned int size, out_size; |
137 | 243 int ret = 0; |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
244 unsigned int track_number; |
137 | 245 int packet_read = 0; |
143 | 246 unsigned char header[8]; |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
247 int audio_frame_count; |
137 | 248 |
249 while (!packet_read) { | |
250 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2410
diff
changeset
|
251 if ((ret = get_buffer(s->pb, header, 8)) < 0) |
143 | 252 return ret; |
1673 | 253 fourcc_tag = AV_RL32(&header[0]); |
254 size = AV_RL32(&header[4]); | |
137 | 255 if (url_feof(pb)) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2273
diff
changeset
|
256 return AVERROR(EIO); |
137 | 257 switch (fourcc_tag) { |
258 | |
144 | 259 case LIST_TAG: |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
260 /* this is a good time to bump the video pts */ |
740 | 261 fourxm->video_pts ++; |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
262 |
144 | 263 /* skip the LIST-* tag and move on to the next fourcc */ |
264 get_le32(pb); | |
265 break; | |
266 | |
137 | 267 case ifrm_TAG: |
268 case pfrm_TAG: | |
2377
2a44e9c75bf3
pass *fr2 chunks to decoder (Toy-Story2_better-image-quality.4xa contains them)
michael
parents:
2274
diff
changeset
|
269 case cfrm_TAG: |
2a44e9c75bf3
pass *fr2 chunks to decoder (Toy-Story2_better-image-quality.4xa contains them)
michael
parents:
2274
diff
changeset
|
270 case ifr2_TAG: |
2a44e9c75bf3
pass *fr2 chunks to decoder (Toy-Story2_better-image-quality.4xa contains them)
michael
parents:
2274
diff
changeset
|
271 case pfr2_TAG: |
2a44e9c75bf3
pass *fr2 chunks to decoder (Toy-Story2_better-image-quality.4xa contains them)
michael
parents:
2274
diff
changeset
|
272 case cfr2_TAG: |
143 | 273 /* allocate 8 more bytes than 'size' to account for fourcc |
274 * and size */ | |
643 | 275 if (size + 8 < size || av_new_packet(pkt, size + 8)) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2273
diff
changeset
|
276 return AVERROR(EIO); |
143 | 277 pkt->stream_index = fourxm->video_stream_index; |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
278 pkt->pts = fourxm->video_pts; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2410
diff
changeset
|
279 pkt->pos = url_ftell(s->pb); |
143 | 280 memcpy(pkt->data, header, 8); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2410
diff
changeset
|
281 ret = get_buffer(s->pb, &pkt->data[8], size); |
143 | 282 |
4302 | 283 if (ret < 0){ |
143 | 284 av_free_packet(pkt); |
4302 | 285 }else |
143 | 286 packet_read = 1; |
139 | 287 break; |
143 | 288 |
137 | 289 case snd__TAG: |
290 track_number = get_le32(pb); | |
145 | 291 out_size= get_le32(pb); |
292 size-=8; | |
293 | |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
294 if (track_number < fourxm->track_count) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2410
diff
changeset
|
295 ret= av_get_packet(s->pb, pkt, size); |
775 | 296 if(ret<0) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2273
diff
changeset
|
297 return AVERROR(EIO); |
885 | 298 pkt->stream_index = |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
299 fourxm->tracks[track_number].stream_index; |
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
300 pkt->pts = fourxm->tracks[track_number].audio_pts; |
775 | 301 packet_read = 1; |
143 | 302 |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
303 /* pts accounting */ |
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
304 audio_frame_count = size; |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
305 if (fourxm->tracks[track_number].adpcm) |
885 | 306 audio_frame_count -= |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
307 2 * (fourxm->tracks[track_number].channels); |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
308 audio_frame_count /= |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
309 fourxm->tracks[track_number].channels; |
4302 | 310 if (fourxm->tracks[track_number].adpcm){ |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
311 audio_frame_count *= 2; |
4302 | 312 }else |
316
9aa23c6d396e
use the proper file framerate (specified by a float); account the pts
melanson
parents:
254
diff
changeset
|
313 audio_frame_count /= |
4301
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
314 (fourxm->tracks[track_number].bits / 8); |
e7ef6404ec88
Export all tracks (each is a different language) instead of just one.
michael
parents:
4300
diff
changeset
|
315 fourxm->tracks[track_number].audio_pts += audio_frame_count; |
143 | 316 |
137 | 317 } else { |
318 url_fseek(pb, size, SEEK_CUR); | |
319 } | |
320 break; | |
321 | |
322 default: | |
323 url_fseek(pb, size, SEEK_CUR); | |
324 break; | |
325 } | |
326 } | |
327 return ret; | |
328 } | |
329 | |
330 static int fourxm_read_close(AVFormatContext *s) | |
331 { | |
2006 | 332 FourxmDemuxContext *fourxm = s->priv_data; |
137 | 333 |
4303
a6789651f297
Prefer av_freep() over av_free() for variables in the context for safety.
michael
parents:
4302
diff
changeset
|
334 av_freep(&fourxm->tracks); |
137 | 335 |
336 return 0; | |
337 } | |
338 | |
1169 | 339 AVInputFormat fourxm_demuxer = { |
137 | 340 "4xm", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
2771
diff
changeset
|
341 NULL_IF_CONFIG_SMALL("4X Technologies format"), |
137 | 342 sizeof(FourxmDemuxContext), |
343 fourxm_probe, | |
344 fourxm_read_header, | |
345 fourxm_read_packet, | |
346 fourxm_read_close, | |
347 }; |