Example #1
0
 def get_metadata(self):
     """ Read metadata from csv db """
     with open(DB_PATH, 'r') as items:
         rows = csv.reader(items)
         for row in rows:
             if row[0] == self.serial:
                 logging.debug('Item {0} found in {1}.'.format(self.serial, DB_PATH))
                 self.artist = row[1]
                 self.album = row[2]
                 self.media_type = row[3].lower()
                 self.option = row[4].lower()
                 self.format = row[5].lower()
                 self.image = row[6] if row[6] else self.serial
                 self.image_path = os.path.join(IMAGES_FOLDER, self.image) + '.jpg'
                 self.copies = int(row[7]) if row[7] else 1
                 self.date_received = row[8]
                 self.customer_notes = row[9]
                 self.private_notes = row[10]                    
                 self.split_point = int(self.private_notes[1:3]) if self.private_notes and self.private_notes[0] == '_' else None
                 if self.split_point:
                     if self.name[-2] is not '_':
                         raise Exception('Error! Split file expected for {0}'.format(self.name))
                     self.side = self.name[-1]
                 else:
                     self.side = None
                 self.tracks = []
                 # Deluxe / 45 stuff
                 if 'std' not in self.option:
                     tracks = []
                     for track_num in range(1, 31):
                         if row[10 + track_num]:
                             tracks.append(row[10 + track_num])
                         else:
                             break
                     else:
                         logging.warning('Careful! 30+ tracks for Deluxe item {0}.'.format(self.name))
                     # Read track times from audio file
                     cues = split.read_markers(self.path)
                     if not cues:
                         raise Exception('Error! No markers found in audio for Deluxe item {0}'.format(self.name))
                     if not tracks:
                         logging.info('No tracks found in db for Deluxe item {0}.'.format(self.name))
                         for cue_num in range(1, len(cues)):
                             tracks.append('Track {0}'.format(cue_num))                        
                     if self.side is '1':
                         tracks = tracks[:self.split_point]
                     elif self.side is '2':
                         tracks = tracks[self.split_point:]                        
                     if len(tracks) is not len(cues) - 1:
                         raise Exception('Error! Item {0} expected {1} tracks, found {2} in audio file.'.format(self.name, len(tracks), len(cues) - 1))
                     Track = namedtuple('Track', ['num', 'title', 'duration'])
                     for i in range(1, len(cues)):
                         duration = cues[i] - cues[i - 1]
                         m, s = divmod(duration / 44100, 60)
                         duration = '{0}:{1}'.format(str(m), str(s).zfill(2))
                         self.tracks.append(Track(num=i, title=tracks[i - 1], duration=duration))
                 return                     
         else:
              logging.warning('Row {0} not found in {1}.'.format(self.serial, DB_PATH))
