Mercurial > libavformat.hg
annotate mp3.c @ 3754:8d267b43eaba libavformat
Move malloc() down until after all initializations, so that the resource is
only allocated if initialization worked. This means that on failure, we
don't have to deallocate it.
author | rbultje |
---|---|
date | Sat, 23 Aug 2008 18:46:30 +0000 |
parents | 3790cb6c893d |
children | 3a874c41adaf |
rev | line source |
---|---|
885 | 1 /* |
1415
3b00fb8ef8e4
replace coder/decoder file description in libavformat by muxer/demuxer
aurel
parents:
1358
diff
changeset
|
2 * MP3 muxer and demuxer |
234 | 3 * Copyright (c) 2003 Fabrice Bellard. |
4 * | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1321
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1321
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1321
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
234 | 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:
1321
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
234 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1321
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
234 | 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:
1321
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 |
234 | 20 */ |
3286 | 21 |
3714 | 22 #include <strings.h> |
3286 | 23 #include "libavutil/avstring.h" |
24 #include "libavcodec/mpegaudio.h" | |
25 #include "libavcodec/mpegaudiodecheader.h" | |
234 | 26 #include "avformat.h" |
27 | |
2096 | 28 #define ID3v2_HEADER_SIZE 10 |
29 #define ID3v1_TAG_SIZE 128 | |
234 | 30 |
2096 | 31 #define ID3v1_GENRE_MAX 125 |
234 | 32 |
2096 | 33 static const char *id3v1_genre_str[ID3v1_GENRE_MAX + 1] = { |
234 | 34 [0] = "Blues", |
35 [1] = "Classic Rock", | |
36 [2] = "Country", | |
37 [3] = "Dance", | |
38 [4] = "Disco", | |
39 [5] = "Funk", | |
40 [6] = "Grunge", | |
41 [7] = "Hip-Hop", | |
42 [8] = "Jazz", | |
43 [9] = "Metal", | |
44 [10] = "New Age", | |
45 [11] = "Oldies", | |
46 [12] = "Other", | |
47 [13] = "Pop", | |
48 [14] = "R&B", | |
49 [15] = "Rap", | |
50 [16] = "Reggae", | |
51 [17] = "Rock", | |
52 [18] = "Techno", | |
53 [19] = "Industrial", | |
54 [20] = "Alternative", | |
55 [21] = "Ska", | |
56 [22] = "Death Metal", | |
57 [23] = "Pranks", | |
58 [24] = "Soundtrack", | |
59 [25] = "Euro-Techno", | |
60 [26] = "Ambient", | |
61 [27] = "Trip-Hop", | |
62 [28] = "Vocal", | |
63 [29] = "Jazz+Funk", | |
64 [30] = "Fusion", | |
65 [31] = "Trance", | |
66 [32] = "Classical", | |
67 [33] = "Instrumental", | |
68 [34] = "Acid", | |
69 [35] = "House", | |
70 [36] = "Game", | |
71 [37] = "Sound Clip", | |
72 [38] = "Gospel", | |
73 [39] = "Noise", | |
74 [40] = "AlternRock", | |
75 [41] = "Bass", | |
76 [42] = "Soul", | |
77 [43] = "Punk", | |
78 [44] = "Space", | |
79 [45] = "Meditative", | |
80 [46] = "Instrumental Pop", | |
81 [47] = "Instrumental Rock", | |
82 [48] = "Ethnic", | |
83 [49] = "Gothic", | |
84 [50] = "Darkwave", | |
85 [51] = "Techno-Industrial", | |
86 [52] = "Electronic", | |
87 [53] = "Pop-Folk", | |
88 [54] = "Eurodance", | |
89 [55] = "Dream", | |
90 [56] = "Southern Rock", | |
91 [57] = "Comedy", | |
92 [58] = "Cult", | |
93 [59] = "Gangsta", | |
94 [60] = "Top 40", | |
95 [61] = "Christian Rap", | |
96 [62] = "Pop/Funk", | |
97 [63] = "Jungle", | |
98 [64] = "Native American", | |
99 [65] = "Cabaret", | |
100 [66] = "New Wave", | |
101 [67] = "Psychadelic", | |
102 [68] = "Rave", | |
103 [69] = "Showtunes", | |
104 [70] = "Trailer", | |
105 [71] = "Lo-Fi", | |
106 [72] = "Tribal", | |
107 [73] = "Acid Punk", | |
108 [74] = "Acid Jazz", | |
109 [75] = "Polka", | |
110 [76] = "Retro", | |
111 [77] = "Musical", | |
112 [78] = "Rock & Roll", | |
113 [79] = "Hard Rock", | |
114 [80] = "Folk", | |
115 [81] = "Folk-Rock", | |
116 [82] = "National Folk", | |
117 [83] = "Swing", | |
118 [84] = "Fast Fusion", | |
119 [85] = "Bebob", | |
120 [86] = "Latin", | |
121 [87] = "Revival", | |
122 [88] = "Celtic", | |
123 [89] = "Bluegrass", | |
124 [90] = "Avantgarde", | |
125 [91] = "Gothic Rock", | |
126 [92] = "Progressive Rock", | |
127 [93] = "Psychedelic Rock", | |
128 [94] = "Symphonic Rock", | |
129 [95] = "Slow Rock", | |
130 [96] = "Big Band", | |
131 [97] = "Chorus", | |
132 [98] = "Easy Listening", | |
133 [99] = "Acoustic", | |
134 [100] = "Humour", | |
135 [101] = "Speech", | |
136 [102] = "Chanson", | |
137 [103] = "Opera", | |
138 [104] = "Chamber Music", | |
139 [105] = "Sonata", | |
140 [106] = "Symphony", | |
141 [107] = "Booty Bass", | |
142 [108] = "Primus", | |
143 [109] = "Porn Groove", | |
144 [110] = "Satire", | |
145 [111] = "Slow Jam", | |
146 [112] = "Club", | |
147 [113] = "Tango", | |
148 [114] = "Samba", | |
149 [115] = "Folklore", | |
150 [116] = "Ballad", | |
151 [117] = "Power Ballad", | |
152 [118] = "Rhythmic Soul", | |
153 [119] = "Freestyle", | |
154 [120] = "Duet", | |
155 [121] = "Punk Rock", | |
156 [122] = "Drum Solo", | |
157 [123] = "A capella", | |
158 [124] = "Euro-House", | |
159 [125] = "Dance Hall", | |
160 }; | |
161 | |
2096 | 162 /* buf must be ID3v2_HEADER_SIZE byte long */ |
163 static int id3v2_match(const uint8_t *buf) | |
234 | 164 { |
3278 | 165 return buf[0] == 'I' && |
234 | 166 buf[1] == 'D' && |
167 buf[2] == '3' && | |
168 buf[3] != 0xff && | |
169 buf[4] != 0xff && | |
170 (buf[6] & 0x80) == 0 && | |
171 (buf[7] & 0x80) == 0 && | |
172 (buf[8] & 0x80) == 0 && | |
3278 | 173 (buf[9] & 0x80) == 0; |
234 | 174 } |
175 | |
2097 | 176 static unsigned int id3v2_get_size(ByteIOContext *s, int len) |
177 { | |
178 int v=0; | |
179 while(len--) | |
180 v= (v<<7) + (get_byte(s)&0x7F); | |
181 return v; | |
182 } | |
183 | |
184 static void id3v2_read_ttag(AVFormatContext *s, int taglen, char *dst, int dstlen) | |
185 { | |
186 char *q; | |
187 int len; | |
188 | |
3539
4dee13c8073a
All id3 parsers are buggy, 0 termination fix 1 of n (issue created by andreas
michael
parents:
3484
diff
changeset
|
189 if(dstlen > 0) |
4dee13c8073a
All id3 parsers are buggy, 0 termination fix 1 of n (issue created by andreas
michael
parents:
3484
diff
changeset
|
190 dst[0]= 0; |
2097 | 191 if(taglen < 1) |
192 return; | |
193 | |
194 taglen--; /* account for encoding type byte */ | |
195 dstlen--; /* Leave space for zero terminator */ | |
196 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
197 switch(get_byte(s->pb)) { /* encoding type */ |
2097 | 198 |
199 case 0: /* ISO-8859-1 (0 - 255 maps directly into unicode) */ | |
200 q = dst; | |
201 while(taglen--) { | |
202 uint8_t tmp; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
203 PUT_UTF8(get_byte(s->pb), tmp, if (q - dst < dstlen - 1) *q++ = tmp;) |
2097 | 204 } |
205 *q = '\0'; | |
206 break; | |
207 | |
208 case 3: /* UTF-8 */ | |
3540
3dfb35d2ac51
All mp3 parsers are buggy fix 2 of n (out of array write, i suspect not exploitable)
michael
parents:
3539
diff
changeset
|
209 len = FFMIN(taglen, dstlen-1); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
210 get_buffer(s->pb, dst, len); |
2097 | 211 dst[len] = 0; |
212 break; | |
213 } | |
214 } | |
215 | |
216 /** | |
217 * ID3v2 parser | |
218 * | |
219 * Handles ID3v2.2, 2.3 and 2.4. | |
220 * | |
221 */ | |
222 | |
223 static void id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags) | |
224 { | |
225 int isv34, tlen; | |
226 uint32_t tag; | |
227 offset_t next; | |
228 char tmp[16]; | |
229 int taghdrlen; | |
230 const char *reason; | |
231 | |
232 switch(version) { | |
233 case 2: | |
234 if(flags & 0x40) { | |
235 reason = "compression"; | |
236 goto error; | |
237 } | |
238 isv34 = 0; | |
239 taghdrlen = 6; | |
240 break; | |
241 | |
2231
7ad682f38b9a
* Getting rid of the use of GCC language extensions
romansh
parents:
2222
diff
changeset
|
242 case 3: |
7ad682f38b9a
* Getting rid of the use of GCC language extensions
romansh
parents:
2222
diff
changeset
|
243 case 4: |
2097 | 244 isv34 = 1; |
245 taghdrlen = 10; | |
246 break; | |
247 | |
248 default: | |
249 reason = "version"; | |
250 goto error; | |
251 } | |
252 | |
253 if(flags & 0x80) { | |
254 reason = "unsynchronization"; | |
255 goto error; | |
256 } | |
257 | |
258 if(isv34 && flags & 0x40) /* Extended header present, just skip over it */ | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
259 url_fskip(s->pb, id3v2_get_size(s->pb, 4)); |
2097 | 260 |
261 while(len >= taghdrlen) { | |
262 if(isv34) { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
263 tag = get_be32(s->pb); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
264 tlen = id3v2_get_size(s->pb, 4); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
265 get_be16(s->pb); /* flags */ |
2097 | 266 } else { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
267 tag = get_be24(s->pb); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
268 tlen = id3v2_get_size(s->pb, 3); |
2097 | 269 } |
270 len -= taghdrlen + tlen; | |
271 | |
272 if(len < 0) | |
273 break; | |
274 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
275 next = url_ftell(s->pb) + tlen; |
2097 | 276 |
277 switch(tag) { | |
278 case MKBETAG('T', 'I', 'T', '2'): | |
279 case MKBETAG(0, 'T', 'T', '2'): | |
280 id3v2_read_ttag(s, tlen, s->title, sizeof(s->title)); | |
281 break; | |
282 case MKBETAG('T', 'P', 'E', '1'): | |
283 case MKBETAG(0, 'T', 'P', '1'): | |
284 id3v2_read_ttag(s, tlen, s->author, sizeof(s->author)); | |
285 break; | |
286 case MKBETAG('T', 'A', 'L', 'B'): | |
287 case MKBETAG(0, 'T', 'A', 'L'): | |
288 id3v2_read_ttag(s, tlen, s->album, sizeof(s->album)); | |
289 break; | |
290 case MKBETAG('T', 'C', 'O', 'N'): | |
291 case MKBETAG(0, 'T', 'C', 'O'): | |
292 id3v2_read_ttag(s, tlen, s->genre, sizeof(s->genre)); | |
293 break; | |
294 case MKBETAG('T', 'C', 'O', 'P'): | |
295 case MKBETAG(0, 'T', 'C', 'R'): | |
296 id3v2_read_ttag(s, tlen, s->copyright, sizeof(s->copyright)); | |
297 break; | |
298 case MKBETAG('T', 'R', 'C', 'K'): | |
299 case MKBETAG(0, 'T', 'R', 'K'): | |
300 id3v2_read_ttag(s, tlen, tmp, sizeof(tmp)); | |
301 s->track = atoi(tmp); | |
302 break; | |
303 case 0: | |
304 /* padding, skip to end */ | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
305 url_fskip(s->pb, len); |
2097 | 306 len = 0; |
307 continue; | |
308 } | |
309 /* Skip to end of tag */ | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
310 url_fseek(s->pb, next, SEEK_SET); |
2097 | 311 } |
312 | |
313 if(version == 4 && flags & 0x10) /* Footer preset, always 10 bytes, skip over it */ | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
314 url_fskip(s->pb, 10); |
2097 | 315 return; |
316 | |
317 error: | |
318 av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n", version, reason); | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
319 url_fskip(s->pb, len); |
2097 | 320 } |
321 | |
2096 | 322 static void id3v1_get_string(char *str, int str_size, |
323 const uint8_t *buf, int buf_size) | |
234 | 324 { |
325 int i, c; | |
326 char *q; | |
327 | |
328 q = str; | |
329 for(i = 0; i < buf_size; i++) { | |
330 c = buf[i]; | |
331 if (c == '\0') | |
332 break; | |
333 if ((q - str) >= str_size - 1) | |
334 break; | |
335 *q++ = c; | |
336 } | |
337 *q = '\0'; | |
338 } | |
339 | |
2096 | 340 /* 'buf' must be ID3v1_TAG_SIZE byte long */ |
341 static int id3v1_parse_tag(AVFormatContext *s, const uint8_t *buf) | |
234 | 342 { |
343 char str[5]; | |
344 int genre; | |
885 | 345 |
234 | 346 if (!(buf[0] == 'T' && |
347 buf[1] == 'A' && | |
348 buf[2] == 'G')) | |
349 return -1; | |
2096 | 350 id3v1_get_string(s->title, sizeof(s->title), buf + 3, 30); |
351 id3v1_get_string(s->author, sizeof(s->author), buf + 33, 30); | |
352 id3v1_get_string(s->album, sizeof(s->album), buf + 63, 30); | |
353 id3v1_get_string(str, sizeof(str), buf + 93, 4); | |
234 | 354 s->year = atoi(str); |
2096 | 355 id3v1_get_string(s->comment, sizeof(s->comment), buf + 97, 30); |
234 | 356 if (buf[125] == 0 && buf[126] != 0) |
357 s->track = buf[126]; | |
358 genre = buf[127]; | |
2096 | 359 if (genre <= ID3v1_GENRE_MAX) |
2189 | 360 av_strlcpy(s->genre, id3v1_genre_str[genre], sizeof(s->genre)); |
234 | 361 return 0; |
362 } | |
363 | |
364 /* mp3 read */ | |
1107 | 365 |
366 static int mp3_read_probe(AVProbeData *p) | |
367 { | |
2234
2bc002540a9b
kill uninitialised variable warning in mp3_read_probe()
mru
parents:
2231
diff
changeset
|
368 int max_frames, first_frames = 0; |
1433
dababce8f69e
dont set the sampling rate just because 1 mp3 packet header says so (fixes playback speed on some old mencoder generated avis which where then dumped to mp3)
michael
parents:
1415
diff
changeset
|
369 int fsize, frames, sample_rate; |
1308
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
370 uint32_t header; |
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
371 uint8_t *buf, *buf2, *end; |
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
372 AVCodecContext avctx; |
1107 | 373 |
2096 | 374 if(id3v2_match(p->buf)) |
375 return AVPROBE_SCORE_MAX/2+1; // this must be less than mpeg-ps because some retards put id3v2 tags before mpeg-ps files | |
1107 | 376 |
1308
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
377 max_frames = 0; |
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
378 buf = p->buf; |
2796 | 379 end = buf + p->buf_size - sizeof(uint32_t); |
1308
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
380 |
2797 | 381 for(; buf < end; buf= buf2+1) { |
1308
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
382 buf2 = buf; |
1107 | 383 |
1312 | 384 for(frames = 0; buf2 < end; frames++) { |
2222 | 385 header = AV_RB32(buf2); |
2090 | 386 fsize = ff_mpa_decode_header(&avctx, header, &sample_rate); |
1308
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
387 if(fsize < 0) |
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
388 break; |
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
389 buf2 += fsize; |
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
390 } |
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
391 max_frames = FFMAX(max_frames, frames); |
1321
9eeb01383e30
reduce scores if the mp3 frames dont start from the begin of the file (fixes flv deteted as mp3 issues)
michael
parents:
1312
diff
changeset
|
392 if(buf == p->buf) |
9eeb01383e30
reduce scores if the mp3 frames dont start from the begin of the file (fixes flv deteted as mp3 issues)
michael
parents:
1312
diff
changeset
|
393 first_frames= frames; |
1308
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
394 } |
1321
9eeb01383e30
reduce scores if the mp3 frames dont start from the begin of the file (fixes flv deteted as mp3 issues)
michael
parents:
1312
diff
changeset
|
395 if (first_frames>=3) return AVPROBE_SCORE_MAX/2+1; |
2798
51e0a502392f
return a slightly larger score if we find more than 500 valid mp3 frames in a row
michael
parents:
2797
diff
changeset
|
396 else if(max_frames>500)return AVPROBE_SCORE_MAX/2; |
1321
9eeb01383e30
reduce scores if the mp3 frames dont start from the begin of the file (fixes flv deteted as mp3 issues)
michael
parents:
1312
diff
changeset
|
397 else if(max_frames>=3) return AVPROBE_SCORE_MAX/4; |
9eeb01383e30
reduce scores if the mp3 frames dont start from the begin of the file (fixes flv deteted as mp3 issues)
michael
parents:
1312
diff
changeset
|
398 else if(max_frames>=1) return 1; |
1308
866d43ed0a67
allow ffmpeg to read mp3s beginning with partial frames
gpoirier
parents:
1169
diff
changeset
|
399 else return 0; |
1107 | 400 } |
401 | |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
402 /** |
2667
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
403 * Try to find Xing/Info/VBRI tags and compute duration from info therein |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
404 */ |
2667
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
405 static void mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, offset_t base) |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
406 { |
2663
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
407 uint32_t v, spf; |
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
408 int frames = -1; /* Total number of frames in file */ |
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
409 const offset_t xing_offtbl[2][2] = {{32, 17}, {17,9}}; |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
410 MPADecodeContext c; |
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
411 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
412 v = get_be32(s->pb); |
2703
2c2da3011d6e
make sure the mpeg audio header is valid before passing it to ff_mpegaudio_decode_header()
andoma
parents:
2667
diff
changeset
|
413 if(ff_mpa_check_header(v) < 0) |
2c2da3011d6e
make sure the mpeg audio header is valid before passing it to ff_mpegaudio_decode_header()
andoma
parents:
2667
diff
changeset
|
414 return; |
2c2da3011d6e
make sure the mpeg audio header is valid before passing it to ff_mpegaudio_decode_header()
andoma
parents:
2667
diff
changeset
|
415 |
2c2da3011d6e
make sure the mpeg audio header is valid before passing it to ff_mpegaudio_decode_header()
andoma
parents:
2667
diff
changeset
|
416 ff_mpegaudio_decode_header(&c, v); |
2663
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
417 if(c.layer != 3) |
2664 | 418 return; |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
419 |
2663
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
420 /* Check for Xing / Info tag */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
421 url_fseek(s->pb, xing_offtbl[c.lsf == 1][c.nb_channels == 1], SEEK_CUR); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
422 v = get_be32(s->pb); |
2663
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
423 if(v == MKBETAG('X', 'i', 'n', 'g') || v == MKBETAG('I', 'n', 'f', 'o')) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
424 v = get_be32(s->pb); |
2664 | 425 if(v & 0x1) |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
426 frames = get_be32(s->pb); |
2663
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
427 } |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
428 |
2667
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
429 /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
430 url_fseek(s->pb, base + 4 + 32, SEEK_SET); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
431 v = get_be32(s->pb); |
2667
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
432 if(v == MKBETAG('V', 'B', 'R', 'I')) { |
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
433 /* Check tag version */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
434 if(get_be16(s->pb) == 1) { |
2667
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
435 /* skip delay, quality and total bytes */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
436 url_fseek(s->pb, 8, SEEK_CUR); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
437 frames = get_be32(s->pb); |
2667
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
438 } |
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
439 } |
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
440 |
2663
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
441 if(frames < 0) |
2664 | 442 return; |
2663
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
443 |
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
444 spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */ |
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
445 st->duration = av_rescale_q(frames, (AVRational){spf, c.sample_rate}, |
be889462edfc
cosmetical change of mp3_parse_xing() to prepare for upcoming VBRI tag support
andoma
parents:
2662
diff
changeset
|
446 st->time_base); |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
447 } |
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
448 |
234 | 449 static int mp3_read_header(AVFormatContext *s, |
450 AVFormatParameters *ap) | |
451 { | |
452 AVStream *st; | |
2096 | 453 uint8_t buf[ID3v1_TAG_SIZE]; |
234 | 454 int len, ret, filesize; |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
455 offset_t off; |
234 | 456 |
457 st = av_new_stream(s, 0); | |
458 if (!st) | |
2273
7eb456c4ed8a
Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents:
2234
diff
changeset
|
459 return AVERROR(ENOMEM); |
234 | 460 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
814
diff
changeset
|
461 st->codec->codec_type = CODEC_TYPE_AUDIO; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
814
diff
changeset
|
462 st->codec->codec_id = CODEC_ID_MP3; |
2023 | 463 st->need_parsing = AVSTREAM_PARSE_FULL; |
2622 | 464 st->start_time = 0; |
885 | 465 |
234 | 466 /* try to get the TAG */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
467 if (!url_is_streamed(s->pb)) { |
234 | 468 /* XXX: change that */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
469 filesize = url_fsize(s->pb); |
234 | 470 if (filesize > 128) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
471 url_fseek(s->pb, filesize - 128, SEEK_SET); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
472 ret = get_buffer(s->pb, buf, ID3v1_TAG_SIZE); |
2096 | 473 if (ret == ID3v1_TAG_SIZE) { |
474 id3v1_parse_tag(s, buf); | |
234 | 475 } |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
476 url_fseek(s->pb, 0, SEEK_SET); |
234 | 477 } |
478 } | |
479 | |
2096 | 480 /* if ID3v2 header found, skip it */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
481 ret = get_buffer(s->pb, buf, ID3v2_HEADER_SIZE); |
2096 | 482 if (ret != ID3v2_HEADER_SIZE) |
234 | 483 return -1; |
2096 | 484 if (id3v2_match(buf)) { |
2097 | 485 /* parse ID3v2 header */ |
234 | 486 len = ((buf[6] & 0x7f) << 21) | |
487 ((buf[7] & 0x7f) << 14) | | |
488 ((buf[8] & 0x7f) << 7) | | |
489 (buf[9] & 0x7f); | |
2097 | 490 id3v2_parse(s, len, buf[3], buf[5]); |
234 | 491 } else { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
492 url_fseek(s->pb, 0, SEEK_SET); |
234 | 493 } |
494 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
495 off = url_ftell(s->pb); |
2667
e896ac505ec6
add support for reading duration from VBRI-tag in mp3 files
andoma
parents:
2664
diff
changeset
|
496 mp3_parse_vbr_tags(s, st, off); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
497 url_fseek(s->pb, off, SEEK_SET); |
2662
08b1ac852321
add support for reading duration from Xing-tag in mp3 files
andoma
parents:
2622
diff
changeset
|
498 |
234 | 499 /* the parameters will be extracted from the compressed bitstream */ |
500 return 0; | |
501 } | |
502 | |
503 #define MP3_PACKET_SIZE 1024 | |
504 | |
505 static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt) | |
506 { | |
507 int ret, size; | |
508 // AVStream *st = s->streams[0]; | |
885 | 509 |
234 | 510 size= MP3_PACKET_SIZE; |
511 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
512 ret= av_get_packet(s->pb, pkt, size); |
234 | 513 |
514 pkt->stream_index = 0; | |
515 if (ret <= 0) { | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2273
diff
changeset
|
516 return AVERROR(EIO); |
234 | 517 } |
518 /* note: we need to modify the packet size here to handle the last | |
519 packet */ | |
520 pkt->size = ret; | |
521 return ret; | |
522 } | |
523 | |
858
66cc656ea404
Replace CONFIG_ENCODERS/CONFIG_DECODERS with CONFIG_MUXERS/CONFIG_DEMUXERS
diego
parents:
820
diff
changeset
|
524 #ifdef CONFIG_MUXERS |
3561
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
525 static void id3v1_create_tag(AVFormatContext *s, uint8_t *buf) |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
526 { |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
527 int v, i; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
528 |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
529 memset(buf, 0, ID3v1_TAG_SIZE); /* fail safe */ |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
530 buf[0] = 'T'; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
531 buf[1] = 'A'; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
532 buf[2] = 'G'; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
533 strncpy(buf + 3, s->title, 30); |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
534 strncpy(buf + 33, s->author, 30); |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
535 strncpy(buf + 63, s->album, 30); |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
536 v = s->year; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
537 if (v > 0) { |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
538 for(i = 0;i < 4; i++) { |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
539 buf[96 - i] = '0' + (v % 10); |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
540 v = v / 10; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
541 } |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
542 } |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
543 strncpy(buf + 97, s->comment, 30); |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
544 if (s->track != 0) { |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
545 buf[125] = 0; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
546 buf[126] = s->track; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
547 } |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
548 for(i = 0; i <= ID3v1_GENRE_MAX; i++) { |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
549 if (!strcasecmp(s->genre, id3v1_genre_str[i])) { |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
550 buf[127] = i; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
551 break; |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
552 } |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
553 } |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
554 } |
bc473761b9e7
Move one function that is only used for muxing below #ifdef CONFIG_MUXERS.
diego
parents:
3540
diff
changeset
|
555 |
234 | 556 /* simple formats */ |
2098 | 557 |
558 static void id3v2_put_size(AVFormatContext *s, int size) | |
559 { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
560 put_byte(s->pb, size >> 21 & 0x7f); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
561 put_byte(s->pb, size >> 14 & 0x7f); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
562 put_byte(s->pb, size >> 7 & 0x7f); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
563 put_byte(s->pb, size & 0x7f); |
2098 | 564 } |
565 | |
3008 | 566 static void id3v2_put_ttag(AVFormatContext *s, const char *string, uint32_t tag) |
2098 | 567 { |
568 int len = strlen(string); | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
569 put_be32(s->pb, tag); |
2098 | 570 id3v2_put_size(s, len + 1); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
571 put_be16(s->pb, 0); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
572 put_byte(s->pb, 3); /* UTF-8 */ |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
573 put_buffer(s->pb, string, len); |
2098 | 574 } |
575 | |
576 | |
577 /** | |
578 * Write an ID3v2.4 header at beginning of stream | |
579 */ | |
580 | |
234 | 581 static int mp3_write_header(struct AVFormatContext *s) |
582 { | |
2098 | 583 int totlen = 0; |
584 char tracktxt[10]; | |
2735 | 585 char yeartxt[10]; |
2098 | 586 |
587 if(s->track) | |
2746 | 588 snprintf(tracktxt, sizeof(tracktxt), "%d", s->track); |
2735 | 589 if(s->year) |
2746 | 590 snprintf( yeartxt, sizeof(yeartxt) , "%d", s->year ); |
2098 | 591 |
592 if(s->title[0]) totlen += 11 + strlen(s->title); | |
593 if(s->author[0]) totlen += 11 + strlen(s->author); | |
594 if(s->album[0]) totlen += 11 + strlen(s->album); | |
595 if(s->genre[0]) totlen += 11 + strlen(s->genre); | |
596 if(s->copyright[0]) totlen += 11 + strlen(s->copyright); | |
597 if(s->track) totlen += 11 + strlen(tracktxt); | |
2735 | 598 if(s->year) totlen += 11 + strlen(yeartxt); |
2098 | 599 if(!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) |
600 totlen += strlen(LIBAVFORMAT_IDENT) + 11; | |
601 | |
602 if(totlen == 0) | |
603 return 0; | |
604 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
605 put_be32(s->pb, MKBETAG('I', 'D', '3', 0x04)); /* ID3v2.4 */ |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
606 put_byte(s->pb, 0); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
607 put_byte(s->pb, 0); /* flags */ |
2098 | 608 |
609 id3v2_put_size(s, totlen); | |
610 | |
611 if(s->title[0]) id3v2_put_ttag(s, s->title, MKBETAG('T', 'I', 'T', '2')); | |
612 if(s->author[0]) id3v2_put_ttag(s, s->author, MKBETAG('T', 'P', 'E', '1')); | |
613 if(s->album[0]) id3v2_put_ttag(s, s->album, MKBETAG('T', 'A', 'L', 'B')); | |
614 if(s->genre[0]) id3v2_put_ttag(s, s->genre, MKBETAG('T', 'C', 'O', 'N')); | |
615 if(s->copyright[0]) id3v2_put_ttag(s, s->copyright, MKBETAG('T', 'C', 'O', 'P')); | |
616 if(s->track) id3v2_put_ttag(s, tracktxt, MKBETAG('T', 'R', 'C', 'K')); | |
2735 | 617 if(s->year) id3v2_put_ttag(s, yeartxt, MKBETAG('T', 'Y', 'E', 'R')); |
2098 | 618 if(!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) |
619 id3v2_put_ttag(s, LIBAVFORMAT_IDENT, MKBETAG('T', 'E', 'N', 'C')); | |
234 | 620 return 0; |
621 } | |
622 | |
468 | 623 static int mp3_write_packet(struct AVFormatContext *s, AVPacket *pkt) |
234 | 624 { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
625 put_buffer(s->pb, pkt->data, pkt->size); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
626 put_flush_packet(s->pb); |
234 | 627 return 0; |
628 } | |
629 | |
630 static int mp3_write_trailer(struct AVFormatContext *s) | |
631 { | |
2096 | 632 uint8_t buf[ID3v1_TAG_SIZE]; |
234 | 633 |
2096 | 634 /* write the id3v1 tag */ |
234 | 635 if (s->title[0] != '\0') { |
2096 | 636 id3v1_create_tag(s, buf); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
637 put_buffer(s->pb, buf, ID3v1_TAG_SIZE); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2746
diff
changeset
|
638 put_flush_packet(s->pb); |
234 | 639 } |
640 return 0; | |
641 } | |
858
66cc656ea404
Replace CONFIG_ENCODERS/CONFIG_DECODERS with CONFIG_MUXERS/CONFIG_DEMUXERS
diego
parents:
820
diff
changeset
|
642 #endif //CONFIG_MUXERS |
234 | 643 |
1169 | 644 #ifdef CONFIG_MP3_DEMUXER |
1167 | 645 AVInputFormat mp3_demuxer = { |
234 | 646 "mp3", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3289
diff
changeset
|
647 NULL_IF_CONFIG_SMALL("MPEG audio"), |
234 | 648 0, |
1107 | 649 mp3_read_probe, |
234 | 650 mp3_read_header, |
651 mp3_read_packet, | |
1756 | 652 .flags= AVFMT_GENERIC_INDEX, |
814 | 653 .extensions = "mp2,mp3,m2a", /* XXX: use probe */ |
234 | 654 }; |
1169 | 655 #endif |
656 #ifdef CONFIG_MP2_MUXER | |
1167 | 657 AVOutputFormat mp2_muxer = { |
234 | 658 "mp2", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3289
diff
changeset
|
659 NULL_IF_CONFIG_SMALL("MPEG audio layer 2"), |
234 | 660 "audio/x-mpeg", |
1622 | 661 #ifdef CONFIG_LIBMP3LAME |
814 | 662 "mp2,m2a", |
234 | 663 #else |
814 | 664 "mp2,mp3,m2a", |
234 | 665 #endif |
666 0, | |
667 CODEC_ID_MP2, | |
3289 | 668 CODEC_ID_NONE, |
2306
d045cbcf37a3
do not write id3v2 header when writing .mp2 files
bcoudurier
parents:
2274
diff
changeset
|
669 NULL, |
234 | 670 mp3_write_packet, |
671 mp3_write_trailer, | |
672 }; | |
1169 | 673 #endif |
674 #ifdef CONFIG_MP3_MUXER | |
1167 | 675 AVOutputFormat mp3_muxer = { |
234 | 676 "mp3", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3289
diff
changeset
|
677 NULL_IF_CONFIG_SMALL("MPEG audio layer 3"), |
234 | 678 "audio/x-mpeg", |
679 "mp3", | |
680 0, | |
681 CODEC_ID_MP3, | |
3289 | 682 CODEC_ID_NONE, |
234 | 683 mp3_write_header, |
684 mp3_write_packet, | |
685 mp3_write_trailer, | |
686 }; | |
687 #endif |