/home/foss/Downloads/coverart-browser/coverart_export.py

# -*- Mode: python; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
#
# Copyright (C) 2012 - fossfreedom
# Copyright (C) 2012 - Agustin Carrasco
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of thie GNU General Public License as published by
# the Free Software Foundation; either version 2, 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.

import shutil
import os
import sys
import subprocess

from gi.repository import GObject
from gi.repository import Gtk
from gi.repository import GLib
from gi.repository import RB
from gi.repository import Gdk
from gi.repository import Peas
from gi.repository import Gst

from coverart_utils import NaturalString
import rb
import coverart_rb3compat as rb3compat


class CoverArtExport(GObject.Object):
    '''
    This class provides for various export routines
    
    '''
    TARGET_BITRATE = 128

    def __init__(self, plugin, shell, album_manager):
        self.plugin = plugin
        self.shell = shell
        self.album_manager = album_manager

        self._gstreamer_has_initialised = False

    def is_search_plugin_enabled(self):
        peas = Peas.Engine.get_default()
        loaded_plugins = peas.get_loaded_plugins()

        result = False
        if 'coverart_search_providers' in loaded_plugins:
            info = peas.get_plugin_info('coverart_search_providers')
            version = info.get_version()

            if NaturalString(version) >= "0.9":
                result = True

        return result

    def embed_albums(self, selected_albums):
        '''
        method to create the menu items for all supported plugins

        :selected_albums: `Album` - array of albums
        '''

        self._initialise_gstreamer()

        from coverart_search_tracks import CoverArtTracks

        search_tracks = CoverArtTracks()
        playlist_manager = self.shell.props.playlist_manager
        playlists_entries = playlist_manager.get_playlists()

        ui = Gtk.Builder()
        ui.add_from_file(rb.find_plugin_file(self.plugin,
                                             'ui/coverart_exportembed.ui'))
        ui.connect_signals(self)
        embeddialog = ui.get_object('exportembeddialog')
        folderchooserbutton = ui.get_object('folderchooserbutton')
        use_album_name_checkbutton = ui.get_object('use_album_name_checkbutton')
        open_filemanager_checkbutton = ui.get_object('open_filemanager_checkbutton')
        convert_checkbutton = ui.get_object('convert_checkbutton')
        bitrate_spinbutton = ui.get_object('bitrate_spinbutton')
        resize_checkbutton = ui.get_object('resize_checkbutton')
        resize_spinbutton = ui.get_object('resize_spinbutton')
        bitrate_spinbutton.set_value(self.TARGET_BITRATE)
        resize_spinbutton.set_value(128)

        downloads_dir = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_DOWNLOAD)
        folderchooserbutton.set_current_folder(downloads_dir)

        response = embeddialog.run()

        if response != Gtk.ResponseType.OK:
            embeddialog.destroy()
            return

        #ok pressed - now fetch values from the dialog
        final_folder_store = folderchooserbutton.get_current_folder()
        use_album_name = use_album_name_checkbutton.get_active()
        open_filemanager = open_filemanager_checkbutton.get_active()
        convert = convert_checkbutton.get_active()
        bitrate = bitrate_spinbutton.get_value()
        toresize = resize_checkbutton.get_active()
        if toresize:
            resize = int(resize_spinbutton.get_value())
        else:
            resize = -1

        embeddialog.destroy()

        albums = {}
        total = 0

        for album in selected_albums:
            albums[album] = album.get_tracks()
            total = total + len(albums[album])

        self._track_count = 1

        def complete():
            self.album_manager.progress = 1

            if open_filemanager:
                #code taken from http://stackoverflow.com/questions/1795111/is-there-a-cross-platform-way-to-open-a-file-browser-in-python
                if sys.platform == 'win32':
                    import winreg

                    path = r('SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon')
                    for root in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE):
                        try:
                            with winreg.OpenKey(root, path) as k:
                                value, regtype = winreg.QueryValueEx(k, 'Shell')
                        except WindowsError:
                            pass
                        else:
                            if regtype in (winreg.REG_SZ, winreg.REG_EXPAND_SZ):
                                shell = value
                            break
                    else:
                        shell = 'Explorer.exe'
                    subprocess.Popen([shell, final_folder_store])

                elif sys.platform == 'darwin':
                    subprocess.Popen(['open', final_folder_store])

                else:
                    subprocess.Popen(['xdg-open', final_folder_store])

        self._albumiter = iter(albums)
        self._tracknumber = 0
        self._album = next(self._albumiter)

        def idle_call(data):
            exit_idle = True

            track = albums[self._album][self._tracknumber]

            if not process_track(self._album, track):
                exit_idle = False

            self._tracknumber = self._tracknumber + 1

            if self._tracknumber >= len(albums[self._album]):
                try:
                    self._tracknumber = 0
                    self._album = next(self._albumiter)
                except StopIteration:
                    exit_idle = False

            if not exit_idle:
                complete()

            return exit_idle

        def process_track(album, track):
            self.album_manager.progress = self._track_count / total
            self._track_count = self._track_count + 1

            key = album.create_ext_db_key()
            finalPath = rb3compat.unquote(track.location)[7:]
            album_name = RB.search_fold(album.name)

            if use_album_name:
                folder_store = final_folder_store + '/' + album_name
            else:
                folder_store = final_folder_store

            try:
                if not os.path.exists(folder_store):
                    os.makedirs(folder_store)

                if convert:
                    self.convert_to_mp3(finalPath, folder_store, bitrate)
                    finalPath = self._calc_mp3_filename(finalPath, folder_store)
                    print(finalPath)
                else:
                    shutil.copy(finalPath, folder_store)
            except IOError as err:
                print(err.args[0])
                return False

            dest = os.path.join(folder_store, os.path.basename(finalPath))
            desturi = 'file://' + rb3compat.pathname2url(dest)

            return search_tracks.embed(desturi, key, resize)

        data = None

        Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT_IDLE, idle_call, data)

    def _initialise_gstreamer(self):

        if self._gstreamer_has_initialised:
            return

        self._gstreamer_has_initialised = True
        Gst.init(None)

        def on_new_decoded_pad(dbin, pad):
            decode = pad.get_parent()
            pipeline = decode.get_parent()
            convert = pipeline.get_by_name('convert')
            decode.link(convert)

        #we are going to mimic the following
        # gst-launch-1.0 filesrc location="02 - ABBA - Knowing Me, Knowing You.ogg" ! 
        # decodebin ! audioconvert ! audioresample ! lamemp3enc target=bitrate bitrate=128 ! 
        # xingmux ! id3v2mux ! filesink location="mytrack.mp3"

        converter = Gst.Pipeline.new('converter')

        source = Gst.ElementFactory.make('filesrc', None)

        decoder = Gst.ElementFactory.make('decodebin', 'decoder')
        convert = Gst.ElementFactory.make('audioconvert', 'convert')
        sample = Gst.ElementFactory.make('audioresample', 'sample')
        encoder = Gst.ElementFactory.make('lamemp3enc', 'encoder')
        encoder.set_property('target', 'bitrate')
        encoder.set_property('bitrate', self.TARGET_BITRATE)

        xing = Gst.ElementFactory.make('xingmux', 'xing')  # needed to make bitrate more accurate
        mux = Gst.ElementFactory.make('id3v2mux', 'mux')
        if not mux:
            # use id3mux where not available
            mux = Gst.ElementFactory.make('id3mux', 'mux')

        sink = Gst.ElementFactory.make('filesink', 'sink')

        converter.add(source)
        converter.add(decoder)
        converter.add(convert)
        converter.add(sample)
        converter.add(encoder)
        converter.add(xing)
        converter.add(mux)
        converter.add(sink)

        Gst.Element.link(source, decoder)
        #note - a decodebin cannot be linked at compile since
        #it doesnt have source-pads (http://stackoverflow.com/questions/2993777/gstreamer-of-pythons-gst-linkerror-problem)

        decoder.connect("pad-added", on_new_decoded_pad)

        Gst.Element.link(convert, sample)
        Gst.Element.link(sample, encoder)
        Gst.Element.link(encoder, xing)
        Gst.Element.link(xing, mux)
        Gst.Element.link(mux, sink)

        self.converter = converter
        self.source = source
        self.sink = sink
        self.encoder = encoder

    def _calc_mp3_filename(self, filename, save_folder):
        finalname = os.path.basename(filename)
        finalname = finalname.rsplit('.')[0] + ".mp3"
        return save_folder + "/" + finalname

    def convert_to_mp3(self, filename, save_folder, bitrate):

        self.source.set_property('location', filename)
        self.sink.set_property('location', self._calc_mp3_filename(filename, save_folder))
        print(bitrate)
        if bitrate < 32:
            bitrate = self.TARGET_BITRATE

        self.encoder.set_property('bitrate', int(bitrate))
        print(bitrate)

        # Start playing
        ret = self.converter.set_state(Gst.State.PLAYING)

        if ret == Gst.StateChangeReturn.FAILURE:
            print("Unable to set the pipeline to the playing state.", sys.stderr)
            exit(-1)

        # Wait until error or EOS
        bus = self.converter.get_bus()
        try:
            msg = bus.timed_pop_filtered(
                Gst.CLOCK_TIME_NONE, Gst.MessageType.ERROR | Gst.MessageType.EOS)
        except:
            # for some reason in ubuntu 12.04 Gst.CLOCK_TIME_NONE fails
            msg = bus.timed_pop_filtered(
                18446744073709551615, Gst.MessageType.ERROR | Gst.MessageType.EOS)

        # Parse message
        if (msg):
            if msg.type == Gst.MessageType.ERROR:
                err, debug = msg.parse_error()
                print("Error received from element %s: %s" % (
                    msg.src.get_name(), err), sys.stderr)
                print("Debugging information: %s" % debug, sys.stderr)
            elif msg.type == Gst.MessageType.EOS:
                print("End-Of-Stream reached.")
            else:
                print("Unexpected message received.", sys.stderr)

        # Free resources
        self.converter.set_state(Gst.State.NULL)