Example #2
0
def split_cd(input_filename):
    def write_marked_file(output_filename_fullpath, audio, cues):
        def write_header_new(initlength):
            WAVE_FORMAT_PCM = 0x0001
            assert not new._headerwritten
            new._file.write('RIFF')
            if not new._nframes:
                new._nframes = initlength / (new._nchannels * new._sampwidth)
            new._datalength = new._nframes * new._nchannels * new._sampwidth
            new._form_length_pos = new._file.tell()
            new._file.write(struct.pack('<L4s4sLHHLLHH',
                36 + 24*len(cues) + 12 + new._datalength,
                'WAVE',
                'fmt ',
                16,
                WAVE_FORMAT_PCM,
                new._nchannels,
                new._framerate,
                new._nchannels * new._framerate * new._sampwidth,
                new._nchannels * new._sampwidth,
                new._sampwidth * 8,
                ))
            # Cues chunk wrapper (length: 12 + 24n)
            new._file.write(struct.pack('<4sLL',
                'cue ', #chunkID
                24*len(cues) + 4, #chunkDataSize
                len(cues))) #cuePointsCount
            # Cue chunks (length: 24 each)
            for num, cue in enumerate(cue_offsets):
                new._file.write(struct.pack('<LL4sLLL',
                    num, #cuePointID
                    cue, #playOrderPosition (no playlist) **According to the spec, this should be 0. But who reads specs, anyway?**
                    'data', #dataChunkID (not silence)
                    0, #chunkStart (standard 'data' chunk)
                    0, #blockStart (uncompressed)
                    cue)) #sampleOffset (cue position)
                print 'Cue', num, 'written @', cue, '/', new._nframes, '(' + str(round(cue/float(new._nframes)*100, 2)) + '%)'
            # Data chunk header
            new._data_length_pos = new._file.tell()
            new._file.write(struct.pack('<4sL',
                'data',
                new._datalength))
            new._headerwritten = True
        """
        Write new file with markers
        """
        cue_offsets = cues
        new = wave.open(output_filename_fullpath, 'wb')
        new._write_header = write_header_new
        new.setnchannels(audio.channels)
        new.setsampwidth(audio.sample_width)
        new.setframerate(audio.frame_rate)
        new.setnframes(int(audio.frame_count()))
        new.writeframesraw(audio._data)
        new.close()

    i = 0
    cd_counter = 0

    print 'input_filename:', input_filename

    if not out_path:
        output_path = input_path
    input_filename_fullpath = os.path.join(input_path, input_filename)
    output_filename_fullpath = os.path.join(output_path, input_filename)
    audio = pydub.AudioSegment.from_wav(input_filename_fullpath)

    # Check CD-type xfer (not mp3)
    with open(db_path, 'r') as db:
        rows = csv.reader(db)
        audio_serial = os.path.basename(input_filename_fullpath).rsplit('_clean')[0]
        for row in rows:
            if row[0] == audio_serial:
                # Check for CD-safe recording length (78:20)
                if 'cd' in row[5].lower() and len(audio) > 4700000:
                    print '(Double!)'
                    markers = read_markers(input_filename)
                    if not markers:
                        raise SystemError('Hey! {0} needs markers!'.format(audio_serial))
                    if not cd_counter:
                        cd_counter = 1
                    # Write file for sides A and B
                    if 'std' in row[4]:
                        if markers[0] == 0:
                            split_point = 1
                        else:
                            split_point = 0
                    elif row[10].startswith('_'):
                        split_point = int(row[10][1:3])
                    else:
                        split_point = 1
                    for i in range(2):
                        temp_filename = output_filename_fullpath.rsplit('_clean')[0] + '_' + str(cd_counter) + '_clean.wav'
                        pydub_markers = [int(marker / 44.1) for marker in markers]
                        print 'temp_filename:', temp_filename
                        print 'markers:', markers
                        print 'pydub_markers:', pydub_markers
                        print 'split_point:', split_point                            
                        if i == 0:
                            split_markers = markers[:split_point + 1]
                            split_audio = audio[:pydub_markers[split_point]]
                        else:
                            split_markers = [marker - markers[split_point] for marker in markers[split_point:]]
                            split_audio = audio[pydub_markers[split_point]:]
                        print 'split_markers:', split_markers
                        print 'len(split_audio):', len(split_audio)
                        write_marked_file(temp_filename, split_audio, split_markers)
                        cd_counter += 1
                    # Delete big original file
                    #os.remove(input_filename_fullpath)
                    #os.remove(os.path.splitext(input_filename_fullpath)[0] + '.pkf')
                    return
                break
        else:
            print 'Row', audio_serial, 'not found in', db_path + '.'
    return
    def add_image(position):
        try:
            img = images_iter.next()
        except StopIteration:
            return
        audio_serial = img.rsplit('_')[0]
        audio_path = os.path.join(folder, img).rsplit('_')[0]

        with open(db_path, 'r') as items:
            # Read spreadsheet
            rows = csv.reader(items)
            for row in rows:
                if row[0] == audio_serial:                    
                    if '45' in row[3]:
                        # DO THE 45 THANG
                        break
                    else:
                        break
            else:
                print 'Row', audio_serial, 'not found in', db_path + '.'
            img_path = os.path.join(images_folder,img).rsplit('_')[0] + '.jpg'
            # Image positioning
            if position == 'top':
                img_adjustment = 118 * mm
                label_adjustment = 10.2 * inch
            elif position == 'bottom':
                img_adjustment = 0
                label_adjustment = 0
            # Draw Ameryn logo watermark
            c.drawImage('Q:/Images/ameryn-logo-watermark-2.jpg', 157 * mm, 25*mm + img_adjustment, width=16 * mm, height=11 * mm)
            # Draw artist/album titles
            line2 = ''
            if row[1] and row[2]:
                line1 = row[1]
                line2 = row[2]
                spine = line1 + ' - ' + line2
            elif row[1]:
                line1 = row[1]
                spine = line1
            elif row[2]:
                line1 = row[2]
                spine = line1
            else:
                line1 = 'Untitled'
            # Add disc # for multi-disc sets
            if img[-2] == '_':
                spine += ' (Disc ' + img[-1] + ')'
                if line2:
                    line2 += ' (Disc ' + img[-1] + ')'
                else:
                    line2 = 'Disc ' + img[-1]
            # Line 1
            c.setFont('Garamond', 18)
            if pdfmetrics.stringWidth(line1, 'Garamond', 18) > 125 * mm:
                c.setFont('Garamond', 16)
            if pdfmetrics.stringWidth(line1, 'Garamond', 16) > 125 * mm:
                c.setFont('Garamond', 14)
            if pdfmetrics.stringWidth(line1, 'Garamond', 14) > 125 * mm:
                c.setFont('Garamond', 12)
            if pdfmetrics.stringWidth(line1, 'Garamond', 12) > 125 * mm:
                c.setFont('Garamond', 11)
            if pdfmetrics.stringWidth(line1, 'Garamond', 11) > 125 * mm:
                c.setFont('Garamond', 10)
            c.drawString(48 * mm, 125*mm + img_adjustment, line1)
            # Line 2
            if line2:
                c.setFont('Garamond', 14)
                if pdfmetrics.stringWidth(line2, 'Garamond', 14) > 125 * mm:
                    c.setFont('Garamond', 12)
                if pdfmetrics.stringWidth(line2, 'Garamond', 12) > 125 * mm:
                    c.setFont('Garamond', 11)
                if pdfmetrics.stringWidth(line2, 'Garamond', 11) > 125 * mm:
                    c.setFont('Garamond', 10)
                c.drawString(48 * mm, 118*mm + img_adjustment, line2)
            # Horizontal divider
            c.setLineWidth(2)
            c.line(48 * mm, 112*mm + img_adjustment, 168 * mm, 112*mm + img_adjustment)
            # Set spine label font size
            c.saveState()
            c.rotate(90)
            fontsize = 9
            if pdfmetrics.stringWidth(spine, 'Garamond', 9) > 116 * mm:
                fontsize = 8
            if pdfmetrics.stringWidth(spine, 'Garamond', 8) > 116 * mm:
                fontsize = 7
            c.setFont('Garamond', fontsize)
            # Left spine label
            x = (118*mm - pdfmetrics.stringWidth(spine, 'Garamond', fontsize))/2 + 21.7*mm + img_adjustment
            y = -37.3 * mm
            c.drawString(x, y, spine)
            # Right spine label
            c.rotate(180)
            x = (118*mm - pdfmetrics.stringWidth(spine, 'Garamond', fontsize))/2 - 139.7*mm - img_adjustment
            y = 178.7 * mm
            c.drawString(x, y, spine)
            c.restoreState()
            # Get track durations
            print audio_path
            cues = split.read_markers(audio_path + '_clean.wav')
            durations = []
            for i in range(1, len(cues)):
                duration = cues[i] - cues[i - 1]
                m, s = divmod(duration / 44100, 60)
                durations.append(str(m) + ':' + str(s).zfill(2))
            print durations
            # Get track listing
            tracks = []
            # No track names
            if not row[11]:
                for i in range(len(durations)):
                    tracks.append('Track ' + str(i + 1))
            else:
                for i in range(30):
                	if row[11 + i]:
                		tracks.append(row[11 + i])
                	else:
                		break
            # Compile track data
            if len(tracks) != len(durations):
                err = 'Track/marker mismatch for ' + audio_serial + ': ' + str(len(tracks)) + ' on spreadsheet; ' + str(len(durations)) + ' on file.'
            	raise SystemError(err)            
            track_data = []
            for i in range(len(durations)):
            	track_data.append([(str(i + 1) + '.'), tracks[i], durations[i]])
            # Draw track listing
            table = Table(track_data, colWidths=[6 * mm, 100 * mm, 10 * mm])
            fontsize = 11
            padding = 2
            if len(tracks) > 14:
            	fontsize = 10
            if len(tracks) > 16:
                fontsize = 9
                padding = 1
            table.setStyle(TableStyle([
                                    ('FONT', (0,0), (-1,-1), 'Garamond', fontsize),
                                    ('TOPPADDING', (0,0), (-1,-1), padding),
                                    ('BOTTOMPADDING', (0,0), (-1,-1), padding),
                                    ]))
            w, h = table.wrap(width, height)
            table.wrapOn(c, width, height)
            table.drawOn(c, 49 * mm, 108*mm - h + img_adjustment)

        # Draw crop lines
        c.setLineWidth(0.5)
        c.rect(33 * mm, 21.7*mm + img_adjustment, 150 * mm , 118 * mm, fill=0) 
        c.line(39 * mm, 21.7*mm + img_adjustment, 39 * mm, 139.7*mm + img_adjustment)
        c.line(177 * mm, 21.7*mm + img_adjustment, 177 * mm, 139.7*mm + img_adjustment)
        # Draw image label
        c.setFont('Helvetica', 12)
        c.drawString(3.8 * inch, 0.3*inch + label_adjustment, img)
 def get_metadata(self):
     """ Read metadata from csv db """
     with open(DB_PATH, "r") as items:
         rows = csv.reader(items)
         for row in rows:
             if row[0] == self.serial:
                 logging.debug("Item {0} found in {1}.".format(self.serial, DB_PATH))
                 self.artist = row[1]
                 self.album = row[2]
                 self.media_type = row[3].lower()
                 self.option = row[4].lower()
                 self.format = row[5].lower()
                 for digital_format in DIGITAL_FORMATS:
                     if digital_format in self.format:
                         self.digital_ext = digital_format
                         break
                 else:
                     self.digital_ext = None
                 self.image = row[6] if row[6] else self.serial
                 self.image_path = os.path.join(IMAGES_FOLDER, self.image) + ".jpg"
                 self.copies = int(row[7]) if row[7] else 1
                 self.date_received = row[8]
                 self.customer_notes = row[9]
                 self.private_notes = row[10]
                 self.split_point = (
                     int(self.private_notes[1:3]) if self.private_notes and self.private_notes[0] == "_" else None
                 )
                 if self.split_point:
                     if self.name[-2] is not "_":
                         raise Exception("Error! Split file expected for {0}".format(self.name))
                     self.side = self.name[-1]
                 else:
                     self.side = None
                 self.tracks = []
                 # Deluxe / 45 stuff
                 if "std" not in self.option:
                     tracks = []
                     for track_num in range(1, 31):
                         if row[10 + track_num]:
                             tracks.append(row[10 + track_num])
                         else:
                             break
                     else:
                         if not self.side:
                             logging.warning("Careful! 30+ tracks for Deluxe item {0}.".format(self.name))
                     # Read track times from audio file
                     self.cues = split.read_markers(self.path)
                     if not self.cues:
                         raise Exception("Error! No markers found in audio for Deluxe item {0}".format(self.name))
                     if not tracks:
                         logging.info("No tracks found in db for Deluxe item {0}.".format(self.name))
                         for cue_num in range(1, len(self.cues)):
                             tracks.append("Track {0}".format(cue_num))
                     if self.side is "1":
                         tracks = tracks[: self.split_point]
                     elif self.side is "2":
                         tracks = tracks[self.split_point :]
                     if len(tracks) is not len(self.cues) - 1:
                         raise Exception(
                             "Error! Item {0} expected {1} tracks, found {2} in audio file.".format(
                                 self.name, len(tracks), len(self.cues) - 1
                             )
                         )
                     for i in range(1, len(self.cues)):
                         duration = self.cues[i] - self.cues[i - 1]
                         m, s = divmod(duration / 44100, 60)
                         duration = "{0}:{1}".format(str(m), str(s).zfill(2))
                         self.tracks.append(Track(num=i, title=tracks[i - 1], duration=duration))
                 return
         else:
             logging.warning("Row {0} not found in {1}.".format(self.serial, DB_PATH))
