CWavWriter

#include <writer_wav.h>

Public Member Functions
void	close ()
void	finalize (abort_callback &p_abort)
audio_chunk::spec_t	get_spec () const
bool	is_open () const
void	open (const char *p_path, const wavWriterSetup_t &p_setup, abort_callback &p_abort)
void	open (service_ptr_t< file > p_file, const wavWriterSetup_t &p_setup, abort_callback &p_abort)
void	write (const audio_chunk &p_chunk, abort_callback &p_abort)

Private Member Functions
size_t	align (abort_callback &abort)
t_uint32	chunkOverhead () const
t_uint32	idOverhead () const
bool	is64 () const
void	writeID (const GUID &id, abort_callback &abort)
void	writeSize (t_uint64 size, abort_callback &abort)

Private Attributes
t_uint64	m_bytes_written
service_ptr_t< file >	m_file
t_uint64	m_offset_fix1
t_uint64	m_offset_fix1_delta
t_uint64	m_offset_fix2
service_ptr_t< audio_postprocessor >	m_postprocessor
mem_block_container_aligned_incremental_impl< 16 >	m_postprocessor_output
wavWriterSetup_t	m_setup
bool	m_wfxe

Detailed Description

Definition at line 27 of file writer_wav.h.

Member Function Documentation

size_t CWavWriter::align ( abort_callback &  abort )

private

Definition at line 117 of file writer_wav.cpp.

                                               {
    t_uint8 dummy[8] = {};
    const t_uint32 val = is64() ? 8 : 2;
    t_filesize pos = m_file->get_position(abort);
    t_size delta = (val - (pos%val)) % val;
    if (delta > 0) m_file->write(dummy, delta, abort);  
    return delta;
}

t_uint32 CWavWriter::chunkOverhead ( ) const

inlineprivate

Definition at line 41 of file writer_wav.h.

{return is64() ? 24 : 8;}

void CWavWriter::close

(

)

Definition at line 271 of file writer_wav.cpp.

{
    m_file.release();
    m_postprocessor.release();
}

void CWavWriter::finalize

(

abort_callback &

p_abort

)

Definition at line 254 of file writer_wav.cpp.

{
    if (m_file.is_valid())
    {
        const size_t alignG = align(p_abort);

        if (m_file->can_seek()) {
            m_file->seek(m_offset_fix1,p_abort);
            writeSize(m_bytes_written + alignG + m_offset_fix1_delta, p_abort);
            m_file->seek(m_offset_fix2,p_abort);
            writeSize(m_bytes_written, p_abort);
        }
        m_file.release();
    }
    m_postprocessor.release();
}

audio_chunk::spec_t CWavWriter::get_spec

(

)

const

Definition at line 277 of file writer_wav.cpp.

                                             {
    audio_chunk::spec_t spec = {};
    spec.sampleRate = m_setup.m_samplerate;
    spec.chanCount = m_setup.m_channels;
    spec.chanMask = m_setup.m_channel_mask;
    return spec;
}

t_uint32 CWavWriter::idOverhead ( ) const

inlineprivate

Definition at line 42 of file writer_wav.h.

{return is64() ? 16 : 4;}

bool CWavWriter::is64 ( ) const

inlineprivate

Definition at line 40 of file writer_wav.h.

{return m_setup.m_wave64;}

bool CWavWriter::is_open ( ) const

inline

Definition at line 35 of file writer_wav.h.

{ return m_file.is_valid(); }

void CWavWriter::open	(	const char *	p_path,
		const wavWriterSetup_t &	p_setup,
		abort_callback &	p_abort
	)

Definition at line 126 of file writer_wav.cpp.

{
    service_ptr_t<file> l_file;
    filesystem::g_open_write_new(l_file,p_path,p_abort);
    open(l_file,p_setup,p_abort);
}

void CWavWriter::open	(	service_ptr_t< file >	p_file,
		const wavWriterSetup_t &	p_setup,
		abort_callback &	p_abort
	)

Definition at line 136 of file writer_wav.cpp.

{
    m_file = p_file;
    m_setup = p_setup;

    if (m_setup.m_channels == 0 || m_setup.m_channels > 18 || m_setup.m_channels != audio_chunk::g_count_channels(m_setup.m_channel_mask)) throw exception_io_data();

    if (!audio_chunk::g_is_valid_sample_rate(m_setup.m_samplerate)) throw exception_io_data();

    if (m_setup.m_bpsValid > m_setup.m_bps) throw exceptionBadBitDepth();

    if (m_setup.m_float)
    {
        if (m_setup.m_bps != 32 && m_setup.m_bps != 64) throw exceptionBadBitDepth();
        if (m_setup.m_bpsValid != m_setup.m_bps) throw exceptionBadBitDepth();
    }
    else
    {
        if (m_setup.m_bps != 8 && m_setup.m_bps != 16 && m_setup.m_bps != 24 && m_setup.m_bps != 32) throw exceptionBadBitDepth();
        if (m_setup.m_bpsValid < 1) throw exceptionBadBitDepth();
    }

    m_wfxe = m_setup.needWFXE();

    writeID(guid_RIFF, p_abort);
    m_offset_fix1 = m_file->get_position(p_abort);
    writeSize(~0, p_abort);
    
    writeID(guid_WAVE, p_abort);
    
    writeID(guid_FMT, p_abort);
    if (m_wfxe) {
        writeSize(sizeof(WAVEFORMATEXTENSIBLE),p_abort);

        WAVEFORMATEXTENSIBLE wfxe;
        m_setup.setup_wfxe(wfxe);
        m_file->write_object(&wfxe,sizeof(wfxe),p_abort);
    } else {
        writeSize(sizeof(PCMWAVEFORMAT),p_abort);

        WAVEFORMATEX wfx;
        m_setup.setup_wfx(wfx);
        m_file->write_object(&wfx,/* blah */ sizeof(PCMWAVEFORMAT),p_abort);
    }
    align(p_abort);

    writeID(guid_DATA, p_abort);
    m_offset_fix2 = m_file->get_position(p_abort);
    writeSize(~0, p_abort);
    m_offset_fix1_delta = m_file->get_position(p_abort) - chunkOverhead();


    m_bytes_written = 0;

    if (!m_setup.m_float)
    {
        m_postprocessor = standard_api_create_t<audio_postprocessor>();
    }
}

