Subversion Repositories sqmusic

/***************************************************************************

    okim6295.h

    OKIM 6295 ADCPM sound chip.

****************************************************************************

    Library to transcode from an ADPCM source to raw PCM.

    Written by Buffoni Mirko in 08/06/97

    References: various sources and documents.

    R. Belmont 31/10/2003

    Updated to allow a driver to use both MSM6295s and "raw" ADPCM voices

    (gcpinbal). Also added some error trapping for MAME_DEBUG builds

****************************************************************************

    OKIM 6295 ADPCM chip:

    Command bytes are sent:

        1xxx xxxx = start of 2-byte command sequence, xxxxxxx is the sample

                    number to trigger

        abcd vvvv = second half of command; one of the abcd bits is set to

                    indicate which voice the v bits seem to be volumed

        0abc d000 = stop playing; one or more of the abcd bits is set to

                    indicate which voice(s)

    Status is read:

        ???? abcd = one bit per voice, set to 0 if nothing is playing, or

                    1 if it is active

***************************************************************************/

#include "emu.h"

#include "okim6295.h"

//**************************************************************************

//  GLOBAL VARIABLES

//**************************************************************************

// device type definition

const device_type OKIM6295 = &device_creator<okim6295_device>;

// volume lookup table. The manual lists only 9 steps, ~3dB per step. Given the dB values,

// that seems to map to a 5-bit volume control. Any volume parameter beyond the 9th index

// results in silent playback.

const UINT8 okim6295_device::s_volume_table[16] =

{

        0x20,   //   0 dB

        0x16,   //  -3.2 dB

        0x10,   //  -6.0 dB

        0x0b,   //  -9.2 dB

        0x08,   // -12.0 dB

        0x06,   // -14.5 dB

        0x04,   // -18.0 dB

        0x03,   // -20.5 dB

        0x02,   // -24.0 dB

        0x00,

        0x00,

        0x00,

        0x00,

        0x00,

        0x00,

        0x00,

};

// default address map

static ADDRESS_MAP_START( okim6295, AS_0, 8, okim6295_device )

        AM_RANGE(0x00000, 0x3ffff) AM_ROM

ADDRESS_MAP_END

//**************************************************************************

//  LIVE DEVICE

//**************************************************************************

//-------------------------------------------------

//  okim6295_device - constructor

//-------------------------------------------------

okim6295_device::okim6295_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)

        : device_t(mconfig, OKIM6295, "OKI6295", tag, owner, clock),

                device_sound_interface(mconfig, *this),

                device_memory_interface(mconfig, *this),

                m_space_config("samples", ENDIANNESS_LITTLE, 8, 18, 0, NULL, *ADDRESS_MAP_NAME(okim6295)),

                m_command(-1),

                m_bank_installed(false),

                m_bank_offs(0),

                m_stream(NULL),

                m_pin7_state(0),

                m_direct(NULL)

{

}

//-------------------------------------------------

//  static_set_pin7 - configuration helper to set

//  the pin 7 state

//-------------------------------------------------

void okim6295_device::static_set_pin7(device_t &device, int pin7)

{

        okim6295_device &okim6295 = downcast<okim6295_device &>(device);

        okim6295.m_pin7_state = pin7;

}

//-------------------------------------------------

//  device_start - device-specific startup

//-------------------------------------------------

void okim6295_device::device_start()

{

        // find our direct access

        m_direct = &space().direct();

        // create the stream

        int divisor = m_pin7_state ? 132 : 165;

        m_stream = machine().sound().stream_alloc(*this, 0, 1, clock() / divisor);

        save_item(NAME(m_command));

        save_item(NAME(m_bank_offs));

        save_item(NAME(m_pin7_state));

        for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++)

        {

                save_item(NAME(m_voice[voicenum].m_playing), voicenum);

                save_item(NAME(m_voice[voicenum].m_sample), voicenum);

                save_item(NAME(m_voice[voicenum].m_count), voicenum);

                save_item(NAME(m_voice[voicenum].m_adpcm.m_signal), voicenum);

                save_item(NAME(m_voice[voicenum].m_adpcm.m_step), voicenum);

                save_item(NAME(m_voice[voicenum].m_volume), voicenum);

                save_item(NAME(m_voice[voicenum].m_base_offset), voicenum);

        }

}

//-------------------------------------------------

//  device_reset - device-specific reset

//-------------------------------------------------

void okim6295_device::device_reset()

{

        m_stream->update();

        for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++)

                m_voice[voicenum].m_playing = false;

}

//-------------------------------------------------

//  device_post_load - device-specific post-load

//-------------------------------------------------

void okim6295_device::device_post_load()

{

        set_bank_base(m_bank_offs, true);

        device_clock_changed();

}

//-------------------------------------------------

//  device_clock_changed - called if the clock

//  changes

//-------------------------------------------------

void okim6295_device::device_clock_changed()

{

        int divisor = m_pin7_state ? 132 : 165;

        m_stream->set_sample_rate(clock() / divisor);

}

//-------------------------------------------------

//  memory_space_config - return a description of

//  any address spaces owned by this device

//-------------------------------------------------

const address_space_config *okim6295_device::memory_space_config(address_spacenum spacenum) const

{

        return (spacenum == 0) ? &m_space_config : NULL;

}

//-------------------------------------------------

//  stream_generate - handle update requests for

//  our sound stream

//-------------------------------------------------

void okim6295_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)

{

        // reset the output stream

        memset(outputs[0], 0, samples * sizeof(*outputs[0]));

        // iterate over voices and accumulate sample data

        for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++)

                m_voice[voicenum].generate_adpcm(*m_direct, outputs[0], samples);

}

//-------------------------------------------------

//  set_bank_base - old-style bank management;

