file_info

#include <file_info.h>

Inheritance diagram for file_info:

Public Types
typedef pfc::string::comparatorCaseInsensitiveASCII	field_name_comparator

Public Member Functions
t_size	__info_add_unsafe (const char *p_name, const char *p_value)
t_size	__info_add_unsafe_ex (const char *p_name, t_size p_name_length, const char *p_value, t_size p_value_length)
t_size	__meta_add_unsafe (const char *p_name, const char *p_value)
t_size	__meta_add_unsafe_ex (const char *p_name, t_size p_name_length, const char *p_value, t_size p_value_length)
void	_add_tag (const file_info &otherTag)
void	_copy_meta_single_nocheck (const file_info &p_source, t_size p_index)
void	_set_tag (const file_info &tag)
bool	are_meta_fields_identical (t_size p_index1, t_size p_index2) const
audio_chunk::spec_t	audio_chunk_spec () const
virtual void	copy (const file_info &p_source)
virtual void	copy_info (const file_info &p_source)
void	copy_info_single (const file_info &p_source, t_size p_index)
void	copy_info_single_by_name (const file_info &p_source, const char *p_name)
void	copy_info_single_by_name_ex (const file_info &p_source, const char *p_name, t_size p_name_length)
virtual void	copy_meta (const file_info &p_source)
void	copy_meta_single (const file_info &p_source, t_size p_index)
void	copy_meta_single_by_name (const file_info &p_source, const char *p_name)
void	copy_meta_single_by_name_ex (const file_info &p_source, const char *p_name, t_size p_name_length)
void	copy_meta_single_rename (const file_info &p_source, t_size p_index, const char *p_new_name)
void	copy_meta_single_rename_ex (const file_info &p_source, t_size p_index, const char *p_new_name, t_size p_new_name_length)
void	from_mem (const void *memPtr, size_t memSize)
void	from_stream (stream_reader *stream, abort_callback &abort)
virtual double	get_length () const =0
virtual replaygain_info	get_replaygain () const =0
void	info_calculate_bitrate (t_filesize p_filesize, double p_length)
virtual const char *	info_enum_name (t_size p_index) const =0
virtual const char *	info_enum_value (t_size p_index) const =0
bool	info_exists (const char *p_name) const
bool	info_exists_ex (const char *p_name, t_size p_name_length) const
t_size	info_find (const char *p_name) const
virtual t_size	info_find_ex (const char *p_name, t_size p_name_length) const
const char *	info_get (const char *p_name) const
t_int64	info_get_bitrate () const
t_int64	info_get_bitrate_vbr () const
virtual t_size	info_get_count () const =0
unsigned	info_get_decoded_bps () const
const char *	info_get_ex (const char *p_name, t_size p_name_length) const
double	info_get_float (const char *name) const
t_int64	info_get_int (const char *name) const
t_int64	info_get_length_samples () const
uint32_t	info_get_wfx_chanMask () const
bool	info_remove (const char *p_name)
void	info_remove_all ()
bool	info_remove_ex (const char *p_name, t_size p_name_length)
void	info_remove_index (t_size p_index)
virtual void	info_remove_mask (const bit_array &p_mask)=0
t_size	info_set (const char *p_name, const char *p_value)
void	info_set_bitrate (t_int64 val)
void	info_set_bitrate_vbr (t_int64 val)
virtual t_size	info_set_ex (const char *p_name, t_size p_name_length, const char *p_value, t_size p_value_length)=0
void	info_set_float (const char *name, double value, unsigned precision, bool force_sign=false, const char *unit=0)
void	info_set_int (const char *name, t_int64 value)
bool	info_set_replaygain (const char *p_name, const char *p_value)
void	info_set_replaygain_album_gain (float value)
void	info_set_replaygain_album_peak (float value)
void	info_set_replaygain_auto (const char *p_name, const char *p_value)
void	info_set_replaygain_auto_ex (const char *p_name, t_size p_name_len, const char *p_value, t_size p_value_len)
bool	info_set_replaygain_ex (const char *p_name, t_size p_name_len, const char *p_value, t_size p_value_len)
void	info_set_replaygain_track_gain (float value)
void	info_set_replaygain_track_peak (float value)
void	info_set_wfx_chanMask (uint32_t val)
bool	is_encoding_lossy () const
void	merge_fallback (const file_info &fallback)
t_size	meta_add (const char *p_name, const char *p_value)
t_size	meta_add_ex (const char *p_name, t_size p_name_length, const char *p_value, t_size p_value_length)
void	meta_add_value (t_size p_index, const char *p_value)
void	meta_add_value_ex (t_size p_index, const char *p_value, t_size p_value_length)
t_size	meta_calc_total_value_count () const
virtual const char *	meta_enum_name (t_size p_index) const =0
virtual const char *	meta_enum_value (t_size p_index, t_size p_value_number) const =0
virtual t_size	meta_enum_value_count (t_size p_index) const =0
bool	meta_exists (const char *p_name) const
bool	meta_exists_ex (const char *p_name, t_size p_name_length) const
t_size	meta_find (const char *p_name) const
virtual t_size	meta_find_ex (const char *p_name, t_size p_name_length) const
bool	meta_format (const char *p_name, pfc::string_base &p_out, const char *separator=", ") const
void	meta_format_entry (t_size index, pfc::string_base &p_out, const char *separator=", ") const
const char *	meta_get (const char *p_name, t_size p_index) const
virtual t_size	meta_get_count () const =0
t_size	meta_get_count_by_name (const char *p_name) const
t_size	meta_get_count_by_name_ex (const char *p_name, t_size p_name_length) const
const char *	meta_get_ex (const char *p_name, t_size p_name_length, t_size p_index) const
void	meta_insert_value (t_size p_index, t_size p_value_index, const char *p_value)
virtual void	meta_insert_value_ex (t_size p_index, t_size p_value_index, const char *p_value, t_size p_value_length)=0
void	meta_modify_value (t_size p_index, t_size p_value_index, const char *p_value)
virtual void	meta_modify_value_ex (t_size p_index, t_size p_value_index, const char *p_value, t_size p_value_length)=0
void	meta_remove_all ()
void	meta_remove_field (const char *p_name)
void	meta_remove_field_ex (const char *p_name, t_size p_name_length)
void	meta_remove_index (t_size p_index)
virtual void	meta_remove_mask (const bit_array &p_mask)=0
void	meta_remove_value (t_size p_index, t_size p_value)
virtual void	meta_remove_values (t_size p_index, const bit_array &p_mask)=0
virtual void	meta_reorder (const t_size *p_order)=0
t_size	meta_set (const char *p_name, const char *p_value)
virtual t_size	meta_set_ex (const char *p_name, t_size p_name_length, const char *p_value, t_size p_value_length)=0
const file_info &	operator= (const file_info &p_source)
void	overwrite_info (const file_info &p_source)
void	overwrite_meta (const file_info &p_source)
void	reset ()
void	reset_replaygain ()
virtual void	set_length (double p_length)=0
virtual void	set_replaygain (const replaygain_info &p_info)=0
void	to_console () const
void	to_formatter (pfc::string_formatter &) const
void	to_stream (stream_writer *stream, abort_callback &abort) const