void CWavWriter::write	(	const audio_chunk &	p_chunk,
		abort_callback &	p_abort
	)

Definition at line 196 of file writer_wav.cpp.

{
    if (p_chunk.get_channels() != m_setup.m_channels 
        || p_chunk.get_channel_config() != m_setup.m_channel_mask
        || p_chunk.get_srate() != m_setup.m_samplerate
        ) throw exception_unexpected_audio_format_change();

    
    if (m_setup.m_float)
    {
        switch(m_setup.m_bps)
        {
        case 32:
            {
#if audio_sample_size == 32
                t_size bytes = p_chunk.get_sample_count() * p_chunk.get_channels() * sizeof(audio_sample);
                m_file->write_object(p_chunk.get_data(),bytes,p_abort);
                m_bytes_written += bytes;
#else
                enum {tempsize = 256};
                float temp[tempsize];
                t_size todo = p_chunk.get_sample_count() * p_chunk.get_channels();
                const audio_sample * readptr = p_chunk.get_data();
                while(todo > 0)
                {
                    unsigned n,delta = todo;
                    if (delta > tempsize) delta = tempsize;
                    for(n=0;n<delta;n++)
                        temp[n] = (float)(*(readptr++));
                    unsigned bytes = delta * sizeof(float);
                    m_file->write_object_e(temp,bytes,p_abort);
                    m_bytes_written += bytes;
                    todo -= delta;
                }
#endif
            }
            break;
#if 0
        case 64:
            {
                unsigned bytes = p_chunk.get_sample_count() * p_chunk.get_channels() * sizeof(audio_sample);
                m_file->write_object_e(p_chunk.get_data(),bytes,p_abort);
                m_bytes_written += bytes;
            }
            break;
#endif
        default:
            throw exception_io_data();
        }
    }
    else
    {
        m_postprocessor->run(p_chunk,m_postprocessor_output,m_setup.m_bpsValid,m_setup.m_bps,m_setup.m_dither,1.0f);
        m_file->write_object(m_postprocessor_output.get_ptr(),m_postprocessor_output.get_size(),p_abort);
        m_bytes_written += m_postprocessor_output.get_size();
    }
}

void CWavWriter::writeID ( const GUID &  id, abort_callback &  abort  )

private

Definition at line 92 of file writer_wav.cpp.

                                                                {
    if (is64()) {
        m_file->write_object_t(id, abort);
    } else {
        for(t_size walk = 0; walk < PFC_TABSIZE(RIFF_chunks); ++walk) {
            if (id == RIFF_chunks[walk].m_guid) {
                m_file->write(RIFF_chunks[walk].m_name, 4, abort); return;
            }
        }
        uBugCheck();
    }
}

void CWavWriter::writeSize ( t_uint64  size, abort_callback &  abort  )

private

Definition at line 105 of file writer_wav.cpp.

                                                                {
    if (is64()) {
        if (size != ~0) size += 24;
        m_file->write_lendian_t(size, abort);
    } else {
        t_uint32 clipped;
        if (size > 0xFFFFFFFF) clipped = 0xFFFFFFFF;
        else clipped = (t_uint32) size;
        m_file->write_lendian_t(clipped, abort);
    }
}

Field Documentation

t_uint64 CWavWriter::m_bytes_written

private

Definition at line 48 of file writer_wav.h.

service_ptr_t<file> CWavWriter::m_file

private

Definition at line 44 of file writer_wav.h.

t_uint64 CWavWriter::m_offset_fix1

private

Definition at line 48 of file writer_wav.h.

t_uint64 CWavWriter::m_offset_fix1_delta

private

Definition at line 48 of file writer_wav.h.

t_uint64 CWavWriter::m_offset_fix2

private

Definition at line 48 of file writer_wav.h.

service_ptr_t<audio_postprocessor> CWavWriter::m_postprocessor

private

Definition at line 45 of file writer_wav.h.

mem_block_container_aligned_incremental_impl<16> CWavWriter::m_postprocessor_output

private

Definition at line 49 of file writer_wav.h.

wavWriterSetup_t CWavWriter::m_setup

private

Definition at line 46 of file writer_wav.h.

bool CWavWriter::m_wfxe

private

Definition at line 47 of file writer_wav.h.

---

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

• foobar2000/helpers/writer_wav.h
• foobar2000/helpers/writer_wav.cpp