Example #5
0
 def get_metadata(self):
     """ Read metadata from csv db """
     with open(db_path, 'r') as items:
         rows = csv.reader(items)
         for row in rows:
             if row[0] == self.serial:
                 logging.debug('Item {0} found in {1}.'.format(self.serial, db_path))
                 self.artist = row[1]
                 self.album = row[2]
                 self.media_type = row[3].lower()
                 self.option = row[4].lower()
                 self.format = row[5].lower()
                 for digital_format in digital_formats:
                     if digital_format in self.format:
                         self.digital_ext = digital_format
                         break
                 else:
                     self.digital_ext = None                    
                 self.bitrate = '320k' if '320' in self.format else mp3_bitrate
                 if row[6].lower() == 'none' and 'cd' not in self.format:
                     self.image = None
                     self.image_path = None
                     self.thumb = None
                     self.thumb_path = None
                 else:
                     if row[6]:
                         self.image = row[6]
                     else:
                         self.image = self.serial
                     if os.path.isfile(os.path.join(images_folder, self.image) + '.jpg'):
                         self.image_path = os.path.join(images_folder, self.image) + '.jpg'
                     elif os.path.isfile(os.path.join(images_folder, 'Archived cover pictures/', self.image) + '.jpg'):
                         self.image_path = os.path.join(images_folder, 'Archived cover pictures/', self.image) + '.jpg'
                     else:
                         self.metadata_errors.append('Error! No image found for {0}'.format(self.name))
                 self.copies = int(row[7]) if row[7] else 1
                 self.date_received = row[8]
                 self.customer_notes = row[9]
                 self.private_notes = row[10]
                 self.split_point = int(self.private_notes[1:3]) if self.private_notes and self.private_notes[0] == '_' else None
                 # Check if long (>78m)
                 with closing(wave.open(self.path, 'r')) as audio:
                     self.duration = audio.getnframes() / audio.getframerate()
                     if self.duration > 4680:
                         self.long = True
                         if 'std' not in self.option and not self.split_point:
                             self.metadata_errors.append('Error! Split point needed for Tracked long item {0}'.format(self.name))
                             return
                         elif 'std' in self.option:
                             self.split_point = 1
                     else:
                         self.long = False
                 self.side = None
                 self.tracks = []
                 self.compilation_counter = None
                 self.compilation_cd_counter = None
                 self.compilation_cds = 0
                 self.compilation_items = 0
                 self.image_counter = 0
                 # Tracks stuff
                 if 'std' not in self.option or self.long:
                     tracks = [track for track in row[12:59] if track]
                     if not self.long and 'cd' in self.format and len(tracks) > 30:
                         logging.warning('Careful! >30 tracks for Tracked {0} {1}.'.format(self.media_type, self.name))
                     # Read track times from audio file
                     self.cues = split.read_markers(self.path)
                     if len(self.cues) < 3 and 'std' not in self.option:
                         self.metadata_errors.append('Error! No markers found in audio for Tracked {0} {1}'.format(self.media_type, self.name))
                         return
                     elif len(self.cues) < 3 and self.long:
                         self.metadata_errors.append('Error! No markers found in audio for long (>78m) {0} {1}'.format(
                             self.media_type, self.name))
                         return
                     if not tracks:
                         if 'std' not in self.option:                                
                             logging.info('No tracks found in db for Tracked {0} {1}.'.format(self.media_type, self.name))
                         for cue_num in range(1, len(self.cues)):
                             tracks.append('Track {0}'.format(cue_num))
                     elif not tracks:
                         # Long std CD
                         tracks = ['Side A', 'Side B']
                     if len(tracks) is not len(self.cues) - 1:
                         self.metadata_errors.append('Error! Item {0} expected {1} tracks, found {2} in audio file.'.format(
                             self.name, len(tracks), len(self.cues) - 1))
                         return
                     # Set file, track durations
                     for i in range(1, len(self.cues)):
                         duration = self.cues[i] - self.cues[i - 1]
                         m, s = divmod(duration / 44100, 60)
                         duration = '{0}:{1}'.format(str(m), str(s).zfill(2))
                         self.tracks.append(Track(num=i, title=tracks[i - 1], duration=duration, start=self.cues[i - 1], stop=self.cues[i]))
                 return
         else:
              logging.warning('Row {0} not found in {1}.'.format(self.serial, db_path))
 def get_metadata(self):
     """ Read metadata from csv db """
     with open(db_path, 'r') as items:
         rows = csv.reader(items)
         for row in rows:
             if row[0] == self.serial:
                 logging.debug('Item {0} found in {1}.'.format(self.serial, db_path))
                 self.artist = row[1]
                 self.album = row[2]
                 self.media_type = row[3].lower()
                 self.option = row[4].lower()
                 self.format = row[5].lower()
                 for digital_format in digital_formats:
                     if digital_format in self.format:
                         self.digital_ext = digital_format
                         break
                 else:
                     self.digital_ext = None                    
                 self.bitrate = '320k' if '320' in self.format else mp3_bitrate
                 if row[6].lower() == 'none' and 'cd' not in self.format:
                     self.image = None
                     self.image_path = None
                     self.thumb = None
                     self.thumb_path = None
                 else:
                     if row[6]:
                         self.image = row[6]
                     else:
                         self.image = self.serial
                     if os.path.isfile(os.path.join(images_folder, self.image) + '.jpg'):
                         self.image_path = os.path.join(images_folder, self.image) + '.jpg'
                     elif os.path.isfile(os.path.join(images_folder, 'Archived cover pictures/', self.image) + '.jpg'):
                         self.image_path = os.path.join(images_folder, 'Archived cover pictures/', self.image) + '.jpg'
                     else:
                         metadata_errors.append('Error! No image found for {0}'.format(self.name))
                 self.copies = int(row[7]) if row[7] else 1
                 self.date_received = row[8]
                 self.customer_notes = row[9]
                 self.private_notes = row[10]                    
                 self.split_point = int(self.private_notes[1:3]) if self.private_notes and self.private_notes[0] == '_' else None
                 if self.split_point:
                     if self.name[-2] is not '_':
                         metadata_errors.append('Error! Split file expected for {0}'.format(self.name))
                         return
                     self.side = self.name[-1]
                 else:
                     self.side = None
                 self.tracks = []                    
                 self.compilation_counter = None
                 self.compilation_cd_counter = None
                 self.compilation_cds = 0
                 self.compilation_items = 0
                 self.image_counter = 0
                 # Deluxe / 45 stuff
                 if 'std' not in self.option:
                     tracks = [track for track in row[11:58] if track]
                     if not self.side and 'cd' in self.format and len(tracks) > 30:
                         logging.warning('Careful! >30 tracks for Deluxe item {0}.'.format(self.name))
                     # Read track times from audio file
                     self.cues = split.read_markers(self.path)
                     if not self.cues:
                         metadata_errors.append('Error! No markers found in audio for Deluxe item {0}'.format(self.name))
                         return
                     if not tracks:
                         logging.info('No tracks found in db for Deluxe item {0}.'.format(self.name))
                         for cue_num in range(1, len(self.cues)):
                             tracks.append('Track {0}'.format(cue_num))                        
                     if self.side is '1':
                         tracks = tracks[:self.split_point]
                     elif self.side is '2':
                         tracks = tracks[self.split_point:]                        
                     if len(tracks) is not len(self.cues) - 1:
                         metadata_errors.append('Error! Item {0} expected {1} tracks, found {2} in audio file.'.format(
                             self.name, len(tracks), len(self.cues) - 1))
                         return
                     # Set file, track durations
                     self.duration = self.cues[-1] / 44100 # seconds
                     for i in range(1, len(self.cues)):
                         duration = self.cues[i] - self.cues[i - 1]
                         m, s = divmod(duration / 44100, 60)
                         duration = '{0}:{1}'.format(str(m), str(s).zfill(2))
                         self.tracks.append(Track(num=i, title=tracks[i - 1], duration=duration))
                 return                     
         else:
              logging.warning('Row {0} not found in {1}.'.format(self.serial, db_path))