Static Public Member Functions
static bool	field_is_person (const char *fieldName)
static bool	field_is_title (const char *fieldName)
static bool	field_name_equals (const char *n1, const char *n2)
static bool	g_is_info_equal (const file_info &p_item1, const file_info &p_item2)
static bool	g_is_meta_equal (const file_info &p_item1, const file_info &p_item2)
static bool	g_is_meta_equal_debug (const file_info &p_item1, const file_info &p_item2)
static bool	g_is_valid_field_name (const char *p_name, t_size p_length=pfc_infinite)

Protected Member Functions
	file_info ()
	~file_info ()
void	copy_info_single_by_name_nocheck (const file_info &p_source, const char *p_name)
void	copy_info_single_by_name_nocheck_ex (const file_info &p_source, const char *p_name, t_size p_name_length)
void	copy_info_single_nocheck (const file_info &p_source, t_size p_index)
void	copy_meta_single_by_name_nocheck (const file_info &p_source, const char *p_name)
void	copy_meta_single_by_name_nocheck_ex (const file_info &p_source, const char *p_name, t_size p_name_length)
void	copy_meta_single_nocheck (const file_info &p_source, t_size p_index)
t_size	info_set_nocheck (const char *p_name, const char *p_value)
virtual t_size	info_set_nocheck_ex (const char *p_name, t_size p_name_length, const char *p_value, t_size p_value_length)=0
t_size	meta_set_nocheck (const char *p_name, const char *p_value)
virtual t_size	meta_set_nocheck_ex (const char *p_name, t_size p_name_length, const char *p_value, t_size p_value_length)=0

Private Member Functions
void	merge (const pfc::list_base_const_t< const file_info * > &p_sources)

Detailed Description

Main interface class for information about some playable object.

Definition at line 73 of file file_info.h.

Member Typedef Documentation

typedef pfc::string::comparatorCaseInsensitiveASCII file_info::field_name_comparator

Definition at line 249 of file file_info.h.

Constructor & Destructor Documentation

file_info::file_info ( )

inlineprotected

Definition at line 266 of file file_info.h.

{}

file_info::~file_info ( )

inlineprotected

Definition at line 267 of file file_info.h.

{}

Member Function Documentation

t_size file_info::__info_add_unsafe ( const char *  p_name, const char *  p_value  )

inline

Unsafe - does not check whether the field already exists and will result in duplicates if it does - call only when appropriate checks have been applied externally.

Definition at line 243 of file file_info.h.

