import deprecation from math import log10 from . import Mp3Exception from ..utils.binfuncs import bytes2bin, bytes2dec, bin2dec from ..utils.log import getLogger from ..__about__ import __version__ log = getLogger(__name__) 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 entirely 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 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 isBOM(buffer, pos): """Check for unicode BOM""" try: if pos - 1 >= 0: if buffer[pos - 1] == 254: return True return buffer[pos + 1] == 254 except IndexError: return False def find_sync(_fp, _pos=0): chunk_sz = 8192 # Measured as optimal _fp.seek(_pos) data = _fp.read(chunk_sz) while data: pos = 0 while 0 <= pos < chunk_sz: pos = data.find(b"\xff", pos) if pos == -1: break if not isBOM(data, pos): h = data[pos:pos + 4] if len(h) == 4: return tuple([_pos + pos, h]) pos += 1 _pos += len(data) data = _fp.read(chunk_sz) 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 tuple([sync_pos, header, header_bytes]) sync_pos, header_bytes = find_sync(fp, start_pos + sync_pos + 2) return None, None, None def timePerFrame(mp3_header, vbr): """Computes the number of seconds per mp3 frame. 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. Be sure to set ``vbr`` True when dealing with VBR, otherwise playtimes may be incorrect.""" # https://bitbucket.org/nicfit/eyed3/issue/32/mp3audioinfotime_secs-incorrect-for-mpeg2 if mp3_header.version >= 2.0 and vbr: row = _mp3VersionKey(mp3_header.version) else: row = 0 return (float(SAMPLES_PER_FRAME_TABLE[row][mp3_header.layer]) / float(mp3_header.sample_freq)) @deprecation.deprecated(deprecated_in="0.9a2", removed_in="1.0", current_version=__version__, details="Use timePerFrame instead") def compute_time_per_frame(mp3_header): if mp3_header is not None: return timePerFrame(mp3_header, False) 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. 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. sample_bits = (header >> 10) & 0x3 self.sample_freq = \ SAMPLE_FREQ_TABLE[sample_bits][_mp3VersionKey(self.version)] if not self.sample_freq: raise Mp3Exception("Illegal MPEG sampling frequency") # Compute bitrate. bit_rate_row = (header >> 12) & 0xf if int(self.version) == 1 and self.layer == 1: bit_rate_col = 0 elif int(self.version) == 1 and self.layer == 2: bit_rate_col = 1 elif int(self.version) == 1 and self.layer == 3: bit_rate_col = 2 elif int(self.version) == 2 and self.layer == 1: bit_rate_col = 3 elif int(self.version) == 2 and (self.layer == 2 or self.layer == 3): bit_rate_col = 4 else: raise Mp3Exception("Mp3 version %f and layer %d is an invalid " "combination" % (self.version, self.layer)) self.bit_rate = BIT_RATE_TABLE[bit_rate_row][bit_rate_col] if self.bit_rate is 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. mode_bits = (header >> 6) & 0x3 if mode_bits == 0: self.mode = MODE_STEREO elif mode_bits == 1: self.mode = MODE_JOINT_STEREO elif mode_bits == 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)) 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 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 class XingHeader: """Header class for the Xing header extensions.""" 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. def decode(self, frame): # mp3 version version = (frame[1] >> 3) & 0x1 # channel mode. mode = (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 == b'Xing') and True or False if head not in [b'Xing', b'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 == b'Xing': self.vbrScale = bin2dec(bytes2bin(frame[pos:pos + 4])) pos += 4 log.debug("%s vbrScale: %d" % (head, self.vbrScale)) return True class LameHeader(dict): """ 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-block:: 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] 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-block:: 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 Radio and Audiofile Replay Gain are often referred to as Track and Album gain, respectively. See https://replaygain.hydrogenaudio.org/ for further details on Replay Gain. See http://gabriel.mp3-tech.org/mp3infotag.html for the gory details of the LAME Tag. """ # 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. """ super().__init__() self.decode(frame) def _crc16(self, data, val=0): """Compute a CRC-16 checksum on a data stream.""" for c in [bytes([b]) for b in data]: val = self._crc16_table[ord(c) ^ (val & 0xff)] ^ (val >> 8) return val def decode(self, frame): """Decode the LAME info tag.""" try: pos = frame.index(b"LAME") except ValueError: return log.debug(f"Lame info tag found at position {pos}") # check the info tag crc. If it's not valid, no point parsing much more. lamecrc = bin2dec(bytes2bin(frame[190:192])) if self._crc16(frame[:190]) != lamecrc: log.warning("Lame tag CRC check failed") else: log.debug("Lame tag CRC OK") try: # Encoder short VersionString, 9 bytes self['encoder_version'] = str(frame[pos:pos + 9].rstrip(), "latin1") 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 # Lame 3.95.1 and above use 89dB as a reference instead of 83dB as defined by the # Replay Gain spec. This will be compensated for with `adj -= 6` lamever = self['encoder_version'] 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'][0] >= 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 except IndexError: log.warning("Truncated LAME info header, values incomplete.") 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 def lamevercmp(x, y): """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 xy. """ def cmp(a, b): # This is Python2's built-in `cmp`, which was removed from Python3 # And depends on bool - bool yielding the integer -1, 0, 1 return (a > b) - (a < b) 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), # noqa (32, 32, 32, 32, 8), # noqa (64, 48, 40, 48, 16), # noqa (96, 56, 48, 56, 24), # noqa (128, 64, 56, 64, 32), # noqa (160, 80, 64, 80, 40), # noqa (192, 96, 80, 96, 48), # noqa (224, 112, 96, 112, 56), # noqa (256, 128, 112, 128, 64), # noqa (288, 160, 128, 144, 80), # noqa (320, 192, 160, 160, 96), # noqa (352, 224, 192, 176, 112), # noqa (384, 256, 224, 192, 128), # noqa (416, 320, 256, 224, 144), # noqa (448, 384, 320, 256, 160), # noqa (None, None, None, None, None)) # Rows 1 and 2 (mpeg 2.x) are only used for those versions *and* VBR. # L1 L2 L3 SAMPLES_PER_FRAME_TABLE = ((None, 384, 1152, 1152), # MPEG 1 (None, 384, 1152, 576), # MPEG 2 (None, 384, 1152, 576), # MPEG 2.5 ) # 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 """ if version == 2.5: key = 2 else: key = int(version - 1) if not 0 <= key <= 2: raise ValueError(f"Invalid mp3 version key value: {key}") return key