album_art.h

Go to the documentation of this file.

class NOVTABLE album_art_data : public service_base {
public:
        virtual const void * get_ptr() const = 0;
        virtual t_size get_size() const = 0;

        static bool equals(album_art_data const & v1, album_art_data const & v2) {
                const t_size s = v1.get_size();
                if (s != v2.get_size()) return false;
                return memcmp(v1.get_ptr(), v2.get_ptr(),s) == 0;
        }
        bool operator==(const album_art_data & other) const {return equals(*this,other);}
        bool operator!=(const album_art_data & other) const {return !equals(*this,other);}

        FB2K_MAKE_SERVICE_INTERFACE(album_art_data,service_base);
};

typedef service_ptr_t<album_art_data> album_art_data_ptr;

class album_art_data_impl : public album_art_data {
public:
        const void * get_ptr() const {return m_content.get_ptr();}
        t_size get_size() const {return m_content.get_size();}

        void * get_ptr() {return m_content.get_ptr();}
        void set_size(t_size p_size) {m_content.set_size(p_size);}

        void from_stream(stream_reader * p_stream,t_size p_bytes,abort_callback & p_abort) {
                set_size(p_bytes); p_stream->read_object(get_ptr(),p_bytes,p_abort);
        }

        static album_art_data_ptr g_create(const void * p_buffer,t_size p_bytes) {
                service_ptr_t<album_art_data_impl> instance = new service_impl_t<album_art_data_impl>();
                instance->set_size(p_bytes);
                memcpy(instance->get_ptr(),p_buffer,p_bytes);
                return instance;
        }
        static album_art_data_ptr g_create(stream_reader * p_stream,t_size p_bytes,abort_callback & p_abort) {
                service_ptr_t<album_art_data_impl> instance = new service_impl_t<album_art_data_impl>();
                instance->from_stream(p_stream,p_bytes,p_abort);
                return instance;
        }

private:
        pfc::array_t<t_uint8> m_content;
};

namespace album_art_ids {
        static const GUID cover_front = { 0xf1e66f4e, 0xfe09, 0x4b94, { 0x91, 0xa3, 0x67, 0xc2, 0x3e, 0xd1, 0x44, 0x5e } };
        static const GUID cover_back = { 0xcb552d19, 0x86d5, 0x434c, { 0xac, 0x77, 0xbb, 0x24, 0xed, 0x56, 0x7e, 0xe4 } };
        static const GUID disc = { 0x3dba9f36, 0xf928, 0x4fa4, { 0x87, 0x9c, 0xd3, 0x40, 0x47, 0x59, 0x58, 0x7e } };
        static const GUID icon = { 0x74cdf5b4, 0x7053, 0x4b3d, { 0x9a, 0x3c, 0x54, 0x69, 0xf5, 0x82, 0x6e, 0xec } };
};

PFC_DECLARE_EXCEPTION(exception_album_art_not_found,exception_io_not_found,"Album Art Not Found");
PFC_DECLARE_EXCEPTION(exception_album_art_unsupported_entry,exception_io_data,"Unsupported Album Art Entry");

class NOVTABLE album_art_extractor_instance : public service_base {
public:
        virtual album_art_data_ptr query(const GUID & p_what,abort_callback & p_abort) = 0;

        FB2K_MAKE_SERVICE_INTERFACE(album_art_extractor_instance,service_base);
};

class NOVTABLE album_art_editor_instance : public album_art_extractor_instance {
public:
        virtual void set(const GUID & p_what,album_art_data_ptr p_data,abort_callback & p_abort) = 0;

        virtual void remove(const GUID & p_what) = 0;

        virtual void commit(abort_callback & p_abort) = 0;
        

        FB2K_MAKE_SERVICE_INTERFACE(album_art_editor_instance,album_art_extractor_instance);
};

typedef service_ptr_t<album_art_extractor_instance> album_art_extractor_instance_ptr;
typedef service_ptr_t<album_art_editor_instance> album_art_editor_instance_ptr;

class NOVTABLE album_art_extractor : public service_base {
public:
        virtual bool is_our_path(const char * p_path,const char * p_extension) = 0;
        
        virtual album_art_extractor_instance_ptr open(file_ptr p_filehint,const char * p_path,abort_callback & p_abort) = 0;

        FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(album_art_extractor);
};

class NOVTABLE album_art_editor : public service_base {
public:
        virtual bool is_our_path(const char * p_path,const char * p_extension) = 0;

        virtual album_art_editor_instance_ptr open(file_ptr p_filehint,const char * p_path,abort_callback & p_abort) = 0;

        static bool g_get_interface(service_ptr_t<album_art_editor> & out,const char * path);
        static bool g_is_supported_path(const char * path);

        FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(album_art_editor);
};

class NOVTABLE album_art_manager_instance : public service_base {
public:
        virtual bool open(const char * p_file,abort_callback & p_abort) = 0;
        virtual void close() = 0;

        virtual album_art_data_ptr query(const GUID & p_what,abort_callback & p_abort) = 0;

        virtual album_art_data_ptr query_stub_image(abort_callback & p_abort) = 0;

        FB2K_MAKE_SERVICE_INTERFACE(album_art_manager_instance,service_base);
};

typedef service_ptr_t<album_art_manager_instance> album_art_manager_instance_ptr;

class NOVTABLE album_art_manager : public service_base {
public:
        virtual album_art_manager_instance_ptr instantiate() = 0;
        
        FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(album_art_manager);
};


class album_art_extractor_instance_simple : public album_art_extractor_instance {
public:
        void set(const GUID & p_what,album_art_data_ptr p_content) {m_content.set(p_what,p_content);}
        bool have_item(const GUID & p_what) {return m_content.have_item(p_what);}
        album_art_data_ptr query(const GUID & p_what,abort_callback & p_abort) {
                album_art_data_ptr temp;
                if (!m_content.query(p_what,temp)) throw exception_album_art_not_found();
                return temp;
        }
        bool is_empty() const {return m_content.get_count() == 0;}
private:
        pfc::map_t<GUID,album_art_data_ptr> m_content;
};

class NOVTABLE tag_processor_album_art_utils : public service_base {
public:

        virtual album_art_extractor_instance_ptr open(file_ptr p_file,abort_callback & p_abort) = 0;

        virtual album_art_editor_instance_ptr edit(file_ptr p_file,abort_callback & p_abort) = 0;

        FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(tag_processor_album_art_utils)
};

class album_art_extractor_impl_stdtags : public album_art_extractor {
public:
        album_art_extractor_impl_stdtags(const char * exts) {
                pfc::splitStringSimple_toList(m_extensions,";",exts);
        }

        bool is_our_path(const char * p_path,const char * p_extension) {
                return m_extensions.have_item(p_extension);
        }

        album_art_extractor_instance_ptr open(file_ptr p_filehint,const char * p_path,abort_callback & p_abort) {
                PFC_ASSERT( is_our_path(p_path, pfc::string_extension(p_path) ) );
                file_ptr l_file ( p_filehint );
                if (l_file.is_empty()) filesystem::g_open_read(l_file, p_path, p_abort);
                return static_api_ptr_t<tag_processor_album_art_utils>()->open( l_file, p_abort );
        }
private:
        pfc::avltree_t<pfc::string,pfc::string::comparatorCaseInsensitiveASCII> m_extensions;
};

---