cue_parser::embeddedcue_metadata_manager

#include <cue_parser.h>

Public Member Functions
t_size	get_cue_track_count () const
void	get_tag (file_info &p_info) const
void	get_track_info (unsigned p_track, file_info &p_info) const
bool	have_cuesheet () const
void	query_track_offsets (unsigned p_track, double &p_begin, double &p_length) const
unsigned	remap_trackno (unsigned p_index) const
void	set_tag (file_info const &p_info)
void	set_track_info (unsigned p_track, file_info const &p_info)

Private Attributes
track_record_list	m_content

Detailed Description

Definition at line 176 of file cue_parser.h.

Member Function Documentation

t_size embeddedcue_metadata_manager::get_cue_track_count

(

)

const

Definition at line 369 of file cue_parser_embedding.cpp.

                                                               {
    return m_content.get_count() - 1;
}

void embeddedcue_metadata_manager::get_tag

(

file_info &

p_info

)

const

Definition at line 145 of file cue_parser_embedding.cpp.

                                                                   {
    if (!have_cuesheet()) {
        m_content.query_ptr((unsigned)0)->m_info.to_info(p_info);
        p_info.meta_remove_field("cuesheet");
    } else {
        cue_creator::t_entry_list entries;
        {
            __get_tag_cue_track_list_builder e(entries);
            m_content.enumerate(e);
        }
        pfc::string_formatter cuesheet;
        cue_creator::create(cuesheet,entries);
        entries.remove_all();
        //parse it back to see what info got stored in the cuesheet and what needs to be stored outside cuesheet in the tags
        cue_parser::parse_full(cuesheet,entries);
        file_info_record output;

        
        

        {
            file_info_record::t_meta_map globals;
            //1. find global infos and forward them
            {
                field_name_list fields;
                { __get_tag__enum_fields_enumerator e(fields); m_content.enumerate(e);}
                { __get_tag__filter_globals e(m_content,globals); fields.enumerate(e); }
            }
            
            output.overwrite_meta(globals);

            //2. find local infos
            {__get_tag__local_field_filter e(globals,output.m_meta); m_content.enumerate(e);}
        }
        

        //strip redundant titles and tracknumbers that the cuesheet already contains
        for(cue_creator::t_entry_list::const_iterator iter = entries.first(); iter.is_valid(); ++iter) {
            strip_redundant_track_meta(iter->m_track_number,iter->m_infos,output.m_meta,"tracknumber");
            strip_redundant_track_meta(iter->m_track_number,iter->m_infos,output.m_meta,"title");
        }


        //add tech infos etc

        {
            const track_record * rec = m_content.query_ptr((unsigned)0);
            if (rec != NULL) {
                output.set_length(rec->m_info.get_length());
                output.set_replaygain(rec->m_info.get_replaygain());
                output.overwrite_info(rec->m_info.m_info);
            }
        }
        output.meta_set("cuesheet",cuesheet);
        output.to_info(p_info);
    }
}

void embeddedcue_metadata_manager::get_track_info	(	unsigned	p_track,
		file_info &	p_info
	)		const

Definition at line 315 of file cue_parser_embedding.cpp.

                                                                                           {
    const track_record * rec = m_content.query_ptr(p_track);
    if (rec == NULL) throw exception_io_data();
    rec->m_info.to_info(p_info);
}

bool embeddedcue_metadata_manager::have_cuesheet

(

)

const

Definition at line 335 of file cue_parser_embedding.cpp.

                                                       {
    return m_content.get_count() > 1;
}

void embeddedcue_metadata_manager::query_track_offsets	(	unsigned	p_track,
		double &	p_begin,
		double &	p_length
	)		const

Definition at line 328 of file cue_parser_embedding.cpp.

                                                                                                                {
    const track_record * rec = m_content.query_ptr(p_track);
    if (rec == NULL) throw exception_io_data();
    p_begin = rec->m_index_list.start();
    p_length = rec->m_info.get_length();
}

unsigned embeddedcue_metadata_manager::remap_trackno

(

unsigned

p_index

)

const

