summaryrefslogtreecommitdiffstats
path: root/src/devices/machine/laserdsc.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/devices/machine/laserdsc.cpp')
-rw-r--r--src/devices/machine/laserdsc.cpp78
1 files changed, 39 insertions, 39 deletions
diff --git a/src/devices/machine/laserdsc.cpp b/src/devices/machine/laserdsc.cpp
index 40632fa42c6..6c20da364e4 100644
--- a/src/devices/machine/laserdsc.cpp
+++ b/src/devices/machine/laserdsc.cpp
@@ -31,21 +31,21 @@
//**************************************************************************
// these specs code from IEC 60857, for NTSC players
-const UINT32 LEAD_IN_MIN_RADIUS_IN_UM = 53500; // 53.5 mm
-const UINT32 PROGRAM_MIN_RADIUS_IN_UM = 55000; // 55 mm
-const UINT32 PROGRAM_MAX_RADIUS_IN_UM = 145000; // 145 mm
-const UINT32 LEAD_OUT_MIN_SIZE_IN_UM = 2000; // 2 mm
+const uint32_t LEAD_IN_MIN_RADIUS_IN_UM = 53500; // 53.5 mm
+const uint32_t PROGRAM_MIN_RADIUS_IN_UM = 55000; // 55 mm
+const uint32_t PROGRAM_MAX_RADIUS_IN_UM = 145000; // 145 mm
+const uint32_t LEAD_OUT_MIN_SIZE_IN_UM = 2000; // 2 mm
// the track pitch is defined as a range; we pick a nominal pitch
// that ensures we can fit 54,000 tracks
-//const UINT32 MIN_TRACK_PITCH_IN_NM = 1400; // 1.4 um
-//const UINT32 MAX_TRACK_PITCH_IN_NM = 2000; // 2 um
-const UINT32 NOMINAL_TRACK_PITCH_IN_NM = (PROGRAM_MAX_RADIUS_IN_UM - PROGRAM_MIN_RADIUS_IN_UM) * 1000 / 54000;
+//const uint32_t MIN_TRACK_PITCH_IN_NM = 1400; // 1.4 um
+//const uint32_t MAX_TRACK_PITCH_IN_NM = 2000; // 2 um
+const uint32_t NOMINAL_TRACK_PITCH_IN_NM = (PROGRAM_MAX_RADIUS_IN_UM - PROGRAM_MIN_RADIUS_IN_UM) * 1000 / 54000;
// we simulate extra lead-in and lead-out tracks
-const UINT32 VIRTUAL_LEAD_IN_TRACKS = (PROGRAM_MIN_RADIUS_IN_UM - LEAD_IN_MIN_RADIUS_IN_UM) * 1000 / NOMINAL_TRACK_PITCH_IN_NM;
-const UINT32 MAX_TOTAL_TRACKS = 54000;
-const UINT32 VIRTUAL_LEAD_OUT_TRACKS = LEAD_OUT_MIN_SIZE_IN_UM * 1000 / NOMINAL_TRACK_PITCH_IN_NM;
+const uint32_t VIRTUAL_LEAD_IN_TRACKS = (PROGRAM_MIN_RADIUS_IN_UM - LEAD_IN_MIN_RADIUS_IN_UM) * 1000 / NOMINAL_TRACK_PITCH_IN_NM;
+const uint32_t MAX_TOTAL_TRACKS = 54000;
+const uint32_t VIRTUAL_LEAD_OUT_TRACKS = LEAD_OUT_MIN_SIZE_IN_UM * 1000 / NOMINAL_TRACK_PITCH_IN_NM;
@@ -57,7 +57,7 @@ const UINT32 VIRTUAL_LEAD_OUT_TRACKS = LEAD_OUT_MIN_SIZE_IN_UM * 1000 / NOMINAL_
// laserdisc_device - constructor
//-------------------------------------------------
-laserdisc_device::laserdisc_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
+laserdisc_device::laserdisc_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, uint32_t clock, const char *shortname, const char *source)
: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
device_sound_interface(mconfig, *this),
device_video_interface(mconfig, *this),
@@ -121,7 +121,7 @@ laserdisc_device::~laserdisc_device()
// read from the disc
//-------------------------------------------------
-UINT32 laserdisc_device::get_field_code(laserdisc_field_code code, bool zero_if_squelched)
+uint32_t laserdisc_device::get_field_code(laserdisc_field_code code, bool zero_if_squelched)
{
// return nothing if the video is off (external devices can't sense)
if (zero_if_squelched && m_videosquelch)
@@ -152,7 +152,7 @@ UINT32 laserdisc_device::get_field_code(laserdisc_field_code code, bool zero_if_
// screen_update - handle updating the screen
//-------------------------------------------------
-UINT32 laserdisc_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
+uint32_t laserdisc_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
// handle the overlay if present
screen_bitmap &overbitmap = m_overbitmap[m_overindex];
@@ -233,7 +233,7 @@ void laserdisc_device::static_set_audio(device_t &device, laserdisc_audio_delega
// static_set_overlay - set the overlay parameters
//-------------------------------------------------
-void laserdisc_device::static_set_overlay(device_t &device, UINT32 width, UINT32 height, screen_update_ind16_delegate update)
+void laserdisc_device::static_set_overlay(device_t &device, uint32_t width, uint32_t height, screen_update_ind16_delegate update)
{
laserdisc_device &ld = downcast<laserdisc_device &>(device);
ld.m_overwidth = width;
@@ -243,7 +243,7 @@ void laserdisc_device::static_set_overlay(device_t &device, UINT32 width, UINT32
ld.m_overupdate_rgb32 = screen_update_rgb32_delegate();
}
-void laserdisc_device::static_set_overlay(device_t &device, UINT32 width, UINT32 height, screen_update_rgb32_delegate update)
+void laserdisc_device::static_set_overlay(device_t &device, uint32_t width, uint32_t height, screen_update_rgb32_delegate update)
{
laserdisc_device &ld = downcast<laserdisc_device &>(device);
ld.m_overwidth = width;
@@ -259,7 +259,7 @@ void laserdisc_device::static_set_overlay(device_t &device, UINT32 width, UINT32
// memregion
//-------------------------------------------------
-void laserdisc_device::static_set_overlay_clip(device_t &device, INT32 minx, INT32 maxx, INT32 miny, INT32 maxy)
+void laserdisc_device::static_set_overlay_clip(device_t &device, int32_t minx, int32_t maxx, int32_t miny, int32_t maxy)
{
downcast<laserdisc_device &>(device).m_overclip.set(minx, maxx, miny, maxy);
}
@@ -416,8 +416,8 @@ void laserdisc_device::device_timer(emu_timer &timer, device_timer_id id, int pa
void laserdisc_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
{
// compute AND values based on the squelch
- INT16 leftand = (m_audiosquelch & 1) ? 0x0000 : 0xffff;
- INT16 rightand = (m_audiosquelch & 2) ? 0x0000 : 0xffff;
+ int16_t leftand = (m_audiosquelch & 1) ? 0x0000 : 0xffff;
+ int16_t rightand = (m_audiosquelch & 2) ? 0x0000 : 0xffff;
// see if we have enough samples to fill the buffer; if not, drop out
int samples_avail = m_audiobufin - m_audiobufout;
@@ -436,8 +436,8 @@ void laserdisc_device::sound_stream_update(sound_stream &stream, stream_sample_t
// otherwise, stream from our buffer
else
{
- INT16 *buffer0 = &m_audiobuffer[0][0];
- INT16 *buffer1 = &m_audiobuffer[1][0];
+ int16_t *buffer0 = &m_audiobuffer[0][0];
+ int16_t *buffer1 = &m_audiobuffer[1][0];
int sampout = m_audiobufout;
// copy samples, clearing behind us as we go
@@ -479,7 +479,7 @@ void laserdisc_device::sound_stream_update(sound_stream &stream, stream_sample_t
// slider speed
//-------------------------------------------------
-void laserdisc_device::set_slider_speed(INT32 tracks_per_vsync)
+void laserdisc_device::set_slider_speed(int32_t tracks_per_vsync)
{
// update to the current time
update_slider_pos();
@@ -507,7 +507,7 @@ void laserdisc_device::set_slider_speed(INT32 tracks_per_vsync)
// a certain number of tracks
//-------------------------------------------------
-void laserdisc_device::advance_slider(INT32 numtracks)
+void laserdisc_device::advance_slider(int32_t numtracks)
{
// first update to the current time
update_slider_pos();
@@ -550,9 +550,9 @@ laserdisc_device::slider_position laserdisc_device::get_slider_position()
// that works for most situations
//-------------------------------------------------
-INT32 laserdisc_device::generic_update(const vbi_metadata &vbi, int fieldnum, const attotime &curtime, player_state_info &newstate)
+int32_t laserdisc_device::generic_update(const vbi_metadata &vbi, int fieldnum, const attotime &curtime, player_state_info &newstate)
{
- INT32 advanceby = 0;
+ int32_t advanceby = 0;
int frame;
// start by assuming the state doesn't change
@@ -688,7 +688,7 @@ INT32 laserdisc_device::generic_update(const vbi_metadata &vbi, int fieldnum, co
// otherwise, if we got frame data from the VBI, update our seeking logic
else if (m_player_state.m_substate == 0 && frame != FRAME_NOT_PRESENT)
{
- INT32 delta = (m_player_state.m_param - 2) - frame;
+ int32_t delta = (m_player_state.m_param - 2) - frame;
// if we're within a couple of frames, just play until we hit it
if (delta >= 0 && delta <= 2)
@@ -772,7 +772,7 @@ void laserdisc_device::init_disc()
throw emu_fatalerror("Laserdisc video must be interlaced!");
// determine the maximum track and allocate a frame buffer
- UINT32 totalhunks = m_disc->hunk_count();
+ uint32_t totalhunks = m_disc->hunk_count();
m_chdtracks = totalhunks / 2;
// allocate memory for the precomputed per-frame metadata
@@ -869,7 +869,7 @@ void laserdisc_device::init_audio()
m_stream = stream_alloc(0, 2, 48000);
// allocate audio buffers
- m_audiomaxsamples = ((UINT64)m_samplerate * 1000000 + m_fps_times_1million - 1) / m_fps_times_1million;
+ m_audiomaxsamples = ((uint64_t)m_samplerate * 1000000 + m_fps_times_1million - 1) / m_fps_times_1million;
m_audiobufsize = m_audiomaxsamples * 4;
m_audiobuffer[0].resize(m_audiobufsize);
m_audiobuffer[1].resize(m_audiobufsize);
@@ -885,15 +885,15 @@ void laserdisc_device::init_audio()
// given color pattern
//-------------------------------------------------
-void laserdisc_device::fillbitmap_yuy16(bitmap_yuy16 &bitmap, UINT8 yval, UINT8 cr, UINT8 cb)
+void laserdisc_device::fillbitmap_yuy16(bitmap_yuy16 &bitmap, uint8_t yval, uint8_t cr, uint8_t cb)
{
- UINT16 color0 = (yval << 8) | cb;
- UINT16 color1 = (yval << 8) | cr;
+ uint16_t color0 = (yval << 8) | cb;
+ uint16_t color1 = (yval << 8) | cr;
// write 32 bits of color (2 pixels at a time)
for (int y = 0; y < bitmap.height(); y++)
{
- UINT16 *dest = &bitmap.pix16(y);
+ uint16_t *dest = &bitmap.pix16(y);
for (int x = 0; x < bitmap.width() / 2; x++)
{
*dest++ = color0;
@@ -925,14 +925,14 @@ void laserdisc_device::update_slider_pos()
// determine how many tracks we covered and advance
if (m_attospertrack >= 0)
{
- INT32 tracks_covered = delta / m_attospertrack;
+ int32_t tracks_covered = delta / m_attospertrack;
add_and_clamp_track(tracks_covered);
if (tracks_covered != 0)
m_sliderupdate += attotime(0, tracks_covered * m_attospertrack);
}
else
{
- INT32 tracks_covered = delta / -m_attospertrack;
+ int32_t tracks_covered = delta / -m_attospertrack;
add_and_clamp_track(-tracks_covered);
if (tracks_covered != 0)
m_sliderupdate += attotime(0, tracks_covered * -m_attospertrack);
@@ -986,10 +986,10 @@ laserdisc_device::frame_data &laserdisc_device::current_frame()
void laserdisc_device::read_track_data()
{
// compute the chdhunk number we are going to read
- INT32 chdtrack = m_curtrack - 1 - VIRTUAL_LEAD_IN_TRACKS;
- chdtrack = (std::max<INT32>)(chdtrack, 0);
- chdtrack = (std::min<UINT32>)(chdtrack, m_chdtracks - 1);
- UINT32 readhunk = chdtrack * 2 + m_fieldnum;
+ int32_t chdtrack = m_curtrack - 1 - VIRTUAL_LEAD_IN_TRACKS;
+ chdtrack = (std::max<int32_t>)(chdtrack, 0);
+ chdtrack = (std::min<uint32_t>)(chdtrack, m_chdtracks - 1);
+ uint32_t readhunk = chdtrack * 2 + m_fieldnum;
// cheat and look up the metadata we are about to retrieve
vbi_metadata vbidata = { 0 };
@@ -1046,7 +1046,7 @@ void laserdisc_device::read_track_data()
// set the VBI data for the new field from our precomputed data
if (!m_vbidata.empty())
{
- UINT32 vbiframe;
+ uint32_t vbiframe;
vbi_metadata_unpack(&m_metadata[m_fieldnum], &vbiframe, &m_vbidata[readhunk * VBI_PACKED_BYTES]);
}
@@ -1118,7 +1118,7 @@ void laserdisc_device::process_track_data()
if (m_avhuff_config.audio[chnum] == &m_audiobuffer[chnum][0])
{
// move data to the end
- UINT32 samplesleft = m_audiobufsize - m_audiobufin;
+ uint32_t samplesleft = m_audiobufsize - m_audiobufin;
samplesleft = std::min(samplesleft, m_audiocursamples);
memmove(&m_audiobuffer[chnum][m_audiobufin], &m_audiobuffer[chnum][0], samplesleft * 2);