//------------------------------------------------- // audit_one_disk - validate a single disk entry //------------------------------------------------- audit_record audit_one_disk(ListPointer <rom_entry> rom, string locationtag = null) //const rom_entry *rom { // allocate and append a new record audit_record record = m_record_list.emplace_back(new audit_record(rom, audit_record.media_type.MEDIA_DISK)).Value; //audit_record &record = *m_record_list.emplace(m_record_list.end(), *rom, media_type::DISK); // open the disk chd_file source = new chd_file(); chd_error err = (chd_error)romload_global.open_disk_image(m_enumerator.options(), m_enumerator.driver(), rom[0], source, locationtag); // if we succeeded, get the hashes if (err == chd_error.CHDERR_NONE) { util.hash_collection hashes = new util.hash_collection(); // if there's a SHA1 hash, add them to the output hash if (source.sha1() != null) { hashes.add_sha1(source.sha1()); } // update the actual values record.set_actual(hashes); } // compute the final status compute_status(record, rom[0], err == chd_error.CHDERR_NONE); return(record); }
//------------------------------------------------- // allocate_color_tables - allocate memory for // pen and color tables //------------------------------------------------- void allocate_color_tables() { int total_colors = m_palette.num_colors() * m_palette.num_groups(); // allocate memory for the pen table switch (m_format) { case bitmap_format.BITMAP_FORMAT_IND16: // create a dummy 1:1 mapping { m_pen_array.resize(total_colors + 2); ListPointer <rgb_t> pentable = new ListPointer <rgb_t>(m_pen_array); //pen_t *pentable = &m_pen_array[0]; m_pens = new ListPointer <rgb_t>(m_pen_array); //m_pens = &m_pen_array[0]; for (int i = 0; i < total_colors + 2; i++) { pentable[i] = new rgb_t((UInt32)i); //pentable[i] = i; } } break; case bitmap_format.BITMAP_FORMAT_RGB32: m_pens = new ListPointer <rgb_t>(m_palette.entry_list_adjusted()); // reinterpret_cast<const pen_t *>(m_palette.entry_list_adjusted()); break; default: m_pens = null; break; } }
//------------------------------------------------- // allocate_shadow_tables - allocate memory for // shadow tables //------------------------------------------------- void allocate_shadow_tables() { int numentries = m_palette.num_colors(); // if we have shadows, allocate shadow tables if (m_shadow_group != 0) { m_shadow_array.resize(65536); // palettized mode gets a single 64k table in slots 0 and 2 if (m_format == bitmap_format.BITMAP_FORMAT_IND16) { m_shadow_tables[2].base_ = new ListPointer <pen_t>(m_shadow_array, 0); //m_shadow_tables[0].base = m_shadow_tables[2].base = &m_shadow_array[0]; m_shadow_tables[0].base_ = new ListPointer <pen_t>(m_shadow_array, 0); for (int i = 0; i < 65536; i++) { m_shadow_array[i] = (i < numentries) ? (pen_t)(i + numentries) : (pen_t)i; } } // RGB mode gets two 32k tables in slots 0 and 2 else { m_shadow_tables[0].base_ = new ListPointer <pen_t>(m_shadow_array, 0); m_shadow_tables[2].base_ = new ListPointer <pen_t>(m_shadow_array, 32768); configure_rgb_shadows(0, PALETTE_DEFAULT_SHADOW_FACTOR); } } // if we have hilights, allocate shadow tables if (m_hilight_group != 0) { m_hilight_array.resize(65536); // palettized mode gets a single 64k table in slots 1 and 3 if (m_format == bitmap_format.BITMAP_FORMAT_IND16) { m_shadow_tables[3].base_ = new ListPointer <pen_t>(m_hilight_array, 0); //m_shadow_tables[1].base_ = m_shadow_tables[3].base_ = &m_hilight_array[0]; m_shadow_tables[1].base_ = new ListPointer <pen_t>(m_hilight_array, 0); for (int i = 0; i < 65536; i++) { m_hilight_array[i] = (i < numentries) ? (pen_t)(i + 2 * numentries) : (pen_t)i; } } // RGB mode gets two 32k tables in slots 1 and 3 else { m_shadow_tables[1].base_ = new ListPointer <pen_t>(m_hilight_array, 0); m_shadow_tables[3].base_ = new ListPointer <pen_t>(m_hilight_array, 32768); configure_rgb_shadows(1, PALETTE_DEFAULT_HIGHLIGHT_FACTOR); } } // set the default table m_shadow_table = m_shadow_tables[0] != null ? new ListPointer <pen_t>(m_shadow_tables[0].base_) : null; }
public static void wav_add_data_16(wav_file wav, ListPointer <int16_t> data, int samples) //wav_file *wav, int16_t *data, int samples) { if (wav == null || samples == 0) { return; } throw new emu_unimplemented(); }
//------------------------------------------------- // audit_device - audit the device //------------------------------------------------- public summary audit_device(device_t device, string validation = AUDIT_VALIDATE_FULL) { // start fresh m_record_list.clear(); // store validation for later m_validation = validation; m_searchpath = device.shortname(); int found = 0; int required = 0; // now iterate over regions and ROMs within for (ListPointer <rom_entry> region = romload_global.rom_first_region(device); region != null; region = romload_global.rom_next_region(region)) { for (ListPointer <rom_entry> rom = romload_global.rom_first_file(region); rom != null; rom = romload_global.rom_next_file(rom)) { util.hash_collection hashes = new util.hash_collection(romload_global.ROM_GETHASHDATA(rom[0])); // count the number of files with hashes if (!hashes.flag(util.hash_collection.FLAG_NO_DUMP) && !romload_global.ROM_ISOPTIONAL(rom[0])) { required++; } // audit a file audit_record record = null; if (romload_global.ROMREGION_ISROMDATA(region[0])) { record = audit_one_rom(rom); } // audit a disk else if (romload_global.ROMREGION_ISDISKDATA(region[0])) { record = audit_one_disk(rom); } // count the number of files that are found. if (record != null && (record.status() == audit_record.audit_status.STATUS_GOOD || record.status() == audit_record.audit_status.STATUS_FOUND_INVALID)) { found++; } } } if (found == 0 && required > 0) { m_record_list.clear(); return(summary.NOTFOUND); } // return a summary string unused = ""; return(summarize(device.shortname(), ref unused)); }
/* generate sound by oversampling */ public uint32_t namco_update_one(ListPointer <stream_sample_t> buffer, int length, ListPointer <int16_t> wave, uint32_t counter, uint32_t freq) //uint32_t namco_audio_device::namco_update_one(stream_sample_t *buffer, int length, const int16_t *wave, uint32_t counter, uint32_t freq) { while (length-- > 0) { buffer[0] = wave[WAVEFORM_POSITION((int)counter)]; // *buffer++ += wave[WAVEFORM_POSITION(counter)]; buffer++; counter += freq; } return(counter); }
void stream_generate(sound_stream stream, ListPointer <stream_sample_t> [] inputs, ListPointer <stream_sample_t> [] outputs, int samples) { ListPointer <stream_sample_t> ptr = new ListPointer <stream_sample_t>(outputs[0]); //stream_sample_t *ptr = outputs[0]; int samplenum = samples; while (samplenum-- > 0) { ptr[0] = m_data; ptr++; } }
// finder public override bool findit(bool isvalidation = false) { if (isvalidation) { return(true); } assert(!this.resolved); this.resolved = true; target = find_memshare(0, out m_bytes, Required); // reinterpret_cast<_PointerType *>(this.find_memshare(m_width, m_bytes, _Required)); return(report_missing(this.target != null, "shared pointer", Required)); }
// construction/destruction //------------------------------------------------- // device_palette_interface - constructor //------------------------------------------------- public device_palette_interface(machine_config mconfig, device_t device) : base(device, "palette") { m_palette = null; m_pens = null; m_format = bitmap_format.BITMAP_FORMAT_RGB32; m_shadow_table = null; m_shadow_group = 0; m_hilight_group = 0; m_white_pen = 0; m_black_pen = 0; }
public override void update_audio_stream(ListPointer<Int16> buffer, int samples_this_frame) //const int16_t *buffer, int samples_this_frame) = 0; { base.update_audio_stream(buffer, samples_this_frame); if (audioUpdateCount++ % 10 == 0) osd_printf_info("osd_interface.update_audio_stream() - {0} - samples: {1}\n", audioUpdateCount, samples_this_frame); lock (osdlock_audio) { for (int i = 0; i < samples_this_frame; i++) m_audiobuffer.Enqueue(buffer[i]); } }
//------------------------------------------------- // find_shared_device - return the source that // shares a media entry with the same hashes //------------------------------------------------- device_t find_shared_device(device_t device, string name, util.hash_collection romhashes, UInt64 romlength) { bool dumped = !romhashes.flag(util.hash_collection.FLAG_NO_DUMP); // special case for non-root devices device_t highest_device = null; if (device.owner() != null) { for (ListPointer <rom_entry> region = romload_global.rom_first_region(device); region != null; region = romload_global.rom_next_region(region)) { for (ListPointer <rom_entry> rom = romload_global.rom_first_file(region); rom != null; rom = romload_global.rom_next_file(rom)) { if (romload_global.ROM_GETLENGTH(rom[0]) == romlength) { util.hash_collection hashes = new util.hash_collection(romload_global.ROM_GETHASHDATA(rom[0])); if ((dumped && hashes == romhashes) || (!dumped && romload_global.ROM_GETNAME(rom[0]) == name)) { highest_device = device; } } } } } else { // iterate up the parent chain for (int drvindex = driver_enumerator.find(m_enumerator.driver().parent); drvindex != -1; drvindex = driver_enumerator.find(driver_enumerator.driver(drvindex).parent)) { foreach (device_t scandevice in new device_iterator(m_enumerator.config(drvindex).root_device())) { for (ListPointer <rom_entry> region = romload_global.rom_first_region(scandevice); region != null; region = romload_global.rom_next_region(region)) { for (ListPointer <rom_entry> rom = romload_global.rom_first_file(region); rom != null; rom = romload_global.rom_next_file(rom)) { if (romload_global.ROM_GETLENGTH(rom[0]) == romlength) { util.hash_collection hashes = new util.hash_collection(romload_global.ROM_GETHASHDATA(rom[0])); if ((dumped && hashes == romhashes) || (!dumped && romload_global.ROM_GETNAME(rom[0]) == name)) { highest_device = scandevice; } } } } } } } return(highest_device); }
device_t m_shared_device; /* device that shares the rom */ // construction/destruction //------------------------------------------------- // audit_record - constructor //------------------------------------------------- public audit_record(ListPointer <rom_entry> media, media_type type) { m_next = null; m_type = type; m_status = audit_status.STATUS_ERROR; m_substatus = audit_substatus.SUBSTATUS_ERROR; m_name = romload_global.ROM_GETNAME(media[0]); m_explength = romload_global.rom_file_size(media); m_length = 0; m_shared_device = null; m_exphashes.from_internal_string(romload_global.ROM_GETHASHDATA(media[0])); }
void FindPlayableCards() { playable = new List <ListPointer>(); if (hand.Count > 0) { SortPlayable(hand); } else if (visible.Count > 0) { SortPlayable(visible); } else { playable = ListPointer.AllPointers(hidden); } }
//------------------------------------------------- // generate_samples - generate the requested // number of samples for a stream, making sure // all inputs have the appropriate number of // samples generated //------------------------------------------------- void generate_samples(int samples) { ListPointer <stream_sample_t> [] inputs = null; //stream_sample_t **inputs = nullptr; ListPointer <stream_sample_t> [] outputs = null; //stream_sample_t **outputs = nullptr; sound_global.VPRINTF("generate_samples({0}, {1})\n", this, samples); assert(samples > 0); // ensure all inputs are up to date and generate resampled data for (int inputnum = 0; inputnum < m_input.size(); inputnum++) { // update the stream to the current time stream_input input = m_input[inputnum]; if (input.m_source != null) { input.m_source.m_stream.update(); } // generate the resampled data m_input_array[inputnum] = generate_resampled_data(input, (UInt32)samples); } if (!m_input.empty()) { inputs = m_input_array; } // loop over all outputs and compute the output pointer for (int outputnum = 0; outputnum < m_output.size(); outputnum++) { stream_output output = m_output[outputnum]; m_output_array[outputnum] = new ListPointer <stream_sample_t>(output.m_buffer, m_output_sampindex - m_output_base_sampindex); // m_output_array[outputnum] = &output.m_buffer[m_output_sampindex - m_output_base_sampindex]; } if (!m_output.empty()) { outputs = m_output_array; } // run the callback sound_global.VPRINTF(" callback({0}, {1})\n", this, samples); m_callback(this, inputs, outputs, samples); sound_global.VPRINTF(" callback done\n"); }
// internal helpers //------------------------------------------------- // audit_one_rom - validate a single ROM entry //------------------------------------------------- audit_record audit_one_rom(ListPointer <rom_entry> rom) //(const rom_entry *rom) { // allocate and append a new record audit_record record = m_record_list.emplace_back(new audit_record(rom, audit_record.media_type.MEDIA_ROM)).Value; //audit_record &record = *m_record_list.emplace(m_record_list.end(), *rom, media_type::ROM); // see if we have a CRC and extract it if so UInt32 crc; bool has_crc = record.expected_hashes().crc(out crc); // find the file and checksum it, getting the file length along the way emu_file file = new emu_file(m_enumerator.options().media_path(), osdcore_global.OPEN_FLAG_READ | osdcore_global.OPEN_FLAG_NO_PRELOAD); file.set_restrict_to_mediapath(true); path_iterator path = new path_iterator(m_searchpath); string curpath; while (path.next(out curpath, record.name())) { // open the file if we can osd_file.error filerr; if (has_crc) { filerr = file.open(curpath, crc); } else { filerr = file.open(curpath); } // if it worked, get the actual length and hashes, then stop if (filerr == osd_file.error.NONE) { record.set_actual(file.hashes(m_validation), file.size()); break; } } file.close(); // compute the final status compute_status(record, rom[0], record.actual_length() != 0); return(record); }
public static void wav_add_data_16lr(wav_file wav, ListPointer <int16_t> left, ListPointer <int16_t> right, int samples) //wav_file *wav, int16_t *left, int16_t *right, int samples) { std.vector <int16_t> temp = new std.vector <int16_t>(); int i; if (wav == null || samples == 0) { return; } /* resize dynamic array */ temp.resize(samples * 2); /* interleave */ for (i = 0; i < samples * 2; i++) { temp[i] = (i & 1) != 0 ? right[i / 2] : left[i / 2]; } throw new emu_unimplemented(); }
public static void wav_add_data_32(wav_file wav, ListPointer <int32_t> data, int samples, int shift) //wav_file *wav, int32_t *data, int samples, int shift) { std.vector <int16_t> temp = new std.vector <int16_t>(); int i; if (wav == null || samples == 0) { return; } /* resize dynamic array */ temp.resize(samples); /* clamp */ for (i = 0; i < samples; i++) { int val = data[i] >> shift; temp[i] = (Int16)((val < -32768) ? -32768 : (val > 32767) ? 32767 : val); } throw new emu_unimplemented(); }
// device_sound_interface overrides //------------------------------------------------- // sound_stream_update - handle a stream update //------------------------------------------------- public override void sound_stream_update(sound_stream stream, ListPointer <stream_sample_t> [] inputs, ListPointer <stream_sample_t> [] outputs, int samples) { msm5205_device pokey = (msm5205_device)device(); ListPointer <stream_sample_t> buffer = outputs[0]; /* if this voice is active */ if (pokey.signal != 0) { short val = (short)(pokey.signal * 16); while (samples != 0) { buffer[0] = val; //*buffer++ = val; buffer++; samples--; } } else { memset(buffer, 0, (UInt32)samples); //memset(buffer, 0, samples * sizeof(*buffer)); } }
public void transpen(bitmap_rgb32 dest, rectangle cliprect, u32 code, u32 color, int flipx, int flipy, s32 destx, s32 desty, u32 trans_pen) { // special case invalid pens to opaque if (trans_pen > 0xff) { opaque(dest, cliprect, code, color, flipx, flipy, destx, desty); return; } // use pen usage to optimize code %= elements(); if (has_pen_usage()) { // fully transparent; do nothing UInt32 usage = pen_usage(code); if ((usage & ~(1 << (int)trans_pen)) == 0) { return; } // fully opaque; draw as such if ((usage & (1 << (int)trans_pen)) == 0) { opaque(dest, cliprect, code, color, flipx, flipy, destx, desty); return; } } // render ListPointer <rgb_t> paldata = new ListPointer <rgb_t>(m_palette.pens(), (int)(colorbase() + granularity() * (color % colors()))); //const pen_t *paldata = m_palette.pens() + colorbase() + granularity() * (color % colors()); //DECLARE_NO_PRIORITY; bitmap_t priority = drawgfxm_global.drawgfx_dummy_priority_bitmap; //DRAWGFX_CORE(u32, PIXEL_OP_REMAP_TRANSPEN, NO_PRIORITY); drawgfxm_global.DRAWGFX_CORE <u32, drawgfxm_global.NO_PRIORITY>(drawgfxm_global.PIXEL_OP_REMAP_TRANSPEN, cliprect, destx, desty, width(), height(), flipx, flipy, rowbytes(), get_data, code, dest, priority, color, trans_pen, paldata, 2); }
public static void wav_add_data_32lr(wav_file wav, ListPointer <int32_t> left, ListPointer <int32_t> right, int samples, int shift) //wav_file *wav, int32_t *left, int32_t *right, int samples, int shift) { std.vector <int16_t> temp = new std.vector <int16_t>(); int i; if (wav == null || samples == 0) { return; } /* resize dynamic array */ temp.resize(samples); /* interleave */ for (i = 0; i < samples * 2; i++) { int val = (i & 1) != 0 ? right[i / 2] : left[i / 2]; val >>= shift; temp[i] = (Int16)((val < -32768) ? -32768 : (val > 32767) ? 32767 : val); } throw new emu_unimplemented(); }
//DISCRETE_CLASS_DESTRUCTOR(_name) \ //~discrete_dsd_555_astbl_node() { } // discrete_base_node //DISCRETE_RESET(dsd_555_astbl) public override void reset() { discrete_555_desc info = (discrete_555_desc)this.custom_data(); //DISCRETE_DECLARE_INFO(discrete_555_desc) m_use_ctrlv = (this.input_is_node() >> 4) & 1; m_output_type = info.options & DISC_555_OUT_MASK; /* Use the defaults or supplied values. */ m_v_out_high = (info.v_out_high == DEFAULT_555_HIGH) ? info.v_pos - 1.2 : info.v_out_high; /* setup v_charge or node */ m_v_charge_node = m_device.node_output_ptr((int)info.v_charge); if (m_v_charge_node == null) { m_v_charge = (info.v_charge == DEFAULT_555_CHARGE) ? info.v_pos : info.v_charge; if ((info.options & DISC_555_ASTABLE_HAS_FAST_CHARGE_DIODE) != 0) { m_v_charge -= 0.5; } } if ((DSD_555_ASTBL__CTRLV != -1) && m_use_ctrlv == 0) { /* Setup based on supplied Control Voltage static value */ m_threshold = DSD_555_ASTBL__CTRLV; m_trigger = DSD_555_ASTBL__CTRLV / 2.0; } else { /* Setup based on v_pos power source */ m_threshold = info.v_pos * 2.0 / 3.0; m_trigger = info.v_pos / 3.0; } /* optimization if none of the values are nodes */ m_has_rc_nodes = 0; if ((this.input_is_node() & DSD_555_ASTBL_RC_MASK) != 0) { m_has_rc_nodes = 1; } else { m_t_rc_bleed = DSD_555_ASTBL_T_RC_BLEED; m_exp_bleed = RC_CHARGE_EXP(m_t_rc_bleed); m_t_rc_charge = DSD_555_ASTBL_T_RC_CHARGE(info); m_exp_charge = RC_CHARGE_EXP(m_t_rc_charge); m_t_rc_discharge = DSD_555_ASTBL_T_RC_DISCHARGE; m_exp_discharge = RC_CHARGE_EXP(m_t_rc_discharge); } m_output_is_ac = info.options & DISC_555_OUT_AC; /* Calculate DC shift needed to make squarewave waveform AC */ m_ac_shift = (m_output_is_ac != 0) ? -m_v_out_high / 2.0 : 0; m_flip_flop = 1; m_cap_voltage = 0; /* Step to set the output */ this.step(); }
// device_sound_interface overrides //------------------------------------------------- // sound_stream_update - handle a stream update //------------------------------------------------- public override void sound_stream_update(sound_stream stream, ListPointer <stream_sample_t> [] inputs, ListPointer <stream_sample_t> [] outputs, int samples) { ay8910_device ay8910 = (ay8910_device)device(); ListPointer <stream_sample_t> [] buf = new ListPointer <stream_sample_t> [ay8910_device.NUM_CHANNELS]; //stream_sample_t *buf[NUM_CHANNELS]; int chan; buf[0] = new ListPointer <stream_sample_t>(outputs[0]); buf[1] = null; buf[2] = null; if (ay8910.m_streams == ay8910_device.NUM_CHANNELS) { buf[1] = outputs[1]; buf[2] = outputs[2]; } /* hack to prevent us from hanging when starting filtered outputs */ if (ay8910.m_ready == 0) { for (chan = 0; chan < ay8910_device.NUM_CHANNELS; chan++) { if (buf[chan] != null) { memset(buf[chan], 0, (UInt32)samples); //memset(buf[chan], 0, samples * sizeof_(*buf[chan])); } } } /* The 8910 has three outputs, each output is the mix of one of the three */ /* tone generators and of the (single) noise generator. The two are mixed */ /* BEFORE going into the DAC. The formula to mix each channel is: */ /* (ToneOn | ToneDisable) & (NoiseOn | NoiseDisable). */ /* Note that this means that if both tone and noise are disabled, the output */ /* is 1, not 0, and can be modulated changing the volume. */ /* buffering loop */ while (samples != 0) { for (chan = 0; chan < ay8910_device.NUM_CHANNELS; chan++) { ay8910.m_count[chan]++; if (ay8910.m_count[chan] >= ay8910.TONE_PERIOD(chan)) { ay8910.m_output[chan] ^= 1; ay8910.m_count[chan] = 0; } } ay8910.m_count_noise++; if (ay8910.m_count_noise >= ay8910.NOISE_PERIOD()) { /* toggle the prescaler output. Noise is no different to * channels. */ ay8910.m_count_noise = 0; ay8910.m_prescale_noise ^= 1; if (ay8910.m_prescale_noise != 0) { /* The Random Number Generator of the 8910 is a 17-bit shift */ /* register. The input to the shift register is bit0 XOR bit3 */ /* (bit0 is the output). This was verified on AY-3-8910 and YM2149 chips. */ ay8910.m_rng ^= (((ay8910.m_rng & 1) ^ ((ay8910.m_rng >> 3) & 1)) << 17); ay8910.m_rng >>= 1; } } for (chan = 0; chan < ay8910_device.NUM_CHANNELS; chan++) { ay8910.m_vol_enabled[chan] = (byte)((ay8910.m_output[chan] | ay8910.TONE_ENABLEQ(chan)) & (ay8910.NOISE_OUTPUT() | ay8910.NOISE_ENABLEQ(chan))); } /* update envelope */ if (ay8910.m_holding == 0) { ay8910.m_count_env++; if (ay8910.m_count_env >= ay8910.ENVELOPE_PERIOD() * ay8910.m_step) { ay8910.m_count_env = 0; ay8910.m_env_step--; /* check envelope current position */ if (ay8910.m_env_step < 0) { if (ay8910.m_hold != 0) { if (ay8910.m_alternate != 0) { ay8910.m_attack ^= ay8910.m_env_step_mask; } ay8910.m_holding = 1; ay8910.m_env_step = 0; } else { /* if CountEnv has looped an odd number of times (usually 1), */ /* invert the output. */ if (ay8910.m_alternate != 0 && (ay8910.m_env_step & (ay8910.m_env_step_mask + 1)) != 0) { ay8910.m_attack ^= ay8910.m_env_step_mask; } ay8910.m_env_step &= (sbyte)ay8910.m_env_step_mask; } } } } ay8910.m_env_volume = (UInt32)(ay8910.m_env_step ^ ay8910.m_attack); if (ay8910.m_streams == 3) { for (chan = 0; chan < ay8910_device.NUM_CHANNELS; chan++) { if (ay8910.TONE_ENVELOPE(chan) != 0) { if (ay8910.type() == ay8914_device.AY8914) // AY8914 Has a two bit tone_envelope field { buf[chan][0] = ay8910.m_env_table[chan, ay8910.m_vol_enabled[chan] != 0 ? ay8910.m_env_volume >> (3 - ay8910.TONE_ENVELOPE(chan)) : 0]; // *(buf[chan]++) buf[chan]++; } else { buf[chan][0] = ay8910.m_env_table[chan, ay8910.m_vol_enabled[chan] != 0 ? ay8910.m_env_volume : 0]; // *(buf[chan]++) buf[chan]++; } } else { buf[chan][0] = ay8910.m_vol_table[chan, ay8910.m_vol_enabled[chan] != 0 ? ay8910.TONE_VOLUME(chan) : 0]; // *(buf[chan]++) buf[chan]++; } } } else { buf[0][0] = ay8910.mix_3D(); // *(buf[0]++) buf[0]++; } samples--; } }
//------------------------------------------------- // generate_resampled_data - generate the // resample buffer for a given input //------------------------------------------------- ListPointer <stream_sample_t> generate_resampled_data(stream_input input, UInt32 numsamples) { // if we don't have an output to pull data from, generate silence ListPointer <stream_sample_t> dest = new ListPointer <stream_sample_t>(input.m_resample); // stream_sample_t *dest = input.m_resample; if (input.m_source == null || input.m_source.m_stream.m_attoseconds_per_sample == 0) { memset(dest, 0, numsamples); //memset(dest, 0, numsamples * sizeof(*dest)); return(new ListPointer <stream_sample_t>(input.m_resample)); } // grab data from the output stream_output output = input.m_source; // stream_output &output = *input.m_source; sound_stream input_stream = output.m_stream; // sound_stream &input_stream = *output.m_stream; s64 gain = (input.m_gain * input.m_user_gain * output.m_gain) >> 16; // determine the time at which the current sample begins, accounting for the // latency we calculated between the input and output streams attoseconds_t basetime = m_output_sampindex * m_attoseconds_per_sample - input.m_latency_attoseconds; // now convert that time into a sample in the input stream s32 basesample; if (basetime >= 0) { basesample = (int)(basetime / input_stream.m_attoseconds_per_sample); } else { basesample = (int)(-(-basetime / input_stream.m_attoseconds_per_sample) - 1); } // compute a source pointer to the first sample assert(basesample >= input_stream.m_output_base_sampindex); ListPointer <stream_sample_t> source = new ListPointer <stream_sample_t>(output.m_buffer, basesample - input_stream.m_output_base_sampindex); // stream_sample_t *source = &output.m_buffer[basesample - input_stream.m_output_base_sampindex]; // determine the current fraction of a sample, expressed as a fraction of FRAC_ONE // (Note: this formula is valid as long as input_stream.m_attoseconds_per_sample signficantly exceeds FRAC_ONE > attoseconds = 4.2E-12 s) u32 basefrac = (u32)((basetime - basesample * input_stream.m_attoseconds_per_sample) / ((input_stream.m_attoseconds_per_sample + FRAC_ONE - 1) >> (int)FRAC_BITS)); assert(basefrac < FRAC_ONE); // compute the stepping fraction u32 step = (u32)(((u64)(input_stream.m_sample_rate) << (int)FRAC_BITS) / m_sample_rate); // if we have equal sample rates, we just need to copy if (step == FRAC_ONE) { while (numsamples-- != 0) { // compute the sample s64 sample = source[0]; // *source++; source++; dest[0] = (int)((sample * gain) >> 8); // *dest++ = (sample * gain) >> 8; dest++; } } // input is undersampled: point sample except where our sample period covers a boundary else if (step < FRAC_ONE) { while (numsamples != 0) { // fill in with point samples until we hit a boundary int nextfrac; while ((nextfrac = (int)(basefrac + step)) < FRAC_ONE && numsamples-- != 0) { dest[0] = (int)((source[0] * gain) >> 8); // *dest++ = (source[0] * gain) >> 8; dest++; basefrac = (UInt32)nextfrac; } // if we're done, we're done if ((s32)(numsamples--) < 0) { break; } // compute starting and ending fractional positions int startfrac = (int)(basefrac >> (int)(FRAC_BITS - 12)); int endfrac = nextfrac >> (int)(FRAC_BITS - 12); // blend between the two samples accordingly s64 sample = ((s64)source[0] * (0x1000 - startfrac) + (s64)source[1] * (endfrac - 0x1000)) / (endfrac - startfrac); dest[0] = (int)((sample * gain) >> 8); // *dest++ = (sample * gain) >> 8; dest++; // advance basefrac = (UInt32)(nextfrac & FRAC_MASK); source++; } } // input is oversampled: sum the energy else { // use 8 bits to allow some extra headroom int smallstep = (int)(step >> (int)(FRAC_BITS - 8)); while (numsamples-- != 0) { s64 remainder = smallstep; int tpos = 0; // compute the sample s64 scale = (FRAC_ONE - basefrac) >> (int)(FRAC_BITS - 8); s64 sample = (s64)source[tpos++] * scale; remainder -= scale; while (remainder > 0x100) { sample += (Int64)source[tpos++] * (Int64)0x100; remainder -= 0x100; } sample += (Int64)source[tpos] * remainder; sample /= smallstep; dest[0] = (int)((sample * gain) >> 8); // *dest++ = (sample * gain) >> 8; dest++; // advance basefrac += step; source += basefrac >> (int)FRAC_BITS; basefrac &= FRAC_MASK; } } return(new ListPointer <stream_sample_t>(input.m_resample)); }
// getters //const simple_list<audit_record> &records() const { return m_record_list; } // audit operations //------------------------------------------------- // audit_media - audit the media described by the // currently-enumerated driver //------------------------------------------------- public summary audit_media(string validation = AUDIT_VALIDATE_FULL) { // start fresh m_record_list.clear(); // store validation for later m_validation = validation; // temporary hack until romload is update: get the driver path and support it for // all searches string driverpath = m_enumerator.config().root_device().searchpath(); int found = 0; int required = 0; int shared_found = 0; int shared_required = 0; // iterate over devices and regions foreach (device_t device in new device_iterator(m_enumerator.config().root_device())) { // determine the search path for this source and iterate through the regions m_searchpath = device.searchpath(); // now iterate over regions and ROMs within for (ListPointer <rom_entry> region = romload_global.rom_first_region(device); region != null; region = romload_global.rom_next_region(region)) { // temporary hack: add the driver path & region name string combinedpath = device.searchpath() + ";" + driverpath; if (!string.IsNullOrEmpty(device.shortname())) { combinedpath += ";" + device.shortname(); } m_searchpath = combinedpath; for (ListPointer <rom_entry> rom = romload_global.rom_first_file(region); rom != null; rom = romload_global.rom_next_file(rom)) { string name = romload_global.ROM_GETNAME(rom[0]); util.hash_collection hashes = new util.hash_collection(romload_global.ROM_GETHASHDATA(rom[0])); device_t shared_device = find_shared_device(device, name, hashes, romload_global.ROM_GETLENGTH(rom[0])); // count the number of files with hashes if (!hashes.flag(util.hash_collection.FLAG_NO_DUMP) && !romload_global.ROM_ISOPTIONAL(rom[0])) { required++; if (shared_device != null) { shared_required++; } } // audit a file audit_record record = null; if (romload_global.ROMREGION_ISROMDATA(region[0])) { record = audit_one_rom(rom); } // audit a disk else if (romload_global.ROMREGION_ISDISKDATA(region[0])) { record = audit_one_disk(rom); } if (record != null) { // count the number of files that are found. if (record.status() == audit_record.audit_status.STATUS_GOOD || (record.status() == audit_record.audit_status.STATUS_FOUND_INVALID && find_shared_device(device, name, record.actual_hashes(), record.actual_length()) == null)) { found++; if (shared_device != null) { shared_found++; } } record.set_shared_device(shared_device); } } } } // if we only find files that are in the parent & either the set has no unique files or the parent is not found, then assume we don't have the set at all if (found == shared_found && required > 0 && (required != shared_required || shared_found == 0)) { m_record_list.clear(); return(summary.NOTFOUND); } // return a summary string unused = ""; return(summarize(m_enumerator.driver().name, ref unused)); }
//------------------------------------------------- // update - mix everything down to its final form // and send it to the OSD layer //------------------------------------------------- void update(object o = null, s32 param = 0) // (void *ptr = nullptr, s32 param = 0); { sound_global.VPRINTF("sound_update\n"); profiler_global.g_profiler.start(profile_type.PROFILER_SOUND); // force all the speaker streams to generate the proper number of samples int samples_this_update = 0; foreach (speaker_device speaker in new speaker_device_iterator(machine().root_device())) { speaker.mix(m_leftmix, m_rightmix, ref samples_this_update, (m_muted & MUTE_REASON_SYSTEM) != 0); } // now downmix the final result u32 finalmix_step = (UInt32)machine().video().speed_factor(); u32 finalmix_offset = 0; ListPointer <s16> finalmix = new ListPointer <s16>(m_finalmix); //s16 *finalmix = &m_finalmix[0]; int sample; for (sample = (int)m_finalmix_leftover; sample < samples_this_update * 1000; sample += (int)finalmix_step) { int sampindex = sample / 1000; // clamp the left side int samp = m_leftmix[sampindex]; if (samp < -32768) { samp = -32768; } else if (samp > 32767) { samp = 32767; } finalmix[finalmix_offset++] = (Int16)samp; // clamp the right side samp = m_rightmix[sampindex]; if (samp < -32768) { samp = -32768; } else if (samp > 32767) { samp = 32767; } finalmix[finalmix_offset++] = (Int16)samp; } m_finalmix_leftover = (UInt32)(sample - samples_this_update * 1000); // play the result if (finalmix_offset > 0) { if (m_nosound_mode == 0) { machine().osd().update_audio_stream(finalmix, (int)(finalmix_offset / 2)); } machine().osd().add_audio_to_recording(finalmix, (int)finalmix_offset / 2); machine().video().add_sound_to_recording(finalmix, (int)(finalmix_offset / 2)); if (m_wavfile != null) { wavwrite_global.wav_add_data_16(m_wavfile, finalmix, (int)finalmix_offset); } } // see if we ticked over to the next second attotime curtime = machine().time(); bool second_tick = false; if (curtime.seconds() != m_last_update.seconds()) { assert(curtime.seconds() == m_last_update.seconds() + 1); second_tick = true; } // iterate over all the streams and update them foreach (var stream in m_stream_list) { stream.update_with_accounting(second_tick); } // remember the update time m_last_update = curtime; // update sample rates if they have changed foreach (var stream in m_stream_list) { stream.apply_sample_rate_changes(); } profiler_global.g_profiler.stop(); }
//~sound_module() { } public abstract void update_audio_stream(bool is_throttled, ListPointer <Int16> buffer, int samples_this_frame); //const int16_t *buffer, int samples_this_frame)
static void Main(string[] args) { int[] arr = new int[9] { 1, 0, 2, 3, 4, 5, 6, 7, 8 }; Console.WriteLine("Welcome to the 8-Puzzle AI solver!"); Console.Write("Enter initial state of puzzle: "); string inititial_State = Console.ReadLine(); if (inititial_State.Length != 9) { Console.WriteLine("Error, missing values"); } else { for (int i = 0; i < 9; i++) { arr[i] = (int)Char.GetNumericValue(inititial_State[i]); } node Leaf = new node(arr); Leaf.printPuzzle(); Leaf.goalTest(); List <node> listOfObjects = new List <node>(); listOfObjects.Add(Leaf); int flag = 0; //to catch the goal node ListPointer; int count = 0; node goalPointer = new node(arr); while (flag == 0) { ListPointer = listOfObjects[count]; //leaf at begining ListPointer.Expand(); for (int i = 0; i < 4; i++) { if (ListPointer.children[i] != null) { if (ListPointer.children[i].goalTest()) { flag = 1; goalPointer = ListPointer.children[i]; break; } else { if (duplication(listOfObjects, ListPointer.children[i].state) == false) { listOfObjects.Add(ListPointer.children[i]); } } } } count++; } int flag2 = 0; List <node> goalList = new List <node>(); while (flag2 == 0) { goalList.Add(goalPointer); goalPointer = goalPointer.parent; if (goalPointer.parent == null) { flag2 = 1; //goalPointer.printPuzzle(); break; } } Console.WriteLine("Path to Solution:"); for (int i = goalList.Count - 1; i >= 0; i--) { goalList[i].printPuzzle(); } Console.WriteLine("Number of generated states = " + node.generatedStates); Console.WriteLine("Number of expanded states = " + node.expandedStates); string end; Console.WriteLine("Press enter to close..."); Console.ReadLine(); } }
//speaker_device &front_left() { set_position(-0.2, 0.0, 1.0); return *this; } //speaker_device &front_right() { set_position(0.2, 0.0, 1.0); return *this; } //speaker_device &rear_center() { set_position(0.0, 0.0, -0.5); return *this; } //speaker_device &rear_left() { set_position(-0.2, 0.0, -0.5); return *this; } //speaker_device &rear_right() { set_position(0.2, 0.0, -0.5); return *this; } //speaker_device &subwoofer() { set_position(0.0, 0.0, 0.0); return *this; } // internally for use by the sound system //------------------------------------------------- // mix - mix in samples from the speaker's stream //------------------------------------------------- public void mix(ListBase <s32> leftmix, ListBase <s32> rightmix, ref int samples_this_update, bool suppress) //s32 *leftmix, s32 *rightmix, int &samples_this_update, bool suppress) { // skip if no stream if (m_dimixer.mixer_stream() == null) { return; } // update the stream, getting the start/end pointers around the operation int numsamples; ListPointer <stream_sample_t> stream_buf = m_dimixer.mixer_stream().output_since_last_update(0, out numsamples); // set or assert that all streams have the same count if (samples_this_update == 0) { samples_this_update = numsamples; // reset the mixing streams //memset(leftmix, 0, samples_this_update * sizeof(*leftmix)); //memset(rightmix, 0, samples_this_update * sizeof(*rightmix)); for (int i = 0; i < samples_this_update; i++) { leftmix[i] = 0; rightmix[i] = 0; } } assert(samples_this_update == numsamples); #if MAME_DEBUG // debug version: keep track of the maximum sample for (int sample = 0; sample < samples_this_update; sample++) { if (stream_buf[sample] > m_max_sample) { m_max_sample = stream_buf[sample]; } else if (-stream_buf[sample] > m_max_sample) { m_max_sample = -stream_buf[sample]; } if (stream_buf[sample] > 32767 || stream_buf[sample] < -32768) { m_clipped_samples++; } m_total_samples++; } #endif // mix if sound is enabled if (!suppress) { // if the speaker is centered, send to both left and right if (m_x == 0) { for (int sample = 0; sample < samples_this_update; sample++) { leftmix[sample] += stream_buf[sample]; rightmix[sample] += stream_buf[sample]; } } // if the speaker is to the left, send only to the left else if (m_x < 0) { for (int sample = 0; sample < samples_this_update; sample++) { leftmix[sample] += stream_buf[sample]; } } // if the speaker is to the right, send only to the right else { for (int sample = 0; sample < samples_this_update; sample++) { rightmix[sample] += stream_buf[sample]; } } } }
public abstract error append_sound_samples(int channel, ListPointer <int16_t> samples, uint32_t numsamples, uint32_t sampleskip); //std::int16_t const *samples
// 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; } } }