Remaining TODO list:
- take WP into account
- test the amstrad, implement its observational format (edsk) using
pasti as a start. Or find the legendary amstrad IPFs. Or both.
- correct read track, the implementation is completely wrong. See
previous for testing, it's only used in protections the check the
inter-sector gaps.
- shake and bake on the amstrad, protections are the best to find bugs
in a fdc
- add the scan id commands, but nothing seems to use them
- debug the 2.88M formatting which is unreliable. Fix its IDAM/DAM
gap size on formatting too (but that's not what's making it
unreliable)
- test all the systems that were hit, and fix what needs to be fixed.
Beware that multiple problems may happen:
- upd765 may be wrong
- the driver may not be working
- the hookup may be wrong/incomplete (bitrate selection and floppy
rpm in particular)
- the driver may be too limited for the new implementation (the x68k
dma device does not handle non-instant dma yet for instance)
- report invalid command when appropriate depending on the actual chip
emulated
- add the russian clones with their real names
and a sparse bitmap for tracking which areas got updated.
This allows sprites to be rendered independently to their own
bitmap and then mixed in a final step. Converted the Sega
sprite device over to this new model, and moved the mixing
steps out of the sprite implementations and into the driver-
specific video updates where it belongs. [Aaron Giles]
Added some further methods and helpers to the bitmap_t and
rectangle classes. [Aaron Giles]
Created a sega_16bit_common_base class which handles the
common Sega palette RAM mappings and open bus reads.
[Aaron Giles]
- Fixed uninitialized variables that were creeping into output
- Changed qsort() callback to never return "equal", working around unstable system libc implementations
sectors. [David Haywood]
Added CD compressor template which separates subcode data from sector
data, removes redundant ECC data prior to compression, and uses
separate compressors for each part. Defined LZMA and ZLib CD
compressors based on this and made them the default for CDs.
[Aaron Giles]
(Sadly couldn't wrap the FLAC compressor here because it would have
produced incompatible output with previous versions.)
driver_device base class. The palette base is now specified via an
AM_SHARE of "paletteram" or "paletteram2". The driver_device base
class now finds these pointers and places them in
m_generic_paletteram_8/_16/_32 and m_generic_paletteram2_8/_16/_32.
Removed machine.generic.paletteram*, and machine.generic entirely.
Removed AM_BASE_GENERIC/AM_SIZE_GENERIC as they don't apply anymore.
Changed required_/optional_shared_ptr to support set_target with
base and size for manually configuring a shared pointer, and a new
allocate method for dynamically allocating (and registering the
memory for save states).
A few subsequent cleanups are coming related to this, but wanted
to get this in before the next modern push.
is included in the SHA1. When creating LD CHDs, don't use a checksum on
the AVLD metadata, like we did before. Fixes recompression of laserdisc
CHDs.
Fix copy/paste error in the chd.h header which caused the flags passed to
be ignored when writing metadata.
samples. Increased CD sectors per hunk to 8 for better compression.
[David Haywood]
Re-did the non-CD FLAC codec to be "smart" in that it can choose
either big-endian or little-endian on the fly and uses the best one.
Added FLAC as a default codec for hard disks, which helps a lot for
certain disks. [Aaron Giles]
only through validity checking. If detected normally, do
a best-effort attempt so that things like CRC(1) SHA1(1) can
be used to force reporting of proper checksums.
src/lib/util/chd.c: In member function 'chd_error chd_file::compress_v5_map()':
src/lib/util/chd.c:1660: warning: comparison is always true due to limited range of data type
reading is now done using the FLAC wrapper. There is now a
samples_iterator class to centralize the logic for handling
the sample list walking.
Also redid the cheesy half-baked votrax device since it relied
on some old samples-based handling. Until we have a real
implementation, it would be good to route the various clients
through the current one to at least wire it up properly, even
if it just plays samples in the end. Will look into that
shortly.
Centralize detection of existing output files. Add detection (require --force)
for extracted files as well. Move checks outside of try/catch so that the
files are not subsequently deleted.
to more optimally use FLAC. Updated flac wrapper to implement a
tell callback so FLAC can tell us how much we've decoded. Updated
chdman to use CD-FLAC codec in preference over the existing
codecs for CDs by default. Credit Haze for the idea.
from 4 to 5. This means any diff CHDs will no longer work. If you
absolutely need to keep the data for any existing ones you have,
find both the diff CHD and the original CHD for the game in question
and upgrade using these commands:
rename diff\game.dif diff\game-old.dif
chdman copy -i diff\game-old.dif -ip roms\game.chd -o diff\game.dif -op roms\game.chd -c none
Specifics regarding this change:
Defined a new CHD version 5. New features/behaviors of this version:
- support for up to 4 codecs; each block can use 1 of the 4
- new LZMA codec, which tends to do better than zlib overall
- new FLAC codec, primarily used for CDs (but can be applied anywhere)
- upgraded AVHuff codec now uses FLAC for encoding audio
- new Huffman codec, used to catch more nearly-uncompressable blocks
- compressed CHDs now use a compressed map for significant savings
- CHDs now are aware of a "unit" size; each hunk holds 1 or more units
(in general units map to sectors for hard disks/CDs)
- diff'ing against a parent now diffs at the unit level, greatly
improving compression
Rewrote and modernized chd.c. CHD versions prior to 3 are unsupported,
and version 3/4 CHDs are only supported for reading. Creating a new
CHD now leaves the file open. Added methods to read and write at the
unit and byte level, removing the need to handle this manually. Added
metadata access methods that pass astrings and dynamic_buffers to
simplify the interfaces. A companion class chd_compressor now
implements full multithreaded compression, analyzing and compressing
multiple hunks independently in parallel. Split the codec
implementations out into a separate file chdcodec.*
Updated harddisk.c and cdrom.c to rely on the caching/byte-level read/
write capabilities of the chd_file class. cdrom.c (and chdman) now also
pad CDs to 4-frame boundaries instead of hunk boundaries, ensuring that
the same SHA1 hashes are produced regardless of the hunk size.
Rewrote chdman.exe entirely, switching from positional parameters to
proper options. Use "chdman help" to get a list of commands, and
"chdman help <command>" to get help for any particular command. Many
redundant commands were removed now that additional flexibility is
available. Some basic mappings:
Old: chdman -createblankhd <out.chd> <cyls> <heads> <secs>
New: chdman createhd -o <out.chd> -chs <cyls>,<heads>,<secs>
Old: chdman -createuncomphd <in.raw> <out.chd> ....
New: chdman createhd -i <in.raw> -o <out.chd> -c none ....
Old: chdman -verifyfix <in.chd>
New: chdman verify -i <in.chd> -f
Old: chdman -merge <parent.chd> <diff.chd> <out.chd>
New: chdman copy -i <diff.chd> -ip <parent.chd> -o <out.chd>
Old: chdman -diff <parent.chd> <compare.chd> <diff.chd>
New: chdman copy -i <compare.chd> -o <diff.chd> -op <parent.chd>
Old: chdman -update <in.chd> <out.chd>
New: chdman copy -i <in.chd> -o <out.chd>
Added new core file coretmpl.h to hold core template classes. For now
just one class, dynamic_array<> is defined, which acts like an array
of a given object but which can be appended to and/or resized. Also
defines dynamic_buffer as dynamic_array<UINT8> for holding an
arbitrary buffer of bytes. Expect to see these used a lot.
Added new core helper hashing.c/.h which defines classes for each of
the common hashing methods and creator classes to wrap the
computation of these hashes. A future work item is to reimplement
the core emulator hashing code using these.
Split bit buffer helpers out into C++ classes and into their own
public header in bitstream.h.
Updated huffman.c/.h to C++, and changed the interface to make it
more flexible to use in nonstandard ways. Also added huffman compression
of the static tree for slightly better compression rates.
Created flac.c/.h as simplified C++ wrappers around the FLAC interface.
A future work item is to convert the samples sound device to a modern
device and leverage this for reading FLAC files.
Renamed avcomp.* to avhuff.*, updated to C++, and added support for
FLAC as the audio encoding mechanism. The old huffman audio is still
supported for decode only.
Added a variant of core_fload that loads to a dynamic_buffer.
Tweaked winwork.c a bit to not limit the maximum number of processors
unless the work queue was created with the WORK_QUEUE_FLAG_HIGH_FREQ
option. Further adjustments here are likely going to be necessary.
Fixed bug in aviio.c which caused errors when reading some AVI files.
and paths consistently for devices, I/O ports, memory
regions, memory banks, and memory shares. [Aaron Giles]
NOTE: there are likely regressions lurking here, mostly
due to devices not being properly found. I have temporarily
added more logging to -verbose to help understand what's
going on. Please let me know ASAP if anything that is being
actively worked on got broken.
As before, the driver device is the root device and all
other devices are owned by it. Previously all devices
were kept in a single master list, and the hierarchy was
purely logical. With this change, each device owns its
own list of subdevices, and the hierarchy is explicitly
manifest. This means when a device is removed, all of its
subdevices are automatically removed as well.
A side effect of this is that walking the device list is
no longer simple. To address this, a new set of iterator
classes is provided, which walks the device tree in a depth
first manner. There is a general device_iterator class for
walking all devices, plus templates for a device_type_iterator
and a device_interface_iterator which are used to build
iterators for identifying only devices of a given type or
with a given interface. Typedefs for commonly-used cases
(e.g., screen_device_iterator, memory_interface_iterator)
are provided. Iterators can also provide counts, and can
perform indexed lookups.
All device name lookups are now done relative to another
device. The maching_config and running_machine classes now
have a root_device() method to get the root of the hierarchy.
The existing machine->device("name") is now equivalent to
machine->root_device().subdevice("name").
A proper and normalized device path structure is now
supported. Device names that start with a colon are
treated as absolute paths from the root device. Device
names can also use a caret (^) to refer to the owning
device. Querying the device's tag() returns the device's
full path from the root. A new method basetag() returns
just the final tag.
The new pathing system is built on top of the
device_t::subtag() method, so anyone using that will
automatically support the new pathing rules. Each device
has its own internal map to cache successful lookups so
that subsequent lookups should be very fast.
Updated every place I could find that referenced devices,
memory regions, I/O ports, memory banks and memory shares
to leverage subtag/subdevice (or siblingtag/siblingdevice
which are built on top).
Removed the device_list class, as it doesn't apply any
more. Moved some of its methods into running_machine
instead.
Simplified the device callback system since the new
pathing can describe all of the special-case devices that
were previously handled manually.
Changed the core output function callbacks to be delegates.
Completely rewrote the validity checking mechanism. The
validity checker is now a proper C++ class, and temporarily
takes over the error and warning outputs. All errors and
warnings are collected during a session, and then output in
a consistent manner, with an explicit driver and source file
listed for each one, as well as additional device and/or
I/O port contexts where appropriate. Validity checkers
should no longer explicitly output this information, just
the error, assuming that the context is provided.
Rewrote the software_list_device as a modern device, getting
rid of the software_list_config abstraction and simplifying
things.
Changed the way FLAC compiles so that it works like other
external libraries, and also compiles successfully for MSVC
builds.
allocates a given bitmap to match the screen size and resizes
it as appropriate when the screen size changes. Updated all
the obvious spots in the code where this could be leveraged.
Move allocate/resize methods in the bitmap classes down into
bitmap_t because they no longer have any dependency on the
bitmap format or type.
Ensured that the bitmap's palette remains set across a resize
call (it is lost doing an allocate).
strictly by the type. Also added code to more aggressively align
the bitmap base and rowbytes, and create a resize method which
attempts to re-use existing memory rather than always
reallocating.
almost certainly some regressions lurking. Let me know if
something seems busted.
Bitmaps are now strongly typed based on format. bitmap_t still
exists as an abstract base class, but it is almost never used.
Instead, format-specific bitmap classes are provided:
bitmap_ind8 == 8bpp indexed
bitmap_ind16 == 16bpp indexed
bitmap_ind32 == 32bpp indexed
bitmap_ind64 == 64bpp indexed
bitmap_rgb32 == 32bpp RGB
bitmap_argb32 == 32bpp ARGB
bitmap_yuy16 == 16bpp YUY
For each format, a generic pix() method is provided which
references pixels of the correct type. The old pix8/pix16/pix32/
pix64 methods still exist in the short term, but the only one
available is the one that matches the bitmap's pixel size. Note
also that the old RGB15 format bitmaps are no longer supported
at all.
Converted model1, megadriv, and stv drivers away from the RGB15
format bitmaps.
New auto_bitmap_<type>_alloc() macros are provided for allocating
the appropriate type of bitmap.
Screen update functions now must specify the correct bitmap type
as their input parameters. For static update functions the
SCREEN_UPDATE macro is now replaced with SCREEN_UPDATE_RGB32 and
SCREEN_UPDATE_IND16 macros. All existing drivers have been
updated to use the correct macros.
Screen update functions are now required for all screens; there
is no longer any default behavior of copying a "default" bitmap
to the screen (in fact the default bitmap has been deprecated).
Use one of the following to specify your screen_update callback:
MCFG_SCREEN_UPDATE_STATIC(name) - static functions
MCFG_SCREEN_UPDATE_DRIVER(class, func) - driver members
MCFG_SCREEN_UPDATE_DEVICE(tag, class, func) - device members
Because the target bitmap format can now be deduced from the
screen update function itself, the MCFG_SCREEN_FORMAT macro is
no longer necessary, and has been removed. If you specify a
screen update callback that takes a bitmap_ind16, then the screen
will be configured to use a 16bpp indexed bitmap, and if you
specify a callback that takes a bitmap_rgb32, then a 32bpp RGB
bitmap will be provided.
Extended the bitmap classes to support wrapping a subregion of
another bitmap, and cleaner allocation/resetting. The preferred
use of bitmaps now is to define them directly in drivers/devices
and use allocate() or wrap() to set them up, rather than
allocating them via auto_bitmap_*_alloc().
Several common devices needed overhauls or changes as a result
of the above changes:
* Reorganized the laserdisc base driver and all the laserdisc
drivers as modern C++ devices, cleaning the code up
considerably. Merged ldsound device into the laserdsc
device since modern devices are flexible enough to handle
it.
* Reorganized the v9938 device as a modern C++ device. Removed
v9938mod.c in favor of template functions in v9938.c directly.
* Added independent ind16 and rgb32 callbacks for TMS340x0 devices.
* All video devices are now hard-coded to either ind16 or rgb32
bitmaps. The most notable is the mc6845 which is rgb32, and
required changes to a number of consumers.
* Added screen_update methods to most video devices so they can be
directly called via MCFG_SCREEN_UPDATE_DEVICE instead of creating
tons of stub functions.
parameters for the global SCREEN_UPDATE callback match the parameters
for the driver_device version. Added allocate() and deallocate()
methods to bitmap_t to permit cleaner handling of bitmaps in drivers
and modern devices. [Aaron Giles]
macros with bitmap->pix* functions, and moved bitmap_fill() to bitmap->fill()
among other similar changes. Bitmap fields now only available via accessors.
Replaced sect_rect with &= and union_rect with |= operators for rectangle
classes. Some general cleanup as a result of these changes. [Aaron Giles]
Little modifications to ap2_dsk.c and gaelco3d.c/.h to compile with MSVC [Samuele Zannoli]
Added a placeholder for ohci usb controller in chihiro plus relative hack to avoid an infinite loop.
This allows chihiro to try to initialize direct3d and to use the nvidia 3d accelerator ... [Samuele Zannoli]
Also update lib/util/options.c so now parsing is not stopped on first unknown parameter, this way order of options in command line is not important for dynamic options (no whatsnew)
a few CPU's to give octal output by default.
Note that for now just some functions things return octal, will add more, but since this change required clean compile better to put it sooner then later (no whatsnew)
Hand-checked the most popular English word misspellings and made the appropriate changes. Nearly all of the changes made were in commented areas. (no whatsnew)
using one cothread for each executable device. This functionality is
strictly internal and should result in no changes in scheduling
behavior. However, it now becomes possible to exit out of a device's
execution in the midst of an instruction by calling
machine().scheduler().make_active(). Note that this is somewhat dangerous
for cores that have logic at the start of their execute loop to check for
interrupts or other conditions, as those checks will be skipped upon
resume, so consider this sort of early exiting to be highly experimental
for now. [Aaron Giles, Miodrag Milanovic, byuu]
loader rewrite, which is still in progress....)
Replaced mamedriv.c with a new driver list mechanism that is generated
by the build tools. The emulator core now expects the presence of a
file called src/$(TARGET)/$(SUBTARGET).lst which is just a raw list of
driver names, one per line. C and C++ comments are still permitted.
This file is parsed by a new build tool makelist which extracts the
driver names, sorts them, and generates a file called drivlist.c, which
is consumed by the core. [Aaron Giles]
Added new osdcore function osd_malloc_array() which is identical to
osd_malloc() but obviously hints that the underlying allocation is for
an array. Updated all callers to use the appropriate form. Modified the
Windows allocator to only use guard pages for array-style allocations,
allowing us to enable them once again in debug builds. [Aaron Giles]
Created new static class driver_list to wrap accesses to the list of
available drivers. Improved speed of driver lookups by relying on the
presorting done by makelist. [Aaron Giles]
Created helper class driver_enumerator as a helper for iterating through
the list of drivers. This class supports basic filtering and iteration,
and also serves as a temporary cache of machine_configs. [Aaron Giles]
Created cli_frontend object to wrap all the CLI handling code in
clifront.c. Updated/simplified all the code to take advantage of the
driver_enumerator. [Aaron Giles]
Created media_auditor object to wrap all the auditing functions in
audit.c. Updated all users to the new interface. Note that the new
auditing mechanism is slightly out of sync with the romload code in
terms of finding ROMs owned by devices, so it may mis-report some
issues until the new ROM loading code is in. [Aaron Giles]
Added concept of a per-device searchpath. For most devices, their
searchpath is just the short name of the device. For driver_devices, the
searchpath is driver[;parent[;bios]]. This searchpath will eventually be
used by the rom loader to find ROMs. For now it is used by the media
auditor only. [Aaron Giles]
Created info_xml_creator object to wrap all the info generation functions
in info.c. Converted the file to C++ and cleaned up the input processing
code. [Aaron Giles]
(not for whatsnew ... Known issues: auditing of CHDs appears busted, and
debug builds report unfreed memory if you use the built-in game picker)
functionality in favor of alternate mechanisms. Errors are
now reported via an astring rather than via callbacks. Every
option must now specify a type (command, integer, float, string,
boolean, etc). Command behavior has changed so that only one
command is permitted. [Aaron Giles]
Changed fileio system to accept just a raw searchpath instead of
an options/option name combination. [Aaron Giles]
Created emu_options class dervied from core_options which wraps
core emulator options. Added mechanisms to cleanly change the
system name and add/remove system-specific options, versus the
old way using callbacks. Also added read accessors for all the
options, to ensure consistency in how parameters are handled.
Changed most core systems to access emu_options instead of
core_options. Also changed machine->options() to return emu_options.
[Aaron Giles]
Created cli_options class derived from emu_options which adds the
command-line specific options. Updated clifront code to leverage
the new class and the new core behaviors. cli_execute() now accepts
a cli_options object when called. [Aaron Giles]
Updated both SDL and Windows to have their own options classes,
derived from cli_options, which add the OSD-specific options on
top of everything else. Added accessors for all the options so
that queries are strongly typed and simplified. [Aaron Giles]
Out of whatsnew: I've surely screwed up some stuff, though I have
smoke tested a bunch of things. Let me know if you hit anything odd.
Also I know this change will impact the WINUI stuff, please let me
know if there are issues. All the functionality necessary should
still be present. If it's not obvious, please talk to me before
adding stuff to the core_options class.
Not for whatsnew: I added -Wno-conversion unconditionally to disable the
warnings Thomas reported. That setting is the default for GCC out-of-the-box
but apparently not on NetBSD. As far as I know it shouldn't cause a problem
with any GCC version back to at least 4.0.0 so we're safe even on PPC OSX,
but do let me know if hilarity ensues.
The luminance normalization now converts r,g,b to y,u,v and
normalizes y prior to converting back to r,g,b. This affects e.g. radarscp, dkong and mario drivers. [Couriersud]
Yes, it is intentional that the x86/x64 backends compile everywhere.
Backends are now derived from drcbe_interface and implement several
required overrides.
x86emit.h now uses namespaces so that the x86/x64 emitters can co-exist.
New file uml.h/uml.c actually describes the UML language, separating
out several concepts from drcuml.c.
Lots of other changes/fixes.
- Updated parse_ini_file so before INI is loaded set of driver name is done, and therefore needed callback is executed.
This fixes issue that when running MESS you are able to mount images even if you did not start driver directly, before this change we got unknown ini options warnings. (no whatsnew)
devices. Debugger now creates one for each device. C++-ified most
debugger operations to hang off the debugging class, and updated
most callers. This still needs a little cleanup, but it fixes most
issues introduced when the CPUs were moved to their own devices.
Got rid of cpu_count, cpu_first, cpu_next, etc. as they were badly
broken. Also removed cpu_is_executing, cpu_is_suspended,
cpu_get_local_time, and cpu_abort_timeslice.
Some minor name changes:
state_value() -> state()
state_set_value() -> set_state()
performance as a result of this change. Do not panic; report issues to the
list in the short term and I will look into them. There are probably also
some details I forgot to mention. Please ask questions if anything is not
clear.
NOTE: This is a major internal change to the way devices are handled in
MAME. There is a small impact on drivers, but the bulk of the changes are
to the devices themselves. Full documentation on the new device handling
is in progress at http://mamedev.org/devwiki/index.php/MAME_Device_Basics
Defined two new casting helpers: [Aaron Giles]
downcast<type>(value) should be used for safe and efficient downcasting
from a base class to a derived class. It wraps static_cast<> by adding
an assert that a matching dynamic_cast<> returns the same result in
debug builds.
crosscast<type>(value) should be used for safe casting from one type to
another in multiple inheritance scenarios. It compiles to a
dynamic_cast<> plus an assert on the result. Since it does not optimize
down to static_cast<>, you should prefer downcast<> over crosscast<>
when you can.
Redefined running_device to be a proper C++ class (now called device_t).
Same for device_config (still called device_config). All devices and
device_configs must now be derived from these base classes. This means
each device type now has a pair of its own unique classes that describe
the device. Drivers are encouraged to use the specific device types
instead of the generic running_device or device_t classes. Drivers that
have a state class defined in their header file are encouraged to use
initializers off the constructor to locate devices. [Aaron Giles]
Removed the following fields from the device and device configuration
classes as they never were necessary or provided any use: device class,
device family, source file, version, credits. [Aaron Giles]
Added templatized variant of machine->device() which performs a downcast
as part of the device fetch. Thus machine->device<timer_device>("timer")
will locate a device named "timer", downcast it to a timer_device, and
assert if the downcast fails. [Aaron Giles]
Removed most publically accessible members of running_device/device_t in
favor of inline accessor functions. The only remaining public member is
machine. Thus all references to device->type are now device->type(), etc.
[Aaron Giles]
Created a number of device interface classes which are designed to be mix-
ins for the device classes, providing specific extended functionality and
information. There are standard interface classes for sound, execution,
state, nvram, memory, and disassembly. Devices can opt into 0 or more of
these classes. [Aaron Giles]
Converted the classic CPU device to a standard device that uses the
execution, state, memory, and disassembly interfaces. Used this new class
(cpu_device) to implement the existing CPU device interface. In the future
it will be possible to convert each CPU core to its own device type, but
for now they are still all CPU devices with a cpu_type() that specifies
exactly which kind of CPU. [Aaron Giles]
Created a new header devlegcy.h which wraps the old device interface using
some special template classes. To use these with an existing device,
simply remove from the device header the DEVICE_GET_INFO() declaration and
the #define mapping the ALL_CAPS name to the DEVICE_GET_INFO. In their
place #include "devlegcy.h" and use the DECLARE_LEGACY_DEVICE() macro.
In addition, there is a DECLARE_LEGACY_SOUND_DEVICE() macro for wrapping
existing sound devices into new-style devices, and a
DECLARE_LEGACY_NVRAM_DEVICE() for wrapping NVRAM devices. Also moved the
token and inline_config members to the legacy device class, as these are
not used in modern devices. [Aaron Giles]
Converted the standard base devices (VIDEO_SCREEN, SPEAKER, and TIMER)
from legacy devices to the new C++ style. Also renamed VIDEO_SCREEN to
simply SCREEN. The various global functions that were previously used to
access information or modify the state of these devices are now replaced
by methods on the device classes. Specifically:
video_screen_configure() == screen->configure()
video_screen_set_visarea() == screen->set_visible_area()
video_screen_update_partial() == screen->update_partial()
video_screen_update_now() == screen->update_now()
video_screen_get_vpos() == screen->vpos()
video_screen_get_hpos() == screen->hpos()
video_screen_get_vblank() == screen->vblank()
video_screen_get_hblank() == screen->hblank()
video_screen_get_width() == screen->width()
video_screen_get_height() == screen->height()
video_screen_get_visible_area() == screen->visible_area()
video_screen_get_time_until_pos() == screen->time_until_pos()
video_screen_get_time_until_vblank_start() ==
screen->time_until_vblank_start()
video_screen_get_time_until_vblank_end() ==
screen->time_until_vblank_end()
video_screen_get_time_until_update() == screen->time_until_update()
video_screen_get_scan_period() == screen->scan_period()
video_screen_get_frame_period() == screen->frame_period()
video_screen_get_frame_number() == screen->frame_number()
timer_device_adjust_oneshot() == timer->adjust()
timer_device_adjust_periodic() == timer->adjust()
timer_device_reset() == timer->reset()
timer_device_enable() == timer->enable()
timer_device_enabled() == timer->enabled()
timer_device_get_param() == timer->param()
timer_device_set_param() == timer->set_param()
timer_device_get_ptr() == timer->get_ptr()
timer_device_set_ptr() == timer->set_ptr()
timer_device_timeelapsed() == timer->time_elapsed()
timer_device_timeleft() == timer->time_left()
timer_device_starttime() == timer->start_time()
timer_device_firetime() == timer->fire_time()
Updated all drivers that use the above functions to fetch the specific
device type (timer_device or screen_device) and call the appropriate
method. [Aaron Giles]
Changed machine->primary_screen and the 'screen' parameter to VIDEO_UPDATE
to specifically pass in a screen_device object. [Aaron Giles]
Defined a new custom interface for the Z80 daisy chain. This interface
behaves like the standard interfaces, and can be added to any device that
implements the Z80 daisy chain behavior. Converted all existing Z80 daisy
chain devices to new-style devices that inherit this interface.
[Aaron Giles]
Changed the way CPU state tables are built up. Previously, these were data
structures defined by a CPU core which described all the registers and how
to output them. This functionality is now part of the state interface and
is implemented via the device_state_entry class. Updated all CPU cores
which were using the old data structure to use the new form. The syntax is
currently awkward, but will be cleaner for CPUs that are native new
devices. [Aaron Giles]
Converted the okim6295 and eeprom devices to the new model. These were
necessary because they both require multiple interfaces to operate and it
didn't make sense to create legacy device templates for these single cases.
(okim6295 needs the sound interface and the memory interface, while eeprom
requires both the nvram and memory interfaces). [Aaron Giles]
Changed parameters in a few callback functions from pointers to references
in situations where they are guaranteed to never be NULL. [Aaron Giles]
Removed MDRV_CPU_FLAGS() which was only used for disabling a CPU. Changed
it to MDRV_DEVICE_DISABLE() instead. Updated drivers. [Aaron Giles]
Reorganized the token parsing for machine configurations. The core parsing
code knows how to create/replace/remove devices, but all device token
parsing is now handled in the device_config class, which in turn will make
use of any interface classes or device-specific token handling for custom
token processing. [Aaron Giles]
Moved many validity checks out of validity.c and into the device interface
classes. For example, address space validation is now part of the memory
interface class. [Aaron Giles]
Consolidated address space parameters (bus width, endianness, etc.) into
a single address_space_config class. Updated all code that queried for
address space parameters to use the new mechanism. [Aaron Giles]
- CDRWIN .bin/.cue images now supported for both input and output
- Pregap and postgap information is now preserved in the format
- Output of CDRDAO images is significantly improved
Existing CHD-CDs will continue to work fine and for data-only discs no action
needs to be taken. For mixed data/audio discs (e.g. analog 573/Bemani games)
they should be re-converted for better preservation.
Added a check for the OPTION_READCONFIG option before executing
the code which would attempt to incorporate configuration file
settings into the current configuration, because if OPTION_READCONFIG
is set to false, then there is no reason to even try to do this as
every single configuration file will be ignored (because config files
have been turned off by OPTION_READCONFIG). [Bryan Ischo]
Fixed small memory leak in mame.c. [Bryan Ischo]
Fixed double-free error in render.c. [Bryan Ischo]
Made core_strdup use osd_malloc instead of malloc. [Bryan Ischo]
As previously discussed, this will be used for the MC680x0 FPU in
order to handle high-precision floats portably. The license is
included in README.txt and is MAME compatible.
along with a tagmap. Changed memory regions, input ports, and devices
to use this class. For devices, converted typenext and classnext
fields into methods which dynamically search for the next item.
Changed a number of macros to use the features of the class, removing
the need for a bunch of helper functions.
- Created new central header "emu.h"; this should be included
by pretty much any driver or device as the first include. This
file in turn includes pretty much everything a driver or device
will need, minus any other devices it references. Note that
emu.h should *never* be included by another header file.
- Updated all files in the core (src/emu) to use emu.h.
- Removed a ton of redundant and poorly-tracked header includes
from within other header files.
- Temporarily changed driver.h to map to emu.h until we update
files outside of the core.
Added class wrapper around tagmap so it can be directly included
and accessed within objects that need it. Updated all users to
embed tagmap objects and changed them to call through the class.
Added nicer functions for finding devices, ports, and regions in
a machine:
machine->device("tag") -- return the named device, or NULL
machine->port("tag") -- return the named port, or NULL
machine->region("tag"[, &length[, &flags]]) -- return the
named region and optionally its length and flags
Made the device tag an astring. This required touching a lot of
code that printed the device to explicitly fetch the C-string
from it. (Thank you gcc for flagging that issue!)
useable as a stack object. Also designed the interfaces to allow
for chaining operations. And added a casting operator to const
char * for seamless use in most functions that take plain old C
strings.
Changed all uses of astring to use the object directly on the
stack or embedded in objects instead of explicitly allocating
and deallocating it. Removed a lot of annoying memory management
code as a result.
Changed interfaces that accepted/returned an astring * to
use an astring & instead.
Removed auto_alloc_astring(machine). Use
auto_alloc(machine, astring) instead.
osd_free(). They take the same parameters as malloc() and free().
Renamed mamecore.h -> emucore.h.
New C++-aware memory manager, implemented in emualloc.*. This is a
simple manager that allows you to add any type of object to a
resource pool. Most commonly, allocated objects are added, and so
a set of allocation macros is provided to allow you to manage
objects in a particular pool:
pool_alloc(p, t) = allocate object of type 't' and add to pool 'p'
pool_alloc_clear(p, t) = same as above, but clear the memory first
pool_alloc_array(p, t, c) = allocate an array of 'c' objects of type
't' and add to pool 'p'
pool_alloc_array_clear(p, t, c) = same, but with clearing
pool_free(p, v) = free object 'v' and remove it from the pool
Note that pool_alloc[_clear] is roughly equivalent to "new t" and
pool_alloc_array[_clear] is roughly equivalent to "new t[c]". Also
note that pool_free works for single objects and arrays.
There is a single global_resource_pool defined which should be used
for any global allocations. It has equivalent macros to the pool_*
macros above that automatically target the global pool.
In addition, the memory module defines global new/delete overrides
that access file and line number parameters so that allocations can
be tracked. Currently this tracking is only done if MAME_DEBUG is
enabled. In debug builds, any unfreed memory will be printed at
the end of the session.
emualloc.h also has #defines to disable malloc/free/realloc/calloc.
Since emualloc.h is included by emucore.h, this means pretty much
all code within the emulator is forced to use the new allocators.
Although straight new/delete do work, their use is discouraged, as
any allocations made with them will not be tracked.
Changed the familar auto_alloc_* macros to map to the resource pool
model described above. The running_machine is now a class and contains
a resource pool which is automatically destructed upon deletion. If
you are a driver writer, all your allocations should be done with
auto_alloc_*.
Changed all drivers and files in the core using malloc/realloc or the
old alloc_*_or_die macros to use (preferably) the auto_alloc_* macros
instead, or the global_alloc_* macros if necessary.
Added simple C++ wrappers for astring and bitmap_t, as these need
proper constructors/destructors to be used for auto_alloc_astring and
auto_alloc_bitmap.
Removed references to the winalloc prefix file. Most of its
functionality has moved into the core, save for the guard page
allocations, which are now implemented in osd_alloc and osd_free.
- added warning messages for auto_malloc, timer, and save state
allocations done after init time. These should be fixed when
detected, as I would eventually like to disallow them entirely.
- changed state registration functions to pass through the caller's
file and line number to facilitate fixing the above warnings
- converted Taito F3 sound to a separate machine driver which is
imported into games that use it
- converted the balsente driver to driver_data structure
- converted harddriv timers into devices
- fixed crash in cps2 games due to not configuring the qsound bank
- cleaned up initialization in taito_l to allocate at init time
instead of reset time
The AM_SHARE() macro now takes a tag parameter. All existing
shares have been bulk renamed to "share##". However, the name
does not matter, so please use descriptive tags going forward.
Also added tag validation for bank and share tags.
Added flag to tagmap_add functions that optionally will
replace existing objects if a duplicate is found.
I found that it needs to be slightly different if you want correctly
terminated audio streams:
/* add up the samples */
if (channelsamples > chunksamples)
file->info.audio_numsamples = stream->samples += chunksamples;
else if (channelsamples > 0)
file->info.audio_numsamples = stream->samples += channelsamples;
Otherwise extra silence will be counted at the end of the audio stream.
Not really that big an issue but a bit sloppy...
large lengths for the audio stream of an AVI file. The occurrence of the
bug depends on the way that audio buffers are filled by the calling code;
if there are never two or more chunk's worth of audio samples queued then
the bug will not occur. [CDiFan]
Updated device and input port lists to use the tagmap for
tag searches. Also removed the whole "quark" thing from the
validity checker in favor of using the tagmaps.
> To: submit@mamedev.org
> CC: atariace@hotmail.com
> Subject: [patch] Eliminate more .data
> Date: Wed, 7 Oct 2009 08:51:56 -0700
>
> Hi mamedev,
>
> Most variables in .data are likely to lead to multisession bugs, so it
> is best to eliminate them and add explicit init/reset code for them
> instead. This patch does that for almost all the cases, with a few
> changes deserving some comments:
>
> z180: cc was global when it should be per-cpu.
> nesapu: the noise table would be different run to run in multisession
> which probably wasn't intended.
> astring: i constified the dummy string to make it impossible to
> modify.
> mediagx: hits was separated from the constant data
> tecmosys: i reduced the number of exports and renamed them to use
> tecmosys_ as a prefix.
> atari: i moved the renderer function into ANTIC.
> naomibd: the array provided to x76f100 was too small and might have
> caused memory corruption.
> n64: i constified the one and zero colors, requiring many more const
> qualifiers to be added.
> ldverify: i encapsulated the audio and video variables to reduce the
> amount of global state.
result, you will need a full recompile with this change, since the
bitmap formats enum was altered.
Introduced new feature -burnin, which can be used to generate a PNG
that represents the overall brightness seen during the course of
running a game. This PNG can be used as a fake "bezel" that overlays
the screen via the artwork systems (with a low alpha, say 0.1 or 0.2)
to simulate running a game with a monitor that has been burned in
from another game.
Fixed the -crsshairpath option to be spelled properly.
Updated src2html, regrep, and chdman tools to use this function where
appropriate.
In chdman, changed -addmeta to -addmetatext or -addmetabin to explicitly
specify the type of data (previous auto-detect was too dangerous).
update old tags.
Modified cdrom.c to expose metadata read/write functions, and changed
chdman to use them. Also changed chdman to parse old-style metadata and
convert it to new-style metadata since we're going to need to re-do this
anyway and the two won't hash to the same value.
Added completely untested support for the ident metadata to the hard
disk creation path. If a filename is provided immediately after the
source filename, it is taken as an ident file and processed for CHS
data and added. Other metadata types can be added afterwards via
-addmeta.
Updated CHD format to version 4. Checksums are now computed and
stored separately for raw data and metadata, and metadata is now
checksummed by default.
We will need to go through all existing CHDs, run a chdman -update
on them, and update the SHA1s stored in the drivers to accommodate
this (MD5s should be removed).
Updated chdman to support a generic metadata addition system:
chdman -addmeta <chdfile> <tag> [<index>] <sourcefile>
The <sourcefile> is examined and if it appears to be strictly text,
any EOFs and trailing EOLs are stripped, and the result is NULL-
terminated to match the behavior of existing metadata.
Updated chdman to report and fix errors in the raw and metadata
SHA1s.
Changed the CHD verify interfaces to pass back a structure containing
all the necessary data for verification and fixing.
compilation:
- new option CPP_COMPILE to trigger this (off by default)
- split CFLAGS into common, C-only, and C++-only flags
- when enabled, CPP_COMPILE causes 'pp' to be appended to
the target name
NOTE THAT THE SYSTEM CANNOT ACTUALLY BE COMPILED THIS WAY
YET. IT IS JUST AN EXPERIMENT.
Modified lib.mak to always build zlib/expat as C regardless
of CPP_COMPILE.
Modified windows.mak to fix warnings with MAXOPT=1, and to
leverage the new CFLAGs definitions.
Modified vconv.c to do appropriate conversions for new C++
options.
Updated sources so that libutil, libocore (Windows), and
libosd (Windows) can be cleanly compiled as C or C++. This
was mostly adding some casts against void *.
Fixed a few more general obvious problems at random
locations in the source:
- device->class is now device->devclass
- TYPES_COMPATIBLE uses typeid() when compiled for C++
- some functions with reserved names ('xor' in particular)
were renamed
- nested enums and structs were pulled out into separate
definitions (under C++ these would need to be scoped to
be referenced)
- TOKEN_VALUE cannot use .field=x initialization in C++ :(
Sent: Monday, February 16, 2009 7:10 PM
To: submit@mamedev.org
Cc: atariace@hotmail.com
Subject: [patch] Add some missing static qualifiers
Hi mamedev,
This patch mostly adds missing static qualifiers, plus a few related header/name adjustments. In particular, I tackled m68kmake.c and tmsmake.c which exposed a fair amount of dead code.
~aa
- Added built-in dirty tile tracking to the gfx_element. This removes
the need for all drivers that had dynamically populated graphics
to do their own dirty tracking. Tiles are marked dirty via the
new function gfx_element_mark_dirty(). Any driver that needs access
to the decoded data must call gfx_element_get_data() in order to
ensure that the referenced tile is clean before proceeding.
- In order to support dirty tracking, the gfx_element was enhanced to
keep track of the original source pointer, so that it can go back
and regenerate tiles on demand. For systems that set NULL for the
region in the gfxdecode, they must use gfx_element_set_source()
to specify a pointer to the raw data before drawing anything.
- Changed allocgfx() to gfx_element_alloc(), and added parameters to
specify the source data pointer, base color index, and total colors.
Many drivers had to whack these values in after the fact, so this
allowed for some minor additional cleanup.
- Added a dirtyseq member to the gfx_element struct. This is
incremented on each tile dirty, and can be used to sniff if
something has changed.
- Added logic in the tilemap engine to track which gfx_elements are
used for a given tilemap, and automatically detect changes to the
tiles so that drivers no longer have to explicitly invalidate the
tilemap when tiles change. In the future, this may grow smarter to
only invalidate the affected tiles, but for now it invalidates the
entire tilemap.
- Updated a number of drivers to remove their own dirty handling and
leverage the new internal dirty marking.
- Because the source data must always be present, updated the atarigen
zwackery and mystwarr graphics handing code to support this.
- Thanks to the dirty tracking, this actually allows all gfx decoding
to happen on the fly instead of all at once up front. Since there
was some concern that this would cause undesirable behavior due to
decoding lots of tiles on the fly, it is controlled with a compile-
time constant in mame.h (PREDECODE_GFX). Set this to 1 to get the
old behavior back.
- Moved decodechar() and decodegfx() to deprecat.h. All drivers in MAME
have been updated to simply mark tiles dirty and let the rendering
system decode them as needed, so these functions may go away in the
future.
- Rewrote entirely the rendering code in drawgfx. This code previously
used extensive recursive #includes and tricks to build, and was
very difficult to understand. The new code is based off of a set of
macros defined in drawgfxm.h. These new macros separate the core
rendering logic from the per-pixel operation, allowing the operation
to be easily "plugged" into any of the renderers. These macros are
also available to any driver that wants custom rendering behavior
that is similar to existing core behavior, without needing to
populate the core with esoteric one-off rendering behaviors.
- Added a set of new functions for [p]drawgfx[zoom], one for each
transparency type. The old [p]drawgfx[zoom] functions are still
present, but now switch off the transparency type and call through
to one of these new transparency-specific functions. The old
functions are also now reduced to only supporting TRANSPARENCY_NONE,
TRANSPARENCY_PEN, and TRANSPARENCY_PENS. All other rendering types
must use the new functions.
- All new rendering functions have extensive asserts to catch improper
clipping rectangles and other common errors.
- All new rendering functions automatically downgrade to optimized
versions where appropriate. For example, calling drawgfx_transpen
with an out-of-range pen automatically falls back to drawgfx_opaque.
And drawgfxzoom_* with xscale=yscale=1.0 automatically falls back
to drawgfx_*. And many other examples. In general, this relieves
drivers from needing to make these sorts of decisions.
- All new rendering functions have a consistent parameter order that
is a bit different from the existing functions. The cliprect
parameter is now specified immediately after the destination bitmap,
to match the convention used throughout the rest of the system.
The core parameters are followed by the scale parameters (for the
zoom functions), and then followed by the priority parameters (for
the pdrawgfx* functions), finally followed by any PIXEL_OP*-specific
parameters (such as transparent pen, alpha, drawing tables, etc.)
- Removed drawgfx_alpha_cache, alpha_set_level(), and the inline
functions alpha_blend16() and alpha_blend32(). To render graphics
with alpha, use the new [p]drawgfx[zoom]_alpha functions, which
take an explicit alpha value. To render tilemaps with alpha, the
TILEMAP_DRAW_ALPHA option now takes an explicit alpha parameter.
And to do you own alpha blending, use the alpha_blend_r16() and
alpha_blend_r32() functions, which take an explicit alpha.
- Updated a number of drivers as a result of removing the implicit
alpha in the drawgfx_alpha_cache.
- Removed drawgfx_pen_table and TRANSPARENCY_PEN_TABLE. To achieve
the same effect, build your own table and pass it to
[p]drawgfx[zoom]_transtable, along with a pointer to the
machine->shadow_table to use for shadows. Eventually
machine->shadow_table is likely to go away, and drivers will need
to fetch the shadow table from the palette directly.
- Updated a number of drivers to remove use of drawgfx_pen_table.
- Removed TRANSPARENCY_ALPHARANGE; it was only used by the psikyosh
driver, so it is now moved locally into that driver and built
using the macros in drawgfxm.h.
- Removed TRANSPARENCY_PEN_RAW; to achieve the same effect, call the
new [p]drawgfx[zoom]_transpen_raw() functions. Updated drivers to
make this change.
- Removed the unused mdrawgfx* functions entirely.
- Added new function gfx_element_set_source_clip() to specify a
source clipping rectangle for any element. This replaces the nasty
hacks that were being used in bnstars, ms32, namcos86, and namcos1
to achieve similar behaviors.
- Simplified the copyrozbitmap() functions to match the copybitmap()
functions in having separate opaque and transparent versions. Also
removed the 'priority' parameter which was only used by one driver,
and moved that logic into a custom renderer built using macros in
drawgfxm.h. Updated copyrozbitmap* to use the destbitmap, cliprect
parameter ordering convention as well.
- Simplified the draw_scanline*() functions to always render opaque.
Only one driver was doing otherwise, and it now does its work
internally (draw_scanline is dead-simple ever since we moved
rotation to the OSD code; I almost just removed it entirely).
Other changes:
- Added a cliprect to the bitmap_t type, which describes the full
bitmap.
- Removed tilemap_set_pen_data_offset; unfortunately, this adds a
random tile offset behind the scenes and goes against the dirty
tile detection and invalidation. Updated the mainsnk, snk, and
snk68 drivers to use old fashioned tile banking. (Sorry Nicola.)
- Changed zac2650 gfxdecode to use scale factors.
- Added function video_assert_out_of_range_pixels() to help find
the source of invalid pixels (generally out-of-range palette
entries due to invalid data or sloppy calculations). Place this
after each step in your rendering in a debug build to discover
which code is generating improper pixels.
- added running_machine to internal structure, removed as explicit parameter
- added new function rom_file_size() to compute the size of a ROM
- removed rom_first_chunk() and rom_next_chunk() which are no longer needed
- changed progress display to be based on size of ROMs loaded, not number
- changed temporary load buffer to be dynamically allocated
- fixed reload logic to handle skipped BIOSes
Also changed rand_memory() to use a fixed seed for consistent behavior.
Updated the fcompress APIs to allow for specifying a compression level.
Removed the concept of state saving tags, which was a hack to get save states
to work with multiple CPU cores. Simplified the state saving system as a
result, performing the operation in a single pass and without allocating
a full blob of memory. Also enabled minimal compression.
To fix this, I had to break old INP files. While I was in there,
I added corefile support for compressing/decompressing data on
the fly, and enabled it for INPs, meaning the newer format INPs
are output and processed compressed.
decoded VBI data. Added plumbing for allowing for overall brightness/
contrast/gamma corrections on laserdisc video. Fixed bug when combining
brightness values in the palette logic.
deprecat.h.
Changed render_texture_set_bitmap() to accept a palette object
instead of a palette index. The renderer remains optimized for the
system palette but will work if objects have their own palette as
well.
Changed renderer to permit palettes for RGB and YUY textures. If
specified, these palettes specify a 32-entry (RGB15) or 256-entry
(others) lookup for applying additional brightness/contrast/gamma
on a per-texture basis.
Removed rescale notification. It never really worked that well and
violated proper layering.
Renamed palette_set_brightness() to palette_set_pen_contrast() for
clarity.
Changed palette objects to support global brightness/contrast/gamma
in addition to per-group and per-entry controls.
palette.c to preserve the alpha when transforming palette values.
These changes should be transparent to almost all drivers and rendering
(ha-ha), but there may be an occasional instance where a driver relied
on the alpha being 0 in the system palette. This also means that the
palette_set_color() function preserves any alpha value that is set.
Changed Firefox to RGB32 to allow for mid-screen palette changes. Because
of the above change, the hacky alpha manipulation that was previously
required is no longer necessary; the alpha is set directly in the palette
entry.
Sent: Wed 9/24/2008 2:00 PM
To: submit@mamedev.org
Subject: Speed up fillbitmap
Hi,
there are many places in mame which make use of "fill_bitmap" or the
equivalent "fillbitmap"
An optimisation is done when the depth of the bitmap is 16 or 32 bpp and
when the UINT16 or UINT32 corresponding to the color is composed of same
bytes (i.e 0xffff for example). This is usefull because most of the calls
are for color 0 (black).
In all other cases, the bitmap is filled one pixel at a time using a loop
with a code like :
================
for (y = fill.min_y; y <= fill.max_y; y++)
{
UINT16 *destrow = BITMAP_ADDR16(dest, y, 0);
for (x = fill.min_x; x <= fill.max_x; x++)
destrow[x] = (UINT16)color;
}
================
However, each rows of the final bitmap will be the same. So I modified this
simple assigned to work as follow :
1) fill the first row one pixel at a time
2) fill all the other rows by copying the first one.
This makes us use memcpy instead of a hard coded loop for most of the
filling process.
Sent: Sunday, September 21, 2008 10:45 AM
To: submit@mamedev.org
Cc: atariace@hotmail.com
Subject: [patch] More static qualifiers
Hi mamedev,
Another static function update from yours truly, almost entirely
affecting code added in the last few months to MAME. The fixes are
the usual lot, changing enum definitions so they aren't declared,
decorating dead code/declarations with #if...#endif, and of course,
adding static where appropriate. In addition, I fixed a bunch of
UNUSED_FUNCTON symbols to be spelled correctly (I didn't introduce
this).
~aa
metadata with pre-decoded frame information. Modified chdman to
automatically produce this for CHDs that are of the appropriate
parameters. To fix up existing CHDs, use chdman -fixavdata on the
CHD.
Modified the laserdisc core to leverage the pre-decoded frame
metadata, which is now required. This improves seek times when
searching and allows the player-specific emulation access to the
VBI data as soon as it would really be available. Changed update
callback timing to fire just before the first line of VBI data
would be read; at that point, the frame selection is assumed to
be committed.
Converted PR-8210 emulation over to using the actual MCU from the
laserdisc player. This MCU controls low-level functions such as
slider position and laser on/off, and receives decoded vertical
blanking data in order to make decisions. Removed old HLE behavior.
Note that the overlay text is displayed via the UI; this is
temporary and will be fixed shortly.
Converted Simutrek-hacked laserdisc emulation to using the actual
MCU from the game, which in turn hands off commands to the PR-8210
MCU. This is still not 100% but is pretty close at this point and
achieves the correct behaviors in most cases.
Fixed Cube Quest overlay scaling to cover the whole screen.
Changed laserdisc video parameters to position the screen area at
the bottom rather than the top, since this corresponds more closely
to standard line numbering.
Extended the vbiparse code to support pack/unpack, and to more
fully document all the meanings of the VBI codes.
Updated ldplayer to support slow/fast forward movement, frame/chapter
display, and separate controls for scanning/stepping.
Added new built-in variable "frame" to the debugger.
Fixed device-based ROM loading to support loading ROMs from the
game's ZIP as well.
This handler works for both disc-only games and those with overlays.
For disc-only games, the base macro is sufficient. For games with
overlays, an additional set of configuration macros are provided:
MDRV_LASERDISC_OVERLAY - specifies update function, width, height,
and bitmap format of the overlay
MDRV_LASERDISC_OVERLAY_CLIP - specifies the visible area of the
overlay bitmap
MDRV_LASERDISC_OVERLAY_POSITION - specifies default x,y position
MDRV_LASERDISC_OVERLAY_SCALE - specifies default x,y scale factors
The update function provided to MDRV_LASERDISC_OVERLAY is identical to
a normal VIDEO_UPDATE callback, so a standard one can be used. All
existing laserdisc drivers have been updated to support this new
rendering mechanism, removing much duplicated code.
Added the ability to configure the overlay position and scale
parameters at runtime. Added OSD menus to control them. Added logic
to save/restore the data in the game's configuration file.
Added new macros MDRV_LASERDISC_SCREEN_ADD_NTSC and _PAL, which
defines a standard screen with the correct video timing characteristics
and update function for laserdiscs. Updated all drivers to use these
macros instead of defining their own screens.
Added DISK_REGIONS to all laserdisc drivers.
Added DISK_IMAGE_READONLY_OPTIONAL to support games (like Cube Quest)
where the disk is non-essential to the game's operation.
Fixed bug in identifying the custom sound driver for the laserdisc.
Updated ldverify to identify blank regions of the disc for post-
processing.
Fixed rendering 16bpp with alpha using bilinear filters (fixes
screenshots of laserdisc games with overlays).
Included support for parsing .gdi files in chdman. [ElSemi]
Added new driver for Cube Quest. This includes CPU cores for the three
bitslice processors, as well as laserdisc support for the hacked
laserdisc that was used to drive the games.
[Philip Bennett, Joe Magiera, Warren Ondras]
Note that the SHA1/MD5 for the laserdisc will likely undergo at least
one more change before being finalized.
item will be visible but not selectable.
Fixed bug that prevented the cheat engine from working when the
debugger was disabled.
Modified xmlfile.c to accept integer values in decimal or hex. The
default is decimal. Numbers may be prefixed by '#' for decimal
values, or by '$' or '0x' to indicate hexadecimal values. Also
added function xml_get_attribute_int_format() to return the format
of the attribute, so that it can be later replicated.
Updated cheat parser to preserve the format of attribute values
used for cheat parameters and items.
Added support for information-only cheat items, which will be
displayed in the menu but which are not selectable and have no
action associated with them. Empty information-only items are
automatically converted to menu separators.
Removed channels parameter from avcomp decode configuration.
Fixed incorrect test in winwork that led to spinning instead
of using the nicely allocated events we had on hand.
Forced a sound synchronization on each vsync in the laserdisc
playback. This prevents overwriting the tail end of the
buffer which was fouling up the MACH 3 audio decoding.
Removed obsolete size check for uncompressable audio data.
streams and a delta-RLE pre-encoding. Added optimized
case for the Y/Cb/Y/Cr video encoding case. Cleaned up
the code.
Updated avcomp.c to use the new huffman.c functions.
Reworked configuration options to allow for both input
and output of naturally aligned data streams. Updated
chdman and laserdsc to use the new interfaces. New
compression gives an additional 3-7% over previous
attempt and compresses the dummy CHDs down significantly.
and reports if no white flags were seen.
Fixed bug in aviio.c which could cause an infinite loop if attempting
to read sound beyond the end of the file.
Rewrote the white flag detection to use a histogram for outlier detection
and peak identification.
tool which walks through either an AVI or CHD capture from a
laserdisc and ensures that there are no anomalies lurking in
the VBI data.
Added new option to chdman, where if you use -createav with
a special filename (either 2:2 or 3:2) it will create a fake
laserdisc files with the equivalent cadence. This can be used
for testing until full captures are available. Most games used
2:2 apart from Dragon's Lair and Space Ace, which were 3:2.
Note that even though these files are essentially blank, they
are Huffman-compressed, meaning that the maximum compression
ratio you will get is 8:1, so they still end up ~5GB.
Moved error strings from chdman.c to chd.c, where they can be
fetched from any caller via the new chd_error_string()
function.
Updated vbiparse to improve Manchester code decoding. It now
assigns a confidence level per bit based on how solid the
data is. Also added a new function vbi_parse_all which parses
the white flag and all three lines of metadata from a
laserdisc frame. It then compares line 17 and 18 against each
other and selects the most likely candidate based on per-bit
confidence and other factors.
Added frame number display to laserdsc.c. It is off by
default, though most players can be configured to turn it on
(not sure if any actually do). It can be manually toggled via
the backslash key during playback.
Commander (MACH 3 hardware). Old laserdisc hacks are now removed.
The code now talks to the standard Pioneer PR-8210 interface. Also
removed hacky "target list" from the MACH 3 ROMs; this information
is now decoded on the fly from the right channel laserdisc audio.
Other Gottlieb cleanups:
- moved sound inputs to audio/gottlieb and included them in
all relevant drivers
- ordered input ports and ROM definitions consistently
Other laserdisc changes:
- changed PR-8210 interface to work consistently for both Gottlieb
and Stern games
- added audio callback mechanism to allow drivers to peek at the
raw audio streams
- extended the VBI parser to be even more lenient
now simply requires an AVI file input.
Relaxed VBI Manchester code clocking to allow for a little bit
of wiggle when finding the clock.
Changed laserdisc support to parse white flags and other data
from the VBI data directly, rather than relying on the textual
metadata. Expanded video frame cache to 3. Changed the way
frames are assembled to decrease the likelihood of getting an
interlaced weave. Fixed sound creation so that it is done at
reset time instead of device start, when the sound devices aren't
yet live.
Fixed bug in winwork that caused the creation of single work
items to return NULL, and thus lead to massive memory leaks when
using A/V CHDs.
files. Removed old option 'cheat_file'.
Updated xmlfile.c to specify the line number for each node, for more
accurate error reporting.
Removed old cheat.c/.h and replaced them with code that will read and
write the new XML-based cheat format using the new cheatpath option
(cheats still need to be enabled in order to load at all). Note that
the cheats are not implemented yet, but they are fully parsed. To test
saving, whenever a cheat file is successfully loaded, it is immediately
written back out as 'output.xml' to the cheat directory for validation.
Subject: [patch] Conditional code cleanup resubmit
Hi mamedev,
This is a resubmit of a previous patch. The earlier version would not
compile with 32-bit MSVC, due to the fact that its linker required
external dependencies in dead code to be met before dead code
elimination was done, causing linker errors. The proper fix for this
would be to add the necessary dependencies, so I instead simply left
the conditional code in place in winalloc.c and chd.c.
~aa
Original submission email below:
----
Conditionally compiled code tends to bitrot, so MAME should try to
avoid it as much as possible. I sent a patch six months ago to
eliminate conditional code associated with logging, here's another
patch that does more of this. Some notes:
1. drc_ops.c: I couldn't find a LOG_CODE anywhere, so I used if (0).
2. romload.c: I converted all the users of debugload to use
LOG((...)) instead, following the traditional conditional logging
pattern.
3. windows/sound.c: I eliminated the separate sound log and directed
the few outputs to the error log.
~aa
lurking. If you run into anything odd, please let me know.
Added new module uiinput.c which manages input for the user interface.
The OSD is responsible for pushing mouse events and character events
to this interface in order to support mouse movement and text-based
input (currently only used for the select game menu). Added support
for navigating through the menus using the mouse.
[Nathan Woods, Aaron Giles]
Redesigned the UI menus so that they can maintain a richer state. Now
the menus can be generated once and reused, rather than requiring them
to be regenerated on each frame. All menus also share a comment eventing
system and navigation through them is managed centrally. Rewrote all the
menus to use the new system, apart from the cheat menus, which are now
disabled. Reorganized the video menu to make it easier to understand.
[Aaron Giles]
names are generated.
Added new astring functions astring_del, astring_replace, and astring_replacec
to help perform simple search/replace substitution.
to write RGB bitmaps. Unfortunately, the only option is fully
uncompressed, which means the resulting AVIs are *HUGE* and
may not play correctly in realtime due to high data rate. The
intention is that these uncompressed AVIs are post-processed
by other utilities to compress the video and produce a
realtime playable result.
Added new command-line option -aviwrite which works just like
-mngwrite, except it produces AVIs and streams sound to them.
Updated documentation accordingly.
Shift+F12 still produces MNGs for now, though this might change
in the future.
Modified fileio.c to retain the full pathname to the file so
that it can be queried while the file is open.
Subject: [patch] Eliminate assignments in conditionals
Hi mamedev,
Assignments in conditionals are never really needed in C and are
occasionally just plain bugs (== gets typed as =). As such, it would
be good to remove these from MAME so that compilers that warn on this
construct can flag the likely bugs (MSVC does this for example). The
attached patch does just that. In addition, it refactors some
repeated code which had this in taito_f3.c into a couple macros. Using
inline functions would unfortunately have required more significant
changes, perhaps I'll tackle that another day.
~aa
Subject: xml_normalize_string() bogusly escapes UTF-8
Various parts of MAME have recently been changed to support UTF-8
strings, so I thought I'd test out using a UTF-8 driver name for the
Sam Coupe driver in MESS, just to see if anything breaks. Most things
do seem to work well - the name is correctly drawn in the UI etc. One
thing that doesn't work properly is the output from -listxml: "Sam
Coupe" becomes "Sam Coupé" - each UTF-8 byte is
individually escaped, resulting in two gibberish characters instead of
the correct character.
The culprit here is xml_normalize_string() in src/lib/util/xmlfile.c -
the code converts any high-bit byte to an XML escape, which is totally
bogus for any encoding but ISO-8859-1 because XML escapes are defined
as Unicode codepoints regardless of the document encoding.
Fortunately, this is very simple to fix - in fact, it is sufficient
just to remove the escaping code and pass through the UTF-8 bytes
directly, because UTF-8 is mandated as the default encoding in the XML
standard.[1] The attached patch does this.
This should be a pretty safe change since as far as I can tell nothing
in MAME or MESS currently triggers this code (that is, the string "&#"
does not occur in the -listxml output of either). One potentially
negative effect is that the ASCII controls which are illegal in XML
(0x00-0x19 excepting line breaks and tabs) would no longer be escaped.
However, I can't imagine why you would want any in a string destined
for -listxml, so IMO that would be a problem elsewhere in the code and
having XML parsers barf on it would be desirable.
-Justin Kerk
suffixed with _func. Did this throughout the core and
drivers I was familiar with.
Fixed gcc compiler error with recent render.c changes.
gcc does not like explicit (int) casts on float or
double functions. This is fracking annoying and stupid,
but there you have it.
* added ATTR_FORCE_INLINE to osdcomm.h
* added ATTR_NONNULL
* moved U64 S64 fram mamecore.h to osdcomm.h
* define SETJMP_GNUC_PROTECT() in osdcomm.h for use in ppc602, ppc603
- I still left drawgfx.c as is, the only piece of code that used any of the functions in drawgfx
was s2636.c -- everything else uses 8-bit bitmaps as a replacement for a two dimensional array
Subject: [patch] Fix some comments
Hi mamedev,
The following patch updates the initialization comments at the top of
mame.c and corrects/adds a few filename declarations at the top of a
handful of files.
~aa
The idea is to create extra work if a driver wants to use these and hopefully
gives an incentive to look for an alternate solution
- Added #include of deprecat.h that rely on these contructs
- Removed a bunch of unneccassary #include's from these files
- removed years from copyright notices
- removed redundant (c) from copyright notices
- updated "the MAME Team" to be "Nicola Salmoria and the MAME Team"
* XTAL-based timing
* Correct video timing
* Full memory map
* Correct memory usage ("zero page" RAM is shared with videoram)
* Removed all input hacks
* Fixed interrupt generation
* Connected coin counters
* Added save state support
Also fixed incorrect dependency in cdrom.c.
This is an updated version of my earlier ATTR_PRINTF patch. It was
reviewed by Atari Ace to use ATTR_PRINTF properly and fixes even more
format errors. I also reviewed the whole source again and it is now
used in all possible places.
The attached patch adjusts most conditional logging in MAME to use the
idiom "do { if (VERBOSE) logerror x; } while (0)". This has the
benefit that the compiler checks the syntax of the logging even in the
case it will be eliminated, and in fact a number of cases here needed
adjustments to compile because of this.