{return info_set_nocheck_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

t_size file_info::__info_add_unsafe_ex ( const char *  p_name, t_size  p_name_length, const char *  p_value, t_size  p_value_length  )

inline

Unsafe - does not check whether the field already exists and will result in duplicates if it does - call only when appropriate checks have been applied externally.

Definition at line 241 of file file_info.h.

{return info_set_nocheck_ex(p_name,p_name_length,p_value,p_value_length);}

t_size file_info::__meta_add_unsafe ( const char *  p_name, const char *  p_value  )

inline

Unsafe - does not check whether the field already exists and will result in duplicates if it does - call only when appropriate checks have been applied externally.

Definition at line 238 of file file_info.h.

{return meta_set_nocheck_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

t_size file_info::__meta_add_unsafe_ex ( const char *  p_name, t_size  p_name_length, const char *  p_value, t_size  p_value_length  )

inline

Unsafe - does not check whether the field already exists and will result in duplicates if it does - call only when appropriate checks have been applied externally.

Definition at line 236 of file file_info.h.

{return meta_set_nocheck_ex(p_name,p_name_length,p_value,p_value_length);}

void file_info::_add_tag

(

const file_info &

otherTag

)

Definition at line 158 of file file_info_merge.cpp.

                                                   {
    this->set_replaygain( replaygain_info::g_merge( this->get_replaygain(), otherTag.get_replaygain() ) );

    const char * tt1 = this->info_get(_tagtype);
    const char * tt2 = otherTag.info_get(_tagtype);
    if (tt2) {
        if (tt1) {
            this->info_set(_tagtype, PFC_string_formatter() << tt1 << "|" << tt2);
        } else {
            this->info_set(_tagtype, tt2);
        }
    }

}

void file_info::_copy_meta_single_nocheck ( const file_info &  p_source, t_size  p_index  )

inline

Definition at line 245 of file file_info.h.

{copy_meta_single_nocheck(p_source, p_index);}

void file_info::_set_tag

(

const file_info &

tag

)

Definition at line 151 of file file_info_merge.cpp.

                                              {
    this->copy_meta(tag);
    this->set_replaygain( replaygain_info::g_merge( this->get_replaygain(), tag.get_replaygain() ) );
    const char * tt = tag.info_get(_tagtype);
    if (tt) this->info_set(_tagtype, tt);
}

bool file_info::are_meta_fields_identical	(	t_size	p_index1,
		t_size	p_index2
	)		const

Definition at line 363 of file file_info.cpp.

{
    const t_size count = meta_enum_value_count(p_index1);
    if (count != meta_enum_value_count(p_index2)) return false;
    t_size n;
    for(n=0;n<count;n++)
    {
        if (strcmp(meta_enum_value(p_index1,n),meta_enum_value(p_index2,n))) return false;
    }
    return true;
}

audio_chunk::spec_t file_info::audio_chunk_spec

(

)

const

Returns ESTIMATED audio chunk spec from what has been put in the file_info.
Provided for convenience. Do not rely on it for processing decoded data.

Definition at line 715 of file file_info.cpp.

{
    audio_chunk::spec_t rv = {};
    rv.sampleRate = (uint32_t)this->info_get_int("samplerate");
    rv.chanCount = (uint32_t)this->info_get_int("channels");
    rv.chanMask = (uint32_t)this->info_get_wfx_chanMask();
    if (audio_chunk::g_count_channels( rv.chanMask ) != rv.chanCount ) {
        rv.chanMask = audio_chunk::g_guess_channel_config( rv.chanCount );
    }
    return rv;
}

void file_info::copy ( const file_info &  p_source )

virtual

Copies entire file_info contents from specified file_info object.

Reimplemented in file_info_const_impl.

Definition at line 166 of file file_info.cpp.

{
    if (&p_source != this) {
        copy_meta(p_source);
        copy_info(p_source);
        set_length(p_source.get_length());
        set_replaygain(p_source.get_replaygain());
    }
}

void file_info::copy_info ( const file_info &  p_source )

virtual

Copies technical info from specified file_info object.

Reimplemented in file_info_impl.

Definition at line 156 of file file_info.cpp.

{
    if (&p_source != this) {
        info_remove_all();
        t_size n, m = p_source.info_get_count();
        for(n=0;n<m;n++)
            copy_info_single_nocheck(p_source,n);
    }
}

void file_info::copy_info_single	(	const file_info &	p_source,
		t_size	p_index
	)

Definition at line 136 of file file_info.cpp.

{
    info_set(p_source.info_enum_name(p_index),p_source.info_enum_value(p_index));
}

void file_info::copy_info_single_by_name ( const file_info &  p_source, const char *  p_name  )

inline

Definition at line 185 of file file_info.h.

{copy_info_single_by_name_ex(p_source,p_name,pfc_infinite);}

void file_info::copy_info_single_by_name_ex	(	const file_info &	p_source,
		const char *	p_name,
		t_size	p_name_length
	)

Definition at line 118 of file file_info.cpp.

{
    t_size index = p_source.info_find_ex(p_name,p_name_length);
    if (index != pfc_infinite) copy_info_single(p_source,index);
}

void file_info::copy_info_single_by_name_nocheck ( const file_info &  p_source, const char *  p_name  )

inlineprotected

Definition at line 273 of file file_info.h.

{copy_info_single_by_name_nocheck_ex(p_source,p_name,pfc_infinite);}

void file_info::copy_info_single_by_name_nocheck_ex ( const file_info &  p_source, const char *  p_name, t_size  p_name_length  )

protected

Definition at line 130 of file file_info.cpp.

{
    t_size index = p_source.info_find_ex(p_name,p_name_length);
    if (index != pfc_infinite) copy_info_single_nocheck(p_source,index);
}

void file_info::copy_info_single_nocheck ( const file_info &  p_source, t_size  p_index  )

protected

Definition at line 141 of file file_info.cpp.

{
    info_set_nocheck(p_source.info_enum_name(p_index),p_source.info_enum_value(p_index));
}

void file_info::copy_meta ( const file_info &  p_source )

virtual

Copies metadata from specified file_info object.

Reimplemented in file_info_impl.

Definition at line 146 of file file_info.cpp.

{
    if (&p_source != this) {
        meta_remove_all();
        t_size n, m = p_source.meta_get_count();
        for(n=0;n<m;n++)
            copy_meta_single_nocheck(p_source,n);
    }
}

void file_info::copy_meta_single	(	const file_info &	p_source,
		t_size	p_index
	)

Definition at line 94 of file file_info.cpp.

{
    copy_meta_single_rename(p_source,p_index,p_source.meta_enum_name(p_index));
}

void file_info::copy_meta_single_by_name ( const file_info &  p_source, const char *  p_name  )

inline

Definition at line 184 of file file_info.h.

{copy_meta_single_by_name_ex(p_source,p_name,pfc_infinite);}

void file_info::copy_meta_single_by_name_ex	(	const file_info &	p_source,
		const char *	p_name,
		t_size	p_name_length
	)

Definition at line 112 of file file_info.cpp.

{
    t_size index = p_source.meta_find_ex(p_name,p_name_length);
    if (index != pfc_infinite) copy_meta_single(p_source,index);
}

void file_info::copy_meta_single_by_name_nocheck ( const file_info &  p_source, const char *  p_name  )

inlineprotected

Definition at line 272 of file file_info.h.

{copy_meta_single_by_name_nocheck_ex(p_source,p_name,pfc_infinite);}

void file_info::copy_meta_single_by_name_nocheck_ex ( const file_info &  p_source, const char *  p_name, t_size  p_name_length  )

protected

Definition at line 124 of file file_info.cpp.

{
    t_size index = p_source.meta_find_ex(p_name,p_name_length);
    if (index != pfc_infinite) copy_meta_single_nocheck(p_source,index);
}

void file_info::copy_meta_single_nocheck ( const file_info &  p_source, t_size  p_index  )

protected

Definition at line 99 of file file_info.cpp.

{
    const char * name = p_source.meta_enum_name(p_index);
    t_size n, m = p_source.meta_enum_value_count(p_index);
    t_size new_index = pfc_infinite;
    for(n=0;n<m;n++)
    {
        const char * value = p_source.meta_enum_value(p_index,n);
        if (n == 0) new_index = meta_set_nocheck(name,value);
        else meta_add_value(new_index,value);
    }
}

void file_info::copy_meta_single_rename ( const file_info &  p_source, t_size  p_index, const char *  p_new_name  )

inline

Definition at line 189 of file file_info.h.

{copy_meta_single_rename_ex(p_source,p_index,p_new_name,pfc_infinite);}

void file_info::copy_meta_single_rename_ex	(	const file_info &	p_source,
		t_size	p_index,
		const char *	p_new_name,
		t_size	p_new_name_length
	)

Definition at line 302 of file file_info.cpp.

{
    t_size n, m = p_source.meta_enum_value_count(p_index);
    t_size new_index = pfc_infinite;
    for(n=0;n<m;n++)
    {
        const char * value = p_source.meta_enum_value(p_index,n);
        if (n == 0) new_index = meta_set_ex(p_new_name,p_new_name_length,value,pfc_infinite);
        else meta_add_value(new_index,value);
    }
}

bool file_info::field_is_person ( const char *  fieldName )

static

Definition at line 553 of file file_info.cpp.

                                                      {
    return field_name_equals(fieldName, "artist") ||
        field_name_equals(fieldName, "album artist") || 
        field_name_equals(fieldName, "composer") || 
        field_name_equals(fieldName, "performer") ||
        field_name_equals(fieldName, "conductor") ||
        field_name_equals(fieldName, "orchestra") ||
        field_name_equals(fieldName, "ensemble") ||
        field_name_equals(fieldName, "engineer");
}

bool file_info::field_is_title ( const char *  fieldName )

static

Definition at line 564 of file file_info.cpp.

                                                     {
    return field_name_equals(fieldName, "title") || field_name_equals(fieldName, "album");
}

static bool file_info::field_name_equals ( const char *  n1, const char *  n2  )

inlinestatic

Definition at line 251 of file file_info.h.

{return field_name_comparator::compare(n1, n2) == 0;}

void file_info::from_mem	(	const void *	memPtr,
		size_t	memSize
	)

Definition at line 672 of file file_info.cpp.

                                                              {
    size_t remaining = memSize;
    const uint8_t * walk = (const uint8_t*) memPtr;

    {
        double len; _readFloat(len, walk, remaining);
        this->set_length( len );
    }

    {
        replaygain_info rg;
        _readFloat(rg.m_track_gain, walk, remaining ); 
        _readFloat(rg.m_album_gain, walk, remaining );
        _readFloat(rg.m_track_peak, walk, remaining );
        _readFloat(rg.m_album_peak, walk, remaining );
        this->set_replaygain( rg );
    }

    {
        this->meta_remove_all();
        for(;;) {
            const char * metaName = _readString( walk, remaining );
            if (*metaName == 0) break;
            size_t metaIndex = pfc_infinite;
            for(;;) {
                const char * metaValue = _readString( walk, remaining );
                if (*metaValue == 0) break;
                if (metaIndex == pfc_infinite) metaIndex = this->meta_add( metaName, metaValue );
                else this->meta_add_value( metaIndex, metaName );
            }
        }
    }
    {
        this->info_remove_all();
        for(;;) {
            const char * infoName = _readString( walk, remaining );
            if (*infoName == 0) break;
            const char * infoValue = _readString( walk, remaining );
            this->info_set( infoName, infoValue );
        }
    }
}

void file_info::from_stream	(	stream_reader *	stream,
		abort_callback &	abort
	)

Definition at line 612 of file file_info.cpp.

                                                                            {
    stream_reader_formatter<> in( *stream, abort );
    pfc::string_formatter tempName, tempValue;
    {
        double len; in >> len; this->set_length( len );
    }
    {
        replaygain_info rg;
        in >> rg.m_track_gain >> rg.m_album_gain >> rg.m_track_peak >> rg.m_album_peak;
    }

    {
        this->meta_remove_all();
        for(;;) {
            in.read_string_nullterm( tempName );
            if (tempName.length() == 0) break;
            size_t metaIndex = pfc_infinite;
            for(;;) {
                in.read_string_nullterm( tempValue );
                if (tempValue.length() == 0) break;
                if (metaIndex == pfc_infinite) metaIndex = this->meta_add( tempName, tempValue );
                else this->meta_add_value( metaIndex, tempValue );
            }
        }
    }
    {
        this->info_remove_all();
        for(;;) {
            in.read_string_nullterm( tempName );
            if (tempName.length() == 0) break;
            in.read_string_nullterm( tempValue );
            this->info_set( tempName, tempValue );
        }
    }
}

bool file_info::g_is_info_equal ( const file_info &  p_item1, const file_info &  p_item2  )

static

Definition at line 474 of file file_info.cpp.

                                                                                   {
    t_size count = p_item1.info_get_count();
    if (count != p_item2.info_get_count()) {
        //uDebugLog() << "info count mismatch";
        return false;
    }
    for(t_size n1=0; n1<count; n1++) {
        t_size n2 = p_item2.info_find(p_item1.info_enum_name(n1));
        if (n2 == pfc_infinite) {
            //uDebugLog() << "item2 does not have " << p_item1.info_enum_name(n1);
            return false;
        }
        if (strcmp(p_item1.info_enum_value(n1),p_item2.info_enum_value(n2)) != 0) {
            //uDebugLog() << "value mismatch: " << p_item1.info_enum_name(n1);
            return false;
        }
    }
    return true;
}

bool file_info::g_is_meta_equal ( const file_info &  p_item1, const file_info &  p_item2  )

static

Definition at line 412 of file file_info.cpp.

                                                                                   {
    const t_size count = p_item1.meta_get_count();
    if (count != p_item2.meta_get_count()) {
        //uDebugLog() << "meta count mismatch";
        return false;
    }
    pfc::map_t<const char*,t_size,field_name_comparator> item2_meta_map;
    for(t_size n=0; n<count; n++) {
        item2_meta_map.set(p_item2.meta_enum_name(n),n);
    }
    for(t_size n1=0; n1<count; n1++) {
        t_size n2;
        if (!item2_meta_map.query(p_item1.meta_enum_name(n1),n2)) {
            //uDebugLog() << "item2 doesn't have " << p_item1.meta_enum_name(n1);
            return false;
        }
        t_size value_count = p_item1.meta_enum_value_count(n1);
        if (value_count != p_item2.meta_enum_value_count(n2)) {
            //uDebugLog() << "meta value count mismatch: " << p_item1.meta_enum_name(n1) << " : " << value_count << " vs " << p_item2.meta_enum_value_count(n2);
            return false;
        }
        for(t_size v = 0; v < value_count; v++) {
            if (strcmp(p_item1.meta_enum_value(n1,v),p_item2.meta_enum_value(n2,v)) != 0) {
                //uDebugLog() << "meta mismatch: " << p_item1.meta_enum_name(n1) << " : " << p_item1.meta_enum_value(n1,v) << " vs " << p_item2.meta_enum_value(n2,v);
                return false;
            }
        }
    }
    return true;
}

bool file_info::g_is_meta_equal_debug ( const file_info &  p_item1, const file_info &  p_item2  )

static

Definition at line 443 of file file_info.cpp.

                                                                                         {
    const t_size count = p_item1.meta_get_count();
    if (count != p_item2.meta_get_count()) {
        FB2K_DebugLog() << "meta count mismatch";
        return false;
    }
    pfc::map_t<const char*,t_size,field_name_comparator> item2_meta_map;
    for(t_size n=0; n<count; n++) {
        item2_meta_map.set(p_item2.meta_enum_name(n),n);
    }
    for(t_size n1=0; n1<count; n1++) {
        t_size n2;
        if (!item2_meta_map.query(p_item1.meta_enum_name(n1),n2)) {
            FB2K_DebugLog() << "item2 doesn't have " << p_item1.meta_enum_name(n1);
            return false;
        }
        t_size value_count = p_item1.meta_enum_value_count(n1);
        if (value_count != p_item2.meta_enum_value_count(n2)) {
            FB2K_DebugLog() << "meta value count mismatch: " << p_item1.meta_enum_name(n1) << " : " << (uint32_t)value_count << " vs " << (uint32_t)p_item2.meta_enum_value_count(n2);
            return false;
        }
        for(t_size v = 0; v < value_count; v++) {
            if (strcmp(p_item1.meta_enum_value(n1,v),p_item2.meta_enum_value(n2,v)) != 0) {
                FB2K_DebugLog() << "meta mismatch: " << p_item1.meta_enum_name(n1) << " : " << p_item1.meta_enum_value(n1,v) << " vs " << p_item2.meta_enum_value(n2,v);
                return false;
            }
        }
    }
    return true;
}

bool file_info::g_is_valid_field_name ( const char *  p_name, t_size  p_length = pfc_infinite  )

static

Definition at line 498 of file file_info.cpp.

                                                                         {
    t_size walk;
    for(walk = 0; walk < p_length && p_name[walk] != 0; walk++) {
        if (!is_valid_field_name_char(p_name[walk])) return false;
    }
    return walk > 0;
}

virtual double file_info::get_length ( ) const

pure virtual

Retrieves audio duration, in seconds.
Note that the reported duration should not be assumed to be the exact length of the track -
with many popular audio formats, exact duration is impossible to determine without performing a full decode pass;
with other formats, the decoded data may be shorter than reported due to truncation other damage.

Implemented in file_info_impl, and file_info_const_impl.

virtual replaygain_info file_info::get_replaygain ( ) const

pure virtual

Retrieves ReplayGain information.

Implemented in file_info_impl, and file_info_const_impl.

void file_info::info_calculate_bitrate	(	t_filesize	p_filesize,
		double	p_length
	)

Definition at line 395 of file file_info.cpp.

{
    if (p_filesize > 0 && p_length > 0) info_set_bitrate((unsigned)floor((double)p_filesize * 8 / (p_length * 1000) + 0.5));
}

virtual const char* file_info::info_enum_name ( t_size  p_index ) const

pure virtual

Retrieves the name of specified technical info entry. Return value is a null-terminated UTF-8 encoded string.

Implemented in file_info_impl, and file_info_const_impl.

virtual const char* file_info::info_enum_value ( t_size  p_index ) const

pure virtual

Retrieves the value of specified technical info entry. Return value is a null-terminated UTF-8 encoded string.

Implemented in file_info_impl, and file_info_const_impl.

bool file_info::info_exists ( const char *  p_name ) const

inline

Definition at line 169 of file file_info.h.

{return info_exists_ex(p_name,pfc_infinite);}

bool file_info::info_exists_ex	(	const char *	p_name,
		t_size	p_name_length
	)		const

Definition at line 61 of file file_info.cpp.

{
    return info_find_ex(p_name,p_name_length) != pfc_infinite;
}

t_size file_info::info_find ( const char *  p_name ) const

inline

Definition at line 168 of file file_info.h.

{return info_find_ex(p_name,pfc_infinite);}

t_size file_info::info_find_ex ( const char *  p_name, t_size  p_name_length  ) const

virtual

Finds technical info entry of specified name. Returns index of found entry on success, infinite on failure.

Definition at line 52 of file file_info.cpp.

{
    t_size n, m = info_get_count();
    for(n=0;n<m;n++) {
        if (pfc::stricmp_ascii_ex(info_enum_name(n),pfc_infinite,p_name,p_name_length) == 0) return n;
    }
    return pfc_infinite;
}

const char* file_info::info_get ( const char *  p_name ) const

inline

Definition at line 171 of file file_info.h.

{return info_get_ex(p_name,pfc_infinite);}

t_int64 file_info::info_get_bitrate ( ) const

inline

Definition at line 205 of file file_info.h.

{return info_get_int("bitrate");}

t_int64 file_info::info_get_bitrate_vbr ( ) const

inline

Definition at line 203 of file file_info.h.

{return info_get_int("bitrate_dynamic");}

virtual t_size file_info::info_get_count ( ) const

pure virtual

Retrieves number of technical info entries.

Implemented in file_info_impl, and file_info_const_impl.

unsigned file_info::info_get_decoded_bps

(

)

const

Definition at line 277 of file file_info.cpp.

{
    t_int64 val = info_get_int("decoded_bitspersample");
    if (is_valid_bps(val)) return (unsigned)val;
    val = info_get_int("bitspersample");
    if (is_valid_bps(val)) return (unsigned)val;
    return 0;

}

const char * file_info::info_get_ex	(	const char *	p_name,
		t_size	p_name_length
	)		const

Definition at line 186 of file file_info.cpp.

{
    t_size index = info_find_ex(p_name,p_name_length);
    if (index == pfc_infinite) return 0;
    return info_enum_value(index);
}

double file_info::info_get_float

(

const char *

name

)

const

Definition at line 214 of file file_info.cpp.

{
    const char * ptr = info_get(name);
    if (ptr) return pfc::string_to_float(ptr);
    else return 0;
}

t_int64 file_info::info_get_int

(

const char *

name

)

const

Definition at line 193 of file file_info.cpp.

{
    PFC_ASSERT(pfc::is_valid_utf8(name));
    const char * val = info_get(name);
    if (val==0) return 0;
    return _atoi64(val);
}

t_int64 file_info::info_get_length_samples

(

)

const

Definition at line 201 of file file_info.cpp.

{
    t_int64 ret = 0;
    double len = get_length();
    t_int64 srate = info_get_int("samplerate");

    if (srate>0 && len>0)
    {
        ret = audio_math::time_to_samples(len,(unsigned)srate);
    }
    return ret;
}

uint32_t file_info::info_get_wfx_chanMask

(

)

const

Definition at line 544 of file file_info.cpp.

                                                {
    const char * str = this->info_get("WAVEFORMATEXTENSIBLE_CHANNEL_MASK");
    if (str == NULL) return 0;
    if (pfc::strcmp_partial( str, "0x") != 0) return 0;
    try {
        return pfc::atohex<uint32_t>( str + 2, strlen(str+2) );
    } catch(...) { return 0;}
}

bool file_info::info_remove ( const char *  p_name )

inline

Definition at line 170 of file file_info.h.

{return info_remove_ex(p_name,pfc_infinite);}

void file_info::info_remove_all

(

)

Definition at line 71 of file file_info.cpp.

{
    info_remove_mask(bit_array_true());
}

bool file_info::info_remove_ex	(	const char *	p_name,
		t_size	p_name_length
	)

Definition at line 76 of file file_info.cpp.

{
    t_size index = info_find_ex(p_name,p_name_length);
    if (index != pfc_infinite)
    {
        info_remove_index(index);
        return true;
    }
    else return false;
}

void file_info::info_remove_index

(

t_size

p_index

)

Definition at line 66 of file file_info.cpp.

{
    info_remove_mask(bit_array_one(p_index));
}

virtual void file_info::info_remove_mask ( const bit_array &  p_mask )

pure virtual

Removes technical info entries indicated by specified bit mask.

Implemented in file_info_impl, and file_info_const_impl.

t_size file_info::info_set ( const char *  p_name, const char *  p_value  )

inline

Definition at line 167 of file file_info.h.

{return info_set_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

void file_info::info_set_bitrate ( t_int64  val )

inline

Definition at line 206 of file file_info.h.

{info_set_int("bitrate",val);}

void file_info::info_set_bitrate_vbr ( t_int64  val )

inline

Definition at line 204 of file file_info.h.

{info_set_int("bitrate_dynamic",val);}

virtual t_size file_info::info_set_ex ( const char *  p_name, t_size  p_name_length, const char *  p_value, t_size  p_value_length  )

pure virtual

Creates a new technical info entry with specified name and specified value. If an entry of the same name already exists, it is erased. Return value is the index of newly created entry.

Implemented in file_info_impl, and file_info_const_impl.

void file_info::info_set_float	(	const char *	name,
		double	value,
		unsigned	precision,
		bool	force_sign = false,
		const char *	unit = 0
	)

Definition at line 227 of file file_info.cpp.

{
    PFC_ASSERT(pfc::is_valid_utf8(name));
    PFC_ASSERT(unit==0 || strlen(unit) <= 64);
    char temp[128];
    pfc::float_to_string(temp,64,value,precision,force_sign);
    temp[63] = 0;
    if (unit)
    {
        strcat_s(temp," ");
        strcat_s(temp,unit);
    }
    info_set(name,temp);
}

void file_info::info_set_int	(	const char *	name,
		t_int64	value
	)

Definition at line 221 of file file_info.cpp.

{
    PFC_ASSERT(pfc::is_valid_utf8(name));
    info_set(name,pfc::format_int(value));
}

t_size file_info::info_set_nocheck ( const char *  p_name, const char *  p_value  )

inlineprotected

Definition at line 278 of file file_info.h.

{return info_set_nocheck_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

virtual t_size file_info::info_set_nocheck_ex ( const char *  p_name, t_size  p_name_length, const char *  p_value, t_size  p_value_length  )

protectedpure virtual

Implemented in file_info_impl, and file_info_const_impl.

bool file_info::info_set_replaygain ( const char *  p_name, const char *  p_value  )

inline

Definition at line 174 of file file_info.h.

{return info_set_replaygain_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

void file_info::info_set_replaygain_album_gain

(

float

value

)

Definition at line 243 of file file_info.cpp.

{
    replaygain_info temp = get_replaygain();
    temp.m_album_gain = value;
    set_replaygain(temp);
}

void file_info::info_set_replaygain_album_peak

(

float

value

)

Definition at line 250 of file file_info.cpp.

{
    replaygain_info temp = get_replaygain();
    temp.m_album_peak = value;
    set_replaygain(temp);
}

void file_info::info_set_replaygain_auto ( const char *  p_name, const char *  p_value  )

inline

Definition at line 176 of file file_info.h.

{info_set_replaygain_auto_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

void file_info::info_set_replaygain_auto_ex	(	const char *	p_name,
		t_size	p_name_len,
		const char *	p_value,
		t_size	p_value_len
	)

Definition at line 349 of file file_info.cpp.

{
    if (!info_set_replaygain_ex(p_name,p_name_len,p_value,p_value_len))
        info_set_ex(p_name,p_name_len,p_value,p_value_len);
}

bool file_info::info_set_replaygain_ex	(	const char *	p_name,
		t_size	p_name_len,
		const char *	p_value,
		t_size	p_value_len
	)

Definition at line 338 of file file_info.cpp.

{
    replaygain_info temp = get_replaygain();
    if (temp.set_from_meta_ex(p_name,p_name_len,p_value,p_value_len))
    {
        set_replaygain(temp);
        return true;
    }
    else return false;
}

void file_info::info_set_replaygain_track_gain

(

float

value

)

Definition at line 257 of file file_info.cpp.

{
    replaygain_info temp = get_replaygain();
    temp.m_track_gain = value;
    set_replaygain(temp);
}

void file_info::info_set_replaygain_track_peak

(

float

value

)

Definition at line 264 of file file_info.cpp.

{
    replaygain_info temp = get_replaygain();
    temp.m_track_peak = value;
    set_replaygain(temp);
}

void file_info::info_set_wfx_chanMask

(

uint32_t

val

)

Definition at line 532 of file file_info.cpp.

                                                  {
    switch(val) {
    case 0:
    case 4:
    case 3:
        break;
    default:
        info_set ("WAVEFORMATEXTENSIBLE_CHANNEL_MASK", PFC_string_formatter() << "0x" << pfc::format_hex(val) );
        break;
    }
}

bool file_info::is_encoding_lossy

(

)

const

Definition at line 400 of file file_info.cpp.

                                        {
    const char * encoding = info_get("encoding");
    if (encoding != NULL) {
        if (pfc::stricmp_ascii(encoding,"lossy") == 0 /*|| pfc::stricmp_ascii(encoding,"hybrid") == 0*/) return true;
    } else {
        //the old way
        //disabled: don't whine if we're not sure what we're dealing with - might be a file with info not-yet-loaded in oddball cases or a mod file
        //if (info_get("bitspersample") == NULL) return true;
    }
    return false;
}

void file_info::merge ( const pfc::list_base_const_t< const file_info * > &  p_sources )

private

Definition at line 74 of file file_info_merge.cpp.

{
    t_size in_count = p_in.get_count();
    if (in_count == 0)
    {
        meta_remove_all();
        return;
    }
    else if (in_count == 1)
    {
        const file_info * info = p_in[0];

        copy_meta(*info);

        set_replaygain(replaygain_info::g_merge(get_replaygain(),info->get_replaygain()));

        overwrite_info(*info);

        //copy_info_single_by_name(*info,"tagtype");
        
        return;
    }
    
    merge_meta(*this,p_in);

    {
        pfc::string8_fastalloc tagtype;
        replaygain_info rg = get_replaygain();
        t_size in_ptr;
        for(in_ptr = 0; in_ptr < in_count; in_ptr++ )
        {
            const file_info * info = p_in[in_ptr];
            rg = replaygain_info::g_merge(rg, info->get_replaygain());
            t_size field_ptr, field_max = info->info_get_count();
            for(field_ptr = 0; field_ptr < field_max; field_ptr++ )
            {
                const char * field_name = info->info_enum_name(field_ptr), * field_value = info->info_enum_value(field_ptr);
                if (*field_value)
                {
                    if (!pfc::stricmp_ascii(field_name,"tagtype"))
                    {
                        if (!tagtype.is_empty()) tagtype += "|";
                        tagtype += field_value;
                    }
                }
            }
        }
        if (!tagtype.is_empty()) info_set("tagtype",tagtype);
        set_replaygain(rg);
    }
}

void file_info::merge_fallback

(

const file_info &

fallback

)

Definition at line 134 of file file_info_merge.cpp.

                                                       {
    set_replaygain( replaygain_info::g_merge(get_replaygain(), source.get_replaygain() ) );
    if (get_length() <= 0) set_length(source.get_length());
    t_size count = source.info_get_count();
    for(t_size infoWalk = 0; infoWalk < count; ++infoWalk) {
        const char * name = source.info_enum_name(infoWalk);
        if (!info_exists(name)) __info_add_unsafe(name, source.info_enum_value(infoWalk));
    }
    count = source.meta_get_count();
    for(t_size metaWalk = 0; metaWalk < count; ++metaWalk) {
        const char * name = source.meta_enum_name(metaWalk);
        if (!meta_exists(name)) _copy_meta_single_nocheck(source, metaWalk);
    }
}

t_size file_info::meta_add ( const char *  p_name, const char *  p_value  )

inline

Definition at line 162 of file file_info.h.

{return meta_add_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

t_size file_info::meta_add_ex	(	const char *	p_name,
		t_size	p_name_length,
		const char *	p_value,
		t_size	p_value_length
	)

Definition at line 314 of file file_info.cpp.

{
    t_size index = meta_find_ex(p_name,p_name_length);
    if (index == pfc_infinite) return meta_set_nocheck_ex(p_name,p_name_length,p_value,p_value_length);
    else
    {
        meta_add_value_ex(index,p_value,p_value_length);
        return index;
    }
}

void file_info::meta_add_value ( t_size  p_index, const char *  p_value  )

inline

Definition at line 159 of file file_info.h.

{meta_add_value_ex(p_index,p_value,pfc_infinite);}

void file_info::meta_add_value_ex	(	t_size	p_index,
		const char *	p_value,
		t_size	p_value_length
	)

Definition at line 325 of file file_info.cpp.

{
    meta_insert_value_ex(p_index,meta_enum_value_count(p_index),p_value,p_value_length);
}

t_size file_info::meta_calc_total_value_count

(

)

const

Definition at line 331 of file file_info.cpp.

{
    t_size n, m = meta_get_count(), ret = 0;
    for(n=0;n<m;n++) ret += meta_enum_value_count(n);
    return ret;
}

virtual const char* file_info::meta_enum_name ( t_size  p_index ) const

pure virtual

Retrieves the name of metadata entry of specified index. Return value is a null-terminated UTF-8 encoded string.

Implemented in file_info_impl, and file_info_const_impl.

virtual const char* file_info::meta_enum_value ( t_size  p_index, t_size  p_value_number  ) const

pure virtual

Retrieves specified value from specified metadata entry. Return value is a null-terminated UTF-8 encoded string.

Implemented in file_info_impl, and file_info_const_impl.

virtual t_size file_info::meta_enum_value_count ( t_size  p_index ) const

pure virtual

Retrieves count of values in metadata entry of specified index. The value is always equal to or greater than 1.

Implemented in file_info_impl, and file_info_const_impl.

bool file_info::meta_exists ( const char *  p_name ) const

inline

Definition at line 155 of file file_info.h.

{return meta_exists_ex(p_name,pfc_infinite);}

bool file_info::meta_exists_ex	(	const char *	p_name,
		t_size	p_name_length
	)		const

Definition at line 18 of file file_info.cpp.

{
    return meta_find_ex(p_name,p_name_length) != pfc_infinite;
}

t_size file_info::meta_find ( const char *  p_name ) const

inline

Definition at line 154 of file file_info.h.

{return meta_find_ex(p_name,pfc_infinite);}

t_size file_info::meta_find_ex ( const char *  p_name, t_size  p_name_length  ) const

virtual

Finds index of metadata entry of specified name. Returns infinite when not found.

Reimplemented in file_info_const_impl.

Definition at line 8 of file file_info.cpp.

{
    t_size n, m = meta_get_count();
    for(n=0;n<m;n++)
    {
        if (pfc::stricmp_ascii_ex(meta_enum_name(n),pfc_infinite,p_name,p_name_length) == 0) return n;
    }
    return pfc_infinite;
}

bool file_info::meta_format	(	const char *	p_name,
		pfc::string_base &	p_out,
		const char *	separator = ", "
	)		const

Definition at line 387 of file file_info.cpp.

                                                                                                    {
    p_out.reset();
    t_size index = meta_find(p_name);
    if (index == pfc_infinite) return false;
    meta_format_entry(index, p_out, separator);
    return true;
}

void file_info::meta_format_entry	(	t_size	index,
		pfc::string_base &	p_out,
		const char *	separator = ", "
	)		const

Definition at line 376 of file file_info.cpp.

                                                                                                  {
    out.reset();
    t_size val, count = meta_enum_value_count(index);
    PFC_ASSERT( count > 0);
    for(val=0;val<count;val++)
    {
        if (val > 0) out += separator;
        out += meta_enum_value(index,val);
    }
}

const char* file_info::meta_get ( const char *  p_name, t_size  p_index  ) const

inline

Definition at line 160 of file file_info.h.

{return meta_get_ex(p_name,pfc_infinite,p_index);}

virtual t_size file_info::meta_get_count ( ) const

pure virtual

Retrieves count of metadata entries.

Implemented in file_info_impl, and file_info_const_impl.

t_size file_info::meta_get_count_by_name ( const char *  p_name ) const

inline

Definition at line 161 of file file_info.h.

{return meta_get_count_by_name_ex(p_name,pfc_infinite);}

t_size file_info::meta_get_count_by_name_ex	(	const char *	p_name,
		t_size	p_name_length
	)		const

Definition at line 45 of file file_info.cpp.

{
    t_size index = meta_find_ex(p_name,p_name_length);
    if (index == pfc_infinite) return 0;
    return meta_enum_value_count(index);
}

const char * file_info::meta_get_ex	(	const char *	p_name,
		t_size	p_name_length,
		t_size	p_index
	)		const

Definition at line 177 of file file_info.cpp.

{
    t_size index = meta_find_ex(p_name,p_name_length);
    if (index == pfc_infinite) return 0;
    t_size max = meta_enum_value_count(index);
    if (p_index >= max) return 0;
    return meta_enum_value(index,p_index);
}

void file_info::meta_insert_value ( t_size  p_index, t_size  p_value_index, const char *  p_value  )

inline

Definition at line 158 of file file_info.h.

{meta_insert_value_ex(p_index,p_value_index,p_value,pfc_infinite);}

virtual void file_info::meta_insert_value_ex ( t_size  p_index, t_size  p_value_index, const char *  p_value, t_size  p_value_length  )

pure virtual

Inserts a new value into specified metadata entry.

Implemented in file_info_impl, and file_info_const_impl.

void file_info::meta_modify_value ( t_size  p_index, t_size  p_value_index, const char *  p_value  )

inline

Definition at line 163 of file file_info.h.

{meta_modify_value_ex(p_index,p_value_index,p_value,pfc_infinite);}

virtual void file_info::meta_modify_value_ex ( t_size  p_index, t_size  p_value_index, const char *  p_value, t_size  p_value_length  )

pure virtual

Alters specified value in specified metadata entry.

Implemented in file_info_impl, and file_info_const_impl.

void file_info::meta_remove_all

(

)

Definition at line 35 of file file_info.cpp.

{
    meta_remove_mask(bit_array_true());
}

void file_info::meta_remove_field ( const char *  p_name )

inline

Definition at line 156 of file file_info.h.

{meta_remove_field_ex(p_name,pfc_infinite);}

void file_info::meta_remove_field_ex	(	const char *	p_name,
		t_size	p_name_length
	)

Definition at line 23 of file file_info.cpp.

{
    t_size index = meta_find_ex(p_name,p_name_length);
    if (index!=pfc_infinite) meta_remove_index(index);
}

void file_info::meta_remove_index

(

t_size

p_index

)

Definition at line 30 of file file_info.cpp.

{
    meta_remove_mask(bit_array_one(p_index));
}

virtual void file_info::meta_remove_mask ( const bit_array &  p_mask )

pure virtual

Removes metadata entries according to specified bit mask.

Implemented in file_info_impl, and file_info_const_impl.

void file_info::meta_remove_value	(	t_size	p_index,
		t_size	p_value
	)

Definition at line 40 of file file_info.cpp.

{
    meta_remove_values(p_index,bit_array_one(p_value));
}

virtual void file_info::meta_remove_values ( t_size  p_index, const bit_array &  p_mask  )

pure virtual

Removes values according to specified bit mask from specified metadata entry. If all values are removed, entire metadata entry is removed as well.

Implemented in file_info_impl, and file_info_const_impl.

virtual void file_info::meta_reorder ( const t_size *  p_order )

pure virtual

Reorders metadata entries according to specified permutation.

Implemented in file_info_impl, and file_info_const_impl.

t_size file_info::meta_set ( const char *  p_name, const char *  p_value  )

inline

Definition at line 157 of file file_info.h.

{return meta_set_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

virtual t_size file_info::meta_set_ex ( const char *  p_name, t_size  p_name_length, const char *  p_value, t_size  p_value_length  )

pure virtual

Creates a new metadata entry of specified name with specified value. If an entry of same name already exists, it is erased. Return value is the index of newly created metadata entry.

Implemented in file_info_impl, and file_info_const_impl.

t_size file_info::meta_set_nocheck ( const char *  p_name, const char *  p_value  )

inlineprotected

Definition at line 277 of file file_info.h.

{return meta_set_nocheck_ex(p_name,pfc_infinite,p_value,pfc_infinite);}

virtual t_size file_info::meta_set_nocheck_ex ( const char *  p_name, t_size  p_name_length, const char *  p_value, t_size  p_value_length  )

protectedpure virtual

Implemented in file_info_impl, and file_info_const_impl.

const file_info& file_info::operator= ( const file_info &  p_source )

inline

Definition at line 229 of file file_info.h.

{copy(p_source);return *this;}

void file_info::overwrite_info

(

const file_info &

p_source

)

Definition at line 126 of file file_info_merge.cpp.

                                                         {
    t_size count = p_source.info_get_count();
    for(t_size n=0;n<count;n++) {
        info_set(p_source.info_enum_name(n),p_source.info_enum_value(n));
    }
}

void file_info::overwrite_meta

(

const file_info &

p_source

)

Definition at line 87 of file file_info.cpp.

                                                         {
    const t_size total = p_source.meta_get_count();
    for(t_size walk = 0; walk < total; ++walk) {
        copy_meta_single(p_source, walk);
    }
}

void file_info::reset

(

)

Definition at line 287 of file file_info.cpp.

{
    info_remove_all();
    meta_remove_all();
    set_length(0);
    reset_replaygain();
}

void file_info::reset_replaygain

(

)

Definition at line 295 of file file_info.cpp.

{
    replaygain_info temp;
    temp.reset();
    set_replaygain(temp);
}

virtual void file_info::set_length ( double  p_length )

pure virtual

Sets audio duration, in seconds.
Note that the reported duration should not be assumed to be the exact length of the track -
with many popular audio formats, exact duration is impossible to determine without performing a full decode pass;
with other formats, the decoded data may be shorter than reported due to truncation other damage.

Implemented in file_info_impl, and file_info_const_impl.

virtual void file_info::set_replaygain ( const replaygain_info &  p_info )

pure virtual

Sets ReplayGain information.

Implemented in file_info_impl, and file_info_const_impl.

void file_info::to_console

(

)

const

Definition at line 519 of file file_info.cpp.

                                 {
    FB2K_console_formatter() << "File info dump:";
    if (get_length() > 0) FB2K_console_formatter() << "Duration: " << pfc::format_time_ex(get_length(), 6);
    pfc::string_formatter temp;
    for(t_size metaWalk = 0; metaWalk < meta_get_count(); ++metaWalk) {
        meta_format_entry(metaWalk, temp);
        FB2K_console_formatter() << "Meta: " << meta_enum_name(metaWalk) << " = " << temp;
    }
    for(t_size infoWalk = 0; infoWalk < info_get_count(); ++infoWalk) {
        FB2K_console_formatter() << "Info: " << info_enum_name(infoWalk) << " = " << info_enum_value(infoWalk);
    }
}

void file_info::to_formatter

(

pfc::string_formatter &

out

)

const

Definition at line 506 of file file_info.cpp.

                                                           {
    out << "File info dump:\n";
    if (get_length() > 0) out<< "Duration: " << pfc::format_time_ex(get_length(), 6) << "\n";
    pfc::string_formatter temp;
    for(t_size metaWalk = 0; metaWalk < meta_get_count(); ++metaWalk) {
        meta_format_entry(metaWalk, temp);
        out << "Meta: " << meta_enum_name(metaWalk) << " = " << temp << "\n";
    }
    for(t_size infoWalk = 0; infoWalk < info_get_count(); ++infoWalk) {
        out << "Info: " << info_enum_name(infoWalk) << " = " << info_enum_value(infoWalk) << "\n";
    }
}

void file_info::to_stream	(	stream_writer *	stream,
		abort_callback &	abort
	)		const

Definition at line 569 of file file_info.cpp.

                                                                                {
    stream_writer_formatter<> out(* stream, abort );
    
    out << this->get_length();
    
    {
        const auto rg = this->get_replaygain();
        out << rg.m_track_gain << rg.m_album_gain << rg.m_track_peak << rg.m_album_peak;
    }

    
    {
        const uint32_t metaCount = pfc::downcast_guarded<uint32_t>( this->meta_get_count() );
        for(uint32_t metaWalk = 0; metaWalk < metaCount; ++metaWalk) {
            const char * name = this->meta_enum_name( metaWalk );
            if (*name) {
                out.write_string_nullterm( this->meta_enum_name( metaWalk ) );
                const size_t valCount = this->meta_enum_value_count( metaWalk );
                for(size_t valWalk = 0; valWalk < valCount; ++valWalk) {
                    const char * value = this->meta_enum_value( metaWalk, valWalk );
                    if (*value) {
                        out.write_string_nullterm( value );
                    }
                }
                out.write_int<char>(0);
            }
        }
        out.write_int<char>(0);
    }

    {
        const uint32_t infoCount = pfc::downcast_guarded<uint32_t>( this->info_get_count() );
        for(uint32_t infoWalk = 0; infoWalk < infoCount; ++infoWalk) {
            const char * name = this->info_enum_name( infoWalk );
            const char * value = this->info_enum_value( infoWalk );
            if (*name && *value) {
                out.write_string_nullterm(name); out.write_string_nullterm(value);
            }
        }
        out.write_int<char>(0);
    }
}

---

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

• foobar2000/SDK/file_info.h
• foobar2000/SDK/file_info.cpp
• foobar2000/SDK/file_info_merge.cpp

---

Generated by   1.8.11