コード例 #1
0
 // construction/destruction
 public samples_iterator(samples_device device)
 {
     m_samples = device;
     m_current = -1;
 }
コード例 #2
0
        // device_sound_interface overrides
        //-------------------------------------------------
        //  sound_stream_update - update a sound stream
        //-------------------------------------------------
        public override void sound_stream_update(sound_stream stream, ListPointer <stream_sample_t> [] inputs, ListPointer <stream_sample_t> [] outputs, int samples)
        {
            samples_device samplesdev = (samples_device)device();

            // find the channel with this stream
            for (int channel = 0; channel < samplesdev.m_channels; channel++)
            {
                if (stream == samplesdev.m_channel[channel].stream)
                {
                    samples_device.channel_t      chan   = samplesdev.m_channel[channel];
                    ListPointer <stream_sample_t> buffer = new ListPointer <stream_sample_t>(outputs[0]);  //stream_sample_t * buffer = outputs[0];

                    // process if we still have a source and we're not paused
                    if (chan.source != null && !chan.paused)
                    {
                        // load some info locally
                        uint32_t           pos           = chan.pos;
                        uint32_t           frac          = chan.frac;
                        uint32_t           step          = chan.step;
                        ListBase <int16_t> sample        = chan.source; //const int16_t *sample = chan.source;
                        uint32_t           sample_length = (UInt32)chan.source_length;

                        while (samples-- != 0)
                        {
                            // do a linear interp on the sample
                            int sample1  = sample[(int)pos];
                            int sample2  = sample[(int)((pos + 1) % sample_length)];
                            int fracmult = (int)(frac >> (samples_device.FRAC_BITS - 14));
                            buffer[0] = ((0x4000 - fracmult) * sample1 + fracmult * sample2) >> 14;  //*buffer++ = ((0x4000 - fracmult) * sample1 + fracmult * sample2) >> 14;
                            buffer++;

                            // advance
                            frac += step;
                            pos  += frac >> samples_device.FRAC_BITS;
                            frac  = frac & ((1 << samples_device.FRAC_BITS) - 1);

                            // handle looping/ending
                            if (pos >= sample_length)
                            {
                                if (chan.loop)
                                {
                                    pos %= sample_length;
                                }
                                else
                                {
                                    chan.source     = null;
                                    chan.source_num = -1;
                                    if (samples > 0)
                                    {
                                        memset(buffer, 0, (UInt32)samples);  //memset(buffer, 0, samples * sizeof(*buffer));
                                    }
                                    break;
                                }
                            }
                        }

                        // push position back out
                        chan.pos  = pos;
                        chan.frac = frac;
                    }
                    else
                    {
                        memset(buffer, 0, (UInt32)samples);  //memset(buffer, 0, samples * sizeof(*buffer));
                    }

                    break;
                }
            }
        }