Mercurial > libavformat.hg

comparison matroskadec.c @ 3642:842752a20c3c libavformat

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
matroskadec: use generic parser to parse tracks
author aurel
date Tue, 05 Aug 2008 00:40:31 +0000
parents 2788411945cf
children 1dfa03e34d5b
comparison
equal deleted inserted replaced
3641:2788411945cf 3642:842752a20c3c
86 uint64_t id_length; 86 uint64_t id_length;
87 char *doctype; 87 char *doctype;
88 uint64_t doctype_version; 88 uint64_t doctype_version;
89 } Ebml; 89 } Ebml;
90 90
91 typedef struct Track { 91 typedef struct {
92 MatroskaTrackType type; 92 uint64_t algo;
93 93 EbmlBin settings;
94 /* Unique track number and track ID. stream_index is the index that 94 } MatroskaTrackCompression;
95 * the calling app uses for this track. */ 95
96 uint32_t num; 96 typedef struct {
97 uint32_t uid; 97 uint64_t scope;
98 98 uint64_t type;
99 char *name; 99 MatroskaTrackCompression compression;
100 char language[4]; 100 } MatroskaTrackEncoding;
101 101
102 char *codec_id; 102 typedef struct {
103 103 double frame_rate;
104 unsigned char *codec_priv; 104 uint64_t display_width;
105 int codec_priv_size; 105 uint64_t display_height;
106 106 uint64_t pixel_width;
107 uint64_t pixel_height;
108 uint64_t fourcc;
109 } MatroskaTrackVideo;
110
111 typedef struct {
112 double samplerate;
113 double out_samplerate;
114 uint64_t bitdepth;
115 uint64_t channels;
116
117 /* real audio header (extracted from extradata) */
118 int coded_framesize;
119 int sub_packet_h;
120 int frame_size;
121 int sub_packet_size;
122 int sub_packet_cnt;
123 int pkt_cnt;
124 uint8_t *buf;
125 } MatroskaTrackAudio;
126
127 typedef struct {
128 uint64_t num;
129 uint64_t type;
130 char *codec_id;
131 EbmlBin codec_priv;
132 char *language;
107 double time_scale; 133 double time_scale;
108 uint64_t default_duration; 134 uint64_t default_duration;
109 uint64_t flag_default; 135 uint64_t flag_default;
110 136 MatroskaTrackVideo video;
111 int encoding_scope; 137 MatroskaTrackAudio audio;
112 MatroskaTrackEncodingCompAlgo encoding_algo; 138 EbmlList encodings;
113 uint8_t *encoding_settings;
114 int encoding_settings_len;
115 139
116 AVStream *stream; 140 AVStream *stream;
117 } MatroskaTrack; 141 } MatroskaTrack;
118
119 typedef struct MatroskaVideoTrack {
120 MatroskaTrack track;
121
122 int pixel_width;
123 int pixel_height;
124 int display_width;
125 int display_height;
126
127 uint32_t fourcc;
128
129 //..
130 } MatroskaVideoTrack;
131
132 typedef struct MatroskaAudioTrack {
133 MatroskaTrack track;
134
135 int channels;
136 int bitdepth;
137 int internal_samplerate;
138 int samplerate;
139 int block_align;
140
141 /* real audio header */
142 int coded_framesize;
143 int sub_packet_h;
144 int frame_size;
145 int sub_packet_size;
146 int sub_packet_cnt;
147 int pkt_cnt;
148 uint8_t *buf;
149 //..
150 } MatroskaAudioTrack;
151
152 typedef struct MatroskaSubtitleTrack {
153 MatroskaTrack track;
154 //..
155 } MatroskaSubtitleTrack;
156
157 #define MAX_TRACK_SIZE (FFMAX3(sizeof(MatroskaVideoTrack), \
158 sizeof(MatroskaAudioTrack), \
159 sizeof(MatroskaSubtitleTrack)))
160 142
161 typedef struct { 143 typedef struct {
162 char *filename; 144 char *filename;
163 char *mime; 145 char *mime;
164 EbmlBin bin; 146 EbmlBin bin;
196 178
197 /* timescale in the file */ 179 /* timescale in the file */
198 uint64_t time_scale; 180 uint64_t time_scale;
199 double duration; 181 double duration;
200 char *title; 182 char *title;
183 EbmlList tracks;
201 EbmlList attachments; 184 EbmlList attachments;
202 EbmlList chapters; 185 EbmlList chapters;
203 EbmlList index; 186 EbmlList index;
204 187
205 /* num_streams is the number of streams that av_new_stream() was called 188 /* num_streams is the number of streams that av_new_stream() was called
206 * for ( = that are available to the calling program). */ 189 * for ( = that are available to the calling program). */
207 int num_tracks;
208 int num_streams; 190 int num_streams;
209 MatroskaTrack *tracks[MAX_STREAMS];
210 191
211 /* cache for ID peeking */ 192 /* cache for ID peeking */
212 uint32_t peek_id; 193 uint32_t peek_id;
213 194
214 /* byte position of the segment inside the stream */ 195 /* byte position of the segment inside the stream */
257 { MATROSKA_ID_SEGMENTUID, EBML_NONE }, 238 { MATROSKA_ID_SEGMENTUID, EBML_NONE },
258 { EBML_ID_VOID, EBML_NONE }, 239 { EBML_ID_VOID, EBML_NONE },
259 { 0 } 240 { 0 }
260 }; 241 };
261 242
243 static EbmlSyntax matroska_track_video[] = {
244 { MATROSKA_ID_VIDEOFRAMERATE, EBML_FLOAT,0, offsetof(MatroskaTrackVideo,frame_rate) },
245 { MATROSKA_ID_VIDEODISPLAYWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_width) },
246 { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_height) },
247 { MATROSKA_ID_VIDEOPIXELWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_width) },
248 { MATROSKA_ID_VIDEOPIXELHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_height) },
249 { MATROSKA_ID_VIDEOCOLORSPACE, EBML_UINT, 0, offsetof(MatroskaTrackVideo,fourcc) },
250 { MATROSKA_ID_VIDEOFLAGINTERLACED,EBML_NONE },
251 { MATROSKA_ID_VIDEOSTEREOMODE, EBML_NONE },
252 { MATROSKA_ID_VIDEOASPECTRATIO, EBML_NONE },
253 { EBML_ID_VOID, EBML_NONE },
254 { 0 }
255 };
256
257 static EbmlSyntax matroska_track_audio[] = {
258 { MATROSKA_ID_AUDIOSAMPLINGFREQ, EBML_FLOAT,0, offsetof(MatroskaTrackAudio,samplerate), {.f=8000.0} },
259 { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ,EBML_FLOAT,0,offsetof(MatroskaTrackAudio,out_samplerate) },
260 { MATROSKA_ID_AUDIOBITDEPTH, EBML_UINT, 0, offsetof(MatroskaTrackAudio,bitdepth) },
261 { MATROSKA_ID_AUDIOCHANNELS, EBML_UINT, 0, offsetof(MatroskaTrackAudio,channels), {.u=1} },
262 { EBML_ID_VOID, EBML_NONE },
263 { 0 }
264 };
265
266 static EbmlSyntax matroska_track_encoding_compression[] = {
267 { MATROSKA_ID_ENCODINGCOMPALGO, EBML_UINT, 0, offsetof(MatroskaTrackCompression,algo), {.u=0} },
268 { MATROSKA_ID_ENCODINGCOMPSETTINGS,EBML_BIN, 0, offsetof(MatroskaTrackCompression,settings) },
269 { EBML_ID_VOID, EBML_NONE },
270 { 0 }
271 };
272
273 static EbmlSyntax matroska_track_encoding[] = {
274 { MATROSKA_ID_ENCODINGSCOPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding,scope), {.u=1} },
275 { MATROSKA_ID_ENCODINGTYPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding,type), {.u=0} },
276 { MATROSKA_ID_ENCODINGCOMPRESSION,EBML_NEST, 0, offsetof(MatroskaTrackEncoding,compression), {.n=matroska_track_encoding_compression} },
277 { EBML_ID_VOID, EBML_NONE },
278 { 0 }
279 };
280
281 static EbmlSyntax matroska_track_encodings[] = {
282 { MATROSKA_ID_TRACKCONTENTENCODING, EBML_NEST, sizeof(MatroskaTrackEncoding), offsetof(MatroskaTrack,encodings), {.n=matroska_track_encoding} },
283 { EBML_ID_VOID, EBML_NONE },
284 { 0 }
285 };
286
287 static EbmlSyntax matroska_track[] = {
288 { MATROSKA_ID_TRACKNUMBER, EBML_UINT, 0, offsetof(MatroskaTrack,num) },
289 { MATROSKA_ID_TRACKTYPE, EBML_UINT, 0, offsetof(MatroskaTrack,type) },
290 { MATROSKA_ID_CODECID, EBML_STR, 0, offsetof(MatroskaTrack,codec_id) },
291 { MATROSKA_ID_CODECPRIVATE, EBML_BIN, 0, offsetof(MatroskaTrack,codec_priv) },
292 { MATROSKA_ID_TRACKLANGUAGE, EBML_UTF8, 0, offsetof(MatroskaTrack,language), {.s="eng"} },
293 { MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, offsetof(MatroskaTrack,default_duration) },
294 { MATROSKA_ID_TRACKTIMECODESCALE, EBML_FLOAT,0, offsetof(MatroskaTrack,time_scale), {.f=1.0} },
295 { MATROSKA_ID_TRACKFLAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTrack,flag_default), {.u=1} },
296 { MATROSKA_ID_TRACKVIDEO, EBML_NEST, 0, offsetof(MatroskaTrack,video), {.n=matroska_track_video} },
297 { MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, offsetof(MatroskaTrack,audio), {.n=matroska_track_audio} },
298 { MATROSKA_ID_TRACKCONTENTENCODINGS,EBML_NEST, 0, 0, {.n=matroska_track_encodings} },
299 { MATROSKA_ID_TRACKUID, EBML_NONE },
300 { MATROSKA_ID_TRACKNAME, EBML_NONE },
301 { MATROSKA_ID_TRACKFLAGENABLED, EBML_NONE },
302 { MATROSKA_ID_TRACKFLAGFORCED, EBML_NONE },
303 { MATROSKA_ID_TRACKFLAGLACING, EBML_NONE },
304 { MATROSKA_ID_CODECNAME, EBML_NONE },
305 { MATROSKA_ID_CODECDECODEALL, EBML_NONE },
306 { MATROSKA_ID_CODECINFOURL, EBML_NONE },
307 { MATROSKA_ID_CODECDOWNLOADURL, EBML_NONE },
308 { MATROSKA_ID_TRACKMINCACHE, EBML_NONE },
309 { MATROSKA_ID_TRACKMAXCACHE, EBML_NONE },
310 { EBML_ID_VOID, EBML_NONE },
311 { 0 }
312 };
313
314 static EbmlSyntax matroska_tracks[] = {
315 { MATROSKA_ID_TRACKENTRY, EBML_NEST, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext,tracks), {.n=matroska_track} },
316 { EBML_ID_VOID, EBML_NONE },
317 { 0 }
318 };
319
262 static EbmlSyntax matroska_attachment[] = { 320 static EbmlSyntax matroska_attachment[] = {
263 { MATROSKA_ID_FILENAME, EBML_UTF8, 0, offsetof(MatroskaAttachement,filename) }, 321 { MATROSKA_ID_FILENAME, EBML_UTF8, 0, offsetof(MatroskaAttachement,filename) },
264 { MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, offsetof(MatroskaAttachement,mime) }, 322 { MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, offsetof(MatroskaAttachement,mime) },
265 { MATROSKA_ID_FILEDATA, EBML_BIN, 0, offsetof(MatroskaAttachement,bin) }, 323 { MATROSKA_ID_FILEDATA, EBML_BIN, 0, offsetof(MatroskaAttachement,bin) },
266 { MATROSKA_ID_FILEUID, EBML_NONE }, 324 { MATROSKA_ID_FILEUID, EBML_NONE },
824 882
825 static MatroskaTrack * 883 static MatroskaTrack *
826 matroska_find_track_by_num (MatroskaDemuxContext *matroska, 884 matroska_find_track_by_num (MatroskaDemuxContext *matroska,
827 int num) 885 int num)
828 { 886 {
887 MatroskaTrack *tracks = matroska->tracks.elem;
829 int i; 888 int i;
830 889
831 for (i = 0; i < matroska->num_tracks; i++) 890 for (i=0; i < matroska->tracks.nb_elem; i++)
832 if (matroska->tracks[i]->num == num) 891 if (tracks[i].num == num)
833 return matroska->tracks[i]; 892 return &tracks[i];
834 893
835 av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %d\n", num); 894 av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %d\n", num);
836 return NULL; 895 return NULL;
837 } 896 }
838 897
1089 } 1148 }
1090 1149
1091 static int 1150 static int
1092 matroska_decode_buffer(uint8_t** buf, int* buf_size, MatroskaTrack *track) 1151 matroska_decode_buffer(uint8_t** buf, int* buf_size, MatroskaTrack *track)
1093 { 1152 {
1153 MatroskaTrackEncoding *encodings = track->encodings.elem;
1094 uint8_t* data = *buf; 1154 uint8_t* data = *buf;
1095 int isize = *buf_size; 1155 int isize = *buf_size;
1096 uint8_t* pkt_data = NULL; 1156 uint8_t* pkt_data = NULL;
1097 int pkt_size = isize; 1157 int pkt_size = isize;
1098 int result = 0; 1158 int result = 0;
1099 int olen; 1159 int olen;
1100 1160
1101 switch (track->encoding_algo) { 1161 switch (encodings[0].compression.algo) {
1102 case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP: 1162 case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP:
1103 return track->encoding_settings_len; 1163 return encodings[0].compression.settings.size;
1104 case MATROSKA_TRACK_ENCODING_COMP_LZO: 1164 case MATROSKA_TRACK_ENCODING_COMP_LZO:
1105 do { 1165 do {
1106 olen = pkt_size *= 3; 1166 olen = pkt_size *= 3;
1107 pkt_data = av_realloc(pkt_data, 1167 pkt_data = av_realloc(pkt_data,
1108 pkt_size+LZO_OUTPUT_PADDING); 1168 pkt_size+LZO_OUTPUT_PADDING);
1163 av_free(pkt_data); 1223 av_free(pkt_data);
1164 return -1; 1224 return -1;
1165 } 1225 }
1166 1226
1167 static int 1227 static int
1168 matroska_add_stream (MatroskaDemuxContext *matroska) 1228 matroska_parse_tracks (MatroskaDemuxContext *matroska)
1169 { 1229 {
1170 int res = 0; 1230 MatroskaTrack *tracks;
1171 uint32_t id; 1231 int i, res;
1172 MatroskaTrack *track; 1232
1173 1233 res = ebml_parse(matroska, matroska_tracks, matroska, MATROSKA_ID_TRACKS, 0);
1174 /* start with the master */ 1234
1175 if ((res = ebml_read_master(matroska, &id)) < 0) 1235 tracks = matroska->tracks.elem;
1176 return res; 1236 for (i=0; i<matroska->tracks.nb_elem; i++) {
1177 1237 MatroskaTrack *track = &tracks[i];
1178 av_log(matroska->ctx, AV_LOG_DEBUG, "parsing track, adding stream..,\n"); 1238 EbmlList *encodings_list = &tracks->encodings;
1179 1239 MatroskaTrackEncoding *encodings = encodings_list->elem;
1180 /* Allocate a generic track. */ 1240
1181 track = av_mallocz(MAX_TRACK_SIZE); 1241 if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
1182 track->time_scale = 1.0; 1242 track->type != MATROSKA_TRACK_TYPE_AUDIO &&
1183 strcpy(track->language, "eng"); 1243 track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
1184 1244 av_log(matroska->ctx, AV_LOG_INFO,
1185 /* try reading the trackentry headers */ 1245 "Unknown or unsupported track type %"PRIu64"\n",
1186 while (res == 0) { 1246 track->type);
1187 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) { 1247 continue;
1188 res = AVERROR(EIO); 1248 }
1189 break; 1249
1190 } else if (matroska->level_up > 0) { 1250 if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
1191 matroska->level_up--; 1251 if (!track->default_duration)
1192 break; 1252 track->default_duration = 1000000000/track->video.frame_rate;
1193 } 1253 if (!track->video.display_width)
1194 1254 track->video.display_width = track->video.pixel_width;
1195 switch (id) { 1255 if (!track->video.display_height)
1196 /* track number (unique stream ID) */ 1256 track->video.display_height = track->video.pixel_height;
1197 case MATROSKA_ID_TRACKNUMBER: { 1257 } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
1198 uint64_t num; 1258 if (!track->audio.out_samplerate)
1199 if ((res = ebml_read_uint(matroska, &id, &num)) < 0) 1259 track->audio.out_samplerate = track->audio.samplerate;
1200 break; 1260 }
1201 track->num = num; 1261 if (encodings_list->nb_elem > 1) {
1202 break; 1262 av_log(matroska->ctx, AV_LOG_ERROR,
1203 } 1263 "Multiple combined encodings no supported");
1204 1264 } else if (encodings_list->nb_elem == 1) {
1205 /* track UID (unique identifier) */ 1265 if (encodings[0].type ||
1206 case MATROSKA_ID_TRACKUID: { 1266 (encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP &&
1207 uint64_t num;
1208 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1209 break;
1210 track->uid = num;
1211 break;
1212 }
1213
1214 /* track type (video, audio, combined, subtitle, etc.) */
1215 case MATROSKA_ID_TRACKTYPE: {
1216 uint64_t num;
1217 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1218 break;
1219 if (track->type && track->type != num) {
1220 av_log(matroska->ctx, AV_LOG_INFO,
1221 "More than one tracktype in an entry - skip\n");
1222 break;
1223 }
1224 track->type = num;
1225
1226 switch (track->type) {
1227 case MATROSKA_TRACK_TYPE_VIDEO:
1228 case MATROSKA_TRACK_TYPE_AUDIO:
1229 case MATROSKA_TRACK_TYPE_SUBTITLE:
1230 break;
1231 case MATROSKA_TRACK_TYPE_COMPLEX:
1232 case MATROSKA_TRACK_TYPE_LOGO:
1233 case MATROSKA_TRACK_TYPE_CONTROL:
1234 default:
1235 av_log(matroska->ctx, AV_LOG_INFO,
1236 "Unknown or unsupported track type 0x%x\n",
1237 track->type);
1238 track->type = MATROSKA_TRACK_TYPE_NONE;
1239 break;
1240 }
1241 break;
1242 }
1243
1244 /* tracktype specific stuff for video */
1245 case MATROSKA_ID_TRACKVIDEO: {
1246 MatroskaVideoTrack *videotrack;
1247 if (!track->type)
1248 track->type = MATROSKA_TRACK_TYPE_VIDEO;
1249 if (track->type != MATROSKA_TRACK_TYPE_VIDEO) {
1250 av_log(matroska->ctx, AV_LOG_INFO,
1251 "video data in non-video track - ignoring\n");
1252 res = AVERROR_INVALIDDATA;
1253 break;
1254 } else if ((res = ebml_read_master(matroska, &id)) < 0)
1255 break;
1256 videotrack = (MatroskaVideoTrack *)track;
1257
1258 while (res == 0) {
1259 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1260 res = AVERROR(EIO);
1261 break;
1262 } else if (matroska->level_up > 0) {
1263 matroska->level_up--;
1264 break;
1265 }
1266
1267 switch (id) {
1268 /* fixme, this should be one-up, but I get it here */
1269 case MATROSKA_ID_TRACKDEFAULTDURATION: {
1270 uint64_t num;
1271 if ((res = ebml_read_uint (matroska, &id,
1272 &num)) < 0)
1273 break;
1274 track->default_duration = num;
1275 break;
1276 }
1277
1278 /* video framerate */
1279 case MATROSKA_ID_VIDEOFRAMERATE: {
1280 double num;
1281 if ((res = ebml_read_float(matroska, &id,
1282 &num)) < 0)
1283 break;
1284 if (!track->default_duration)
1285 track->default_duration = 1000000000/num;
1286 break;
1287 }
1288
1289 /* width of the size to display the video at */
1290 case MATROSKA_ID_VIDEODISPLAYWIDTH: {
1291 uint64_t num;
1292 if ((res = ebml_read_uint(matroska, &id,
1293 &num)) < 0)
1294 break;
1295 videotrack->display_width = num;
1296 break;
1297 }
1298
1299 /* height of the size to display the video at */
1300 case MATROSKA_ID_VIDEODISPLAYHEIGHT: {
1301 uint64_t num;
1302 if ((res = ebml_read_uint(matroska, &id,
1303 &num)) < 0)
1304 break;
1305 videotrack->display_height = num;
1306 break;
1307 }
1308
1309 /* width of the video in the file */
1310 case MATROSKA_ID_VIDEOPIXELWIDTH: {
1311 uint64_t num;
1312 if ((res = ebml_read_uint(matroska, &id,
1313 &num)) < 0)
1314 break;
1315 videotrack->pixel_width = num;
1316 break;
1317 }
1318
1319 /* height of the video in the file */
1320 case MATROSKA_ID_VIDEOPIXELHEIGHT: {
1321 uint64_t num;
1322 if ((res = ebml_read_uint(matroska, &id,
1323 &num)) < 0)
1324 break;
1325 videotrack->pixel_height = num;
1326 break;
1327 }
1328
1329 /* whether the video is interlaced */
1330 case MATROSKA_ID_VIDEOFLAGINTERLACED: {
1331 uint64_t num;
1332 if ((res = ebml_read_uint(matroska, &id,
1333 &num)) < 0)
1334 break;
1335 break;
1336 }
1337
1338 /* colorspace (only matters for raw video)
1339 * fourcc */
1340 case MATROSKA_ID_VIDEOCOLORSPACE: {
1341 uint64_t num;
1342 if ((res = ebml_read_uint(matroska, &id,
1343 &num)) < 0)
1344 break;
1345 videotrack->fourcc = num;
1346 break;
1347 }
1348
1349 default:
1350 av_log(matroska->ctx, AV_LOG_INFO,
1351 "Unknown video track header entry "
1352 "0x%x - ignoring\n", id);
1353 /* pass-through */
1354
1355 case MATROSKA_ID_VIDEOSTEREOMODE:
1356 case MATROSKA_ID_VIDEOASPECTRATIO:
1357 case EBML_ID_VOID:
1358 res = ebml_read_skip(matroska);
1359 break;
1360 }
1361
1362 if (matroska->level_up) {
1363 matroska->level_up--;
1364 break;
1365 }
1366 }
1367 break;
1368 }
1369
1370 /* tracktype specific stuff for audio */
1371 case MATROSKA_ID_TRACKAUDIO: {
1372 MatroskaAudioTrack *audiotrack;
1373 if (!track->type)
1374 track->type = MATROSKA_TRACK_TYPE_AUDIO;
1375 if (track->type != MATROSKA_TRACK_TYPE_AUDIO) {
1376 av_log(matroska->ctx, AV_LOG_INFO,
1377 "audio data in non-audio track - ignoring\n");
1378 res = AVERROR_INVALIDDATA;
1379 break;
1380 } else if ((res = ebml_read_master(matroska, &id)) < 0)
1381 break;
1382 audiotrack = (MatroskaAudioTrack *)track;
1383 audiotrack->channels = 1;
1384 audiotrack->samplerate = 8000;
1385
1386 while (res == 0) {
1387 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1388 res = AVERROR(EIO);
1389 break;
1390 } else if (matroska->level_up > 0) {
1391 matroska->level_up--;
1392 break;
1393 }
1394
1395 switch (id) {
1396 /* samplerate */
1397 case MATROSKA_ID_AUDIOSAMPLINGFREQ: {
1398 double num;
1399 if ((res = ebml_read_float(matroska, &id,
1400 &num)) < 0)
1401 break;
1402 audiotrack->internal_samplerate =
1403 audiotrack->samplerate = num;
1404 break;
1405 }
1406
1407 case MATROSKA_ID_AUDIOOUTSAMPLINGFREQ: {
1408 double num;
1409 if ((res = ebml_read_float(matroska, &id,
1410 &num)) < 0)
1411 break;
1412 audiotrack->samplerate = num;
1413 break;
1414 }
1415
1416 /* bitdepth */
1417 case MATROSKA_ID_AUDIOBITDEPTH: {
1418 uint64_t num;
1419 if ((res = ebml_read_uint(matroska, &id,
1420 &num)) < 0)
1421 break;
1422 audiotrack->bitdepth = num;
1423 break;
1424 }
1425
1426 /* channels */
1427 case MATROSKA_ID_AUDIOCHANNELS: {
1428 uint64_t num;
1429 if ((res = ebml_read_uint(matroska, &id,
1430 &num)) < 0)
1431 break;
1432 audiotrack->channels = num;
1433 break;
1434 }
1435
1436 default:
1437 av_log(matroska->ctx, AV_LOG_INFO,
1438 "Unknown audio track header entry "
1439 "0x%x - ignoring\n", id);
1440 /* pass-through */
1441
1442 case EBML_ID_VOID:
1443 res = ebml_read_skip(matroska);
1444 break;
1445 }
1446
1447 if (matroska->level_up) {
1448 matroska->level_up--;
1449 break;
1450 }
1451 }
1452 break;
1453 }
1454
1455 /* codec identifier */
1456 case MATROSKA_ID_CODECID: {
1457 char *text;
1458 if ((res = ebml_read_ascii(matroska, &id, &text)) < 0)
1459 break;
1460 track->codec_id = text;
1461 break;
1462 }
1463
1464 /* codec private data */
1465 case MATROSKA_ID_CODECPRIVATE: {
1466 uint8_t *data;
1467 int size;
1468 if ((res = ebml_read_binary(matroska, &id, &data, &size) < 0))
1469 break;
1470 track->codec_priv = data;
1471 track->codec_priv_size = size;
1472 break;
1473 }
1474
1475 /* name of this track */
1476 case MATROSKA_ID_TRACKNAME: {
1477 char *text;
1478 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1479 break;
1480 track->name = text;
1481 break;
1482 }
1483
1484 /* language (matters for audio/subtitles, mostly) */
1485 case MATROSKA_ID_TRACKLANGUAGE: {
1486 char *text, *end;
1487 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1488 break;
1489 if ((end = strchr(text, '-')))
1490 *end = '\0';
1491 if (strlen(text) == 3)
1492 strcpy(track->language, text);
1493 av_free(text);
1494 break;
1495 }
1496
1497 /* whether this is actually used */
1498 case MATROSKA_ID_TRACKFLAGENABLED: {
1499 uint64_t num;
1500 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1501 break;
1502 break;
1503 }
1504
1505 /* whether it's the default for this track type */
1506 case MATROSKA_ID_TRACKFLAGDEFAULT: {
1507 uint64_t num;
1508 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1509 break;
1510 track->flag_default = num;
1511 break;
1512 }
1513
1514 /* lacing (like MPEG, where blocks don't end/start on frame
1515 * boundaries) */
1516 case MATROSKA_ID_TRACKFLAGLACING: {
1517 uint64_t num;
1518 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1519 break;
1520 break;
1521 }
1522
1523 /* default length (in time) of one data block in this track */
1524 case MATROSKA_ID_TRACKDEFAULTDURATION: {
1525 uint64_t num;
1526 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1527 break;
1528 track->default_duration = num;
1529 break;
1530 }
1531
1532 case MATROSKA_ID_TRACKCONTENTENCODINGS: {
1533 if ((res = ebml_read_master(matroska, &id)) < 0)
1534 break;
1535
1536 while (res == 0) {
1537 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1538 res = AVERROR(EIO);
1539 break;
1540 } else if (matroska->level_up > 0) {
1541 matroska->level_up--;
1542 break;
1543 }
1544
1545 switch (id) {
1546 case MATROSKA_ID_TRACKCONTENTENCODING: {
1547 int encoding_scope = 1;
1548 if ((res = ebml_read_master(matroska, &id)) < 0)
1549 break;
1550
1551 while (res == 0) {
1552 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1553 res = AVERROR(EIO);
1554 break;
1555 } else if (matroska->level_up > 0) {
1556 matroska->level_up--;
1557 break;
1558 }
1559
1560 switch (id) {
1561 case MATROSKA_ID_ENCODINGSCOPE: {
1562 uint64_t num;
1563 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1564 break;
1565 encoding_scope = num;
1566 break;
1567 }
1568
1569 case MATROSKA_ID_ENCODINGTYPE: {
1570 uint64_t num;
1571 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1572 break;
1573 if (num)
1574 av_log(matroska->ctx, AV_LOG_ERROR,
1575 "Unsupported encoding type");
1576 break;
1577 }
1578
1579 case MATROSKA_ID_ENCODINGCOMPRESSION: {
1580 if ((res = ebml_read_master(matroska, &id)) < 0)
1581 break;
1582
1583 while (res == 0) {
1584 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1585 res = AVERROR(EIO);
1586 break;
1587 } else if (matroska->level_up > 0) {
1588 matroska->level_up--;
1589 break;
1590 }
1591
1592 switch (id) {
1593 case MATROSKA_ID_ENCODINGCOMPALGO: {
1594 uint64_t num;
1595 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1596 break;
1597 if (num != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP &&
1598 #ifdef CONFIG_ZLIB 1267 #ifdef CONFIG_ZLIB
1599 num != MATROSKA_TRACK_ENCODING_COMP_ZLIB && 1268 encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB &&
1600 #endif 1269 #endif
1601 #ifdef CONFIG_BZLIB 1270 #ifdef CONFIG_BZLIB
1602 num != MATROSKA_TRACK_ENCODING_COMP_BZLIB && 1271 encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_BZLIB &&
1603 #endif 1272 #endif
1604 num != MATROSKA_TRACK_ENCODING_COMP_LZO) 1273 encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_LZO)) {
1605 av_log(matroska->ctx, AV_LOG_ERROR, 1274 encodings[0].scope = 0;
1606 "Unsupported compression algo\n"); 1275 av_log(matroska->ctx, AV_LOG_ERROR,
1607 track->encoding_algo = num; 1276 "Unsupported encoding type");
1608 break; 1277 } else if (track->codec_priv.size && encodings[0].scope&2) {
1609 } 1278 uint8_t *codec_priv = track->codec_priv.data;
1610 1279 int offset = matroska_decode_buffer(&track->codec_priv.data,
1611 case MATROSKA_ID_ENCODINGCOMPSETTINGS: { 1280 &track->codec_priv.size,
1612 uint8_t *data; 1281 track);
1613 int size; 1282 if (offset < 0) {
1614 if ((res = ebml_read_binary(matroska, &id, &data, &size) < 0)) 1283 track->codec_priv.data = NULL;
1615 break; 1284 track->codec_priv.size = 0;
1616 track->encoding_settings = data; 1285 av_log(matroska->ctx, AV_LOG_ERROR,
1617 track->encoding_settings_len = size; 1286 "Failed to decode codec private data\n");
1618 break; 1287 } else if (offset > 0) {
1619 } 1288 track->codec_priv.data = av_malloc(track->codec_priv.size + offset);
1620 1289 memcpy(track->codec_priv.data,
1621 default: 1290 encodings[0].compression.settings.data, offset);
1622 av_log(matroska->ctx, AV_LOG_INFO, 1291 memcpy(track->codec_priv.data+offset, codec_priv,
1623 "Unknown compression header entry " 1292 track->codec_priv.size);
1624 "0x%x - ignoring\n", id); 1293 track->codec_priv.size += offset;
1625 /* pass-through */
1626
1627 case EBML_ID_VOID:
1628 res = ebml_read_skip(matroska);
1629 break;
1630 }
1631
1632 if (matroska->level_up) {
1633 matroska->level_up--;
1634 break;
1635 }
1636 }
1637 break;
1638 }
1639
1640 default:
1641 av_log(matroska->ctx, AV_LOG_INFO,
1642 "Unknown content encoding header entry "
1643 "0x%x - ignoring\n", id);
1644 /* pass-through */
1645
1646 case EBML_ID_VOID:
1647 res = ebml_read_skip(matroska);
1648 break;
1649 }
1650
1651 if (matroska->level_up) {
1652 matroska->level_up--;
1653 break;
1654 }
1655 }
1656
1657 track->encoding_scope = encoding_scope;
1658 break;
1659 }
1660
1661 default:
1662 av_log(matroska->ctx, AV_LOG_INFO,
1663 "Unknown content encodings header entry "
1664 "0x%x - ignoring\n", id);
1665 /* pass-through */
1666
1667 case EBML_ID_VOID:
1668 res = ebml_read_skip(matroska);
1669 break;
1670 }
1671
1672 if (matroska->level_up) {
1673 matroska->level_up--;
1674 break;
1675 }
1676 } 1294 }
1677 break; 1295 if (codec_priv != track->codec_priv.data)
1678 } 1296 av_free(codec_priv);
1679 1297 }
1680 case MATROSKA_ID_TRACKTIMECODESCALE: {
1681 double num;
1682 if ((res = ebml_read_float(matroska, &id, &num)) < 0)
1683 break;
1684 track->time_scale = num;
1685 break;
1686 }
1687
1688 default:
1689 av_log(matroska->ctx, AV_LOG_INFO,
1690 "Unknown track header entry 0x%x - ignoring\n", id);
1691 /* pass-through */
1692
1693 case EBML_ID_VOID:
1694 /* we ignore these because they're nothing useful. */
1695 case MATROSKA_ID_TRACKFLAGFORCED:
1696 case MATROSKA_ID_CODECNAME:
1697 case MATROSKA_ID_CODECDECODEALL:
1698 case MATROSKA_ID_CODECINFOURL:
1699 case MATROSKA_ID_CODECDOWNLOADURL:
1700 case MATROSKA_ID_TRACKMINCACHE:
1701 case MATROSKA_ID_TRACKMAXCACHE:
1702 res = ebml_read_skip(matroska);
1703 break;
1704 }
1705
1706 if (matroska->level_up) {
1707 matroska->level_up--;
1708 break;
1709 }
1710 }
1711
1712 if (track->codec_priv_size && track->encoding_scope & 2) {
1713 uint8_t *orig_priv = track->codec_priv;
1714 int offset = matroska_decode_buffer(&track->codec_priv,
1715 &track->codec_priv_size, track);
1716 if (offset > 0) {
1717 track->codec_priv = av_malloc(track->codec_priv_size + offset);
1718 memcpy(track->codec_priv, track->encoding_settings, offset);
1719 memcpy(track->codec_priv+offset, orig_priv, track->codec_priv_size);
1720 track->codec_priv_size += offset;
1721 av_free(orig_priv);
1722 } else if (!offset) {
1723 av_free(orig_priv);
1724 } else
1725 av_log(matroska->ctx, AV_LOG_ERROR,
1726 "Failed to decode codec private data\n");
1727 }
1728
1729 if (track->type && matroska->num_tracks < ARRAY_SIZE(matroska->tracks)) {
1730 matroska->tracks[matroska->num_tracks++] = track;
1731 } else {
1732 av_free(track);
1733 }
1734 return res;
1735 }
1736
1737 static int
1738 matroska_parse_tracks (MatroskaDemuxContext *matroska)
1739 {
1740 int res = 0;
1741 uint32_t id;
1742
1743 av_log(matroska->ctx, AV_LOG_DEBUG, "parsing tracks...\n");
1744
1745 while (res == 0) {
1746 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1747 res = AVERROR(EIO);
1748 break;
1749 } else if (matroska->level_up) {
1750 matroska->level_up--;
1751 break;
1752 }
1753
1754 switch (id) {
1755 /* one track within the "all-tracks" header */
1756 case MATROSKA_ID_TRACKENTRY:
1757 res = matroska_add_stream(matroska);
1758 break;
1759
1760 default:
1761 av_log(matroska->ctx, AV_LOG_INFO,
1762 "Unknown entry 0x%x in track header\n", id);
1763 /* fall-through */
1764
1765 case EBML_ID_VOID:
1766 res = ebml_read_skip(matroska);
1767 break;
1768 }
1769
1770 if (matroska->level_up) {
1771 matroska->level_up--;
1772 break;
1773 } 1298 }
1774 } 1299 }
1775 1300
1776 return res; 1301 return res;
1777 } 1302 }
2119 break; 1644 break;
2120 } 1645 }
2121 1646
2122 /* track info headers */ 1647 /* track info headers */
2123 case MATROSKA_ID_TRACKS: { 1648 case MATROSKA_ID_TRACKS: {
2124 if ((res = ebml_read_master(matroska, &id)) < 0)
2125 break;
2126 res = matroska_parse_tracks(matroska); 1649 res = matroska_parse_tracks(matroska);
2127 break; 1650 break;
2128 } 1651 }
2129 1652
2130 /* stream index */ 1653 /* stream index */
2186 } 1709 }
2187 } 1710 }
2188 1711
2189 /* Have we found a cluster? */ 1712 /* Have we found a cluster? */
2190 if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) { 1713 if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) {
1714 MatroskaTrack *tracks = matroska->tracks.elem;
2191 int i, j; 1715 int i, j;
2192 MatroskaTrack *track;
2193 AVStream *st; 1716 AVStream *st;
2194 1717
2195 for (i = 0; i < matroska->num_tracks; i++) { 1718 for (i=0; i < matroska->tracks.nb_elem; i++) {
1719 MatroskaTrack *track = &tracks[i];
2196 enum CodecID codec_id = CODEC_ID_NONE; 1720 enum CodecID codec_id = CODEC_ID_NONE;
2197 uint8_t *extradata = NULL; 1721 uint8_t *extradata = NULL;
2198 int extradata_size = 0; 1722 int extradata_size = 0;
2199 int extradata_offset = 0; 1723 int extradata_offset = 0;
2200 track = matroska->tracks[i];
2201 1724
2202 /* Apply some sanity checks. */ 1725 /* Apply some sanity checks. */
2203 if (track->codec_id == NULL) 1726 if (track->codec_id == NULL)
2204 continue; 1727 continue;
2205 1728
2218 /* Set the FourCC from the CodecID. */ 1741 /* Set the FourCC from the CodecID. */
2219 /* This is the MS compatibility mode which stores a 1742 /* This is the MS compatibility mode which stores a
2220 * BITMAPINFOHEADER in the CodecPrivate. */ 1743 * BITMAPINFOHEADER in the CodecPrivate. */
2221 if (!strcmp(track->codec_id, 1744 if (!strcmp(track->codec_id,
2222 MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) && 1745 MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&
2223 (track->codec_priv_size >= 40) && 1746 (track->codec_priv.size >= 40) &&
2224 (track->codec_priv != NULL)) { 1747 (track->codec_priv.data != NULL)) {
2225 MatroskaVideoTrack *vtrack = (MatroskaVideoTrack *) track;
2226
2227 /* Offset of biCompression. Stored in LE. */ 1748 /* Offset of biCompression. Stored in LE. */
2228 vtrack->fourcc = AV_RL32(track->codec_priv + 16); 1749 track->video.fourcc = AV_RL32(track->codec_priv.data + 16);
2229 codec_id = codec_get_id(codec_bmp_tags, vtrack->fourcc); 1750 codec_id = codec_get_id(codec_bmp_tags, track->video.fourcc);
2230 1751
2231 } 1752 }
2232 1753
2233 /* This is the MS compatibility mode which stores a 1754 /* This is the MS compatibility mode which stores a
2234 * WAVEFORMATEX in the CodecPrivate. */ 1755 * WAVEFORMATEX in the CodecPrivate. */
2235 else if (!strcmp(track->codec_id, 1756 else if (!strcmp(track->codec_id,
2236 MATROSKA_CODEC_ID_AUDIO_ACM) && 1757 MATROSKA_CODEC_ID_AUDIO_ACM) &&
2237 (track->codec_priv_size >= 18) && 1758 (track->codec_priv.size >= 18) &&
2238 (track->codec_priv != NULL)) { 1759 (track->codec_priv.data != NULL)) {
2239 uint16_t tag;
2240
2241 /* Offset of wFormatTag. Stored in LE. */ 1760 /* Offset of wFormatTag. Stored in LE. */
2242 tag = AV_RL16(track->codec_priv); 1761 uint16_t tag = AV_RL16(track->codec_priv.data);
2243 codec_id = codec_get_id(codec_wav_tags, tag); 1762 codec_id = codec_get_id(codec_wav_tags, tag);
2244 1763
2245 } 1764 }
2246 1765
2247 if (!strcmp(track->codec_id, "V_QUICKTIME") && 1766 if (!strcmp(track->codec_id, "V_QUICKTIME") &&
2248 (track->codec_priv_size >= 86) && 1767 (track->codec_priv.size >= 86) &&
2249 (track->codec_priv != NULL)) { 1768 (track->codec_priv.data != NULL)) {
2250 MatroskaVideoTrack *vtrack = (MatroskaVideoTrack *) track; 1769 track->video.fourcc = AV_RL32(track->codec_priv.data);
2251 1770 codec_id=codec_get_id(codec_movvideo_tags, track->video.fourcc);
2252 vtrack->fourcc = AV_RL32(track->codec_priv); 1771 }
2253 codec_id = codec_get_id(codec_movvideo_tags, vtrack->fourcc); 1772
2254 } 1773 else if (codec_id == CODEC_ID_AAC && !track->codec_priv.size) {
2255
2256 else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {
2257 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
2258 int profile = matroska_aac_profile(track->codec_id); 1774 int profile = matroska_aac_profile(track->codec_id);
2259 int sri = matroska_aac_sri(audiotrack->internal_samplerate); 1775 int sri = matroska_aac_sri(track->audio.samplerate);
2260 extradata = av_malloc(5); 1776 extradata = av_malloc(5);
2261 if (extradata == NULL) 1777 if (extradata == NULL)
2262 return AVERROR(ENOMEM); 1778 return AVERROR(ENOMEM);
2263 extradata[0] = (profile << 3) | ((sri&0x0E) >> 1); 1779 extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
2264 extradata[1] = ((sri&0x01) << 7) | (audiotrack->channels<<3); 1780 extradata[1] = ((sri&0x01) << 7) | (track->audio.channels<<3);
2265 if (strstr(track->codec_id, "SBR")) { 1781 if (strstr(track->codec_id, "SBR")) {
2266 sri = matroska_aac_sri(audiotrack->samplerate); 1782 sri = matroska_aac_sri(track->audio.out_samplerate);
2267 extradata[2] = 0x56; 1783 extradata[2] = 0x56;
2268 extradata[3] = 0xE5; 1784 extradata[3] = 0xE5;
2269 extradata[4] = 0x80 | (sri<<3); 1785 extradata[4] = 0x80 | (sri<<3);
2270 extradata_size = 5; 1786 extradata_size = 5;
2271 } else { 1787 } else {
2272 extradata_size = 2; 1788 extradata_size = 2;
2273 } 1789 }
2274 } 1790 }
2275 1791
2276 else if (codec_id == CODEC_ID_TTA) { 1792 else if (codec_id == CODEC_ID_TTA) {
2277 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
2278 ByteIOContext b; 1793 ByteIOContext b;
2279 extradata_size = 30; 1794 extradata_size = 30;
2280 extradata = av_mallocz(extradata_size); 1795 extradata = av_mallocz(extradata_size);
2281 if (extradata == NULL) 1796 if (extradata == NULL)
2282 return AVERROR(ENOMEM); 1797 return AVERROR(ENOMEM);
2283 init_put_byte(&b, extradata, extradata_size, 1, 1798 init_put_byte(&b, extradata, extradata_size, 1,
2284 NULL, NULL, NULL, NULL); 1799 NULL, NULL, NULL, NULL);
2285 put_buffer(&b, "TTA1", 4); 1800 put_buffer(&b, "TTA1", 4);
2286 put_le16(&b, 1); 1801 put_le16(&b, 1);
2287 put_le16(&b, audiotrack->channels); 1802 put_le16(&b, track->audio.channels);
2288 put_le16(&b, audiotrack->bitdepth); 1803 put_le16(&b, track->audio.bitdepth);
2289 put_le32(&b, audiotrack->samplerate); 1804 put_le32(&b, track->audio.out_samplerate);
2290 put_le32(&b, matroska->ctx->duration * audiotrack->samplerate); 1805 put_le32(&b, matroska->ctx->duration * track->audio.out_samplerate);
2291 } 1806 }
2292 1807
2293 else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 || 1808 else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
2294 codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) { 1809 codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
2295 extradata_offset = 26; 1810 extradata_offset = 26;
2296 track->codec_priv_size -= extradata_offset; 1811 track->codec_priv.size -= extradata_offset;
2297 } 1812 }
2298 1813
2299 else if (codec_id == CODEC_ID_RA_144) { 1814 else if (codec_id == CODEC_ID_RA_144) {
2300 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track; 1815 track->audio.out_samplerate = 8000;
2301 audiotrack->samplerate = 8000; 1816 track->audio.channels = 1;
2302 audiotrack->channels = 1;
2303 } 1817 }
2304 1818
2305 else if (codec_id == CODEC_ID_RA_288 || 1819 else if (codec_id == CODEC_ID_RA_288 ||
2306 codec_id == CODEC_ID_COOK || 1820 codec_id == CODEC_ID_COOK ||
2307 codec_id == CODEC_ID_ATRAC3) { 1821 codec_id == CODEC_ID_ATRAC3) {
2308 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2309 ByteIOContext b; 1822 ByteIOContext b;
2310 1823
2311 init_put_byte(&b, track->codec_priv, track->codec_priv_size, 0, 1824 init_put_byte(&b, track->codec_priv.data,track->codec_priv.size,
2312 NULL, NULL, NULL, NULL); 1825 0, NULL, NULL, NULL, NULL);
2313 url_fskip(&b, 24); 1826 url_fskip(&b, 24);
2314 audiotrack->coded_framesize = get_be32(&b); 1827 track->audio.coded_framesize = get_be32(&b);
2315 url_fskip(&b, 12); 1828 url_fskip(&b, 12);
2316 audiotrack->sub_packet_h = get_be16(&b); 1829 track->audio.sub_packet_h = get_be16(&b);
2317 audiotrack->frame_size = get_be16(&b); 1830 track->audio.frame_size = get_be16(&b);
2318 audiotrack->sub_packet_size = get_be16(&b); 1831 track->audio.sub_packet_size = get_be16(&b);
2319 audiotrack->buf = av_malloc(audiotrack->frame_size * audiotrack->sub_packet_h); 1832 track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h);
2320 if (codec_id == CODEC_ID_RA_288) { 1833 if (codec_id == CODEC_ID_RA_288) {
2321 audiotrack->block_align = audiotrack->coded_framesize; 1834 st->codec->block_align = track->audio.coded_framesize;
2322 track->codec_priv_size = 0; 1835 track->codec_priv.size = 0;
2323 } else { 1836 } else {
2324 audiotrack->block_align = audiotrack->sub_packet_size; 1837 st->codec->block_align = track->audio.sub_packet_size;
2325 extradata_offset = 78; 1838 extradata_offset = 78;
2326 track->codec_priv_size -= extradata_offset; 1839 track->codec_priv.size -= extradata_offset;
2327 } 1840 }
2328 } 1841 }
2329 1842
2330 if (codec_id == CODEC_ID_NONE) { 1843 if (codec_id == CODEC_ID_NONE) {
2331 av_log(matroska->ctx, AV_LOG_INFO, 1844 av_log(matroska->ctx, AV_LOG_INFO,
2348 track->default_duration, 1000000000, 30000); 1861 track->default_duration, 1000000000, 30000);
2349 1862
2350 if(extradata){ 1863 if(extradata){
2351 st->codec->extradata = extradata; 1864 st->codec->extradata = extradata;
2352 st->codec->extradata_size = extradata_size; 1865 st->codec->extradata_size = extradata_size;
2353 } else if(track->codec_priv && track->codec_priv_size > 0){ 1866 } else if(track->codec_priv.data && track->codec_priv.size > 0){
2354 st->codec->extradata = av_malloc(track->codec_priv_size); 1867 st->codec->extradata = av_malloc(track->codec_priv.size);
2355 if(st->codec->extradata == NULL) 1868 if(st->codec->extradata == NULL)
2356 return AVERROR(ENOMEM); 1869 return AVERROR(ENOMEM);
2357 st->codec->extradata_size = track->codec_priv_size; 1870 st->codec->extradata_size = track->codec_priv.size;
2358 memcpy(st->codec->extradata,track->codec_priv+extradata_offset, 1871 memcpy(st->codec->extradata,
2359 track->codec_priv_size); 1872 track->codec_priv.data + extradata_offset,
1873 track->codec_priv.size);
2360 } 1874 }
2361 1875
2362 if (track->type == MATROSKA_TRACK_TYPE_VIDEO) { 1876 if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2363 MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
2364
2365 st->codec->codec_type = CODEC_TYPE_VIDEO; 1877 st->codec->codec_type = CODEC_TYPE_VIDEO;
2366 st->codec->codec_tag = videotrack->fourcc; 1878 st->codec->codec_tag = track->video.fourcc;
2367 st->codec->width = videotrack->pixel_width; 1879 st->codec->width = track->video.pixel_width;
2368 st->codec->height = videotrack->pixel_height; 1880 st->codec->height = track->video.pixel_height;
2369 if (videotrack->display_width == 0)
2370 videotrack->display_width= videotrack->pixel_width;
2371 if (videotrack->display_height == 0)
2372 videotrack->display_height= videotrack->pixel_height;
2373 av_reduce(&st->codec->sample_aspect_ratio.num, 1881 av_reduce(&st->codec->sample_aspect_ratio.num,
2374 &st->codec->sample_aspect_ratio.den, 1882 &st->codec->sample_aspect_ratio.den,
2375 st->codec->height * videotrack->display_width, 1883 st->codec->height * track->video.display_width,
2376 st->codec-> width * videotrack->display_height, 1884 st->codec-> width * track->video.display_height,
2377 255); 1885 255);
2378 st->need_parsing = AVSTREAM_PARSE_HEADERS; 1886 st->need_parsing = AVSTREAM_PARSE_HEADERS;
2379 } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) { 1887 } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2380 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2381
2382 st->codec->codec_type = CODEC_TYPE_AUDIO; 1888 st->codec->codec_type = CODEC_TYPE_AUDIO;
2383 st->codec->sample_rate = audiotrack->samplerate; 1889 st->codec->sample_rate = track->audio.out_samplerate;
2384 st->codec->channels = audiotrack->channels; 1890 st->codec->channels = track->audio.channels;
2385 st->codec->block_align = audiotrack->block_align;
2386 } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) { 1891 } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
2387 st->codec->codec_type = CODEC_TYPE_SUBTITLE; 1892 st->codec->codec_type = CODEC_TYPE_SUBTITLE;
2388 } 1893 }
2389 1894
2390 /* What do we do with private data? E.g. for Vorbis. */ 1895 /* What do we do with private data? E.g. for Vorbis. */
2552 2057
2553 for (n = 0; n < laces; n++) { 2058 for (n = 0; n < laces; n++) {
2554 if (st->codec->codec_id == CODEC_ID_RA_288 || 2059 if (st->codec->codec_id == CODEC_ID_RA_288 ||
2555 st->codec->codec_id == CODEC_ID_COOK || 2060 st->codec->codec_id == CODEC_ID_COOK ||
2556 st->codec->codec_id == CODEC_ID_ATRAC3) { 2061 st->codec->codec_id == CODEC_ID_ATRAC3) {
2557 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2558 int a = st->codec->block_align; 2062 int a = st->codec->block_align;
2559 int sps = audiotrack->sub_packet_size; 2063 int sps = track->audio.sub_packet_size;
2560 int cfs = audiotrack->coded_framesize; 2064 int cfs = track->audio.coded_framesize;
2561 int h = audiotrack->sub_packet_h; 2065 int h = track->audio.sub_packet_h;
2562 int y = audiotrack->sub_packet_cnt; 2066 int y = track->audio.sub_packet_cnt;
2563 int w = audiotrack->frame_size; 2067 int w = track->audio.frame_size;
2564 int x; 2068 int x;
2565 2069
2566 if (!audiotrack->pkt_cnt) { 2070 if (!track->audio.pkt_cnt) {
2567 if (st->codec->codec_id == CODEC_ID_RA_288) 2071 if (st->codec->codec_id == CODEC_ID_RA_288)
2568 for (x=0; x<h/2; x++) 2072 for (x=0; x<h/2; x++)
2569 memcpy(audiotrack->buf+x*2*w+y*cfs, 2073 memcpy(track->audio.buf+x*2*w+y*cfs,
2570 data+x*cfs, cfs); 2074 data+x*cfs, cfs);
2571 else 2075 else
2572 for (x=0; x<w/sps; x++) 2076 for (x=0; x<w/sps; x++)
2573 memcpy(audiotrack->buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps); 2077 memcpy(track->audio.buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps);
2574 2078
2575 if (++audiotrack->sub_packet_cnt >= h) { 2079 if (++track->audio.sub_packet_cnt >= h) {
2576 audiotrack->sub_packet_cnt = 0; 2080 track->audio.sub_packet_cnt = 0;
2577 audiotrack->pkt_cnt = h*w / a; 2081 track->audio.pkt_cnt = h*w / a;
2578 } 2082 }
2579 } 2083 }
2580 while (audiotrack->pkt_cnt) { 2084 while (track->audio.pkt_cnt) {
2581 pkt = av_mallocz(sizeof(AVPacket)); 2085 pkt = av_mallocz(sizeof(AVPacket));
2582 av_new_packet(pkt, a); 2086 av_new_packet(pkt, a);
2583 memcpy(pkt->data, audiotrack->buf 2087 memcpy(pkt->data, track->audio.buf
2584 + a * (h*w / a - audiotrack->pkt_cnt--), a); 2088 + a * (h*w / a - track->audio.pkt_cnt--), a);
2585 pkt->pos = pos; 2089 pkt->pos = pos;
2586 pkt->stream_index = st->index; 2090 pkt->stream_index = st->index;
2587 matroska_queue_packet(matroska, pkt); 2091 matroska_queue_packet(matroska, pkt);
2588 } 2092 }
2589 } else { 2093 } else {
2094 MatroskaTrackEncoding *encodings = track->encodings.elem;
2590 int offset = 0, pkt_size = lace_size[n]; 2095 int offset = 0, pkt_size = lace_size[n];
2591 uint8_t *pkt_data = data; 2096 uint8_t *pkt_data = data;
2592 2097
2593 if (track->encoding_scope & 1) { 2098 if (encodings && encodings->scope & 1) {
2594 offset = matroska_decode_buffer(&pkt_data, &pkt_size, 2099 offset = matroska_decode_buffer(&pkt_data, &pkt_size,
2595 track); 2100 track);
2596 if (offset < 0) 2101 if (offset < 0)
2597 continue; 2102 continue;
2598 } 2103 }
2604 res = AVERROR(ENOMEM); 2109 res = AVERROR(ENOMEM);
2605 n = laces-1; 2110 n = laces-1;
2606 break; 2111 break;
2607 } 2112 }
2608 if (offset) 2113 if (offset)
2609 memcpy (pkt->data, track->encoding_settings, offset); 2114 memcpy (pkt->data, encodings->compression.settings.data, offset);
2610 memcpy (pkt->data+offset, pkt_data, pkt_size); 2115 memcpy (pkt->data+offset, pkt_data, pkt_size);
2611 2116
2612 if (pkt_data != data) 2117 if (pkt_data != data)
2613 av_free(pkt_data); 2118 av_free(pkt_data);
2614 2119
2855 2360
2856 static int 2361 static int
2857 matroska_read_close (AVFormatContext *s) 2362 matroska_read_close (AVFormatContext *s)
2858 { 2363 {
2859 MatroskaDemuxContext *matroska = s->priv_data; 2364 MatroskaDemuxContext *matroska = s->priv_data;
2365 MatroskaTrack *tracks = matroska->tracks.elem;
2860 int n = 0; 2366 int n = 0;
2861 2367
2862 matroska_clear_queue(matroska); 2368 matroska_clear_queue(matroska);
2863 2369
2864 for (n = 0; n < matroska->num_tracks; n++) { 2370 for (n=0; n < matroska->tracks.nb_elem; n++)
2865 MatroskaTrack *track = matroska->tracks[n]; 2371 if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
2866 av_free(track->codec_id); 2372 av_free(tracks[n].audio.buf);
2867 av_free(track->codec_priv); 2373 ebml_free(matroska_tracks, matroska);
2868 av_free(track->name);
2869
2870 if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2871 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2872 av_free(audiotrack->buf);
2873 }
2874
2875 av_free(track);
2876 }
2877 ebml_free(matroska_index, matroska); 2374 ebml_free(matroska_index, matroska);
2878 2375
2879 return 0; 2376 return 0;
2880 } 2377 }
2881 2378