playlist_loader.cpp File Reference

Go to the source code of this file.

Functions
static void	index_tracks_helper (const char *p_path, const service_ptr_t< file > &p_reader, const t_filestats &p_stats, playlist_loader_callback::t_entry_type p_type, playlist_loader_callback::ptr p_callback, abort_callback &p_abort, bool &p_got_input)
static void	process_path_internal (const char *p_path, const service_ptr_t< file > &p_reader, playlist_loader_callback::ptr callback, abort_callback &abort, playlist_loader_callback::t_entry_type type, const t_filestats &p_stats)
static void	track_indexer__g_get_tracks_wrap (const char *p_path, const service_ptr_t< file > &p_reader, const t_filestats &p_stats, playlist_loader_callback::t_entry_type p_type, playlist_loader_callback::ptr p_callback, abort_callback &p_abort)

Function Documentation

static void index_tracks_helper ( const char *  p_path, const service_ptr_t< file > &  p_reader, const t_filestats &  p_stats, playlist_loader_callback::t_entry_type  p_type, playlist_loader_callback::ptr  p_callback, abort_callback &  p_abort, bool &  p_got_input  )

static

Definition at line 88 of file playlist_loader.cpp.

{
    TRACK_CALL_TEXT("index_tracks_helper");
    if (p_reader.is_empty() && filesystem::g_is_remote_safe(p_path))
    {
        TRACK_CALL_TEXT("remote");
        metadb_handle_ptr handle;
        p_callback->handle_create(handle,make_playable_location(p_path,0));
        p_got_input = true;
        p_callback->on_entry(handle,p_type,p_stats,true);
    } else {
        TRACK_CALL_TEXT("hintable");
        service_ptr_t<input_info_reader> instance;
        input_entry::g_open_for_info_read(instance,p_reader,p_path,p_abort);

        t_filestats stats = instance->get_file_stats(p_abort);

        t_uint32 subsong,subsong_count = instance->get_subsong_count();
        bool bInfoGetError = false;
        for(subsong=0;subsong<subsong_count;subsong++)
        {
            TRACK_CALL_TEXT("subsong-loop");
            p_abort.check();
            metadb_handle_ptr handle;
            t_uint32 index = instance->get_subsong(subsong);
            p_callback->handle_create(handle,make_playable_location(p_path,index));

            p_got_input = true;
            if (! bInfoGetError && p_callback->want_info(handle,p_type,stats,true) )
            {
                file_info_impl info;
                try {
                    TRACK_CODE("get_info",instance->get_info(index,info,p_abort));
                } catch(...) {
                    bInfoGetError = true;
                }
                p_callback->on_entry_info(handle,p_type,stats,info,true);
            }
            else
            {
                p_callback->on_entry(handle,p_type,stats,true);
            }
        }
    }
}

static void process_path_internal ( const char *  p_path, const service_ptr_t< file > &  p_reader, playlist_loader_callback::ptr  callback, abort_callback &  abort, playlist_loader_callback::t_entry_type  type, const t_filestats &  p_stats  )

static

Definition at line 198 of file playlist_loader.cpp.

{
    //p_path must be canonical

    abort.check();

    callback->on_progress(p_path);

    
    {
        if (p_reader.is_empty() && type != playlist_loader_callback::entry_directory_enumerated) {
            directory_callback_impl2 directory_results(true);
            try {
                filesystem::g_list_directory(p_path,directory_results,abort);
                for(t_size n=0;n<directory_results.get_count();n++) {
                    process_path_internal(directory_results.get_item(n),0,callback,abort,playlist_loader_callback::entry_directory_enumerated,directory_results.get_item_stats(n));
                }
                return;
            } catch(exception_aborted) {throw;}
            catch(...) {
                //do nothing, fall thru
                //fixme - catch only filesystem exceptions?
            }
        }

        bool found = false;


        {
            archive_callback_impl archive_results(callback, abort);
            service_enum_t<filesystem> e;
            service_ptr_t<filesystem> f;
            while(e.next(f)) {
                abort.check();
                service_ptr_t<archive> arch;
                if (f->service_query_t(arch)) {
                    if (p_reader.is_valid()) p_reader->reopen(abort);

                    try {
                        TRACK_CODE("archive::archive_list",arch->archive_list(p_path,p_reader,archive_results,true));
                        return;
                    } catch(exception_aborted) {throw;} 
                    catch(...) {}
                }
            } 
        }
    }

    

    {
        service_ptr_t<link_resolver> ptr;
        if (link_resolver::g_find(ptr,p_path))
        {
            if (p_reader.is_valid()) p_reader->reopen(abort);

            pfc::string8 temp;
            try {
                TRACK_CODE("link_resolver::resolve",ptr->resolve(p_reader,p_path,temp,abort));

                track_indexer__g_get_tracks_wrap(temp,0,filestats_invalid,playlist_loader_callback::entry_from_playlist,callback, abort);
                return;//success
            } catch(exception_aborted) {throw;}
            catch(...) {}
        }
    }

    if (callback->is_path_wanted(p_path,type)) {
        track_indexer__g_get_tracks_wrap(p_path,p_reader,p_stats,type,callback, abort);
    }
}

static void track_indexer__g_get_tracks_wrap ( const char *  p_path, const service_ptr_t< file > &  p_reader, const t_filestats &  p_stats, playlist_loader_callback::t_entry_type  p_type, playlist_loader_callback::ptr  p_callback, abort_callback &  p_abort  )

static

Definition at line 134 of file playlist_loader.cpp.

                                                                                                                                                                                                                                                {
    bool got_input = false;
    bool fail = false;
    try {
        index_tracks_helper(p_path,p_reader,p_stats,p_type,p_callback,p_abort, got_input);
    } catch(exception_aborted) {
        throw;
    } catch(exception_io_unsupported_format) {
        fail = true;
    } catch(std::exception const & e) {
        fail = true;
        console::formatter() << "could not enumerate tracks (" << e << ") on:\n" << file_path_display(p_path);
    }
    if (fail) {
        if (!got_input && !p_abort.is_aborting()) {
            if (p_type == playlist_loader_callback::entry_user_requested)
            {
                metadb_handle_ptr handle;
                p_callback->handle_create(handle,make_playable_location(p_path,0));
                p_callback->on_entry(handle,p_type,p_stats,true);
            }
        }
    }
}