def add_tracks(self, tracklist=[], force_played=False):
for id, track in enumerate(tracklist):
if self.cancelled:
return False
self.notify('progress', id+1, len(tracklist))
if not track.is_downloaded():
continue
if track.is_played() and gl.config.only_sync_not_played and not force_played:
continue
if track.file_type() not in self.allowed_types:
continue
added=self.add_track(track)
if gl.config.on_sync_mark_played:
log('Marking as played on transfer: %s', track.url, sender=self)
gl.history_mark_played(track.url)
if added and gl.config.on_sync_delete:
log('Removing episode after transfer: %s', track.url, sender=self)
track.delete_from_disk()
return True
def add_track(self, episode):
self.notify('status', _('Adding %s') % episode.title)
if gl.config.fssync_channel_subfolders:
# Add channel title as subfolder
folder=episode.channel.title
# Don't allow extremely long folder names (filesystem limitations)
if len(folder) > self.MAX_FILENAME_LENGTH:
log('Limiting folder "%s" to %d characters.', folder, self.MAX_FILENAME_LENGTH, sender=self)
folder=folder[:self.MAX_FILENAME_LENGTH]
folder=re.sub('[/|?*<>:+\[\]\"\\\]', '_', folder.encode(self.enc, 'ignore'))
folder=os.path.join(self.destination, folder)
else:
folder=self.destination
from_file=episode.local_filename()
filename_base=episode.sync_filename()
# don't allow extremely long file names (filesystem limitations)
if len(filename_base) > self.MAX_FILENAME_LENGTH:
log('Limiting filename "%s" to %d characters.', filename_base, self.MAX_FILENAME_LENGTH, sender=self)
filename_base=filename_base[:self.MAX_FILENAME_LENGTH]
to_file=filename_base + os.path.splitext(from_file)[1].lower()
# Encode the file name to our system's
# encoding and remove the characters that are invalid
# for FAT-based drives (replace with the empty string)
to_file=re.sub('[/|?*<>:+\[\]\"\\\]', '_', to_file.encode(self.enc, 'ignore'))
# dirty workaround: on bad (empty) episode titles,
# we simply use the from_file basename
# (please, podcast authors, FIX YOUR RSS FEEDS!)
if os.path.splitext(to_file)[0] == '':
to_file=os.path.basename(from_file)
to_file=os.path.join(folder, to_file)
if not os.path.exists(folder):
try:
os.makedirs(folder)
except:
log('Cannot create folder on MP3 player: %s', folder, sender=self)
return False
if (gl.config.mp3_player_use_scrobbler_log and not episode.is_played()
and [episode.channel.title, episode.title] in self.scrobbler_log):
log('Marking "%s" from "%s" as played', episode.title, episode.channel.title, sender=self)
gl.history_mark_played(episode.url)
if not os.path.exists(to_file):
log('Copying %s => %s', os.path.basename(from_file), to_file.decode(self.enc), sender=self)
return self.copy_file_progress(from_file, to_file)
return True
def add_track(self, episode):
self.notify('status', _('Adding %s') % episode.title)
for track in gpod.sw_get_playlist_tracks(self.podcasts_playlist):
if episode.url == track.podcasturl:
if track.playcount > 0:
gl.history_mark_played(track.podcasturl)
# Mark as played on iPod if played locally (and set podcast flags)
self.set_podcast_flags(track)
return True
original_filename=str(episode.local_filename())
local_filename=original_filename
# Reserve 10 MiB for iTunesDB writing (to be on the safe side)
RESERVED_FOR_ITDB=1024*1024*10
space_for_track=util.get_free_disk_space(self.mountpoint) - RESERVED_FOR_ITDB
needed=util.calculate_size(local_filename)
if needed > space_for_track:
log('Not enough space on %s: %s available, but need at least %s', self.mountpoint, util.format_filesize(space_for_track), util.format_filesize(needed), sender=self)
self.errors.append( _('Error copying %s: Not enough free disk space on %s') % (episode.title, self.mountpoint))
self.cancelled=True
return False
(fn, extension)=os.path.splitext(original_filename)
if libconverter.converters.has_converter(extension):
log('Converting: %s', original_filename, sender=self)
callback_status=lambda percentage: self.notify('sub-progress', int(percentage))
local_filename=libconverter.converters.convert(original_filename, callback=callback_status)
if not libtagupdate.update_metadata_on_file(local_filename, title=episode.title, artist=episode.channel.title):
log('Could not set metadata on converted file %s', local_filename, sender=self)
if local_filename is None:
log('Cannot convert %s', original_filename, sender=self)
return False
else:
local_filename=str(local_filename)
(fn, extension)=os.path.splitext(local_filename)
if extension.lower().endswith('ogg'):
log('Cannot copy .ogg files to iPod.', sender=self)
return False
track=gpod.itdb_track_new()
# Add release time to track if pubDate is parseable
ipod_date=email.Utils.parsedate(episode.pubDate)
if ipod_date is not None:
try:
# libgpod>= 0.5.x uses a new timestamp format
track.time_released=gpod.itdb_time_host_to_mac(int(time.mktime(ipod_date)))
except:
# old (pre-0.5.x) libgpod versions expect mactime, so
# we're going to manually build a good mactime timestamp here :)
#
# + 2082844800 for unixtime => mactime (1970 => 1904)
track.time_released=int(time.mktime(ipod_date) + 2082844800)
track.title=str(episode.title)
track.album=str(episode.channel.title)
track.artist=str(episode.channel.title)
track.description=str(episode.description)
track.podcasturl=str(episode.url)
track.podcastrss=str(episode.channel.url)
track.tracklen=get_track_length(local_filename)
track.size=os.path.getsize(local_filename)
if episode.file_type() == 'audio':
track.filetype='mp3'
track.mediatype=0x00000004
elif episode.file_type() == 'video':
track.filetype='m4v'
track.mediatype=0x00000006
self.set_podcast_flags(track)
self.set_cover_art(track, local_filename)
gpod.itdb_track_add(self.itdb, track, -1)
gpod.itdb_playlist_add_track(self.podcasts_playlist, track, -1)
gpod.itdb_cp_track_to_ipod( track, local_filename, None)
# If the file has been converted, delete the temporary file here
if local_filename != original_filename:
util.delete_file(local_filename)
return True
