Source code for eyed3.mp3.headers

################################################################################
#  Copyright (C) 2002-2012  Travis Shirk <travis@pobox.com>
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
################################################################################
from math import log10

from . import Mp3Exception

from ..utils.binfuncs import bytes2bin, bytes2dec, bin2dec
from .. import core

import logging
log = logging.getLogger(__name__)


[docs]def isValidHeader(header): '''Determine if ``header`` (an integer, 4 bytes compared) is a valid mp3 frame header.''' # Test for the mp3 frame sync: 11 set bits. sync = (header >> 16) if sync & 0xffe0 != 0xffe0: # ffe0 is 11 sync bits, 12 are not used in order to support identifying # mpeg v2.5 (bits 20,19) return False # All the remaining tests are not entireley required, but do help in # finding false syncs version = (header >> 19) & 0x3 if version == 1: # This is a "reserved" version log.debug("invalid mpeg version") return False layer = (header >> 17) & 0x3 if layer == 0: # This is a "reserved" layer log.debug("invalid mpeg layer") return False bitrate = (header >> 12) & 0xf if bitrate in (0, 0xf): # free and bad bitrate values log.debug("invalid mpeg bitrate") return False sample_rate = (header >> 10) & 0x3 if sample_rate == 0x3: # this is a "reserved" sample rate log.debug("invalid mpeg sample rate") return False return True
[docs]def findHeader(fp, start_pos=0): '''Locate the first mp3 header in file stream ``fp`` starting a offset ``start_pos`` (defaults to 0). Returned is a 3-tuple containing the offset where the header was found, the header as an integer, and the header as 4 bytes. If no header is found header_int will equal 0. ''' def find_sync(fp, start_pos=0): CHUNK_SIZE = 8192 # Measured as optimal fp.seek(start_pos) data = fp.read(CHUNK_SIZE) while data: sync_pos = data.find('\xff', 0) if sync_pos >= 0: header = data[sync_pos:sync_pos + 4] if len(header) == 4: return (start_pos + sync_pos, header) data = fp.read(CHUNK_SIZE) return (None, None) sync_pos, header_bytes = find_sync(fp, start_pos) while sync_pos is not None: header = bytes2dec(header_bytes) if isValidHeader(header): return (sync_pos, header, header_bytes) sync_pos, header_bytes = find_sync(fp, start_pos + sync_pos + 2) return (None, None, None)
[docs]def compute_time_per_frame(mp3_header): '''Computes the number of seconds per mp3 frame (for VBR). This function is only useful when dealing with Xing headers and VBR mp3. It can be used to compute overall playtime and bitrate. The mp3 layer and sample rate from ``mp3_header`` are used to compute the number of seconds (fractional float point value) per mp3 frame.''' return (float(TIME_PER_FRAME_TABLE[mp3_header.layer]) / float(mp3_header.sample_freq))
[docs]class Mp3Header: '''Header container for MP3 frames.''' def __init__(self, header_data=None): self.version = None self.layer = None self.error_protection = None self.bit_rate = None self.sample_freq = None self.padding = None self.private_bit = None self.copyright = None self.original = None self.emphasis = None self.mode = None # This value is left as is: 0<=mode_extension<=3. # See http://www.dv.co.yu/mpgscript/mpeghdr.htm for how to interpret self.mode_extension = None self.frame_length = None if header_data: self.decode(header_data) # This may throw an Mp3Exception if the header is malformed.
[docs] def decode(self, header): if not isValidHeader(header): raise Mp3Exception("Invalid MPEG header") # MPEG audio version from bits 19 and 20. version = (header >> 19) & 0x3 self.version = [2.5, None, 2.0, 1.0][version] if self.version is None: raise Mp3Exception("Illegal MPEG version") # MPEG layer self.layer = 4 - ((header >> 17) & 0x3) if self.layer == 4: raise Mp3Exception("Illegal MPEG layer") # Decode some simple values. self.error_protection = not (header >> 16) & 0x1 self.padding = (header >> 9) & 0x1 self.private_bit = (header >> 8) & 0x1 self.copyright = (header >> 3) & 0x1 self.original = (header >> 2) & 0x1 # Obtain sampling frequency. sampleBits = (header >> 10) & 0x3 self.sample_freq = SAMPLE_FREQ_TABLE[sampleBits]\ [_mp3VersionKey(self.version)] if not self.sample_freq: raise Mp3Exception("Illegal MPEG sampling frequency") # Compute bitrate. bitRateIndex = (header >> 12) & 0xf if int(self.version) == 1 and self.layer == 1: bitRateCol = 0 elif int(self.version) == 1 and self.layer == 2: bitRateCol = 1 elif int(self.version) == 1 and self.layer == 3: bitRateCol = 2 elif int(self.version) == 2 and self.layer == 1: bitRateCol = 3 elif int(self.version) == 2 and (self.layer == 2 or \ self.layer == 3): bitRateCol = 4 else: raise Mp3Exception("Mp3 version %f and layer %d is an invalid "\ "combination" % (self.version, self.layer)) self.bit_rate = BIT_RATE_TABLE[bitRateIndex][bitRateCol] if self.bit_rate == None: raise Mp3Exception("Invalid bit rate") # We know know the bit rate specified in this frame, but if the file # is VBR we need to obtain the average from the Xing header. # This is done by the caller since right now all we have is the frame # header. # Emphasis; whatever that means?? emph = header & 0x3 if emph == 0: self.emphasis = EMPHASIS_NONE elif emph == 1: self.emphasis = EMPHASIS_5015 elif emph == 2: self.emphasis = EMPHASIS_CCIT else: raise Mp3Exception("Illegal mp3 emphasis value: %d" % emph) # Channel mode. modeBits = (header >> 6) & 0x3 if modeBits == 0: self.mode = MODE_STEREO elif modeBits == 1: self.mode = MODE_JOINT_STEREO elif modeBits == 2: self.mode = MODE_DUAL_CHANNEL_STEREO else: self.mode = MODE_MONO self.mode_extension = (header >> 4) & 0x3 # Layer II has restrictions wrt to mode and bit rate. This code # enforces them. if self.layer == 2: m = self.mode br = self.bit_rate if (br in [32, 48, 56, 80] and (m != MODE_MONO)): raise Mp3Exception("Invalid mode/bitrate combination for layer " "II") if (br in [224, 256, 320, 384] and (m == MODE_MONO)): raise Mp3Exception("Invalid mode/bitrate combination for layer " "II") br = self.bit_rate * 1000 sf = self.sample_freq p = self.padding if self.layer == 1: # Layer 1 uses 32 bit slots for padding. p = self.padding * 4 self.frame_length = int((((12 * br) / sf) + p) * 4) else: # Layer 2 and 3 uses 8 bit slots for padding. p = self.padding * 1 self.frame_length = int(((144 * br) / sf) + p) # Dump the state. log.debug("MPEG audio version: " + str(self.version)) log.debug("MPEG audio layer: " + ("I" * self.layer)) log.debug("MPEG sampling frequency: " + str(self.sample_freq)) log.debug("MPEG bit rate: " + str(self.bit_rate)) log.debug("MPEG channel mode: " + self.mode) log.debug("MPEG channel mode extension: " + str(self.mode_extension)) log.debug("MPEG CRC error protection: " + str(self.error_protection)) log.debug("MPEG original: " + str(self.original)) log.debug("MPEG copyright: " + str(self.copyright)) log.debug("MPEG private bit: " + str(self.private_bit)) log.debug("MPEG padding: " + str(self.padding)) log.debug("MPEG emphasis: " + str(self.emphasis)) log.debug("MPEG frame length: " + str(self.frame_length))
[docs]class VbriHeader(object): def __init__(self): self.vbr = True self.version = None ## # \brief Decode the VBRI info from \a frame. # http://www.codeproject.com/audio/MPEGAudioInfo.asp#VBRIHeader
[docs] def decode(self, frame): # The header is 32 bytes after the end of the first MPEG audio header, # therefore 4 + 32 = 36 offset = 36 head = frame[offset:offset + 4] if head != 'VBRI': return False log.debug("VBRI header detected @ %x" % (offset)) offset += 4 self.version = bin2dec(bytes2bin(frame[offset:offset + 2])) offset += 2 self.delay = bin2dec(bytes2bin(frame[offset:offset + 2])) offset += 2 self.quality = bin2dec(bytes2bin(frame[offset:offset + 2])) offset += 2 self.num_bytes = bin2dec(bytes2bin(frame[offset:offset + 4])) offset += 4 self.num_frames = bin2dec(bytes2bin(frame[offset:offset + 4])) offset += 4 return True ## # \brief Header class for the Xing header extensions.
[docs]class XingHeader: def __init__(self): self.numFrames = int() self.numBytes = int() self.toc = [0] * 100 self.vbrScale = int() # Pass in the first mp3 frame from the file as a byte string. # If an Xing header is present in the file it'll be in the first mp3 # frame. This method returns true if the Xing header is found in the # frame, and false otherwise.
[docs] def decode(self, frame): # mp3 version version = (ord(frame[1]) >> 3) & 0x1 # channel mode. mode = (ord(frame[3]) >> 6) & 0x3 # Find the start of the Xing header. if version: # +4 in all of these to skip initial mp3 frame header. if mode != 3: pos = 32 + 4 else: pos = 17 + 4 else: if mode != 3: pos = 17 + 4 else: pos = 9 + 4 head = frame[pos:pos+4] self.vbr = (head == 'Xing') and True or False if head not in ['Xing', 'Info']: return False log.debug("%s header detected @ %x" % (head, pos)) pos += 4 # Read Xing flags. headFlags = bin2dec(bytes2bin(frame[pos:pos + 4])) pos += 4 log.debug("%s header flags: 0x%x" % (head, headFlags)) # Read frames header flag and value if present if headFlags & FRAMES_FLAG: self.numFrames = bin2dec(bytes2bin(frame[pos:pos + 4])) pos += 4 log.debug("%s numFrames: %d" % (head, self.numFrames)) # Read bytes header flag and value if present if headFlags & BYTES_FLAG: self.numBytes = bin2dec(bytes2bin(frame[pos:pos + 4])) pos += 4 log.debug("%s numBytes: %d" % (head, self.numBytes)) # Read TOC header flag and value if present if headFlags & TOC_FLAG: self.toc = frame[pos:pos + 100] pos += 100 log.debug("%s TOC (100 bytes): PRESENT" % head) else: log.debug("%s TOC (100 bytes): NOT PRESENT" % head) # Read vbr scale header flag and value if present if headFlags & VBR_SCALE_FLAG and head == 'Xing': self.vbrScale = bin2dec(bytes2bin(frame[pos:pos + 4])) pos += 4 log.debug("%s vbrScale: %d" % (head, self.vbrScale)) return True ## # \brief Mp3 Info tag (AKA LAME Tag) # # Lame (and some other encoders) write a tag containing various bits of info # about the options used at encode time. If available, the following are # parsed and stored in the LameHeader dict: # # encoder_version: short encoder version [str] # tag_revision: revision number of the tag [int] # vbr_method: VBR method used for encoding [str] # lowpass_filter: lowpass filter frequency in Hz [int] # replaygain: if available, radio and audiofile gain (see below) [dict] # encoding_flags: encoding flags used [list] # nogap: location of gaps when --nogap was used [list] # ath_type: ATH type [int] # bitrate: bitrate and type (Constant, Target, Minimum) [tuple] # encoder_delay: samples added at the start of the mp3 [int] # encoder_padding: samples added at the end of the mp3 [int] # noise_shaping: noise shaping method [int] # stereo_mode: stereo mode used [str] # unwise_settings: whether unwise settings were used [boolean] # sample_freq: source sample frequency [str] # mp3_gain: mp3 gain adjustment (rarely used) [float] # preset: preset used [str] # surround_info: surround information [str] # music_length: length in bytes of original mp3 [int] # music_crc: CRC-16 of the mp3 music data [int] # infotag_crc: CRC-16 of the info tag [int] # # Prior to ~3.90, Lame simply stored the encoder version in the first frame. # If the infotag_crc is invalid, then we try to read this version string. A # simple way to tell if the LAME Tag is complete is to check for the # infotag_crc key. # # Replay Gain data is only available since Lame version 3.94b. If set, the # replaygain dict has the following structure: # # \code # peak_amplitude: peak signal amplitude [float] # radio: # name: name of the gain adjustment [str] # adjustment: gain adjustment [float] # originator: originator of the gain adjustment [str] # audiofile: [same as radio] # \endcode # # Note that as of 3.95.1, Lame uses 89dB as a reference level instead of the # 83dB that is specified in the Replay Gain spec. This is not automatically # compensated for. You can do something like this if you want: # # \code # import eyeD3 # af = eyeD3.mp3.Mp3AudioFile('/path/to/some.mp3') # lamever = af.lameTag['encoder_version'] # name, ver = lamever[:4], lamever[4:] # gain = af.lameTag['replaygain']['radio']['adjustment'] # if name == 'LAME' and eyeD3.mp3.lamevercmp(ver, '3.95') > 0: # gain -= 6 # \endcode # # Radio and Audiofile Replay Gain are often referrered to as Track and Album # gain, respectively. See http://replaygain.hydrogenaudio.org/ for futher # details on Replay Gain. # # See http://gabriel.mp3-tech.org/mp3infotag.html for the gory details of the # LAME Tag.
[docs]class LameHeader(dict): # from the LAME source: # http://lame.cvs.sourceforge.net/*checkout*/lame/lame/libmp3lame/VbrTag.c _crc16_table = [ 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040] ENCODER_FLAGS = { 'NSPSYTUNE' : 0x0001, 'NSSAFEJOINT' : 0x0002, 'NOGAP_NEXT' : 0x0004, 'NOGAP_PREV' : 0x0008,} PRESETS = { 0: 'Unknown', # 8 to 320 are reserved for ABR bitrates 410: 'V9', 420: 'V8', 430: 'V7', 440: 'V6', 450: 'V5', 460: 'V4', 470: 'V3', 480: 'V2', 490: 'V1', 500: 'V0', 1000: 'r3mix', 1001: 'standard', 1002: 'extreme', 1003: 'insane', 1004: 'standard/fast', 1005: 'extreme/fast', 1006: 'medium', 1007: 'medium/fast',} REPLAYGAIN_NAME = { 0: 'Not set', 1: 'Radio', 2: 'Audiofile',} REPLAYGAIN_ORIGINATOR = { 0: 'Not set', 1: 'Set by artist', 2: 'Set by user', 3: 'Set automatically', 100: 'Set by simple RMS average',} SAMPLE_FREQUENCIES = { 0: '<= 32 kHz', 1: '44.1 kHz', 2: '48 kHz', 3: '> 48 kHz',} STEREO_MODES = { 0: 'Mono', 1: 'Stereo', 2: 'Dual', 3: 'Joint', 4: 'Force', 5: 'Auto', 6: 'Intensity', 7: 'Undefined',} SURROUND_INFO = { 0: 'None', 1: 'DPL encoding', 2: 'DPL2 encoding', 3: 'Ambisonic encoding', 8: 'Reserved',} VBR_METHODS = { 0: 'Unknown', 1: 'Constant Bitrate', 2: 'Average Bitrate', 3: 'Variable Bitrate method1 (old/rh)', 4: 'Variable Bitrate method2 (mtrh)', 5: 'Variable Bitrate method3 (mt)', 6: 'Variable Bitrate method4', 8: 'Constant Bitrate (2 pass)', 9: 'Average Bitrate (2 pass)', 15: 'Reserved',} def __init__(self, frame): """Read the LAME info tag. frame should be the first frame of an mp3. """ self.decode(frame) def _crc16(self, data, val = 0): """Compute a CRC-16 checksum on a data stream.""" for c in data: val = self._crc16_table[ord(c) ^ (val & 0xff)] ^ (val >> 8) return val
[docs] def decode(self, frame): """Decode the LAME info tag.""" try: pos = frame.index("LAME") except: return # check the info tag crc.Iif it's not valid, no point parsing much more. lamecrc = bin2dec(bytes2bin(frame[190:192])) if self._crc16(frame[:190]) != lamecrc: #log.debug('Lame tag CRC check failed') # read version string from the first 30 bytes, up to any # non-ascii chars, then strip padding chars. # # XXX (How many bytes is proper to read? madplay reads 20, but I've # got files with longer version strings) lamever = [] for c in frame[pos:pos + 30]: if ord(c) not in list(range(32, 127)): break lamever.append(c) self['encoder_version'] = ''.join(lamever).rstrip('\x55') log.debug('Lame Encoder Version: %s' % self['encoder_version']) return log.debug('Lame info tag found at position %d' % pos) # Encoder short VersionString, 9 bytes self['encoder_version'] = lamever = frame[pos:pos + 9].rstrip() log.debug('Lame Encoder Version: %s' % self['encoder_version']) pos += 9 # Info Tag revision + VBR method, 1 byte self['tag_revision'] = bin2dec(bytes2bin(frame[pos:pos + 1])[:5]) vbr_method = bin2dec(bytes2bin(frame[pos:pos + 1])[5:]) self['vbr_method'] = self.VBR_METHODS.get(vbr_method, 'Unknown') log.debug('Lame info tag version: %s' % self['tag_revision']) log.debug('Lame VBR method: %s' % self['vbr_method']) pos += 1 # Lowpass filter value, 1 byte self['lowpass_filter'] = bin2dec(bytes2bin(frame[pos:pos + 1])) * 100 log.debug('Lame Lowpass filter value: %s Hz' % self['lowpass_filter']) pos += 1 # Replay Gain, 8 bytes total replaygain = {} # Peak signal amplitude, 4 bytes peak = bin2dec(bytes2bin(frame[pos:pos + 4])) << 5 if peak > 0: peak /= float(1 << 28) db = 20 * log10(peak) replaygain['peak_amplitude'] = peak log.debug('Lame Peak signal amplitude: %.8f (%+.1f dB)' % (peak, db)) pos += 4 # Radio and Audiofile Gain, AKA track and album, 2 bytes each for gaintype in ['radio', 'audiofile']: name = bin2dec(bytes2bin(frame[pos:pos + 2])[:3]) orig = bin2dec(bytes2bin(frame[pos:pos + 2])[3:6]) sign = bin2dec(bytes2bin(frame[pos:pos + 2])[6:7]) adj = bin2dec(bytes2bin(frame[pos:pos + 2])[7:]) / 10.0 if sign: adj *= -1 # XXX Lame 3.95.1 and above use 89dB as a reference instead of 83dB # as defined by the Replay Gain spec. Should this be compensated # for? # if lamever[:4] == 'LAME' and lamevercmp(lamever[4:], '3.95') > 0: # adj -= 6 if orig: name = self.REPLAYGAIN_NAME.get(name, 'Unknown') orig = self.REPLAYGAIN_ORIGINATOR.get(orig, 'Unknown') replaygain[gaintype] = {'name': name, 'adjustment': adj, 'originator': orig} log.debug('Lame %s Replay Gain: %s dB (%s)' % (name, adj, orig)) pos += 2 if replaygain: self['replaygain'] = replaygain # Encoding flags + ATH Type, 1 byte encflags = bin2dec(bytes2bin(frame[pos:pos + 1])[:4]) self['encoding_flags'], self['nogap'] = self._parse_encflags(encflags) self['ath_type'] = bin2dec(bytes2bin(frame[pos:pos + 1])[4:]) log.debug('Lame Encoding flags: %s' % ' '.join(self['encoding_flags'])) if self['nogap']: log.debug('Lame No gap: %s' % ' and '.join(self['nogap'])) log.debug('Lame ATH type: %s' % self['ath_type']) pos += 1 # if ABR {specified bitrate} else {minimal bitrate}, 1 byte btype = 'Constant' if 'Average' in self['vbr_method']: btype = 'Target' elif 'Variable' in self['vbr_method']: btype = 'Minimum' # bitrate may be modified below after preset is read self['bitrate'] = (bin2dec(bytes2bin(frame[pos:pos + 1])), btype) log.debug('Lame Bitrate (%s): %s' % (btype, self['bitrate'][0])) pos += 1 # Encoder delays, 3 bytes self['encoder_delay'] = bin2dec(bytes2bin(frame[pos:pos + 3])[:12]) self['encoder_padding'] = bin2dec(bytes2bin(frame[pos:pos + 3])[12:]) log.debug('Lame Encoder delay: %s samples' % self['encoder_delay']) log.debug('Lame Encoder padding: %s samples' % self['encoder_padding']) pos += 3 # Misc, 1 byte sample_freq = bin2dec(bytes2bin(frame[pos:pos + 1])[:2]) unwise_settings = bin2dec(bytes2bin(frame[pos:pos + 1])[2:3]) stereo_mode = bin2dec(bytes2bin(frame[pos:pos + 1])[3:6]) self['noise_shaping'] = bin2dec(bytes2bin(frame[pos:pos + 1])[6:]) self['sample_freq'] = self.SAMPLE_FREQUENCIES.get(sample_freq, 'Unknown') self['unwise_settings'] = bool(unwise_settings) self['stereo_mode'] = self.STEREO_MODES.get(stereo_mode, 'Unknown') log.debug('Lame Source Sample Frequency: %s' % self['sample_freq']) log.debug('Lame Unwise settings used: %s' % self['unwise_settings']) log.debug('Lame Stereo mode: %s' % self['stereo_mode']) log.debug('Lame Noise Shaping: %s' % self['noise_shaping']) pos += 1 # MP3 Gain, 1 byte sign = bytes2bin(frame[pos:pos + 1])[0] gain = bin2dec(bytes2bin(frame[pos:pos + 1])[1:]) if sign: gain *= -1 self['mp3_gain'] = gain db = gain * 1.5 log.debug('Lame MP3 Gain: %s (%+.1f dB)' % (self['mp3_gain'], db)) pos += 1 # Preset and surround info, 2 bytes surround = bin2dec(bytes2bin(frame[pos:pos + 2])[2:5]) preset = bin2dec(bytes2bin(frame[pos:pos + 2])[5:]) if preset in range(8, 321): if self['bitrate'] >= 255: # the value from preset is better in this case self['bitrate'] = (preset, btype) log.debug('Lame Bitrate (%s): %s' % (btype, self['bitrate'][0])) if 'Average' in self['vbr_method']: preset = 'ABR %s' % preset else: preset = 'CBR %s' % preset else: preset = self.PRESETS.get(preset, preset) self['surround_info'] = self.SURROUND_INFO.get(surround, surround) self['preset'] = preset log.debug('Lame Surround Info: %s' % self['surround_info']) log.debug('Lame Preset: %s' % self['preset']) pos += 2 # MusicLength, 4 bytes self['music_length'] = bin2dec(bytes2bin(frame[pos:pos + 4])) log.debug('Lame Music Length: %s bytes' % self['music_length']) pos += 4 # MusicCRC, 2 bytes self['music_crc'] = bin2dec(bytes2bin(frame[pos:pos + 2])) log.debug('Lame Music CRC: %04X' % self['music_crc']) pos += 2 # CRC-16 of Info Tag, 2 bytes self['infotag_crc'] = lamecrc # we read this earlier log.debug('Lame Info Tag CRC: %04X' % self['infotag_crc']) pos += 2
def _parse_encflags(self, flags): """Parse encoder flags. Returns a tuple containing lists of encoder flags and nogap data in human readable format. """ encoder_flags, nogap = [], [] if not flags: return encoder_flags, nogap if flags & self.ENCODER_FLAGS['NSPSYTUNE']: encoder_flags.append('--nspsytune') if flags & self.ENCODER_FLAGS['NSSAFEJOINT']: encoder_flags.append('--nssafejoint') NEXT = self.ENCODER_FLAGS['NOGAP_NEXT'] PREV = self.ENCODER_FLAGS['NOGAP_PREV'] if flags & (NEXT | PREV): encoder_flags.append('--nogap') if flags & PREV: nogap.append('before') if flags & NEXT: nogap.append('after') return encoder_flags, nogap ## # \brief Compare LAME version strings. # # alpha and beta versions are considered older. # Versions with sub minor parts or end with 'r' are considered newer. # # \param x The first version to compare. # \param y The second version to compare. # \returns Return negative if x<y, zero if x==y, positive if x>y.
[docs]def lamevercmp(x, y): x = x.ljust(5) y = y.ljust(5) if x[:5] == y[:5]: return 0 ret = cmp(x[:4], y[:4]) if ret: return ret xmaj, xmin = x.split('.')[:2] ymaj, ymin = y.split('.')[:2] minparts = ['.'] # lame 3.96.1 added the use of r in the very short version for post releases if (xmaj == '3' and xmin >= '96') or (ymaj == '3' and ymin >= '96'): minparts.append('r') if x[4] in minparts: return 1 if y[4] in minparts: return -1 if x[4] == ' ': return 1 if y[4] == ' ': return -1 return cmp(x[4], y[4]) # MPEG1 MPEG2 MPEG2.5
SAMPLE_FREQ_TABLE = ((44100, 22050, 11025), (48000, 24000, 12000), (32000, 16000, 8000), (None, None, None)) # V1/L1 V1/L2 V1/L3 V2/L1 V2/L2&L3 BIT_RATE_TABLE = ((0, 0, 0, 0, 0), (32, 32, 32, 32, 8), (64, 48, 40, 48, 16), (96, 56, 48, 56, 24), (128, 64, 56, 64, 32), (160, 80, 64, 80, 40), (192, 96, 80, 96, 48), (224, 112, 96, 112, 56), (256, 128, 112, 128, 64), (288, 160, 128, 144, 80), (320, 192, 160, 160, 96), (352, 224, 192, 176, 112), (384, 256, 224, 192, 128), (416, 320, 256, 224, 144), (448, 384, 320, 256, 160), (None, None, None, None, None)) # L1 L2 L3 TIME_PER_FRAME_TABLE = (None, 384, 1152, 1152) # Emphasis constants EMPHASIS_NONE = "None" EMPHASIS_5015 = "50/15 ms" EMPHASIS_CCIT = "CCIT J.17" # Mode constants MODE_STEREO = "Stereo" MODE_JOINT_STEREO = "Joint stereo" MODE_DUAL_CHANNEL_STEREO = "Dual channel stereo" MODE_MONO = "Mono" # Xing flag bits FRAMES_FLAG = 0x0001 BYTES_FLAG = 0x0002 TOC_FLAG = 0x0004 VBR_SCALE_FLAG = 0x0008 def _mp3VersionKey(version): '''Map mp3 version float to a data structure index. 1 -> 0, 2 -> 1, 2.5 -> 2 ''' key = None if version == 2.5: key = 2 else: key = int(version - 1) assert(0 <= key <= 2) return key