Definition at line 359 of file cue_parser_embedding.cpp.

                                                                           {
    if (have_cuesheet()) {
        __remap_trackno_enumerator wrapper(p_index);
        m_content.enumerate(wrapper);
        return wrapper.result();
    } else {
        return 0;
    }   
}

void embeddedcue_metadata_manager::set_tag

(

file_info const &

p_info

)

Definition at line 233 of file cue_parser_embedding.cpp.

                                                                   {
    m_content.remove_all();
    
    {
        track_record & track0 = m_content.find_or_add((unsigned)0);
        track0.m_info.from_info(p_info);
        track0.m_info.m_info.set("cue_embedded","no");
    }
    
    

    const char * cuesheet = p_info.meta_get("cuesheet",0);
    if (cuesheet == NULL) {
        return;
    }

    //processing order
    //1. cuesheet content
    //2. overwrite with global metadata from the tag
    //3. overwrite with local metadata from the tag

    {
        cue_creator::t_entry_list entries;
        try {
            cue_parser::parse_full(cuesheet,entries);
        } catch(exception_io_data const & e) {
            console::complain("Attempting to embed an invalid cuesheet", e.what());
            return;
        }

        {
            const double length = p_info.get_length();
            for(cue_creator::t_entry_list::const_iterator iter = entries.first(); iter.is_valid(); ++iter ) {
                if (iter->m_index_list.start() > length) {
                    console::info("Invalid cuesheet - index outside allowed range");
                    return;
                }
            }
        }

        for(cue_creator::t_entry_list::const_iterator iter = entries.first(); iter.is_valid(); ) {
            cue_creator::t_entry_list::const_iterator next = iter;
            ++next;
            track_record & entry = m_content.find_or_add(iter->m_track_number);
            entry.m_file = iter->m_file;
            entry.m_flags = iter->m_flags;
            entry.m_index_list = iter->m_index_list;
            entry.m_info.from_info(iter->m_infos);
            entry.m_info.from_info_overwrite_info(p_info);
            entry.m_info.m_info.set("cue_embedded","yes");
            double begin = entry.m_index_list.start(), end = next.is_valid() ? next->m_index_list.start() : p_info.get_length();
            if (end <= begin) throw exception_io_data();
            entry.m_info.set_length(end - begin);
            iter = next;
        }
    }
    
    for(t_size metawalk = 0, metacount = p_info.meta_get_count(); metawalk < metacount; ++metawalk) {
        const char * name = p_info.meta_enum_name(metawalk);
        const t_size valuecount = p_info.meta_enum_value_count(metawalk);
        if (valuecount > 0 && !is_reserved_meta_entry(name) && is_global_meta_entry(name)) {
            __set_tag_global_field_relay relay(p_info,metawalk);
            m_content.enumerate(relay);
        }
    }

    {
        pfc::string8_fastalloc namebuffer;
        for(t_size metawalk = 0, metacount = p_info.meta_get_count(); metawalk < metacount; ++metawalk) {
            const char * name = p_info.meta_enum_name(metawalk);
            const t_size valuecount = p_info.meta_enum_value_count(metawalk);
            unsigned trackno;
            if (valuecount > 0 && !is_reserved_meta_entry(name) && resolve_cue_meta_name(name,namebuffer,trackno)) {
                track_record * rec = m_content.query_ptr(trackno);
                if (rec != NULL) {
                    rec->m_info.transfer_meta_entry(namebuffer,p_info,metawalk);
                }
            }
        }
    }
}

void embeddedcue_metadata_manager::set_track_info	(	unsigned	p_track,
		file_info const &	p_info
	)

Definition at line 321 of file cue_parser_embedding.cpp.

                                                                                           {
    track_record * rec = m_content.query_ptr(p_track);
    if (rec == NULL) throw exception_io_data();
    rec->m_info.from_info_set_meta(p_info);
    rec->m_info.set_replaygain(p_info.get_replaygain());
}

Field Documentation

track_record_list cue_parser::embeddedcue_metadata_manager::m_content

private

Definition at line 188 of file cue_parser.h.

---

The documentation for this class was generated from the following files:

• foobar2000/helpers/cue_parser.h
• foobar2000/helpers/cue_parser_embedding.cpp

---

Generated by   1.8.9.1