---

streamed_mikmod_sample.cpp

Go to the documentation of this file.

/*
        $Id: streamed_mikmod_sample.cpp,v 1.4 2001/01/30 23:34:05 mbn Exp $

        ------------------------------------------------------------------------
        ClanLib, the platform independent game SDK.

        This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
        version 2. See COPYING for details.

        For a total list of contributers see CREDITS.

        ------------------------------------------------------------------------

        File purpose:
                Streamed sample

*/

#include "API/MikMod/streamed_mikmod_sample.h"
#include "resourcetype_module.h"
#include "module_reader.h"

/*****************************
      CL_Streamed_MikModSample
*****************************/

CL_SoundBuffer *CL_Streamed_MikModSample::create(
        const char *filename,
        CL_InputSourceProvider *inputprovider, 
        bool looped)
{
        return CL_SoundBuffer::create(new CL_Streamed_MikModSample(filename, inputprovider, looped), true);
}

CL_SoundBuffer *CL_Streamed_MikModSample::load(
        const char *res_id,
        CL_ResourceManager *manager, 
        bool looped)
{
        return CL_SoundBuffer::create(new CL_Streamed_MikModSample(res_id, manager, looped), true);
}

CL_Streamed_MikModSample::CL_Streamed_MikModSample(
        const char *_filename, 
        CL_InputSourceProvider *_inputprovider, 
        bool _looped)
{
        CL_InputSourceProvider *inputprovider;
        filename = _filename;
        looped = _looped;

        if (_inputprovider == NULL)
        {
                inputprovider = CL_InputSourceProvider::create_file_provider(".");
        }
        else
        {
                inputprovider = _inputprovider->clone();
        }

        CL_InputSource *input=inputprovider->open_source(filename.c_str());
        cl_assert ( input != NULL );

        MREADER *reader=new_clanlib_reader((void *) input);
        cl_assert ( reader != NULL );

        module = Player_LoadGeneric(reader,CLANLIB_READER_CHANNELS,0);

        if (module == NULL)
        {
                throw CL_Error(MikMod_strerror(MikMod_errno));
        }

        delete_clanlib_reader(reader);
        delete input;
        delete inputprovider;
}

CL_Streamed_MikModSample::CL_Streamed_MikModSample(
        const char *_res_id, 
        CL_ResourceManager *_manager, 
        bool _looped)
{
        looped=_looped;
        CL_ModuleResource *res;
        res=(CL_ModuleResource *) _manager->get_resource(_res_id);
        module=res->get_value();
}

CL_Streamed_MikModSample::~CL_Streamed_MikModSample()
{
        Player_Free(module);
}

CL_StreamSoundProvider_Session *CL_Streamed_MikModSample::begin_session()
{
        return new CL_Streamed_MikModSample_Session(module, looped);
}

void CL_Streamed_MikModSample::end_session(CL_StreamSoundProvider_Session *session)
{
        delete session;
}


/*****************************
  CL_Streamed_MikModSample_Session
*****************************/

CL_Streamed_MikModSample_Session::CL_Streamed_MikModSample_Session(
        MODULE *_module,
        bool _looped)
{
        module=_module;
        looped=_looped;

        cl_assert (module != NULL);

        module->loop=looped;

        Player_Start (module);

        sample_freq = md_mixfreq;

        int bytes_per_sample = ((md_mode&DMODE_STEREO)?2:1) * ((md_mode&DMODE_16BITS)?2:1);

        if (((md_mode&DMODE_STEREO)?2:1) == 2 && bytes_per_sample == 4) sample_format = sf_16bit_signed_stereo;
        else if (((md_mode&DMODE_STEREO)?2:1) == 2 && bytes_per_sample == 2) sample_format = sf_8bit_signed_stereo;
        else if (((md_mode&DMODE_STEREO)?2:1) == 1 && bytes_per_sample == 2) sample_format = sf_16bit_signed;
        else if (((md_mode&DMODE_STEREO)?2:1) == 1 && bytes_per_sample == 1) sample_format = sf_8bit_signed;
        else
        {
                std::cout << "    Invalid wave file format         " << std::endl;
                std::cout << "---------------------------------" << std::endl;
                std::cout << "Sample size: " << sample_size << std::endl;
                std::cout << "Sample frequency: " << sample_freq << std::endl;
                std::cout << "Number of channels: " << ((md_mode&DMODE_STEREO)?2:1) << std::endl;
                std::cout << "Number of bytes pr. sample: " << bytes_per_sample << std::endl;
                std::cout << "---------------------------------" << std::endl;

                throw CL_Error("Invalid wave file format");
        }
}

CL_Streamed_MikModSample_Session::~CL_Streamed_MikModSample_Session()
{
        Player_Stop();
}

bool CL_Streamed_MikModSample_Session::eof() const
{
        return !Player_Active();
}

bool CL_Streamed_MikModSample_Session::set_position(int pos)
{
        Player_SetPosition(pos);
        return true; // (Player_GetPosition() == pos); does not exist, what to do?
}

bool CL_Streamed_MikModSample_Session::play()
{
        if (Player_Active())
                return false;
                
        Player_Start(module);
        return Player_Active() != 0;
}

void CL_Streamed_MikModSample_Session::stop()
{
        Player_Stop();
}

int CL_Streamed_MikModSample_Session::get_data(void *data_ptr, int data_requested)
{
        MikMod_Update();
        int read = VC_WriteBytes((SBYTE*)data_ptr,data_requested);

        return read;
}

int CL_Streamed_MikModSample_Session::get_frequency() const
{
        return sample_freq;
}

SoundFormat CL_Streamed_MikModSample_Session::get_format() const
{
        return sample_format;
}

// EOF //

---