Example #1
0
void mm6221aa_tune_w(int chip, int tune)
{
	struct TMS36XX *tms = sndti_token(SOUND_TMS36XX, chip);

    /* which tune? */
    tune &= 3;
    if( tune == tms->tune_num )
        return;

	LOG(("%s tune:%X\n", tms->subtype, tune));

    /* update the stream before changing the tune */
    stream_update(tms->channel);

    tms->tune_num = tune;
    tms->tune_ofs = 0;
    tms->tune_max = 96; /* fixed for now */
}
Example #2
0
void okim6295_device::set_bank_base(offs_t base)
{
	// flush out anything pending
	stream_update(m_stream);

	// 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
		memory_install_read_bank(space(), 0x00000, 0x3ffff, 0, 0, tag());
		m_bank_installed = true;
	}

	// if we have a bank number, set the base pointer
	if (m_bank_installed)
	{
		m_bank_offs = base;
		memory_set_bankptr(&m_machine, tag(), m_region->base() + base);
	}
}
Example #3
0
void channelf_sound_w(int mode)
{
	if (mode == sound_mode)
		return;

    stream_update(channel, 0);
	sound_mode = mode;

    switch(mode)
    {
		case 0:
			envelope = 0;
			break;
		case 1:
		case 2:
		case 3:
			envelope = max_amplitude;
			break;
	}
}
Example #4
0
void wave_close(int id)
{
	struct wave_file *w = &wave[id];

    if( !w->file )
		return;

    if( w->timer )
	{
		if( w->channel != -1 )
			stream_update(w->channel, 0);
		w->samples = w->playpos;
		w->length = w->samples * w->resolution / 8;
		timer_remove(w->timer);
		w->timer = NULL;
	}

    if( w->mode )
	{
		wave_output(id,0);
		wave_write(id);
		w->mode = 0;
	}

    if( w->data )
		free(w->data);
    w->data = NULL;

	if (w->file) {
		osd_fclose(w->file);
		w->file = NULL;
	}
	w->offset = 0;
	w->playpos = 0;
	w->counter = 0;
	w->smpfreq = 0;
	w->resolution = 0;
	w->samples = 0;
	w->length = 0;
}
Example #5
0
void tms36xx_note_w(const device_config *device, int octave, int note)
{
	tms_state *tms = get_safe_token(device);

	octave &= 3;
	note &= 15;

	if (note > 12)
        return;

	LOG(("%s octave:%X note:%X\n", tms->subtype, octave, note));

	/* update the stream before changing the tune */
    stream_update(tms->channel);

	/* play a single note from 'tune 4', a list of the 13 tones */
	tms36xx_reset_counters(tms);
	tms->octave = octave;
    tms->tune_num = 4;
	tms->tune_ofs = note;
	tms->tune_max = note + 1;
}
Example #6
0
void sample_start_raw_n(int num,int channel,INT16 *sampledata,int samples,int frequency,int loop)
{
    struct samples_info *info = sndti_token(SOUND_SAMPLES, num);
    struct sample_channel *chan;

    assert( channel < info->numchannels );

    chan = &info->channel[channel];

	/* force an update before we start */
	stream_update(chan->stream);

	/* update the parameters */
	chan->source = sampledata;
	chan->source_length = samples;
	chan->source_num = -1;
	chan->pos = 0;
	chan->frac = 0;
	chan->basefreq = frequency;
	chan->step = ((INT64)chan->basefreq << FRAC_BITS) / Machine->sample_rate;
	chan->loop = loop;
}
Example #7
0
void sample_start_raw(const device_config *device,int channel,const INT16 *sampledata,int samples,int frequency,int loop)
{
    samples_info *info = get_safe_token(device);
    sample_channel *chan;

    assert( channel < info->numchannels );

    chan = &info->channel[channel];

	/* force an update before we start */
	stream_update(chan->stream);

	/* update the parameters */
	chan->source = sampledata;
	chan->source_length = samples;
	chan->source_num = -1;
	chan->pos = 0;
	chan->frac = 0;
	chan->basefreq = frequency;
	chan->step = ((INT64)chan->basefreq << FRAC_BITS) / info->device->machine->sample_rate;
	chan->loop = loop;
}
Example #8
0
void ay8910_write_ym(void *chip, int addr, int data)
{
	ay8910_context *psg = chip;

	if (addr & 1)
	{	/* Data port */
		int r = psg->register_latch;

		if (r > 15) return;
		if (r == AY_ESHAPE || psg->regs[r] != data)
		{
			/* update the output buffer before changing the register */
			stream_update(psg->channel);
		}

		ay8910_write_reg(psg,r,data);
	}
	else
	{	/* Register port */
		psg->register_latch = data & 0x0f;
	}
}
Example #9
0
void tms36xx_note_w(int chip, int octave, int note)
{
	struct TMS36XX *tms = tms36xx[chip];

	octave &= 3;
	note &= 15;

	if (note > 12)
        return;

	LOG((errorlog,"%s octave:%X note:%X\n", tms->subtype, octave, note));

	/* update the stream before changing the tune */
    stream_update(tms->channel,0);

	/* play a single note from 'tune 4', a list of the 13 tones */
	tms36xx_reset_counters(chip);
	tms->octave = octave;
    tms->tune_num = 4;
	tms->tune_ofs = note;
	tms->tune_max = note + 1;
}
Example #10
0
/* ストリームの先頭がmatchだったら読み飛ばす */
int stream_take(stream_t* buff, const char* match, int sensitive)
{
    if (stream_skip(buff) == ERR_FATAL
        || stream_update(buff) == ERR_FATAL) {
        return ERR_FATAL;
    }
    int tail = buff->tail;
    while (buff->tail != buff->head
            && sensitive_eq(buff->buff[buff->tail], *match, sensitive)
            && *match != '\0') {
        buff->tail += 1;
        match += 1;
        if (buff->tail == BUFF_SIZE) {
            buff->tail = 0;
        }
    }
    if (*match == '\0') {
        return 1;
    } else {
        buff->tail = tail;
        return 0;
    }
}
Example #11
0
void tms3617_enable_w(int chip, int enable)
{
	struct TMS36XX *tms = tms36xx[chip];
	int i, bits = 0;

	/* duplicate the 6 voice enable bits */
    enable = (enable & 0x3f) | ((enable & 0x3f) << 6);
	if (enable == tms->enable)
		return;

    /* update the stream before changing the tune */
    stream_update(tms->channel,0);

	LOG((errorlog, "%s enable voices", tms->subtype));
    for (i = 0; i < 6; i++)
	{
		if (enable & (1 << i))
		{
			bits += 2;	/* each voice has two instances */
#if VERBOSE
			switch (i)
			{
			case 0: LOG((errorlog," 16'")); break;
			case 1: LOG((errorlog," 8'")); break;
			case 2: LOG((errorlog," 5 1/3'")); break;
			case 3: LOG((errorlog," 4'")); break;
			case 4: LOG((errorlog," 2 2/3'")); break;
			case 5: LOG((errorlog," 2'")); break;
			}
#endif
        }
    }
	/* set the enable mask and number of active voices */
	tms->enable = enable;
    tms->voices = bits;
	LOG((errorlog, "%s\n", bits ? "" : " none"));
}
Example #12
0
void dmadac_transfer(const device_config **devlist, UINT8 num_channels, offs_t channel_spacing, offs_t frame_spacing, offs_t total_frames, INT16 *data)
{
	int i, j;

	/* flush out as much data as we can */
	for (i = 0; i < num_channels; i++)
	{
		dmadac_state *info = get_safe_token(devlist[i]);
		stream_update(info->channel);
	}

	/* loop over all channels and accumulate the data */
	for (i = 0; i < num_channels; i++)
	{
		dmadac_state *ch = get_safe_token(devlist[i]);
		if (ch->enabled)
		{
			int maxin = (ch->bufout + BUFFER_SIZE - 1) % BUFFER_SIZE;
			INT16 *src = data + i * channel_spacing;
			int curin = ch->bufin;

			/* copy the data */
			for (j = 0; j < total_frames && curin != maxin; j++)
			{
				ch->buffer[curin++ % BUFFER_SIZE] = *src;
				src += frame_spacing;
			}
			ch->bufin = curin;

			/* log overruns */
			if (j != total_frames)
				logerror("dmadac_transfer: buffer overrun (short %d frames)\n", total_frames - j);
		}
	}

	//LOG(("dmadac_transfer - %d samples, %d effective, %d in buffer\n", total_frames, (int)(total_frames * (double)DEFAULT_SAMPLE_RATE / dmadac[first_channel].frequency), dmadac[first_channel].curinpos - dmadac[first_channel].curoutpos));
}
Example #13
0
/* update request from fm.c */
void YM2203UpdateRequest(void *param)
{
	struct ym2203_info *info = param;
	stream_update(info->stream,0);
}
Example #14
0
int tms5110_ready_r(void)
{
    /* bring up to date first */
    stream_update(stream, 0);
    return tms5110_ready_read();
}
Example #15
0
/* update request from fm.c */
void YM2151UpdateRequest(int chip)
{
	stream_update(stream[chip],0);
}
Example #16
0
static void saa1099_write_port_w( int chip, int offset, int data )
{
	struct SAA1099 *saa = sndti_token(SOUND_SAA1099, chip);
	int reg = saa->selected_reg;
	int ch;

	/* first update the stream to this point in time */
	stream_update(saa->stream);

	switch (reg)
	{
	/* channel i amplitude */
	case 0x00:	case 0x01:	case 0x02:	case 0x03:	case 0x04:	case 0x05:
		ch = reg & 7;
		saa->channels[ch].amplitude[LEFT] = amplitude_lookup[data & 0x0f];
		saa->channels[ch].amplitude[RIGHT] = amplitude_lookup[(data >> 4) & 0x0f];
		break;
	/* channel i frequency */
	case 0x08:	case 0x09:	case 0x0a:	case 0x0b:	case 0x0c:	case 0x0d:
		ch = reg & 7;
		saa->channels[ch].frequency = data & 0xff;
		break;
	/* channel i octave */
	case 0x10:	case 0x11:	case 0x12:
		ch = (reg - 0x10) << 1;
		saa->channels[ch + 0].octave = data & 0x07;
		saa->channels[ch + 1].octave = (data >> 4) & 0x07;
		break;
	/* channel i frequency enable */
	case 0x14:
		saa->channels[0].freq_enable = data & 0x01;
		saa->channels[1].freq_enable = data & 0x02;
		saa->channels[2].freq_enable = data & 0x04;
		saa->channels[3].freq_enable = data & 0x08;
		saa->channels[4].freq_enable = data & 0x10;
		saa->channels[5].freq_enable = data & 0x20;
		break;
	/* channel i noise enable */
	case 0x15:
		saa->channels[0].noise_enable = data & 0x01;
		saa->channels[1].noise_enable = data & 0x02;
		saa->channels[2].noise_enable = data & 0x04;
		saa->channels[3].noise_enable = data & 0x08;
		saa->channels[4].noise_enable = data & 0x10;
		saa->channels[5].noise_enable = data & 0x20;
		break;
	/* noise generators parameters */
	case 0x16:
		saa->noise_params[0] = data & 0x03;
		saa->noise_params[1] = (data >> 4) & 0x03;
		break;
	/* envelope generators parameters */
	case 0x18:	case 0x19:
		ch = reg - 0x18;
		saa->env_reverse_right[ch] = data & 0x01;
		saa->env_mode[ch] = (data >> 1) & 0x07;
		saa->env_bits[ch] = data & 0x10;
		saa->env_clock[ch] = data & 0x20;
		saa->env_enable[ch] = data & 0x80;
		/* reset the envelope */
		saa->env_step[ch] = 0;
		break;
	/* channels enable & reset generators */
	case 0x1c:
		saa->all_ch_enable = data & 0x01;
		saa->sync_state = data & 0x02;
		if (data & 0x02)
		{
			int i;

			/* Synch & Reset generators */
			logerror("%04x: (SAA1099 #%d) -reg 0x1c- Chip reset\n",activecpu_get_pc(), chip);
			for (i = 0; i < 6; i++)
			{
                saa->channels[i].level = 0;
				saa->channels[i].counter = 0.0;
			}
		}
		break;
	default:	/* Error! */
		logerror("%04x: (SAA1099 #%d) Unknown operation (reg:%02x, data:%02x)\n",activecpu_get_pc(), chip, reg, data);
	}
}
Example #17
0
/* update request from fm.c */
void ym2610_update_request(void *param)
{
	ym2610_state *info = (ym2610_state *)param;
	stream_update(info->stream);
}
Example #18
0
void S14001A_reg_0_w(int data)
{
	if (stream != -1)
		stream_update(stream, 0);
	WordInput = data;
}
Example #19
0
void tia_sh_update(void)
{
	stream_update(channel, 0);
}
Example #20
0
void tms36xx_sh_update(void)
{
	int i;
    for( i = 0; i < intf->num; i++ )
		stream_update(i,0);
}
Example #21
0
static void _stream_update_3526(void *param, int interval)
{
	struct ym3526_info *info = param;
	stream_update(info->stream, interval);
}
Example #22
0
static void _stream_update_8950(void *param, int interval)
{
	struct y8950_info *info = param;
	stream_update(info->stream);
}
Example #23
0
void discrete_sh_update(void)
{
	if(!init_ok) return;
	/* Bring stream upto the present time */
	stream_update(discrete_stream, 0);
}
Example #24
0
void speaker_sh_update(void)
{
	int i;
	for( i = 0; i < intf->num; i++ )
		stream_update(speaker[i].channel, 0);
}
Example #25
0
void streams_update(running_machine *machine)
{
	streams_private *strdata = machine->streams_data;
	attotime curtime = timer_get_time(machine);
	int second_tick = FALSE;
	sound_stream *stream;

	VPRINTF(("streams_update\n"));

	/* see if we ticked over to the next second */
	if (curtime.seconds != strdata->last_update.seconds)
	{
		assert(curtime.seconds == strdata->last_update.seconds + 1);
		second_tick = TRUE;
	}

	/* iterate over all the streams */
	for (stream = strdata->stream_head; stream != NULL; stream = stream->next)
	{
		INT32 output_bufindex = stream->output_sampindex - stream->output_base_sampindex;
		int outputnum;

		/* make sure this stream is up-to-date */
		stream_update(stream);

		/* if we've ticked over another second, adjust all the counters that are relative to
           the current second */
		if (second_tick)
		{
			stream->output_sampindex -= stream->sample_rate;
			stream->output_base_sampindex -= stream->sample_rate;
		}

		/* note our current output sample */
		stream->output_update_sampindex = stream->output_sampindex;

		/* if we don't have enough output buffer space to hold two updates' worth of samples,
           we need to shuffle things down */
		if (stream->output_bufalloc - output_bufindex < 2 * stream->max_samples_per_update)
		{
			INT32 samples_to_lose = output_bufindex - stream->max_samples_per_update;
			if (samples_to_lose > 0)
			{
				/* if we have samples to move, do so for each output */
				if (output_bufindex > 0)
					for (outputnum = 0; outputnum < stream->outputs; outputnum++)
					{
						stream_output *output = &stream->output[outputnum];
						memmove(&output->buffer[0], &output->buffer[samples_to_lose], sizeof(output->buffer[0]) * (output_bufindex - samples_to_lose));
					}

				/* update the base position */
				stream->output_base_sampindex += samples_to_lose;
			}
		}
	}

	/* remember the update time */
	strdata->last_update = curtime;

	/* update sample rates if they have changed */
	for (stream = strdata->stream_head; stream != NULL; stream = stream->next)
		if (stream->new_sample_rate != 0)
		{
			UINT32 old_rate = stream->sample_rate;
			int outputnum;

			/* update to the new rate and remember the old rate */
			stream->sample_rate = stream->new_sample_rate;
			stream->new_sample_rate = 0;

			/* recompute all the data */
			recompute_sample_rate_data(machine, stream);

			/* reset our sample indexes to the current time */
			stream->output_sampindex = (INT64)stream->output_sampindex * (INT64)stream->sample_rate / old_rate;
			stream->output_update_sampindex = (INT64)stream->output_update_sampindex * (INT64)stream->sample_rate / old_rate;
			stream->output_base_sampindex = stream->output_sampindex - stream->max_samples_per_update;

			/* clear out the buffer */
			for (outputnum = 0; outputnum < stream->outputs; outputnum++)
				memset(stream->output[outputnum].buffer, 0, stream->max_samples_per_update * sizeof(stream->output[outputnum].buffer[0]));
		}
}
Example #26
0
/* update request from fm.c */
void YM2612UpdateRequest(int chip)
{
	stream_update(stream[chip],100);
}
Example #27
0
/* update request from fm.c */
void YM2610UpdateRequest(void *param)
{
	struct ym2610_info *info = param;
	stream_update(info->stream);
}
Example #28
0
void sid6581_port_w (SID6581 *This, int offset, int data)
{
	offset &= 0x1f;

	switch (offset)
	{
		case 0x19: case 0x1a: case 0x1b: case 0x1c:
		case 0x1d:
		case 0x1e:
		case 0x1f:
			break;
		case 0x15: case 0x16: case 0x17:
		case 0x18:
			stream_update(This->mixer_channel);
			This->reg[offset] = data;
			This->masterVolume = ( This->reg[0x18] & 15 );
			This->masterVolumeAmplIndex = This->masterVolume << 8;

			if ((This->reg[0x18]&0x80) &&
				((This->reg[0x17]&This->optr3.filtVoiceMask)==0))
				This->optr3_outputmask = 0;     /* off */
			else
				This->optr3_outputmask = ~0;  /* on */

			This->filter.Type = This->reg[0x18] & 0x70;
			if (This->filter.Type != This->filter.CurType)
			{
				This->filter.CurType = This->filter.Type;
				This->optr1.filtLow = (This->optr1.filtRef = 0);
				This->optr2.filtLow = (This->optr2.filtRef = 0);
				This->optr3.filtLow = (This->optr3.filtRef = 0);
			}
			if ( This->filter.Enabled )
			{
				This->filter.Value = 0x7ff & ( (This->reg[0x15]&7) | ( (UINT16)This->reg[0x16] << 3 ));
				if (This->filter.Type == 0x20)
					This->filter.Dy = bandPassParam ? bandPassParam[This->filter.Value] : 0.0f;
				else
					This->filter.Dy = lowPassParam ? lowPassParam[This->filter.Value] : 0.0f;
				This->filter.ResDy = filterResTable[This->reg[0x17] >> 4] - This->filter.Dy;
				if ( This->filter.ResDy < 1.0f )
					This->filter.ResDy = 1.0f;
			}

			sidEmuSet( &This->optr1 );
			sidEmuSet( &This->optr3 );
			sidEmuSet( &This->optr2 );

			// relies on sidEmuSet also for other channels!
			sidEmuSet2( &This->optr1 );
			sidEmuSet2( &This->optr2 );
			sidEmuSet2( &This->optr3 );
			break;

		default:
			stream_update(This->mixer_channel);
			This->reg[offset] = data;

			if (offset<7) {
				This->optr1.reg[offset] = data;
			} else if (offset<14) {
				This->optr2.reg[offset-7] = data;
			} else if (offset<21) {
				This->optr3.reg[offset-14] = data;
			}

			sidEmuSet( &This->optr1 );
			sidEmuSet( &This->optr3 );
			sidEmuSet( &This->optr2 );

			// relies on sidEmuSet also for other channels!
			sidEmuSet2( &This->optr1 );
			sidEmuSet2( &This->optr2 );
			sidEmuSet2( &This->optr3 );
			break;
	}
Example #29
0
static void _stream_update_3812(void * param, int interval)
{
	struct ym3812_info *info = param;
	stream_update(info->stream);
}
Example #30
0
void s14001a_set_volume(device_t *device, int volume)
{
	S14001AChip *chip = get_safe_token(device);
	stream_update(chip->stream);
	chip->VSU1000_amp = volume;
}