Example #7
0
    def get_metadata(self):
        """ Read metadata from csv db """
        with open(config.db_path, 'r') as items:
            rows = csv.reader(items)
            for row in rows:
                if row[0] == self.serial:
                    logging.debug('Item {0} found in {1}.'.format(self.serial, config.db_path))
                    self.artist = row[1]
                    self.album = row[2]
                    self.media_type = row[3].lower()
                    self.option = row[4].lower()
                    self.format = row[5].lower()
                    for digital_format in config.digital_formats:
                        if digital_format in self.format:
                            self.digital_ext = digital_format
                            break
                    else:
                        self.digital_ext = None
                    # Bitrate
                    if 'vbr' in self.format:
                        self.bitrate = None
                        self.export_parameters = ['-q:a', '2'] # LAME VBR -V2
                    elif '320' in self.format:
                        self.bitrate = '320k'
                        self.export_parameters = None
                    elif '128' in self.format:
                        self.bitrate = '128k'
                        self.export_parameters = None
                    else:
                        self.bitrate = config.mp3_bitrate
                        self.export_parameters = None
                    if row[6].lower() == 'none' and 'cd' not in self.format:
                        self.image = None
                        self.image_path = None
                        self.thumb = None
                        self.thumb_path = None
                    else:
                        if row[6]:
                            self.image = row[6]
                        else:
                            self.image = self.serial
                        if os.path.isfile(os.path.join(config.images_folder, self.image) + '.jpg'):
                            self.image_path = os.path.join(config.images_folder, self.image) + '.jpg'
                        elif os.path.isfile(os.path.join(config.images_folder, 'Archived cover pictures/', self.image) + '.jpg'):
                            self.image_path = os.path.join(config.images_folder, 'Archived cover pictures/', self.image) + '.jpg'
                        elif '45' not in self.media_type:
                            self.metadata_errors.append('Error! No image found for {0}'.format(self.name))
                    self.counter_image_path = None
                    self.copies = int(row[7]) if row[7] else 1
                    self.copy_counter = None
                    self.date_received = row[8]
                    self.customer_notes = row[9]
                    self.private_notes = row[10]
                    split_points = re.search('(?:_)([0-9]+)', self.private_notes) # ex. '_9' or '_21'
                    self.split_point = int(split_points.group(1)) if split_points else None
                    self.side = None
                    self.tracks = []
                    self.compilation_counter = None
                    self.compilation_cd_item_counter = None
                    self.compilation_cd_counter = None
                    self.compilation_cds = 0
                    self.compilation_items = 0
                    self.image_counter = 0
                    # Tracks stuff, if files allegedly have tracks added
                    if self.tracks_added:
                        # Check if long (>78m)
                        if self.split_point:
                            self.long = True
                        else:
                            with closing(wave.open(self.path, 'r')) as audio:
                                self.duration = audio.getnframes() / audio.getframerate()
                                if self.duration > 4680 and 'cd' in self.format:
                                    self.long = True
                                    if 'std' not in self.option and not self.split_point and len([track for track in row[12:59] if track]) != 2:
                                        self.metadata_errors.append('Error! Split point needed for Tracked long item {0}'.format(self.name))
                                        return
                                    elif not self.split_point:
                                        self.split_point = 1
                                else:
                                    self.long = False                            
                        if 'std' not in self.option or self.long:
                            tracks = [track for track in row[12:79] if track]
                            if not self.long and 'cd' in self.format and len(tracks) > 30:
                                logging.warning('Careful! >30 tracks for Tracked {0} {1}.'.format(self.media_type, self.name))
                            # Read track times from audio file
                            self.cues = split.read_markers(self.path)
                            # Remove duplicated cues (length <3s)
                            for cue_num in range(1, len(self.cues)):
                                if self.cues[cue_num] - self.cues[cue_num - 1] < 132300:
                                    print 'Short track (duplicate marker?) (len {0}) for item {1}'.format(
                                        self.cues[cue_num] - self.cues[cue_num - 1], self.name)
                                    if cue_num == 1:
                                        del self.cues[1]
                                    else:
                                        del self.cues[cue_num - 1]

                            if len(self.cues) < 2 and 'std' not in self.option:
                                self.metadata_errors.append('Error! No markers found in audio for Tracked {0} {1}'.format(
                                    self.media_type, self.name))
                                return
                            elif len(self.cues) < 3 and self.long:
                                self.metadata_errors.append('Error! No markers found in audio for long (>78m) {0} {1}'.format(
                                    self.media_type, self.name))
                                return
                            if not tracks:
                                if 'std' in self.option and len(self.cues) == 3:
                                    tracks = ['Side A', 'Side B']
                                else:
                                    logging.info('No tracks found in db for Tracked {0} {1}.'.format(self.media_type, self.name))
                                    for cue_num in range(1, len(self.cues)):
                                        tracks.append('Track {0}'.format(cue_num))
                            if len(tracks) is not len(self.cues) - 1:
                                self.metadata_errors.append('Error! Item {0} expected {1} tracks, found {2} in audio file.'.format(
                                    self.name, len(tracks), len(self.cues) - 1))
                                return
                            # Set file, track durations; truncate filename at 190 chars
                            for i in range(1, len(self.cues)):
                                duration = self.cues[i] - self.cues[i - 1]
                                m, s = divmod(duration / 44100, 60)
                                duration = '{0}:{1}'.format(str(m), str(s).zfill(2))
                                self.tracks.append(Track(num=i, title=tracks[i - 1][:190], \
                                    duration=duration, start=self.cues[i - 1], stop=self.cues[i]))
                    return
            else:
                 logging.warning('Row {0} not found in {1}.'.format(self.serial, config.db_path))
                 self.metadata_errors.append('Row {0} not found in {1}.'.format(self.serial, config.db_path))