//  assumes multiple 256k banks

//-------------------------------------------------

void okim6295_device::set_bank_base(offs_t base, bool bDontUpdateStream)

{

        // flush out anything pending (but not on e.g. a state load)

        if (!bDontUpdateStream)

        {

                m_stream->update();

        }

        // if we are setting a non-zero base, and we have no bank, allocate one

        if (!m_bank_installed && base != 0)

        {

                // override our memory map with a bank

                space().install_read_bank(0x00000, 0x3ffff, tag());

                m_bank_installed = true;

        }

        // if we have a bank number, set the base pointer

        if (m_bank_installed)

        {

                m_bank_offs = base;

                membank(tag())->set_base(m_region->base() + base);

        }

}

//-------------------------------------------------

//  set_pin7 - change the state of pin 7, which

//  alters the frequency we output

//-------------------------------------------------

void okim6295_device::set_pin7(int pin7)

{

        m_pin7_state = pin7;

        device_clock_changed();

}

//-------------------------------------------------

//  read_status - read the status register

//-------------------------------------------------

UINT8 okim6295_device::read_status()

{

        UINT8 result = 0xf0;    // naname expects bits 4-7 to be 1

        // set the bit to 1 if something is playing on a given channel

        m_stream->update();

        for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++)

                if (m_voice[voicenum].m_playing)

                        result |= 1 << voicenum;

        return result;

}

//-------------------------------------------------

//  read - memory interface for read

//-------------------------------------------------

READ8_MEMBER( okim6295_device::read )

{

        return read_status();

}

//-------------------------------------------------

//  write_command - write to the command register

//-------------------------------------------------

void okim6295_device::write_command(UINT8 command)

{

        // if a command is pending, process the second half

        if (m_command != -1)

        {

                // the manual explicitly says that it's not possible to start multiple voices at the same time

                int voicemask = command >> 4;

                //if (voicemask != 0 && voicemask != 1 && voicemask != 2 && voicemask != 4 && voicemask != 8)

                //  popmessage("OKI6295 start %x contact MAMEDEV", voicemask);

                // update the stream

                m_stream->update();

                // determine which voice(s) (voice is set by a 1 bit in the upper 4 bits of the second byte)

                for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++, voicemask >>= 1)

                        if (voicemask & 1)

                        {

                                okim_voice &voice = m_voice[voicenum];

                                if (!voice.m_playing) // fixes Got-cha and Steel Force

                                {

                                        // determine the start/stop positions

                                        offs_t base = m_command * 8;

                                        offs_t start = m_direct->read_raw_byte(base + 0) << 16;

                                        start |= m_direct->read_raw_byte(base + 1) << 8;

                                        start |= m_direct->read_raw_byte(base + 2) << 0;

                                        start &= 0x3ffff;

                                        offs_t stop = m_direct->read_raw_byte(base + 3) << 16;

                                        stop |= m_direct->read_raw_byte(base + 4) << 8;

                                        stop |= m_direct->read_raw_byte(base + 5) << 0;

                                        stop &= 0x3ffff;

                                        if (start < stop)

                                        {

                                                // set up the voice to play this sample

                                                voice.m_playing = true;

                                                voice.m_base_offset = start;

                                                voice.m_sample = 0;

                                                voice.m_count = 2 * (stop - start + 1);

                                                // also reset the ADPCM parameters

                                                voice.m_adpcm.reset();

                                                voice.m_volume = s_volume_table[command & 0x0f];

                                        }

                                        // invalid samples go here

                                        else

                                        {

                                                logerror("OKIM6295:'%s' requested to play invalid sample %02x\n",tag(),m_command);

                                        }

                                }

                                else

                                {

                                        logerror("OKIM6295:'%s' requested to play sample %02x on non-stopped voice\n",tag(),m_command);

                                }

                        }

                // reset the command

                m_command = -1;

        }

        // if this is the start of a command, remember the sample number for next time

        else if (command & 0x80)

                m_command = command & 0x7f;

        // otherwise, see if this is a silence command

        else

        {

                // update the stream, then turn it off

                m_stream->update();

                // determine which voice(s) (voice is set by a 1 bit in bits 3-6 of the command

                int voicemask = command >> 3;

                for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++, voicemask >>= 1)

                        if (voicemask & 1)

                                m_voice[voicenum].m_playing = false;

        }

}

//-------------------------------------------------

//  write - memory interface for write

//-------------------------------------------------

WRITE8_MEMBER( okim6295_device::write )

{

        write_command(data);

}

//**************************************************************************

//  OKIM VOICE

//**************************************************************************

//-------------------------------------------------

//  okim_voice - constructor

//-------------------------------------------------

okim6295_device::okim_voice::okim_voice()

        : m_playing(false),

                m_base_offset(0),

                m_sample(0),

                m_count(0),

                m_volume(0)

{

}

//-------------------------------------------------

//  generate_adpcm - generate ADPCM samples and

//  add them to an output stream

//-------------------------------------------------

void okim6295_device::okim_voice::generate_adpcm(direct_read_data &direct, stream_sample_t *buffer, int samples)

{

        // skip if not active

        if (!m_playing)

                return;

        // loop while we still have samples to generate

        while (samples-- != 0)

        {

                // fetch the next sample byte

                int nibble = direct.read_raw_byte(m_base_offset + m_sample / 2) >> (((m_sample & 1) << 2) ^ 4);

                // output to the buffer, scaling by the volume

                // signal in range -2048..2047, volume in range 2..32 => signal * volume / 2 in range -32768..32767

                *buffer++ += m_adpcm.clock(nibble) * m_volume / 2;

                // next!

                if (++m_sample >= m_count)

                {

                        m_playing = false;

                        break;

                }

        }

}