mp3info.py00006440000001000000100000036420072735415730012755 0ustar unknownunknown__doc__ = """Python MPEG Audio Information Module.""" __version__ = '0.3 20042001' # # Python MPEG Information Module # # (c)Eduardo Roldan, Under the GPL License # e-mail: trazor@adinet.com.uy # ######################################################### # Adapted by Marc Lindahl, still under GPL # # 4/20/01 # # changed to operate on a string, instead of a file. # # use dictionaries for id3 params # # # ######################################################### # Check the included READMEmp3info.txt for instructions (no many '#' comments here) import string _mpeg_strings = ['2.5', '', '2', '1'] _layers = ['', 'III', 'II', 'I'] _bitrates_mpeg1 = [ [], [-1, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320], [-1, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384], [-1, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448] ] # !! -1 = free bitrate _bitrates_mpeg2 = [ [], [-1, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160], [-1, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160], [-1, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256] ] _frequency_strings = [ [11025, 12000, 8000], [], [22050, 24000, 16000,], [44100, 48000, 32000,] ] _channel_mode_strings= ['Stereo', 'Joint Stereo', 'Dual Channel', 'Single Channel'] InvalidHeaderError = 'Can\'t read an invalid header' NoHeaderError = 'No header present' NoTagError = 'No id3 tag present' #Extracted from mpg123 0.59q _genre_list = [ "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "Alt", "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta Rap", "Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave", "Psychedelic", "Rave", "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock", "Folk", "Folk/Rock", "National Folk", "Swing", "Fast-Fusion", "Bebob", "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock", "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech", "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba", "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle", "Duet", "Punk Rock", "Drum Solo", "A Cappella", "Euro-House", "Dance Hall", "Goa", "Drum & Bass", "Club/House", "Hardcore", "Terror", "Indie", "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap", "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian", "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "JPop", "Synthpop","" ] class mp3info: """ Extract and insert MP3 meta information """ ### Id3 ### def __init__(self, file=''): #read-only info (because it's in EVERY frame of the file) self.header = {'mpeg':'', 'layer':'', 'protection':'', 'bitrate':0, 'frequency':0, 'channel_mode':'', 'copyright':'', 'original':'', 'length':[0, 0, 0], 'framelength':0} #changeable info (at end of the file) self.id3 = {'genre':'', 'genre_no':0, 'songname':'', 'artist':'', 'album':'', 'year':0, 'comment':'', 'filesize':len(file), 'genre_no':255} self.data = file try: self.read_tag() except NoTagError: self.id3 = {'genre':'', 'genre_no':0, 'songname':'', 'artist':'', 'album':'', 'year':0, 'comment':'', 'filesize':len(file)} if file != '': self._initheader() #no empty error if just constructing before using def __call__(self, file=None): """ basically same as init, reads file and strips tags, etc., don't catch excepts call with no arg to re-read current file """ if file != None: self.data = file self.read_tag() self._initheader() def mp3_file(self, file=None, dict=None): #call w arg to update file (w/opt. dict), w/o to use most recent file """ output an mp3 file with updated id3 tags """ if file != None: self.data = file self.read_tag() self._initheader() if dict != None: self.set_id3(dict) return string.join([self.data[:-128], 'TAG', string.ljust(self.id3['songname'], 30)[:30], string.ljust(self.id3['artist'], 30)[:30], string.ljust(self.id3['album'], 30)[:30], string.rjust(self.id3['year'], 4)[-4:], string.ljust(self.id3['comment'], 30)[:30], chr(self.id3['genre_no'])], '') def mp3_tag(self, file=None, dict=None): #call w arg to update file (w/opt. dict), w/o to use most recent file """ output just the last 128 bytes of an mp3 file (tag data) with updated id3 tags """ if file != None: self.data = file self.read_tag() self._initheader() if dict != None: self.set_id3(dict) return string.join(['TAG', string.ljust(self.id3['songname'], 30)[:30], string.ljust(self.id3['artist'], 30)[:30], string.ljust(self.id3['album'], 30)[:30], string.rjust(self.id3['year'], 4)[-4:], string.ljust(self.id3['comment'], 30)[:30], chr(self.id3['genre_no'])], '') def free_file(self): #free data storage """ free data store (which could be large) """ self.data = None def _initheader(self): self.sync_read_header(0, 1024) self.header['mpeg'] = self.get_mpeg_version() self.header['layer'] = self.get_layer() self.header['protection'] = self.get_protection() self.header['bitrate'] = `self.get_bitrate()` self.header['frequency'] = `self.get_frequency()` self.header['channel_mode'] = self.get_channel_mode() self.header['copyright'] = self.get_copyright() self.header['original'] = self.get_original() self.header['length'] = string.zfill(self.get_length()[1], 2) + ':' + string.zfill(self.get_length()[2], 2) self.header['framelength'] = `self.get_framelength()` self.id3.update(self.header) #put readonly info into id3 dict def read_tag(self): """ update id3 info dictionary """ self.id3['filesize'] = len(self.data) if self.id3['filesize'] <= 128: raise NoTagError if self.data[-128:-125] == 'TAG': self.id3['songname'] = self.data[-125:-95] self.id3['artist'] = self.data[-95:-65] self.id3['album'] = self.data[-65:-35] self.id3['year'] = self.data[-35:-31] self.id3['comment'] = self.data[-31:-1] self.id3['genre_no'] = ord(self.data[-1]) self.id3['genre'] = self.get_genre() return 1 else: raise NoTagError def get_genre(self, g = None): """ get genre """ if g == None: g = self.id3['genre_no'] try: return _genre_list[g] except IndexError: return 'Unknown' def get_genre_list(self): ##MSL added 4/20/01 """ get list of genres """ return _genre_list def get_id3(self): ##MSL added 4/20/01 """ get id3 info dictionary """ return self.id3 ### Set method ### ##MSL added 4/20/01 def set_id3(self, id3): """ set id3 info dictionary """ self.id3.update(id3) self.id3['genre'] = self.get_genre() self.id3.update(self.header) #put readonly info into id3 dict return self.id3 ### Header ### def sync_read_header(self, offset = 0, depth = 0): if depth == 0 or depth > len(self.data): depth = len(self.data) _seek = offset #MSL 04/21/01 hackery - since original code dealt with filesystem (open, seek, etc) while 1: while _seek < depth: if ord(self.data[_seek]) != 0xff: _seek = _seek + 1 break _seek = _seek + 1 _second_byte = ord(self.data[_seek]) _seek = _seek + 1 if _second_byte >> 5 != 0x07: _seek = _seek - 1 break self._sync_byte = 255 self._mpeg_version = (_second_byte & 0x18) >> 3 # B self._layer = (_second_byte & 0x06) >> 1 # C _third_byte = ord(self.data[_seek]) _seek = _seek + 1 self._bitrate = (_third_byte & 0xf0) >> 4 # E self._frequency = (_third_byte & 0x0c) >> 2 # F self._padding = (_third_byte & 0x02) >> 1 # G _fourth_byte = ord(self.data[_seek]) _seek = _seek + 1 self._emphasis = (_fourth_byte & 0x03) # M try: self.check_header() except InvalidHeaderError: _seek = _seek - 3 break ctuple1 = self._mpeg_version, self._layer, self._frequency, self._emphasis step_1_ = self.get_framelength() _seek = _seek + step_1_ - 4 try: self.read_header(_seek) except InvalidHeaderError: _seek = _seek - (step_1_ + 3) break ctuple2 = self._mpeg_version, self._layer, self._frequency, self._emphasis if ctuple1 == ctuple2: return _seek - (step_1_+4) else: _seek = _seek - (step_1_ + 3) break else: raise NoHeaderError def read_header(self, offset = 0): # AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM _seek = offset #MSL 04/21/01 hackery - since original code dealt with filesystem (open, seek, etc) self._sync_byte = ord(self.data[_seek]) _seek = _seek + 1 _second_byte = ord(self.data[_seek]) _seek = _seek + 1 self._mpeg_version = (_second_byte & 0x18) >> 3 # B self._layer = (_second_byte & 0x06) >> 1 # C self.protection = (_second_byte & 0x01) # D _third_byte = ord(self.data[_seek]) _seek = _seek + 1 self._bitrate = (_third_byte & 0xf0) >> 4 # E self._frequency = (_third_byte & 0x0c) >> 2 # F self._padding = (_third_byte & 0x02) >> 1 # G self.private = (_third_byte & 0x01) # H _fourth_byte = ord(self.data[_seek]) _seek = _seek + 1 self.channel_mode = (_fourth_byte & 0xc0) >> 6 # I self.mode_ext = (_fourth_byte & 0x30) >> 4 # J self.copyright = (_fourth_byte & 0x08) >> 3 # K self.original = (_fourth_byte & 0x04) >> 2 # L self._emphasis = (_fourth_byte & 0x03) # M self.check_header() return 1 def check_header(self): if self._sync_byte != 255 or self._mpeg_version == 1 or self._layer == 0\ or self._bitrate == 15 or self._frequency == 3 or self._emphasis == 2 : raise InvalidHeaderError def get_mpeg_version(self): return _mpeg_strings[self._mpeg_version] def get_layer(self): return _layers[self._layer] def get_protection(self): if self.protection: return 'No' else: return 'Yes' def get_bitrate(self): if self._mpeg_version == 3: return _bitrates_mpeg1[self._layer][self._bitrate] elif self._mpeg_version == 2 or self._mpeg_version == 0: return _bitrates_mpeg2[self._layer][self._bitrate] def get_frequency(self): return _frequency_strings[self._mpeg_version][self._frequency] def get_channel_mode(self): return _channel_mode_strings[self.channel_mode] def get_copyright(self): if self.copyright: return 'Yes' else: return 'No' def get_original(self): if self.original: return 'Yes' else: return 'No' def get_length(self): if self._bitrate == 0: return 0, 0, 0 else: _const = self.get_bitrate() * 125 _seconds = self.id3['filesize'] / _const _minutes = _seconds / 60 _seconds_part = _seconds % 60 return _seconds, _minutes, _seconds_part def get_framelength(self): if self._layer == 1 or self._layer == 2: return 144 * self.get_bitrate() * 1000 / self.get_frequency() + self._padding else: return 12 * self.get_bitrate() * 1000 / self.get_frequency() + self._padding 28:-125] == 'TAG': self.id3['songname'] = self.data[-125:-95] self.id3['artist'] = self.data[-95:-65] self.id3['album'] = self.data[-65:-35] self.id3['year'] = self.data[-35:-3MPEG AUDIO FRAME HEADER.txt00006440000001000000100000050320072735415600014656 0ustar unknownunknownThis is a brief and informal document targeted to those who want to deal with the MPEG format. If you are one of them, you probably already know what is MPEG audio. If not, jump to http://www.mp3.com/ or http://www.layer3.org/ where you will find more details and also more links. This document does not cover compression and decompression algorithm. NOTE: You cannot just search the Internet and find the MPEG audio specs. It is copyrighted and you will have to pay quite a bit to get the Paper. That's why I made this. Information I got is gathered from the Internet, and mostly originate from program sources I found available for free. Despite my intention to always specify the information sources, I am not able to do it this time. Sorry, I did not maintain the list. :-( These are not a decoding specs, it just informs you how to read the MPEG headers and the MPEG TAG. MPEG Version 1, 2 and 2.5 and Layer I, II and III are supported, the MP3 TAG (ID3v1 and ID3v1.1) also.. Those of you who use Delphi may find MPGTools Delphi unit (freeware source) useful, it is where I implemented this stuff. I do not claim information presented in this document is accurate. At first I just gathered it from different sources. It was not an easy task but I needed it. Later, I received lots of comments as feedback when I published this document. I think this last release is highly accurate due to comments and corrections I received. This document is last updated on December 22, 1999. MPEG Audio Compression Basics This is one of many methods to compress audio in digital form trying to consume as little space as possible but keep audio quality as good as possible. MPEG compression showed up as one of the best achievements in this area. This is a lossy compression, which means, you will certainly loose some audio information when you use this compression methods. But, this lost can hardly be noticed because the compression method tries to control it. By using several quite complicate and demanding mathematical algorithms it will only loose those parts of sound that are hard to be heard even in the original form. This leaves more space for information that is important. This way you can compress audio up to 12 times (you may choose compression ratio) which is really significant. Due to its quality MPEG audio became very popular. MPEG standards MPEG-1, MPEG-2 and MPEG-4 are known but this document covers first two of them. There is an unofficial MPEG-2.5 which is rarely used. It is also covered. MPEG-1 audio (described in ISO/IEC 11172-3) describes three Layers of audio coding with the following properties: *one or two audio channels *sample rate 32kHz, 44.1kHz or 48kHz. *bit rates from 32kbps up to 448kbps Each layer has its merits. MPEG-2 audio (described in ISO/IEC 13818-3) has two extensions to MPEG-1, usually referred as MPEG-2/LSF and MPEG-2/Multichannel. MPEG-2/LSF has the following properties: *one or two audio channels *sample rates half those of MPEG-1 *bit rates from 8 kbps up to 256kbps. MPEG-2/Multichannel has the following properties: *up to 5 full range audio channels and an LFE-channel (Low Frequency Enhancement <> subwoofer!) *sample rates the same as those of MPEG-1 *highest possible bitrate goes up to about 1Mbps for 5.1 MPEG Audio Frame Header An MPEG audio file is built up from smaller parts called frames. Generally, frames are independent items. Each frame has its own header and audio informations. There is no file header. Therefore, you can cut any part of MPEG file and play it correctly (this should be done on frame boundaries but most applications will handle incorrect headers). For Layer III, this is not 100% correct. Due to internal data organization in MPEG version 1 Layer III files, frames are often dependent of each other and they cannot be cut off just like that. When you want to read info about an MPEG file, it is usually enough to find the first frame, read its header and assume that the other frames are the same This may not be always the case. Variable bitrate MPEG files may use so called bitrate switching, which means that bitrate changes according to the content of each frame. This way lower bitrates may be used in frames where it will not reduce sound quality. This allows making better compression while keeping high quality of sound. The frame header is constituted by the very first four bytes (32bits) in a frame. The first eleven bits (or first twelve bits, see below about frame sync) of a frame header are always set and they are called "frame sync". Therefore, you can search through the file for the first occurence of frame sync (meaning that you have to find a byte with a value of 255, and followed by a byte with its three (or four) most significant bits set). Then you read the whole header and check if the values are correct. You will see in the following table the exact meaning of each bit in the header, and which values may be checked for validity. Each value that is specified as reserved, invalid, bad, or not allowed should indicate an invalid header. Remember, this is not enough, frame sync can be easily (and very frequently) found in any binary file. Also it is likely that MPEG file contains garbage on it's beginning which also may contain false sync. Thus, you have to check two or more frames in a row to assure you are really dealing with MPEG audio file. Frames may have a CRC check. The CRC is 16 bits long and, if it exists, it follows the frame header. After the CRC comes the audio data. You may calculate the length of the frame and use it if you need to read other headers too or just want to calculate the CRC of the frame, to compare it with the one you read from the file. This is actually a very good method to check the MPEG header validity. Here is "graphical" presentation of the header content. Characters from A to M are used to indicate different fields. In the table, you can see details about the content of each field. AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM Sign Length Position Description (bits) (bits) A 11 (31-21) Frame sync (all bits set) B 2 (20,19) MPEG Audio version ID 00 - MPEG Version 2.5 01 - reserved 10 - MPEG Version 2 (ISO/IEC 13818-3) 11 - MPEG Version 1 (ISO/IEC 11172-3) Note: MPEG Version 2.5 is not official standard. Bit No 20 in frame header is used to indicate version 2.5. Applications that do not support this MPEG version expect this bit always to be set, meaning that frame sync (A) is twelve bits long, not eleve as stated here. Accordingly, B is one bit long (represents only bit No 19). I recommend using methodology presented here, since this allows you to distinguish all three versions and keep full compatibility. C 2 (18,17) Layer description 00 - reserved 01 - Layer III 10 - Layer II 11 - Layer I D 1 (16) Protection bit 0 - Protected by CRC (16bit crc follows header) 1 - Not protected E 4 (15,12) Bitrate index bitsV1,L1 V1,L2V1,L3 V2,L1V2, L2 & L3 0000free free free free free 000132 32 32 32 8 001064 48 40 48 16 001196 56 48 56 24 0100128 64 56 64 32 0101160 80 64 80 40 0110192 96 80 96 48 0111224 112 96 112 56 1000256 128 112 128 64 1001288 160 128 144 80 1010320 192 160 160 96 1011352 224 192 176 112 1100384 256 224 192 128 1101416 320 256 224 144 1110448 384 320 256 160 1111bad bad bad bad bad NOTES: All values are in kbps V1 - MPEG Version 1 V2 - MPEG Version 2 and Version 2.5 L1 - Layer I L2 - Layer II L3 - Layer III "free" means free format. If the correct fixed bitrate (such files cannot use variable bitrate) is different than those presented in upper table it must be determined by the application. This may be implemented only for internal purposes since third party applications have no means to find out correct bitrate. Howewer, this is not impossible to do but demands lot's of efforts. "bad" means that this is not an allowed value MPEG files may have variable bitrate (VBR). This means that bitrate in the file may change. I have learned about two used methods: * bitrate switching. Each frame may be created with different bitrate. It may be used in all layers. Layer III decoders must support this method. Layer I & II decoders may support it. * bit reservoir. Bitrate may be borrowed (within limits) from previous frames in order to provide more bits to demanding parts of the input signal. This causes, however, that the frames are no longer independent, which means you should not cut this files. This is supported only in Layer III. More about VBR you may find on Xing Tech site For Layer II there are some combinations of bitrate and mode which are not allowed. Here is a list of allowed combinations. bitrateallowed modes free all 32 single channel 48 single channel 56 single channel 64 all 80 single channel 96 all 112 all 128 all 160 all 192 all 224 stereo, intensity stereo, dual channel 256 stereo, intensity stereo, dual channel 320 stereo, intensity stereo, dual channel 384 stereo, intensity stereo, dual channel F 2 (11,10) Sampling rate frequency index (values are in Hz) bitsMPEG1 MPEG2 MPEG2.5 00 44100 22050 11025 01 48000 24000 12000 10 32000 16000 8000 11 reserv. reserv.reserv. G 1 (9) Padding bit 0 - frame is not padded 1 - frame is padded with one extra slot Padding is used to fit the bit rates exactly. For an example: 128k 44.1kHz layer II uses a lot of 418 bytes and some of 417 bytes long frames to get the exact 128k bitrate. For Layer I slot is 32 bits long, for Layer II and Layer III slot is 8 bits long. How to calculate frame length First, let's distinguish two terms frame size and frame length. Frame size is the number of samples contained in a frame. It is constant and always 384 samples for Layer I and 1152 samples for Layer II and Layer III. Frame length is length of a frame when compressed. It is calculated in slots. One slot is 4 bytes long for Layer I, and one byte long for Layer II and Layer III. When you are reading MPEG file you must calculate this to be able to find each consecutive frame. Remember, frame length may change from frame to frame due to padding or bitrate switching. Read the BitRate, SampleRate and Padding of the frame header. For Layer I files us this formula: FrameLengthInBytes = (12 * BitRate / SampleRate + Padding) * 4 For Layer II & III files use this formula: FrameLengthInBytes = 144 * BitRate / SampleRate + Padding Example: Layer III, BitRate=128000, SampleRate=441000, Padding=0 ==> FrameSize=417 bytes H 1 (8) Private bit. It may be freely used for specific needs of an application, i.e. if it has to trigger some application specific events. I 2 (7,6) Channel Mode 00 - Stereo 01 - Joint stereo (Stereo) 10 - Dual channel (Stereo) 11 - Single channel (Mono) J 2 (5,4) Mode extension (Only if Joint stereo) Mode extension is used to join informations that are of no use for stereo effect, thus reducing needed resources. These bits are dynamically determined by an encoder in Joint stereo mode. Complete frequency range of MPEG file is divided in subbands There are 32 subbands. For Layer I & II these two bits determine frequency range (bands) where intensity stereo is applied. For Layer III these two bits determine which type of joint stereo is used (intensity stereo or m/s stereo). Frequency range is determined within decompression algorythm. Layer I and II Layer III value Layer I & II Intensity stereoMS stereo 00 bands 4 to 31 off off 01 bands 8 to 31 on off 10 bands 12 to 31 off on 11 bands 16 to 31 on on K 1 (3) Copyright 0 - Audio is not copyrighted 1 - Audio is copyrighted L 1 (2) Original 0 - Copy of original media 1 - Original media M 2 (1,0) Emphasis 00 - none 01 - 50/15 ms 10 - reserved 11 - CCIT J.17 MPEG Audio Tag ID3v1 The TAG is used to describe the MPEG Audio file. It contains information about artist, title, album, publishing year and genre. There is some extra space for comments. It is exactly 128 bytes long and is located at very end of the audio data. You can get it by reading the last 128 bytes of the MPEG audio file. AAABBBBB BBBBBBBB BBBBBBBB BBBBBBBB BCCCCCCC CCCCCCCC CCCCCCCC CCCCCCCD DDDDDDDD DDDDDDDD DDDDDDDD DDDDDEEE EFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFG Sign Length Position Description (bytes)(bytes) A 3 (0-2) Tag identification. Must contain 'TAG' if tag exists and is correct. B 30 (3-32) Title C 30 (33-62) Artist D 30 (63-92) Album E 4 (93-96) Year F 30 (97-126) Comment G 1 (127) Genre The specification asks for all fields to be padded with null character (ASCII 0). However, not all applications respect this (an example is WinAmp which pads fields with , ASCII 32). There is a small change proposed in ID3v1.1 structure. The last byte of the Comment field may be used to specify the track number of a song in an album. It should contain a null character (ASCII 0) if the information is unknown. Genre is a numeric field which may have one of the following values: 0 'Blues' 20 'Alternative' 40 'AlternRock' 60 'Top 40' 1 'Classic 21 'Ska' 41 'Bass' 61 'Christian Rock' Rap' 2 'Country' 22 'Death Metal' 42 'Soul' 62 'Pop/Funk' 3 'Dance' 23 'Pranks' 43 'Punk' 63 'Jungle' 4 'Disco' 24 'Soundtrack' 44 'Space' 64 'Native American' 5 'Funk' 25 'Euro-Techno' 45 'Meditative' 65 'Cabaret' 6 'Grunge' 26 'Ambient' 46 'Instrumental Pop' 66 'New Wave' 7 'Hip-Hop' 27 'Trip-Hop' 47 'Instrumental Rock'67 'Psychadelic' 8 'Jazz' 28 'Vocal' 48 'Ethnic' 68 'Rave' 9 'Metal' 29 'Jazz+Funk' 49 'Gothic' 69 'Showtunes' 10 'New Age' 30 'Fusion' 50 'Darkwave' 70 'Trailer' 11 'Oldies' 31 'Trance' 51 'Techno-Industrial'71 'Lo-Fi' 12 'Other' 32 'Classical' 52 'Electronic' 72 'Tribal' 13 'Pop' 33 'Instrumental'53 'Pop-Folk' 73 'Acid Punk' 14 'R&B' 34 'Acid' 54 'Eurodance' 74 'Acid Jazz' 15 'Rap' 35 'House' 55 'Dream' 75 'Polka' 16 'Reggae' 36 'Game' 56 'Southern Rock' 76 'Retro' 17 'Rock' 37 'Sound Clip' 57 'Comedy' 77 'Musical' 18 'Techno' 38 'Gospel' 58 'Cult' 78 'Rock & Roll' 19 'Industrial'39 'Noise' 59 'Gangsta' 79 'Hard Rock' WinAmp expanded this table with next codes: 80 'Folk' 92 'Progressive 104'Chamber 116'Ballad' Rock' Music' 81 'Folk-Rock' 93 'Psychedelic 105'Sonata' 117'Poweer Rock' Ballad' 82 'National 94 'Symphonic 106'Symphony' 118'Rhytmic Soul' Folk' Rock' 83 'Swing' 95 'Slow Rock' 107'Booty 119'Freestyle' Brass' 84 'Fast Fusion'96 'Big Band' 108'Primus' 120'Duet' 85 'Bebob' 97 'Chorus' 109'Porn 121'Punk Rock' Groove' 86 'Latin' 98 'Easy 110'Satire' 122'Drum Solo' Listening' 87 'Revival' 99 'Acoustic' 111'Slow Jam' 123'A Capela' 88 'Celtic' 100 'Humour' 112'Club' 124'Euro-House' 89 'Bluegrass' 101 'Speech' 113'Tango' 125'Dance Hall' 90 'Avantgarde' 102 'Chanson' 114'Samba' 91 'Gothic Rock'103 'Opera' 115'Folklore' Any other value should be considered as 'Unknown' MPEG Audio Tag ID3v2 This is new proposed TAG format which is different than ID3v1 and ID3v1.1. Complete tech specs for it may be found at http://www.id3.org/. ------------------------------------------------------------------------ Created on September 1998. by Predrag Supurovic. Thanks to Jean for debugging and polishing of this document, Peter Luijer, Guwani, Rob Leslie and Franc Zijderveld for valuable comments and corrections. 1998, 1999 Copyright by DataVoyage This document may be changed. Check http://www.dv.co.yu/mpgscript/mpeghdr.htm for updates. You may use it freely. Distribution is allowed only in unaltered form. If you can help me make it more accurate, please do. tag exists and is correct. B 30 (3-32) Title C 30 (33-62) Artist D 30 (63-92) Album E 4 (93-96) Year F 30 (97-126) Comment G 1 (127) Genre The specification asks for all fields to beREADMEmp3info.txt00006440000001000000100000016766072735415340014032 0ustar unknownunknown Python MPEG Audio Information Module 20/04/01 Version 0.3 - adapted from MP3infor (Eduardo Roldan) by Marc Lindahl This software (C) Marc Lindahl, with parts (C) Eduardo Roldan, under the GPL License 29/10/99 Version 0.2 Introduction: This module allows you to create a string which holds an mp3 file, and has some extra data to easily read the header and id3 tag info. Also, it's set up to easily change the id3 information and output a new string with the new information. In the future it could be extended to be able to modify the header info too, but that would mean walking the entire file, since the header is stored in every frame. Marc Lindahl 4/21/01 ----------OLD INTRO----------- The capabilities of this module are read id3 version1 tags (genre, autor, etc), and get all header information of an mpeg audio stream (time, layer,bitrate, etc). It's written entirely in python (no C code). This module was created to satisfy my special needs, but I think that is usable by others. Feel free to modify the code, if you add some features please send to me them. And of course, use at your own risk (this can be high because this is my first module!). email: trazor@adinet.com.uy This software (C) Eduardo Roldan, under the GPL License -------------------------------- Instalation: Copy the included mp3info.py to your modules directory, usually /usr/local/lib/python/site-packages Instructions: 1. To create mp3 object: import mp3info mp3obj = mp3info.mp3info() or you could directly read a file while creating: file = open('LeftAndRightDream.mp3') mp3obj = mp3info.mp3info(file.read()) 2. Constants in the object after mp3info(): file copy of file as a big string id3 dictionary of id3 tags and values header dictionary of mp3 file headers (from reading first one) 3. Methods for ID3 information: mp3_file(file, dict) Returns a complete mp3 file. If file=None, uses previously stored (internally) file. If dict=None, uses previously stored or read id3 tags (or if a new file is provided, uses newly read tags) mp3_tag(file, dict) Returns the last 128 bytes (tag) of a mp3 file. If file=None, uses previously stored (internally) file. If dict=None, uses previously stored or read id3 tags (or if a new file is provided, uses newly read tags) read_tag() Refreshes id3 dictionary with data embedded in file, raises NoTagError if no tag is present. Returns 1 if read is sucessful. get_genre() Returns the genre string of the song. get_genre(n) Returns string corresponding with genre #n (useful for building GUIs) get_genre_list() Returns a list of all genres get_id3() Returns a dictionary with all current id3 and mpeg header values. set_id3(dict) Update the current id3 dictionary with dict. Returns the new current id3 dictionary. __call__(file) Calling the object with an mp3 file is the same as with init - sets the (internal) file and gathers fresh tags 4. Keys in the id3 dictionary: songname song name string artist artist name string album album name string year year field string comment comment field string genre_no the genre int (*) genre genre string corresponding to genre_no filesize int mpeg stuff from mpeg header (also in header dictionary) layer (all strings) protection bitrate frequency channel_mode copyright original length framelength 5. Methods for mpeg header information: read_header([offset]) Parse the header information in offset bytes. Do this before any other mpeg header method. If not specified offset = 0. Raises InvalidHeaderError if an invalid header is present in offset bytes. Return 1 in sucessfull read. sync_read_header([offset], [depth]) Try to sync to a valid header from offset bytes and parse the header information. Do this before any other mpeg header method and your mp3 file is corrupted(read_header() fails). If not specified offset = 0. If not speciied depth = EOF. Raises NoHeaderError if no valid header is present in the range {offset to depth} Returns the position of the first valid header readed (Caution: this can be 0). This method is useful when your mp3 have trash bytes at beginning(some Win 9x compressors add a wav header to the mp3s).It's more slow than read_header(), but you can use it only when read_header() fails. get_mpeg_version() Returns string with mpeg version description get_layer() Returns string with mpeg layer description get_protection() Returns string with protection status get_bitrate() Returns int with mpeg bitrate in Kbps get_frequency() Returns int with mpeg sound frequency in Hz get_channel_mode() Returns string with mpeg channel mode description get_copyright() Returns string with copyright status get_original() Returns string with original/copy status get_lenght() Returns tuple with: length in seconds, length in minutes, seconds remaining from minutes get_framelenght() Returns int with frame lenght in bytes of the readed header 6. Constants in the object after initialization: data the file stored as a string (the name specifically chosen to support Mixin classing in Zope) id3 the id3+header dictionary header the mpeg header dictionary everything else is private. 7. Getting an mp3 file. You can get a fully formed mp3 file from the object as a string: mp3_file(arg, dict) When called without an arg, the object returns a string formed from the file, with ID3 information from the dictionary inserted at the end. When called with an arg, the object uses the new file (replacing the old one stored in the obj) and recalculates the header, and returns the string. If you include a second arg, it's an id3 dictionary. For example, you could feed back the already stored dictionary: d = m.mp3_file(file.read(),m.id3) 8. Exceptions Whenever the object is called with a new file, or init'ed with a file, you should trap the exceptions: NoTagError NoHeaderError InvalidHeaderError the strings are available for reporting: mp3info.NoTagError mp3info.NoHeaderError mp3info.InvalidHeaderError 9. Storage Audio files can be big.... the class instance stores the file internally, which is convenient. But you might want to free this memory after getting info from a file, or you might want to use the object as a sometime data filter. There is a method to free up the storage without affecting any of the other structures: free_file() 10. Examples #this example adds a comment to the mp3 file and writes it back f = file.open('loptop:LeftAndRightDream.mp3') import mp3info m = mp3info.mp3info(f.read()) m.id3['comment'] = 'source: http://bowery.com' f.close() f = file.open('loptop:LeftAndRightDream.mp3','w') f.write(m()) f.close() #this example uses the object just to get id3 tags and discard the file f = file.open('loptop:LeftAndRightDream.mp3') import mp3info m = mp3info.mp3info(f.read()) m.file_free() f.close() print m.mp3 #print the tags print m.header #print just the header info (*) = Check mpeghdr.htm, http://www.dv.co.yu/mpgscript/mpeghdr.htm for updates. ShortSilence.mp300006440000001000000100000007461072733433700014051 0ustar unknownunknownDK `,%DK `,%D K `,%D K `,%D K `,%D K `,%D K `,%D K `,%D K `,%TAGtenth second of silence the quiet brothers the sound of silence 2001very short test file 'DK `,%