?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
New e-d-s backend which indexes all local addressbooks and calendars.
[beagle.git] / Util / Mp3Reader.cs
blob3614eccb436a7449dd63377b868a0066ba798c23
1 //
2 // Mp3Reader.cs : Reads an Id3v1.0,1.1,2.2,2.3 tag from the given stream
3 //
4 // Author:
5 // Raphaël Slinckx <raf.raf@wol.be>
6 //
7 // Copyright 2004 (C) Raphaël Slinckx (ported from http://entagged.sourceforge.net)
8 //
9
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining a
12 // copy of this software and associated documentation files (the "Software"),
13 // to deal in the Software without restriction, including without limitation
14 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 // and/or sell copies of the Software, and to permit persons to whom the
16 // Software is furnished to do so, subject to the following conditions:
17 //
18 // The above copyright notice and this permission notice shall be included in
19 // all copies or substantial portions of the Software.
20 //
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27 // DEALINGS IN THE SOFTWARE.
28 //
29
30 using System;
31 using System.IO;
32 using System.Text;
33 using System.Collections;
34
35 namespace Beagle.Util.AudioUtil {
36
37 namespace Mp3 {
38
39 public class Id3v2TagSynchronizer {
40
41 public int synchronize (byte[] b)
42 {
43 int newPtr = 0;
44 int oldPtr = 0;
45
46 byte cur;
47 while (oldPtr < b.Length && newPtr < b.Length) {
48 cur = b[oldPtr++];
49 b[newPtr++] = cur;
50 if (((cur&0xFF) == 0xFF) && (oldPtr < b.Length)) { //First part of synchronization
51 cur = b[oldPtr++];
52 if (cur != 0x00) { //If different, we have not a synchronization, so we take this value
53 b[newPtr++] = cur;
54 }
55 }
56 }
57
58 //We have finished, retun the length of the new data.
59 return newPtr;
60 }
61 }
62
63 public class Id3v23TagReader {
64
65 public static int ID3V22 = 0;
66 public static int ID3V23 = 1;
67
68 private Hashtable conversion;
69 private ASCIIEncoding ascii = new ASCIIEncoding ();
70 private UTF8Encoding utf = new UTF8Encoding ();
71
72 public Id3v23TagReader ()
73 {
74 this.conversion = initConversionTable ();
75 }
76
77 public Tag Read (byte[] data, int tagSize, byte flags, int version)
78 {
79 Tag tag = new Tag ();
80
81 int elapsedBytes = 0;
82
83 bool extended = ((flags&64) == 64) ? true : false;
84 //--------------------------------------------------------------
85 if (version == ID3V23 && extended)
86 elapsedBytes = processExtendedHeader (data);
87 //--------------------------------------------------------------
88 Hashtable ht = new Hashtable (10);
89
90 int specSize = (version == ID3V22) ? 3 : 4;
91 for (int a = 0; a < tagSize; a+=elapsedBytes) {
92 string field = ascii.GetString (data, elapsedBytes, specSize);
93
94 if (data[elapsedBytes] == 0)
95 break;
96 elapsedBytes += specSize;
97
98 //-------------------------------------
99 int frameSize = ReadInteger (data, elapsedBytes, version);
100 elapsedBytes += specSize;
101
102 if (version == ID3V23) {
103 //Frame flags, skipping
104 elapsedBytes += 2;
105 }
106
107 if ((frameSize + elapsedBytes) > tagSize || frameSize <= 0){
108 throw new Exception ("Frame size error, skipping file");
109 }
110 else {
111 if (version == ID3V22) {
112 //We try to translte the tag from a 3 letters
113 //v22 format to a 4 letter v23-4 format
114 field = convertFromId3v22 (field);
115 //if the conversion do not succeed,
116 //then the frame is lost
117 }
118
119 if (field != "") {
120 byte[] content = new byte[frameSize];
121
122 for (int i = 0; i<content.Length; i++)
123 content[i] = data[i+elapsedBytes];
124
125 ht[field] = toSimplestring (field, content);
126 }
127 elapsedBytes += frameSize;
128 }
129 }
130 //--------------------------------------------------------------
131
132 foreach (DictionaryEntry en in ht) {
133 string field = (string) en.Key;
134 string content = (string) en.Value;
135
136 if (field == "TIT2")
137 tag.Title = content;
138 else if (field == "TPE1")
139 tag.Artist = content;
140 else if (field == "TALB")
141 tag.Album = content;
142 else if (field == "TYER")
143 tag.Year = content;
144 else if (field == "COMM") {
145 tag.Comment = content.Substring (4);
146 } else if (field == "TRCK")
147 tag.Track = content;
148 else if (field == "TCON")
149 tag.Genre = content;
150 }
151
152 return tag;
153 }
154
155 private Hashtable initConversionTable ()
156 {
157 Hashtable ht = new Hashtable (64, 1.0f);
158 string[] v22 = {
159 "BUF", "CNT", "COM", "CRA",
160 "CRM", "ETC", "EQU", "GEO",
161 "IPL", "LNK", "MCI", "MLL",
162 "PIC", "POP", "REV", "RVA",
163 "SLT", "STC", "TAL", "TBP",
164 "TCM", "TCO", "TCR", "TDA",
165 "TDY", "TEN","TFT", "TIM",
166 "TKE", "TLA", "TLE", "TMT",
167 "TOA", "TOF", "TOL", "TOR",
168 "TOT", "TP1", "TP2", "TP3",
169 "TP4", "TPA", "TPB", "TRC",
170 "TRD", "TRK", "TSI", "TSS",
171 "TT1", "TT2", "TT3", "TXT",
172 "TXX", "TYE", "UFI", "ULT",
173 "WAF", "WAR", "WAS", "WCM",
174 "WCP", "WPB", "WXX"
175 };
176 string[] v23 = {
177 "RBUF", "PCNT", "COMM", "AENC",
178 "", "ETCO", "EQUA", "GEOB",
179 "IPLS", "LINK", "MCDI", "MLLT",
180 "APIC", "POPM", "RVRB", "RVAD",
181 "SYLT", "SYTC", "TALB", "TBPM",
182 "TCOM", "TCON", "TCOP", "TDAT",
183 "TDLY", "TENC", "TFLT", "TIME",
184 "TKEY", "TLAN", "TLEN", "TMED",
185 "TOPE", "TOFN", "TOLY", "TORY",
186 "TOAL", "TPE1", "TPE2", "TPE3",
187 "TPE4", "TPOS", "TPUB", "TSRC",
188 "TRDA", "TRCK", "TSIZ", "TSSE",
189 "TIT1", "TIT2", "TIT3", "TEXT",
190 "TXXX", "TYER", "UFID", "USLT",
191 "WOAF", "WOAR", "WOAS", "WCOM",
192 "WCOP", "WPUB", "WXXX"
193 };
194
195 for (int i = 0; i<v22.Length; i++)
196 ht[v22[i]] = v23[i];
197
198 return ht;
199 }
200
201 private string convertFromId3v22 (string field)
202 {
203 string s = (string) this.conversion[field];
204
205 if (s == null)
206 return "";
207
208 return s;
209 }
210
211 //returns the number of bytes to skip, to skip the extended data
212 private int processExtendedHeader (byte[] data)
213 {
214 int extsize = ReadInteger (data,0, ID3V23);
215 // The extended header size includes those first four bytes.
216 return extsize -4;
217 }
218
219 private string toSimplestring (string field, byte[] content)
220 {
221 //-----------HERE FRAME SPECIFICITIES WILL BE HANDLED !! -----
222 //Text frames
223 if (field.StartsWith ("T") && !field.StartsWith ("TX")) {
224 //Structure:
225 //Encoding|string| (Termination)
226
227 //Are we null terminated ? x00 or x0000 if ISO or UTF
228 int idx = indexOfFirstNull (content, 1);
229 int length;
230 if (idx != -1)
231 length = idx-1;
232 else
233 length = content.Length-1;
234
235 if (content[0] == 1) {
236 //UTF-8 encoding
237 return utf.GetString (content, 1, length);
238 }
239
240 //if content[0] == 0 , we use ISO-8859-1, if not, this is a default.
241 return ascii.GetString (content, 1, length);
242 }
243 else if (field.StartsWith ("COMM") || field.StartsWith ("WX")
244 || field.StartsWith ("IPLS") || field.StartsWith ("USLT")
245 || field.StartsWith ("TX") || field.StartsWith ("USER")) {
246 //Structure:
247 //Encoding|string
248
249
250 //We get here the custom TXXX and WXXX frames, same constitution
251 int length = content.Length - 1;
252
253 if (content[0] == 1) {
254 //UTF-8 encoding
255 return utf.GetString (content, 1, length);
256 }
257
258 //if content[0] == 0 , we use ISO-8859-1, if not, this is a default.
259 return ascii.GetString (content, 1, length);
260 }
261 else if (field.StartsWith ("UFID") || field.StartsWith ("MCDI")
262 || field.StartsWith ("ETCO") || field.StartsWith ("MLLT")
263 || field.StartsWith ("SYTC") || field.StartsWith ("RVAD")
264 || field.StartsWith ("EQUA") || field.StartsWith ("RVRB")
265 || field.StartsWith ("APIC") || field.StartsWith ("GEOB")
266 || field.StartsWith ("SYLT") || field.StartsWith ("PCNT")
267 || field.StartsWith ("POPM") || field.StartsWith ("RBUF")
268 || field.StartsWith ("AENC") || field.StartsWith ("LINK")
269 || field.StartsWith ("POSS") || field.StartsWith ("OWNE")
270 || field.StartsWith ("COMR") || field.StartsWith ("ENCR")
271 || field.StartsWith ("GRID") || field.StartsWith ("PRIV")) {
272 //Structure:
273 //|string| aka Binary data
274
275 //WARNING APIC, GEOB, OWNE, SYLT, COMR use a mix of ISO and UTF encoding
276 //They are saved as binary data and, one to further process the contained data
277 //has to trasform the string o bytes (using iso) then parse appropriately !
278
279 return ascii.GetString (content);
280 }
281 else if (field.StartsWith ("W") && !field.StartsWith ("WX")) {
282 //Structure:
283 //|string| (Termination)
284
285 int idx = indexOfFirstNull (content, 1);
286 int length;
287 if (idx != -1)
288 length = idx-1;
289 else
290 length = content.Length-1;
291
292 return ascii.GetString (content, 1, length);
293 }
294 else {
295 //We get here for all the frame that are not supported by the ID3 document
296 //We simply save the content as binary data !
297 Console.Error.Write ("Unknown Tag frame: " + field);
298 return ascii.GetString (content);
299 }
300 }
301
302 private int indexOfFirstNull (byte[] b, int offset)
303 {
304 for (int i = offset; i<b.Length; i++)
305 if (b[i] == 0)
306 return i;
307 return -1;
308 }
309
310 private int ReadInteger (byte[] bb, int offset, int version)
311 {
312 int value = 0;
313
314 if (version == ID3V23)
315 value += (bb[offset]& 0xFF) << 24;
316 value += (bb[offset+1]& 0xFF) << 16;
317 value += (bb[offset+2]& 0xFF) << 8;
318 value += (bb[offset+3]& 0xFF);
319
320 return value;
321 }
322 }
323 }
324
325 public class Id3v1TagReader {
326
327 public static string[] ID3V1_GENRES = new string[] {"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz",
328 "Metal", "New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative",
329 "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk", "Fusion",
330 "Trance", "Classical", "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
331 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic",
332 "Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
333 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave",
334 "Psychadelic", "Rave", "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro",
335 "Musical", "Rock & Roll", "Hard Rock", "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob", "Latin", "Revival",
336 "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
337 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech", "Chanson", "Opera", "Chamber Music", "Sonata",
338 "Symphony", "Booty Bass", "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba", "Folklore", "Ballad",
339 "Power Ballad", "Rhythmic Soul", "Freestyle", "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall"};
340
341 public Tag Read (FileStream fs)
342 {
343 byte[] buf = new byte[30];
344 ASCIIEncoding ascii = new ASCIIEncoding ();
345 Tag tag = new Tag ();
346
347 //Check wether the file contains an Id3v1 tag--------------------------------
348 fs.Seek (-128, SeekOrigin.End);
349
350 fs.Read (buf, 0, 3);
351 fs.Seek (0, SeekOrigin.Begin);
352
353 string tagS = ascii.GetString (buf, 0, 3);
354 if (tagS != "TAG"){
355 throw new Exception ("There is no Id3v1 Tag in this file");
356 }
357 //Parse the tag -)------------------------------------------------
358 fs.Seek (-128 + 3, SeekOrigin.End);
359 fs.Read (buf, 0, 30);
360 string songName = ascii.GetString (buf, 0, 30);
361 songName = songName.Trim ();
362 //------------------------------------------------
363 fs.Read (buf, 0, 30);
364 string artist = ascii.GetString (buf, 0, 30);
365 artist = artist.Trim ();
366 //------------------------------------------------
367 fs.Read (buf, 0, 30);
368 string album = ascii.GetString (buf, 0, 30);
369 album = album.Trim ();
370 //------------------------------------------------
371 fs.Read (buf, 0, 4);
372 string year = ascii.GetString (buf, 0, 4);
373 year = year.Trim ();
374 //------------------------------------------------
375 fs.Read (buf, 0, 30);
376
377 string trackNumber = "";
378 string comment;
379
380 if (buf[28] == 0) {
381 trackNumber = buf[29].ToString ();
382
383 comment = ascii.GetString (buf, 0, 28);
384 comment = comment.Trim ();
385 }
386 else {
387 comment = ascii.GetString (buf, 0, 30);
388 comment = comment.Trim ();
389 }
390 //------------------------------------------------
391 fs.Read (buf, 0, 1);
392 byte genreByte = buf[0];
393
394 tag.Title = songName;
395 tag.Artist = artist;
396 tag.Album = album;
397 tag.Year = year;
398 tag.Comment = comment;
399 tag.Track = trackNumber;
400 tag.Genre = TranslateGenre (genreByte);
401
402 fs.Seek (0, SeekOrigin.Begin);
403
404 return tag;
405 }
406
407 private string TranslateGenre (byte b)
408 {
409 int i = b & 0xFF;
410
411 if (i == 255 || i > ID3V1_GENRES.Length - 1)
412 return "";
413
414 return ID3V1_GENRES[i];
415 }
416 }
417
418 public class Id3v2TagReader {
419
420 private Mp3.Id3v2TagSynchronizer synchronizer = new Mp3.Id3v2TagSynchronizer ();
421 private Mp3.Id3v23TagReader v23 = new Mp3.Id3v23TagReader ();
422 private ASCIIEncoding ascii = new ASCIIEncoding ();
423
424 public Tag Read (Stream fs)
425 {
426 Tag tag = null;
427
428 fs.Seek (0, SeekOrigin.Begin);
429 byte[] buf = new byte[3];
430 fs.Read (buf, 0, 3);
431
432 string ID3 = ascii.GetString (buf);
433 if (ID3 != "ID3") {
434 throw new Exception ("There is no Id3v2 Tag in this file");
435 }
436 //Begins tag parsing ---------------------------------------------
437 fs.Seek (3, SeekOrigin.Begin);
438 //----------------------------------------------------------------------------
439 string versionHigh = fs.ReadByte () + "";
440
441 // Since we never use versionID3, we just read the byte off of
442 // the stream instead of constructing the version string.
443 //string versionID3 = versionHigh + "." + fs.ReadByte ();
444 fs.ReadByte ();
445
446 //------------------------------------------------------------------------- ---
447 byte flags = (byte) fs.ReadByte (); //ID3 Flags, skipping
448 //----------------------------------------------------------------------------
449 int tagSize = ReadSyncsafeInt (fs);
450 //-----------------------------------------------------------------
451 //Fill a byte buffer, then process according to correct version
452 buf = new byte[tagSize+2];
453 fs.Read (buf, 0, buf.Length);
454
455 bool unsynch = ((flags&128) == 128) ? true : false;
456 if (unsynch) {
457 //We have unsynchronization, first re-synchronize
458 tagSize = synchronizer.synchronize (buf);
459 }
460
461 if (versionHigh == "2") {
462 tag = v23.Read (buf, tagSize, flags, Mp3.Id3v23TagReader.ID3V22);
463 }
464 else if (versionHigh == "3") {
465 tag = v23.Read (buf, tagSize, flags, Mp3.Id3v23TagReader.ID3V23);
466 }
467 else if (versionHigh == "4") {
468 //tag = v24.Read (raf, ID3Flags);
469 throw new Exception ("Cannot read ID3v2.4 tags right now !");
470 }
471 else {
472 throw new Exception ("Cannot read unknown version: ID3v2."+versionHigh);
473 }
474
475 return tag;
476 }
477
478 private int ReadSyncsafeInt (Stream fs)
479 {
480 int val = 0;
481
482 val += (fs.ReadByte ()& 0xFF) << 21;
483 val += (fs.ReadByte ()& 0xFF) << 14;
484 val += (fs.ReadByte ()& 0xFF) << 7;
485 val += fs.ReadByte ()& 0xFF;
486
487 return val;
488 }
489 }
490
491 }
A Beagle Git Repo