Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-04 17:38:08 +03:00
Code Issues Actions 36 Packages Projects Releases Wiki Activity

Converted palette_t and palette_client to classes. General palette.c

Browse Source 
cleanup.
This commit is contained in:
Aaron Giles 2014-02-18 08:05:44 +00:00
parent 847cecbadc
commit 3e2995cbba
74 changed files with 717 additions and 980 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/emu/bus/a2bus/a2videoterm.c
View File

@ -349,7 +349,7 @@ void a2bus_videx80_device::write_c800(address_space &space, UINT16 offset, UINT8
static MC6845_UPDATE_ROW( videoterm_update_row )
{
a2bus_videx80_device *vterm = downcast<a2bus_videx80_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT16 chr_base = ra; //( ra & 0x08 ) ? 0x800 | ( ra & 0x07 ) : ra;
int i;

2
src/emu/bus/ecbbus/grip.c
View File

@ -253,7 +253,7 @@ static MC6845_UPDATE_ROW( grip_update_row )
static MC6845_UPDATE_ROW( grip5_update_row )
{
grip5_state *state = device->machine().driver_data<grip5_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int column, bit;
for (column = 0; column < x_count; column++)

37
src/emu/emupal.c
View File

@ -144,7 +144,7 @@ void palette_init(running_machine &machine)
allocate_shadow_tables(machine, palette);
/* set up save/restore of the palette */
numcolors = palette_get_num_colors(machine.palette);
numcolors = machine.palette->num_colors();
palette->save_pen = auto_alloc_array(machine, pen_t, numcolors);
palette->save_bright = auto_alloc_array(machine, float, numcolors);
machine.save().save_pointer(NAME(palette->save_pen), numcolors);
@ -170,7 +170,7 @@ void palette_set_shadow_factor(running_machine &machine, double factor)
palette_private *palette = machine.palette_data;
assert(palette->shadow_group != 0);
palette_group_set_contrast(machine.palette, palette->shadow_group, factor);
machine.palette->group_set_contrast(palette->shadow_group, factor);
}
@ -184,7 +184,7 @@ void palette_set_highlight_factor(running_machine &machine, double factor)
palette_private *palette = machine.palette_data;
assert(palette->hilight_group != 0);
palette_group_set_contrast(machine.palette, palette->hilight_group, factor);
machine.palette->group_set_contrast(palette->hilight_group, factor);
}
@ -530,15 +530,15 @@ pen_t get_white_pen(running_machine &machine)
static void palette_presave(running_machine &machine)
{
int numcolors = palette_get_num_colors(machine.palette);
int numcolors = machine.palette->num_colors();
palette_private *palette = machine.palette_data;
int index;
/* fill the save arrays with updated pen and brightness information */
for (index = 0; index < numcolors; index++)
{
palette->save_pen[index] = palette_entry_get_color(machine.palette, index);
palette->save_bright[index] = palette_entry_get_contrast(machine.palette, index);
palette->save_pen[index] = machine.palette->entry_color(index);
palette->save_bright[index] = machine.palette->entry_contrast(index);
}
}
@ -550,15 +550,15 @@ static void palette_presave(running_machine &machine)
static void palette_postload(running_machine &machine)
{
int numcolors = palette_get_num_colors(machine.palette);
int numcolors = machine.palette->num_colors();
palette_private *palette = machine.palette_data;
int index;
/* reset the pen and brightness for each entry */
for (index = 0; index < numcolors; index++)
{
palette_entry_set_color(machine.palette, index, palette->save_pen[index]);
palette_entry_set_contrast(machine.palette, index, palette->save_bright[index]);
machine.palette->entry_set_color(index, palette->save_pen[index]);
machine.palette->entry_set_contrast(index, palette->save_bright[index]);
}
}
@ -571,7 +571,7 @@ static void palette_exit(running_machine &machine)
{
/* dereference the palette */
if (machine.palette != NULL)
palette_deref(machine.palette);
machine.palette->deref();
}
@ -593,26 +593,25 @@ static void allocate_palette(running_machine &machine, palette_private *palette)
assert_always(machine.total_colors() * numgroups <= 65536, "Error: palette has more than 65536 colors.");
/* allocate a palette object containing all the colors and groups */
machine.palette = palette_alloc(machine.total_colors(), numgroups);
assert_always(machine.palette != NULL, "Failed to allocate system palette");
machine.palette = new palette_t(machine.total_colors(), numgroups);
/* configure the groups */
if (palette->shadow_group != 0)
palette_group_set_contrast(machine.palette, palette->shadow_group, (float)PALETTE_DEFAULT_SHADOW_FACTOR);
machine.palette->group_set_contrast(palette->shadow_group, (float)PALETTE_DEFAULT_SHADOW_FACTOR);
if (palette->hilight_group != 0)
palette_group_set_contrast(machine.palette, palette->hilight_group, (float)PALETTE_DEFAULT_HIGHLIGHT_FACTOR);
machine.palette->group_set_contrast(palette->hilight_group, (float)PALETTE_DEFAULT_HIGHLIGHT_FACTOR);
/* set the initial colors to a standard rainbow */
for (index = 0; index < machine.total_colors(); index++)
palette_entry_set_color(machine.palette, index, MAKE_RGB(pal1bit(index >> 0), pal1bit(index >> 1), pal1bit(index >> 2)));
machine.palette->entry_set_color(index, MAKE_RGB(pal1bit(index >> 0), pal1bit(index >> 1), pal1bit(index >> 2)));
/* switch off the color mode */
switch (palette->format)
{
/* 16-bit paletteized case */
case BITMAP_FORMAT_IND16:
palette->black_pen = palette_get_black_entry(machine.palette);
palette->white_pen = palette_get_white_entry(machine.palette);
palette->black_pen = machine.palette->black_entry();
palette->white_pen = machine.palette->white_entry();
if (palette->black_pen >= 65536)
palette->black_pen = 0;
if (palette->white_pen >= 65536)
@ -640,7 +639,7 @@ static void allocate_palette(running_machine &machine, palette_private *palette)
static void allocate_color_tables(running_machine &machine, palette_private *palette)
{
int total_colors = palette_get_num_colors(machine.palette) * palette_get_num_groups(machine.palette);
int total_colors = machine.palette->num_colors() * machine.palette->num_groups();
pen_t *pentable;
int i;
@ -655,7 +654,7 @@ static void allocate_color_tables(running_machine &machine, palette_private *pal
break;
case BITMAP_FORMAT_RGB32:
machine.pens = palette_entry_list_adjusted(machine.palette);
machine.pens = machine.palette->entry_list_adjusted();
break;
default:

10
src/emu/emupal.h
View File

@ -198,7 +198,7 @@ pen_t get_white_pen(running_machine &machine);
INLINE void palette_set_color(running_machine &machine, pen_t pen, rgb_t rgb)
{
palette_entry_set_color(machine.palette, pen, rgb);
machine.palette->entry_set_color(pen, rgb);
}
@ -209,7 +209,7 @@ INLINE void palette_set_color(running_machine &machine, pen_t pen, rgb_t rgb)
INLINE void palette_set_color_rgb(running_machine &machine, pen_t pen, UINT8 r, UINT8 g, UINT8 b)
{
palette_entry_set_color(machine.palette, pen, MAKE_RGB(r, g, b));
machine.palette->entry_set_color(pen, MAKE_RGB(r, g, b));
}
@ -220,7 +220,7 @@ INLINE void palette_set_color_rgb(running_machine &machine, pen_t pen, UINT8 r,
INLINE rgb_t palette_get_color(running_machine &machine, pen_t pen)
{
return palette_entry_get_color(machine.palette, pen);
return machine.palette->entry_color(pen);
}
@ -231,7 +231,7 @@ INLINE rgb_t palette_get_color(running_machine &machine, pen_t pen)
INLINE void palette_set_pen_contrast(running_machine &machine, pen_t pen, double bright)
{
palette_entry_set_contrast(machine.palette, pen, bright);
machine.palette->entry_set_contrast(pen, bright);
}
@ -243,7 +243,7 @@ INLINE void palette_set_pen_contrast(running_machine &machine, pen_t pen, double
INLINE void palette_set_colors(running_machine &machine, pen_t color_base, const rgb_t *colors, int color_count)
{
while (color_count--)
palette_entry_set_color(machine.palette, color_base++, *colors++);
machine.palette->entry_set_color(color_base++, *colors++);
}

6
src/emu/machine/laserdsc.c
View File

@ -325,7 +325,7 @@ void laserdisc_device::device_stop()
if (m_videotex != NULL)
machine().render().texture_free(m_videotex);
if (m_videopalette != NULL)
palette_deref(m_videopalette);
m_videopalette->deref();
if (m_overtex != NULL)
machine().render().texture_free(m_overtex);
}
@ -769,11 +769,11 @@ void laserdisc_device::init_video()
m_screen->register_vblank_callback(vblank_state_delegate(FUNC(laserdisc_device::vblank_state_changed), this));
// allocate palette for applying brightness/contrast/gamma
m_videopalette = palette_alloc(256, 1);
m_videopalette = new palette_t(256);
if (m_videopalette == NULL)
throw emu_fatalerror("Out of memory allocating video palette");
for (int index = 0; index < 256; index++)
palette_entry_set_color(m_videopalette, index, MAKE_RGB(index, index, index));
m_videopalette->entry_set_color(index, MAKE_RGB(index, index, index));
// allocate video frames
for (int index = 0; index < ARRAY_LENGTH(m_frame); index++)

25
src/emu/render.c
View File

@ -467,7 +467,7 @@ bool render_texture::get_scaled(UINT32 dwidth, UINT32 dheight, render_texinfo &t
texinfo.osddata = m_osddata;
// are we scaler-free? if so, just return the source bitmap
const rgb_t *palbase = (m_format == TEXFORMAT_PALETTE16 || m_format == TEXFORMAT_PALETTEA16) ? palette_entry_list_adjusted(m_bitmap->palette()) : NULL;
const rgb_t *palbase = (m_format == TEXFORMAT_PALETTE16 || m_format == TEXFORMAT_PALETTEA16) ? m_bitmap->palette()->entry_list_adjusted() : NULL;
if (m_scaler == NULL || (m_bitmap != NULL && swidth == dwidth && sheight == dheight))
{
// add a reference and set up the source bitmap
@ -554,7 +554,7 @@ const rgb_t *render_texture::get_adjusted_palette(render_container &container)
// if no adjustment necessary, return the raw palette
assert(m_bitmap->palette() != NULL);
adjusted = palette_entry_list_adjusted(m_bitmap->palette());
adjusted = m_bitmap->palette()->entry_list_adjusted();
if (!container.has_brightness_contrast_gamma_changes())
return adjusted;
@ -564,7 +564,7 @@ const rgb_t *render_texture::get_adjusted_palette(render_container &container)
return adjusted;
// otherwise, ensure we have memory allocated and compute the adjusted result ourself
numentries = palette_get_num_colors(m_bitmap->palette()) * palette_get_num_groups(m_bitmap->palette());
numentries = m_bitmap->palette()->num_colors() * m_bitmap->palette()->num_groups();
if (m_bcglookup == NULL || m_bcglookup_entries < numentries)
{
rgb_t *newlookup = auto_alloc_array(m_manager->machine(), rgb_t, numentries);
@ -637,7 +637,7 @@ render_container::render_container(render_manager &manager, screen_device *scree
// allocate a client to the main palette
if (manager.machine().palette != NULL)
m_palclient = palette_client_alloc(manager.machine().palette);
m_palclient = global_alloc(palette_client(*manager.machine().palette));
recompute_lookups();
}
@ -655,8 +655,7 @@ render_container::~render_container()
m_manager.texture_free(m_overlaytexture);
// release our palette client
if (m_palclient != NULL)
palette_client_free(m_palclient);
global_free(m_palclient);
}
@ -772,7 +771,7 @@ const rgb_t *render_container::bcg_lookup_table(int texformat, palette_t *palett
{
case TEXFORMAT_PALETTE16:
case TEXFORMAT_PALETTEA16:
return (palette != NULL && palette == palette_client_get_palette(m_palclient)) ? m_bcglookup : NULL;
return (palette != NULL && palette == &m_palclient->palette()) ? m_bcglookup : NULL;
case TEXFORMAT_RGB32:
case TEXFORMAT_ARGB32:
@ -858,9 +857,9 @@ void render_container::recompute_lookups()
// recompute the palette entries
if (m_palclient != NULL)
{
palette_t *palette = palette_client_get_palette(m_palclient);
const pen_t *adjusted_palette = palette_entry_list_adjusted(palette);
int colors = palette_get_num_colors(palette) * palette_get_num_groups(palette);
palette_t &palette = m_palclient->palette();
const pen_t *adjusted_palette = palette.entry_list_adjusted();
int colors = palette.num_colors() * palette.num_groups();
for (int i = 0; i < colors; i++)
{
@ -887,13 +886,13 @@ void render_container::update_palette()
// get the dirty list
UINT32 mindirty, maxdirty;
const UINT32 *dirty = palette_client_get_dirty_list(m_palclient, &mindirty, &maxdirty);
const UINT32 *dirty = m_palclient->dirty_list(mindirty, maxdirty);
// iterate over dirty items and update them
if (dirty != NULL)
{
palette_t *palette = palette_client_get_palette(m_palclient);
const pen_t *adjusted_palette = palette_entry_list_adjusted(palette);
palette_t &palette = m_palclient->palette();
const pen_t *adjusted_palette = palette.entry_list_adjusted();
// loop over chunks of 32 entries, since we can quickly examine 32 at a time
for (UINT32 entry32 = mindirty / 32; entry32 <= maxdirty / 32; entry32++)

2
src/emu/screen.c
View File

@ -880,7 +880,7 @@ void screen_device::update_burnin()
{
UINT64 *dst = &m_burnin.pix64(y);
const UINT16 *src = &srcbitmap.pix16(srcy >> 16);
const rgb_t *palette = palette_entry_list_adjusted(machine().palette);
const rgb_t *palette = machine().palette->entry_list_adjusted();
for (x = 0, srcx = xstart; x < dstwidth; x++, srcx += xstep)
{
rgb_t pixel = palette[src[srcx >> 16]];

4
src/emu/tilemap.c
View File

@ -1183,7 +1183,7 @@ void tilemap_t::draw_instance(_BitmapClass &dest, const blit_parameters &blit, i
x_end = MIN(x_end, x2);
// if we're rendering something, compute the pointers
const rgb_t *clut = (dest.palette() != NULL) ? palette_entry_list_raw(dest.palette()) : machine().pens;
const rgb_t *clut = (dest.palette() != NULL) ? dest.palette()->entry_list_raw() : machine().pens;
if (prev_trans != WHOLLY_TRANSPARENT)
{
const UINT16 *source0 = source_baseaddr + x_start;
@ -1277,7 +1277,7 @@ void tilemap_t::draw_roz_core(_BitmapClass &destbitmap, const blit_parameters &b
UINT32 startx, UINT32 starty, int incxx, int incxy, int incyx, int incyy, bool wraparound)
{
// pre-cache all the inner loop values
const rgb_t *clut = ((destbitmap.palette() != NULL) ? palette_entry_list_raw(destbitmap.palette()) : machine().pens) + (blit.tilemap_priority_code >> 16);
const rgb_t *clut = ((destbitmap.palette() != NULL) ? destbitmap.palette()->entry_list_raw() : machine().pens) + (blit.tilemap_priority_code >> 16);
bitmap_ind8 &priority_bitmap = *blit.priority;
const int xmask = m_pixmap.width() - 1;
const int ymask = m_pixmap.height() - 1;

4
src/emu/ui/viewgfx.c
View File

@ -257,7 +257,7 @@ static void palette_handler(running_machine &machine, render_container *containe
{
int total = state->palette.which ? colortable_palette_get_size(machine.colortable) : machine.total_colors();
const char *title = state->palette.which ? "COLORTABLE" : "PALETTE";
const rgb_t *raw_color = palette_entry_list_raw(machine.palette);
const rgb_t *raw_color = machine.palette->entry_list_raw();
render_font *ui_font = machine.ui().get_font();
float cellwidth, cellheight;
float chwidth, chheight;
@ -787,7 +787,7 @@ static void gfxset_draw_item(running_machine &machine, gfx_element *gfx, int ind
};
int width = (rotate & ORIENTATION_SWAP_XY) ? gfx->height() : gfx->width();
int height = (rotate & ORIENTATION_SWAP_XY) ? gfx->width() : gfx->height();
const rgb_t *palette = (machine.total_colors() != 0) ? palette_entry_list_raw(machine.palette) : NULL;
const rgb_t *palette = (machine.total_colors() != 0) ? machine.palette->entry_list_raw() : NULL;
UINT32 palette_mask = ~0;
int x, y;

6
src/emu/video.c
View File

@ -310,7 +310,7 @@ void video_manager::save_snapshot(screen_device *screen, emu_file &file)
png_add_text(&pnginfo, "System", text2);
// now do the actual work
const rgb_t *palette = (machine().palette != NULL) ? palette_entry_list_adjusted(machine().palette) : NULL;
const rgb_t *palette = (machine().palette != NULL) ? machine().palette->entry_list_adjusted() : NULL;
png_error error = png_write_bitmap(file, &pnginfo, m_snap_bitmap, machine().total_colors(), palette);
if (error != PNGERR_NONE)
mame_printf_error("Error generating PNG for snapshot: png_error = %d\n", error);
@ -1230,7 +1230,7 @@ void video_manager::record_frame()
}
// write the next frame
const rgb_t *palette = (machine().palette != NULL) ? palette_entry_list_adjusted(machine().palette) : NULL;
const rgb_t *palette = (machine().palette != NULL) ? machine().palette->entry_list_adjusted() : NULL;
png_error error = mng_capture_frame(*m_mngfile, &pnginfo, m_snap_bitmap, machine().total_colors(), palette);
png_free(&pnginfo);
if (error != PNGERR_NONE)
@ -1258,7 +1258,7 @@ bool video_assert_out_of_range_pixels(running_machine &machine, bitmap_ind16 &bi
{
#ifdef MAME_DEBUG
// iterate over rows
int maxindex = palette_get_max_index(machine.palette);
int maxindex = machine.palette->max_index();
for (int y = 0; y < bitmap.height(); y++)
{
UINT16 *rowbase = &bitmap.pix16(y);

22
src/emu/video/pc_cga.c
View File

@ -482,7 +482,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -522,7 +522,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_comp_grey_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -561,7 +561,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_alt_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -600,7 +600,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -644,7 +644,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_update_row_si )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -696,7 +696,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_alt_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -744,7 +744,7 @@ static MC6845_UPDATE_ROW( cga_gfx_4bppl_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -802,7 +802,7 @@ static MC6845_UPDATE_ROW( cga_gfx_4bpph_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -846,7 +846,7 @@ static MC6845_UPDATE_ROW( cga_gfx_2bpp_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -882,7 +882,7 @@ static MC6845_UPDATE_ROW( cga_gfx_1bpp_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 fg = cga.color_select & 0x0F;
int i;
running_machine &machine = device->machine();
@ -1460,7 +1460,7 @@ static MC6845_UPDATE_ROW( pc1512_gfx_4bpp_update_row )
{
UINT8 *videoram = cga.videoram;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT16 offset_base = ra << 13;
int j;
running_machine &machine = device->machine();

4
src/lib/util/bitmap.c
View File

@ -271,14 +271,14 @@ void bitmap_t::set_palette(palette_t *palette)
// first dereference any existing palette
if (m_palette != NULL)
{
palette_deref(m_palette);
m_palette->deref();
m_palette = NULL;
}
// then reference any new palette
if (palette != NULL)
{
palette_ref(palette);
palette->ref();
m_palette = palette;
}
}

982
src/lib/util/palette.c
View File

File diff suppressed because it is too large Load Diff

369
src/lib/util/palette.h
View File

@ -14,162 +14,177 @@
#define __PALETTE_H__
#include "osdcore.h"
#include "coretmpl.h"
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
//**************************************************************************
// MACROS
//**************************************************************************
/* an rgb_t is a single combined R,G,B (and optionally alpha) value */
typedef UINT32 rgb_t;
/* an rgb15_t is a single combined 15-bit R,G,B value */
typedef UINT16 rgb15_t;
/* a palette is an opaque, reference counted object */
struct palette_t;
/* a palette client is someone who is tracking the dirty state of a palette */
struct palette_client;
/***************************************************************************
MACROS
***************************************************************************/
/* macros to assemble rgb_t values */
#define MAKE_ARGB(a,r,g,b) ((((rgb_t)(a) & 0xff) << 24) | (((rgb_t)(r) & 0xff) << 16) | (((rgb_t)(g) & 0xff) << 8) | ((rgb_t)(b) & 0xff))
// macros to assemble rgb_t values */
#define MAKE_ARGB(a,r,g,b) (((rgb_t(a) & 0xff) << 24) | ((rgb_t(r) & 0xff) << 16) | ((rgb_t(g) & 0xff) << 8) | (rgb_t(b) & 0xff))
#define MAKE_RGB(r,g,b) (MAKE_ARGB(255,r,g,b))
/* macros to extract components from rgb_t values */
// macros to extract components from rgb_t values */
#define RGB_ALPHA(rgb) (((rgb) >> 24) & 0xff)
#define RGB_RED(rgb) (((rgb) >> 16) & 0xff)
#define RGB_GREEN(rgb) (((rgb) >> 8) & 0xff)
#define RGB_BLUE(rgb) ((rgb) & 0xff)
/* common colors */
// common colors */
#define RGB_BLACK (MAKE_ARGB(255,0,0,0))
#define RGB_WHITE (MAKE_ARGB(255,255,255,255))
/***************************************************************************
FUNCTION PROTOTYPES
***************************************************************************/
//**************************************************************************
// TYPE DEFINITIONS
//**************************************************************************
// an rgb_t is a single combined R,G,B (and optionally alpha) value */
typedef UINT32 rgb_t;
// an rgb15_t is a single combined 15-bit R,G,B value */
typedef UINT16 rgb15_t;
// forward definitions
class palette_t;
// ======================> palette_client
// a single palette client
class palette_client
{
public:
// construction/destruction
palette_client(palette_t &palette);
~palette_client();
// getters
palette_client *next() const { return m_next; }
palette_t &palette() const { return m_palette; }
const UINT32 *dirty_list(UINT32 &mindirty, UINT32 &maxdirty);
// dirty marking
void mark_dirty(UINT32 index) { m_live->mark_dirty(index); }
private:
// internal object to track dirty states
class dirty_state
{
public:
// construction
dirty_state();
// operations
const UINT32 *dirty_list(UINT32 &mindirty, UINT32 &maxdirty);
void resize(UINT32 colors);
void mark_dirty(UINT32 index);
void reset();
private:
// internal state
dynamic_array<UINT32> m_dirty; // bitmap of dirty entries
UINT32 m_mindirty; // minimum dirty entry
UINT32 m_maxdirty; // minimum dirty entry
};
// internal state
palette_t & m_palette; // reference to the palette
palette_client *m_next; // pointer to next client
dirty_state * m_live; // live dirty state
dirty_state * m_previous; // previous dirty state
dirty_state m_dirty[2]; // two dirty states
};
/* ----- palette allocation ----- */
// ======================> palette_t
/* allocate a new palette object and take a single reference on it */
palette_t *palette_alloc(UINT32 numcolors, UINT32 numgroups);
// a palette object
class palette_t
{
friend class palette_client;
/* reference a palette object, incrementing its reference count */
void palette_ref(palette_t *palette);
public:
// construction/destruction
palette_t(UINT32 numcolors, UINT32 numgroups = 1);
// reference counting
void ref() { m_refcount++; }
void deref();
/* dereference a palette object; if the reference count goes to 0, it is freed */
void palette_deref(palette_t *palette);
// getters
int num_colors() const { return m_numcolors; }
int num_groups() const { return m_numgroups; }
int max_index() const { return m_numcolors * m_numgroups + 2; }
UINT32 black_entry() const { return m_numcolors * m_numgroups + 0; }
UINT32 white_entry() const { return m_numcolors * m_numgroups + 1; }
// overall adjustments
void set_brightness(float brightness);
void set_contrast(float contrast);
void set_gamma(float gamma);
// entry getters
rgb_t entry_color(UINT32 index) const { return (index < m_numcolors) ? m_entry_color[index] : RGB_BLACK; }
rgb_t entry_adjusted_color(UINT32 index) const { return (index < m_numcolors * m_numgroups) ? m_adjusted_color[index] : RGB_BLACK; }
float entry_contrast(UINT32 index) const { return (index < m_numcolors) ? m_entry_contrast[index] : 1.0f; }
// entry setters
void entry_set_color(UINT32 index, rgb_t rgb);
void entry_set_contrast(UINT32 index, float contrast);
// entry list getters
const rgb_t *entry_list_raw() const { return m_entry_color; }
const rgb_t *entry_list_adjusted() const { return m_adjusted_color; }
const rgb_t *entry_list_adjusted_rgb15() const { return m_adjusted_rgb15; }
// group adjustments
void group_set_brightness(UINT32 group, float brightness);
void group_set_contrast(UINT32 group, float contrast);
// utilities
void normalize_range(UINT32 start, UINT32 end, int lum_min = 0, int lum_max = 255);
private:
// destructor -- can only destruct via
~palette_t();
// internal helpers
rgb_t adjust_palette_entry(rgb_t entry, float brightness, float contrast, const UINT8 *gamma_map);
void update_adjusted_color(UINT32 group, UINT32 index);
// internal state
UINT32 m_refcount; // reference count on the palette
UINT32 m_numcolors; // number of colors in the palette
UINT32 m_numgroups; // number of groups in the palette
float m_brightness; // overall brightness value
float m_contrast; // overall contrast value
float m_gamma; // overall gamma value
UINT8 m_gamma_map[256]; // gamma map
dynamic_array<rgb_t> m_entry_color; // array of raw colors
dynamic_array<float> m_entry_contrast; // contrast value for each entry
dynamic_array<rgb_t> m_adjusted_color; // array of adjusted colors
dynamic_array<rgb_t> m_adjusted_rgb15; // array of adjusted colors as RGB15
dynamic_array<float> m_group_bright; // brightness value for each group
dynamic_array<float> m_group_contrast; // contrast value for each group
palette_client *m_client_list; // list of clients for this palette
};
/* ----- palette information ----- */
//**************************************************************************
// INLINE FUNCTIONS
//**************************************************************************
/* return the number of colors managed by the palette */
int palette_get_num_colors(palette_t *palette);
/* return the number of groups managed by the palette */
int palette_get_num_groups(palette_t *palette);
/* return the maximum allowed index (i.e., length of arrays returned by palette_entry_list*) */
int palette_get_max_index(palette_t *palette);
/* return the index of the black entry */
UINT32 palette_get_black_entry(palette_t *palette);
/* return the index of the white entry */
UINT32 palette_get_white_entry(palette_t *palette);
/* ----- palette clients ----- */
/* add a new client to a palette */
palette_client *palette_client_alloc(palette_t *palette);
/* remove a client from a palette */
void palette_client_free(palette_client *client);
/* return a pointer to the palette for this client */
palette_t *palette_client_get_palette(palette_client *client);
/* atomically get the current dirty list for a client */
const UINT32 *palette_client_get_dirty_list(palette_client *client, UINT32 *mindirty, UINT32 *maxdirty);
/* ----- color management ----- */
/* set the raw RGB color for a given palette index */
void palette_entry_set_color(palette_t *palette, UINT32 index, rgb_t rgb);
/* return the raw RGB color for a given palette index */
rgb_t palette_entry_get_color(palette_t *palette, UINT32 index);
/* return the adjusted RGB color (after all adjustments) for a given palette index */
rgb_t palette_entry_get_adjusted_color(palette_t *palette, UINT32 index);
/* return the entire palette as an array of raw RGB values */
const rgb_t *palette_entry_list_raw(palette_t *palette);
/* return the entire palette as an array of adjusted RGB values */
const rgb_t *palette_entry_list_adjusted(palette_t *palette);
/* return the entire palette as an array of adjusted RGB-15 values */
const rgb_t *palette_entry_list_adjusted_rgb15(palette_t *palette);
/* ----- palette adjustments ----- */
/* set the overall brightness for the palette */
void palette_set_brightness(palette_t *palette, float brightness);
/* set the overall contrast for the palette */
void palette_set_contrast(palette_t *palette, float contrast);
/* set the overall gamma for the palette */
void palette_set_gamma(palette_t *palette, float gamma);
/* set the contrast adjustment for a single palette index */
void palette_entry_set_contrast(palette_t *palette, UINT32 index, float contrast);
/* return the contrast adjustment for a single palette index */
float palette_entry_get_contrast(palette_t *palette, UINT32 index);
/* configure overall brightness for a palette group */
void palette_group_set_brightness(palette_t *palette, UINT32 group, float brightness);
/* configure overall contrast for a palette group */
void palette_group_set_contrast(palette_t *palette, UINT32 group, float contrast);
/* ----- palette utilities ----- */
/* normalize a range of palette entries, mapping minimum brightness to lum_min and maximum
brightness to lum_max; if either value is < 0, that boundary value is not modified */
void palette_normalize_range(palette_t *palette, UINT32 start, UINT32 end, int lum_min, int lum_max);
/***************************************************************************
INLINE FUNCTIONS
***************************************************************************/
/*-------------------------------------------------
rgb_to_rgb15 - convert an RGB triplet to
a 15-bit OSD-specified RGB value
-------------------------------------------------*/
//-------------------------------------------------
// rgb_to_rgb15 - convert an RGB triplet to
// a 15-bit OSD-specified RGB value
//-------------------------------------------------
inline rgb15_t rgb_to_rgb15(rgb_t rgb)
{
@ -177,9 +192,9 @@ inline rgb15_t rgb_to_rgb15(rgb_t rgb)
}
/*-------------------------------------------------
rgb_clamp - clamp an RGB component to 0-255
-------------------------------------------------*/
//-------------------------------------------------
// rgb_clamp - clamp an RGB component to 0-255
//-------------------------------------------------
inline UINT8 rgb_clamp(INT32 value)
{
@ -191,9 +206,9 @@ inline UINT8 rgb_clamp(INT32 value)
}
/*-------------------------------------------------
pal1bit - convert a 1-bit value to 8 bits
-------------------------------------------------*/
//-------------------------------------------------
// pal1bit - convert a 1-bit value to 8 bits
//-------------------------------------------------
inline UINT8 pal1bit(UINT8 bits)
{
@ -201,9 +216,9 @@ inline UINT8 pal1bit(UINT8 bits)
}
/*-------------------------------------------------
pal2bit - convert a 2-bit value to 8 bits
-------------------------------------------------*/
//-------------------------------------------------
// pal2bit - convert a 2-bit value to 8 bits
//-------------------------------------------------
inline UINT8 pal2bit(UINT8 bits)
{
@ -212,9 +227,9 @@ inline UINT8 pal2bit(UINT8 bits)
}
/*-------------------------------------------------
pal3bit - convert a 3-bit value to 8 bits
-------------------------------------------------*/
//-------------------------------------------------
// pal3bit - convert a 3-bit value to 8 bits
//-------------------------------------------------
inline UINT8 pal3bit(UINT8 bits)
{
@ -223,9 +238,9 @@ inline UINT8 pal3bit(UINT8 bits)
}
/*-------------------------------------------------
pal4bit - convert a 4-bit value to 8 bits
-------------------------------------------------*/
//-------------------------------------------------
// pal4bit - convert a 4-bit value to 8 bits
//-------------------------------------------------
inline UINT8 pal4bit(UINT8 bits)
{
@ -234,9 +249,9 @@ inline UINT8 pal4bit(UINT8 bits)
}
/*-------------------------------------------------
pal5bit - convert a 5-bit value to 8 bits
-------------------------------------------------*/
//-------------------------------------------------
// pal5bit - convert a 5-bit value to 8 bits
//-------------------------------------------------
inline UINT8 pal5bit(UINT8 bits)
{
@ -245,9 +260,9 @@ inline UINT8 pal5bit(UINT8 bits)
}
/*-------------------------------------------------
pal6bit - convert a 6-bit value to 8 bits
-------------------------------------------------*/
//-------------------------------------------------
// pal6bit - convert a 6-bit value to 8 bits
//-------------------------------------------------
inline UINT8 pal6bit(UINT8 bits)
{
@ -256,9 +271,9 @@ inline UINT8 pal6bit(UINT8 bits)
}
/*-------------------------------------------------
pal7bit - convert a 7-bit value to 8 bits
-------------------------------------------------*/
//-------------------------------------------------
// pal7bit - convert a 7-bit value to 8 bits
//-------------------------------------------------
inline UINT8 pal7bit(UINT8 bits)
{
@ -285,10 +300,10 @@ inline UINT8 palexpand(UINT8 data)
}
/*-------------------------------------------------
pal332 - create a 3-3-2 color by extracting
bits from a UINT32
-------------------------------------------------*/
//-------------------------------------------------
// pal332 - create a 3-3-2 color by extracting
// bits from a UINT32
//-------------------------------------------------
inline rgb_t pal332(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
{
@ -296,10 +311,10 @@ inline rgb_t pal332(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
}
/*-------------------------------------------------
pal444 - create a 4-4-4 color by extracting
bits from a UINT32
-------------------------------------------------*/
//-------------------------------------------------
// pal444 - create a 4-4-4 color by extracting
// bits from a UINT32
//-------------------------------------------------
inline rgb_t pal444(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
{
@ -307,10 +322,10 @@ inline rgb_t pal444(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
}
/*-------------------------------------------------
pal555 - create a 5-5-5 color by extracting
bits from a UINT32
-------------------------------------------------*/
//-------------------------------------------------
// pal555 - create a 5-5-5 color by extracting
// bits from a UINT32
//-------------------------------------------------
inline rgb_t pal555(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
{
@ -318,10 +333,10 @@ inline rgb_t pal555(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
}
/*-------------------------------------------------
pal565 - create a 5-6-5 color by extracting
bits from a UINT32
-------------------------------------------------*/
//-------------------------------------------------
// pal565 - create a 5-6-5 color by extracting
// bits from a UINT32
//-------------------------------------------------
inline rgb_t pal565(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
{
@ -329,10 +344,10 @@ inline rgb_t pal565(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
}
/*-------------------------------------------------
pal888 - create a 8-8-8 color by extracting
bits from a UINT32
-------------------------------------------------*/
//-------------------------------------------------
// pal888 - create a 8-8-8 color by extracting
// bits from a UINT32
//-------------------------------------------------
inline rgb_t pal888(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
{
@ -340,4 +355,4 @@ inline rgb_t pal888(UINT32 data, UINT8 rshift, UINT8 gshift, UINT8 bshift)
}
#endif /* __PALETTE_H__ */
#endif // __PALETTE_H__ */

2
src/mame/drivers/othello.c
View File

@ -105,7 +105,7 @@ public:
static MC6845_UPDATE_ROW( update_row )
{
othello_state *state = device->machine().driver_data<othello_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int cx, x;
UINT32 data_address;
UINT32 tmp;

2
src/mame/video/carjmbre.c
View File

@ -37,7 +37,7 @@ void carjmbre_state::palette_init()
rgb = compute_res_net_all(machine(), color_prom, &carjmbre_decode_info, &carjmbre_net_info);
palette_set_colors(machine(), 0, rgb, 64);
palette_normalize_range(machine().palette, 0, 63, 0, 255);
machine().palette->normalize_range(0, 63);
auto_free(machine(), rgb);
}

10
src/mame/video/dkong.c
View File

@ -218,7 +218,7 @@ PALETTE_INIT_MEMBER(dkong_state,dkong2b)
palette_set_color_rgb(machine(),i,r,g,b);
}
palette_normalize_range(machine().palette, 0, 255, 0, 255);
machine().palette->normalize_range(0, 255);
color_prom += 512;
/* color_prom now points to the beginning of the character color codes */
@ -257,7 +257,7 @@ PALETTE_INIT_MEMBER(dkong_state,dkong4b)
palette_set_color_rgb(machine(),i,r,g,b);
}
palette_normalize_range(machine().palette, 0, 255, 0, 255);
machine().palette->normalize_range(0, 255);
color_prom += 256;
/* color_prom now points to the beginning of the character color codes */
@ -321,7 +321,7 @@ PALETTE_INIT_MEMBER(dkong_state,radarscp)
palette_set_color_rgb(machine(),RADARSCP_GRID_COL_OFFSET + i,r,g,b);
}
palette_normalize_range(machine().palette, 0, RADARSCP_GRID_COL_OFFSET+7, 0, 255);
machine().palette->normalize_range(0, RADARSCP_GRID_COL_OFFSET+7);
color_prom += 256;
/* color_prom now points to the beginning of the character color codes */
@ -383,7 +383,7 @@ PALETTE_INIT_MEMBER(dkong_state,radarscp1)
palette_set_color_rgb(machine(),RADARSCP_GRID_COL_OFFSET + i,r,g,b);
}
palette_normalize_range(machine().palette, 0, RADARSCP_GRID_COL_OFFSET+7, 0, 255);
machine().palette->normalize_range(0, RADARSCP_GRID_COL_OFFSET+7);
color_prom += 512;
/* color_prom now points to the beginning of the character color codes */
@ -434,7 +434,7 @@ PALETTE_INIT_MEMBER(dkong_state,dkong3)
rgb = compute_res_net_all(machine(), color_prom, &dkong3_decode_info, &dkong3_net_info);
palette_set_colors(machine(), 0, rgb, 256);
palette_normalize_range(machine().palette, 0, 255, 0, 255);
machine().palette->normalize_range(0, 255);
auto_free(machine(), rgb);
color_prom += 1024;

2
src/mame/video/k001604.c
View File

@ -249,7 +249,7 @@ void k001604_device::draw_back_layer( bitmap_rgb32 &bitmap, const rectangle &cli
int ex = cliprect.max_x;
int ey = cliprect.max_y;
const rgb_t *clut = palette_entry_list_raw(bitmap.palette());
const rgb_t *clut = bitmap.palette()->entry_list_raw();
int window_x, window_y, window_xmask, window_ymask;

6
src/mame/video/m62.c
View File

@ -184,17 +184,17 @@ void m62_state::m62_amplify_contrast(palette_t *palette, UINT32 numcolors)
{
// m62 palette is very dark, so amplify default contrast
UINT32 i, ymax=1;
if (!numcolors) numcolors = palette_get_num_colors(palette);
if (!numcolors) numcolors = palette->num_colors();
// find maximum brightness
for (i=0;i < numcolors;i++)
{
rgb_t rgb = palette_entry_get_color(palette,i);
rgb_t rgb = palette->entry_color(i);
UINT32 y = 299 * RGB_RED(rgb) + 587 * RGB_GREEN(rgb) + 114 * RGB_BLUE(rgb);
ymax = MAX(ymax, y);
}
palette_set_contrast(palette, 255000.0/ymax);
palette->set_contrast(255000.0/ymax);
}
void m62_state::palette_init()

2
src/mame/video/malzak.c
View File

@ -18,7 +18,7 @@
UINT32 malzak_state::screen_update_malzak(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int sx, sy;
int x,y;

4
src/mame/video/mario.c
View File

@ -74,8 +74,8 @@ void mario_state::palette_init()
palette_set_colors(machine(), 256, rgb, 256);
auto_free(machine(), rgb);
palette_normalize_range(machine().palette, 0, 255, 0, 255);
palette_normalize_range(machine().palette, 256, 511, 0, 255);
machine().palette->normalize_range(0, 255);
machine().palette->normalize_range(256, 511);
}
WRITE8_MEMBER(mario_state::mario_videoram_w)

6
src/mame/video/phoenix.c
View File

@ -89,7 +89,7 @@ PALETTE_INIT_MEMBER(phoenix_state,phoenix)
col = ((i << 3 ) & 0x18) | ((i>>2) & 0x07) | (i & 0x60);
palette_set_color(machine(),i,rgb[col]);
}
palette_normalize_range(machine().palette, 0, 255, 0, 255);
machine().palette->normalize_range(0, 255);
auto_free(machine(), rgb);
}
@ -107,7 +107,7 @@ PALETTE_INIT_MEMBER(phoenix_state,survival)
col = ((i << 3 ) & 0x18) | ((i>>2) & 0x07) | (i & 0x60);
palette_set_color(machine(),i,rgb[col]);
}
palette_normalize_range(machine().palette, 0, 255, 0, 255);
machine().palette->normalize_range(0, 255);
auto_free(machine(), rgb);
}
@ -125,7 +125,7 @@ PALETTE_INIT_MEMBER(phoenix_state,pleiads)
col = ((i << 3 ) & 0x18) | ((i>>2) & 0x07) | (i & 0xE0);
palette_set_color(machine(),i,rgb[col]);
}
palette_normalize_range(machine().palette, 0, 255, 0, 255);
machine().palette->normalize_range(0, 255);
auto_free(machine(), rgb);
}

2
src/mame/video/popper.c
View File

@ -45,7 +45,7 @@ void popper_state::palette_init()
rgb = compute_res_net_all(machine(), color_prom, &popper_decode_info, &popper_net_info);
palette_set_colors(machine(), 0, rgb, 64);
palette_normalize_range(machine().palette, 0, 63, 0, 255);
machine().palette->normalize_range(0, 63);
auto_free(machine(), rgb);
}

2
src/mame/video/taito_b.c
View File

@ -396,7 +396,7 @@ UINT32 taitob_state::screen_update_taitob(screen_device &screen, bitmap_ind16 &b
UINT32 taitob_state::screen_update_realpunc(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
address_space &space = machine().driver_data()->generic_space();
const rgb_t *palette = palette_entry_list_adjusted(machine().palette);
const rgb_t *palette = machine().palette->entry_list_adjusted();
UINT8 video_control = m_tc0180vcu->get_videoctrl(space, 0);
int x, y;

2
src/mame/video/toobin.c
View File

@ -223,7 +223,7 @@ UINT32 toobin_state::screen_update_toobin(screen_device &screen, bitmap_rgb32 &b
/* draw and merge the MO */
bitmap_ind16 &mobitmap = m_mob->bitmap();
const rgb_t *palette = palette_entry_list_adjusted(machine().palette);
const rgb_t *palette = machine().palette->entry_list_adjusted();
for (int y = cliprect.min_y; y <= cliprect.max_y; y++)
{
UINT32 *dest = &bitmap.pix32(y);

4
src/mess/drivers/a5105.c
View File

@ -92,7 +92,7 @@ public:
static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
{
a5105_state *state = device->machine().driver_data<a5105_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int xi,gfx;
UINT8 pen;
@ -110,7 +110,7 @@ static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
static UPD7220_DRAW_TEXT_LINE( hgdc_draw_text )
{
a5105_state *state = device->machine().driver_data<a5105_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int x;
int xi,yi;
int tile,color;

2
src/mess/drivers/alphatro.c
View File

@ -156,7 +156,7 @@ void alphatro_state::video_start()
static MC6845_UPDATE_ROW( alphatro_update_row )
{
alphatro_state *state = device->machine().driver_data<alphatro_state>();
const rgb_t *pens = palette_entry_list_raw(bitmap.palette());
const rgb_t *pens = bitmap.palette()->entry_list_raw();
bool palette = BIT(state->ioport("CONFIG")->read(), 5);
UINT8 chr,gfx,attr,fg,inv;
UINT16 mem,x;

2
src/mess/drivers/apc.c
View File

@ -190,7 +190,7 @@ static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
static UPD7220_DRAW_TEXT_LINE( hgdc_draw_text )
{
apc_state *state = device->machine().driver_data<apc_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int xi,yi,yi_trans;
int x;
UINT8 char_size;

2
src/mess/drivers/applix.c
View File

@ -774,7 +774,7 @@ static MC6845_UPDATE_ROW( applix_update_row )
// Need to display a border colour.
// There is a monochrome mode, but no info found as yet.
applix_state *state = device->machine().driver_data<applix_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 i;
UINT16 chr,x;
UINT32 mem, vidbase = (state->m_video_latch & 15) << 14, *p = &bitmap.pix32(y);

2
src/mess/drivers/bigbord2.c
View File

@ -585,7 +585,7 @@ GFXDECODE_END
MC6845_UPDATE_ROW( bigbord2_update_row )
{
bigbord2_state *state = device->machine().driver_data<bigbord2_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx,inv;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/bml3.c
View File

@ -586,7 +586,7 @@ INPUT_PORTS_END
static MC6845_UPDATE_ROW( update_row )
{
bml3_state *state = device->machine().driver_data<bml3_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
// The MB-6890 has a 5-bit colour RAM region. The meaning of the bits are:
// 0: blue
// 1: red

4
src/mess/drivers/camplynx.c
View File

@ -384,7 +384,7 @@ void camplynx_state::palette_init()
static MC6845_UPDATE_ROW( lynx48k_update_row )
{
UINT8 *RAM = device->machine().root_device().memregion("maincpu")->base();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 r,g,b;
UINT32 x, *p = &bitmap.pix32(y);
@ -408,7 +408,7 @@ static MC6845_UPDATE_ROW( lynx48k_update_row )
static MC6845_UPDATE_ROW( lynx128k_update_row )
{
UINT8 *RAM = device->machine().root_device().memregion("maincpu")->base();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 r,g,b;
UINT32 x, *p = &bitmap.pix32(y);

2
src/mess/drivers/dim68k.c
View File

@ -225,7 +225,7 @@ void dim68k_state::video_start()
MC6845_UPDATE_ROW( dim68k_update_row )
{
dim68k_state *state = device->machine().driver_data<dim68k_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx,x,xx,inv;
UINT16 chr16=0x2020; // set to spaces if screen is off
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/dmv.c
View File

@ -151,7 +151,7 @@ static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
static UPD7220_DRAW_TEXT_LINE( hgdc_draw_text )
{
dmv_state *state = device->machine().driver_data<dmv_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 * chargen = state->memregion("maincpu")->base() + 0x1000;
for( int x = 0; x < pitch; x++ )

2
src/mess/drivers/ec65.c
View File

@ -134,7 +134,7 @@ void ec65_state::video_start()
static MC6845_UPDATE_ROW( ec65_update_row )
{
ec65_state *state = device->machine().driver_data<ec65_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx,inv;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/einstein.c
View File

@ -102,7 +102,7 @@ READ8_MEMBER(einstein_state::einstein_80col_ram_r)
static MC6845_UPDATE_ROW( einstein_6845_update_row )
{
einstein_state *einstein = device->machine().driver_data<einstein_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *data = einstein->m_region_gfx1->base();
UINT8 char_code, data_byte;
int i, x;

2
src/mess/drivers/h19.c
View File

@ -321,7 +321,7 @@ void h19_state::video_start()
static MC6845_UPDATE_ROW( h19_update_row )
{
h19_state *state = device->machine().driver_data<h19_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/if800.c
View File

@ -32,7 +32,7 @@ public:
static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
{
if800_state *state = device->machine().driver_data<if800_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int xi,gfx;
UINT8 pen;

2
src/mess/drivers/ipds.c
View File

@ -81,7 +81,7 @@ static I8275_DISPLAY_PIXELS(ipds_display_pixels)
{
int i;
ipds_state *state = device->machine().driver_data<ipds_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *charmap = state->memregion("chargen")->base();
UINT8 pixels = charmap[(linecount & 7) + (charcode << 3)] ^ 0xff;

2
src/mess/drivers/lola8a.c
View File

@ -197,7 +197,7 @@ static MC6845_UPDATE_ROW( lola8a_update_row )
{
lola8a_state *state = device->machine().driver_data<lola8a_state>();
address_space &program = state->m_maincpu->space(AS_PROGRAM);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
for (int sx = 0; sx < x_count; sx++)
{

2
src/mess/drivers/mx2178.c
View File

@ -106,7 +106,7 @@ static ACIA6850_INTERFACE( acia_intf )
static MC6845_UPDATE_ROW( update_row )
{
mx2178_state *state = device->machine().driver_data<mx2178_state>();
const rgb_t *pens = palette_entry_list_raw(bitmap.palette());
const rgb_t *pens = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/mycom.c
View File

@ -130,7 +130,7 @@ void mycom_state::video_start()
static MC6845_UPDATE_ROW( mycom_update_row )
{
mycom_state *state = device->machine().driver_data<mycom_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx=0,z;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/mz3500.c
View File

@ -147,7 +147,7 @@ static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
static UPD7220_DRAW_TEXT_LINE( hgdc_draw_text )
{
mz3500_state *state = device->machine().driver_data<mz3500_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int x;
int xi,yi;
int tile;

2
src/mess/drivers/mz6500.c
View File

@ -37,7 +37,7 @@ public:
static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
{
mz6500_state *state = device->machine().driver_data<mz6500_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int gfx[3];
UINT8 i,pen;

2
src/mess/drivers/pasopia.c
View File

@ -86,7 +86,7 @@ void pasopia_state::video_start()
MC6845_UPDATE_ROW( pasopia_update_row )
{
pasopia_state *state = device->machine().driver_data<pasopia_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *m_p_chargen = state->memregion("chargen")->base();
UINT8 chr,gfx,fg=7,bg=0; // colours need to be determined
UINT16 mem,x;

4
src/mess/drivers/pc9801.c
View File

@ -787,7 +787,7 @@ UINT32 pc9801_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap,
static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
{
pc9801_state *state = device->machine().driver_data<pc9801_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int xi;
int res_x,res_y;
UINT8 pen;
@ -849,7 +849,7 @@ static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
static UPD7220_DRAW_TEXT_LINE( hgdc_draw_text )
{
pc9801_state *state = device->machine().driver_data<pc9801_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int xi,yi;
int x;
UINT8 char_size;

4
src/mess/drivers/pyl601.c
View File

@ -385,7 +385,7 @@ void pyl601_state::video_start()
static MC6845_UPDATE_ROW( pyl601_update_row )
{
pyl601_state *state = device->machine().driver_data<pyl601_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *charrom = state->memregion("chargen")->base();
int column, bit, i;
@ -428,7 +428,7 @@ static MC6845_UPDATE_ROW( pyl601_update_row )
static MC6845_UPDATE_ROW( pyl601a_update_row )
{
pyl601_state *state = device->machine().driver_data<pyl601_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *charrom = state->memregion("chargen")->base();
int column, bit, i;

4
src/mess/drivers/qx10.c
View File

@ -152,7 +152,7 @@ public:
static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
{
qx10_state *state = device->machine().driver_data<qx10_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int xi,gfx[3];
UINT8 pen;
@ -182,7 +182,7 @@ static UPD7220_DISPLAY_PIXELS( hgdc_display_pixels )
static UPD7220_DRAW_TEXT_LINE( hgdc_draw_text )
{
qx10_state *state = device->machine().driver_data<qx10_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int x;
int xi,yi;
int tile;

2
src/mess/drivers/samcoupe.c
View File

@ -508,7 +508,7 @@ void samcoupe_state::palette_init()
palette_set_color(machine(), i, MAKE_RGB(r, g, b));
}
palette_normalize_range(machine().palette, 0, 127, 0, 255);
machine().palette->normalize_range(0, 127);
}

2
src/mess/drivers/sapi1.c
View File

@ -407,7 +407,7 @@ UINT32 sapi1_state::screen_update_sapi3(screen_device &screen, bitmap_ind16 &bit
static MC6845_UPDATE_ROW( update_row )
{
sapi1_state *state = device->machine().driver_data<sapi1_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx,inv;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/sm1800.c
View File

@ -88,7 +88,7 @@ static I8275_DISPLAY_PIXELS(sm1800_display_pixels)
{
int i;
sm1800_state *state = device->machine().driver_data<sm1800_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *charmap = state->memregion("chargen")->base();
UINT8 pixels = charmap[(linecount & 7) + (charcode << 3)] ^ 0xff;
if (vsp)

2
src/mess/drivers/tavernie.c
View File

@ -199,7 +199,7 @@ WRITE8_MEMBER( tavernie_state::ds_w )
static MC6845_UPDATE_ROW( update_row )
{
tavernie_state *state = device->machine().driver_data<tavernie_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx=0;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/tiki100.c
View File

@ -394,7 +394,7 @@ INPUT_PORTS_END
UINT32 tiki100_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT16 addr = (m_scroll << 7);
int sx, y, pixel, mode = (m_mode >> 4) & 0x03;

2
src/mess/drivers/tim100.c
View File

@ -82,7 +82,7 @@ static I8275_DISPLAY_PIXELS(tim100_display_pixels)
{
tim100_state *state = device->machine().driver_data<tim100_state>();
int i;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *charmap = state->memregion("chargen")->base();
UINT8 pixels = charmap[(linecount & 15) + (charcode << 4)];
if (vsp)

2
src/mess/drivers/tvc.c
View File

@ -513,7 +513,7 @@ void tvc_state::machine_reset()
static MC6845_UPDATE_ROW( tvc_update_row )
{
tvc_state *state = device->machine().driver_data<tvc_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT8 *vram = state->memregion("vram")->base() + ((state->m_vram_bank & 0x30)<<10);
UINT16 offset = ((ma*4 + ra*0x40) & 0x3fff);

2
src/mess/drivers/unior.c
View File

@ -252,7 +252,7 @@ WRITE8_MEMBER( unior_state::scroll_w )
static I8275_DISPLAY_PIXELS(display_pixels)
{
unior_state *state = device->machine().driver_data<unior_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 gfx = state->m_p_chargen[(linecount & 7) | (charcode << 3)];
if (vsp)
gfx = 0;

2
src/mess/drivers/v6809.c
View File

@ -160,7 +160,7 @@ GFXDECODE_END
MC6845_UPDATE_ROW( v6809_update_row )
{
v6809_state *state = device->machine().driver_data<v6809_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/drivers/victor9k.c
View File

@ -268,7 +268,7 @@ static MC6845_UPDATE_ROW( victor9k_update_row )
{
victor9k_state *state = device->machine().driver_data<victor9k_state>();
address_space &program = state->m_maincpu->space(AS_PROGRAM);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
if (BIT(ma, 13))
{

2
src/mess/drivers/zorba.c
View File

@ -278,7 +278,7 @@ static I8275_DISPLAY_PIXELS( zorba_update_chr )
{
int i;
zorba_state *state = device->machine().driver_data<zorba_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 gfx = state->m_p_chargen[(linecount & 15) + (charcode << 4)];
if (vsp)

2
src/mess/drivers/zrt80.c
View File

@ -214,7 +214,7 @@ void zrt80_state::video_start()
static MC6845_UPDATE_ROW( zrt80_update_row )
{
zrt80_state *state = device->machine().driver_data<zrt80_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx,inv;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);

2
src/mess/machine/svi318.c
View File

@ -326,7 +326,7 @@ READ8_MEMBER(svi318_state::svi318_fdc_irqdrq_r)
MC6845_UPDATE_ROW( svi806_crtc6845_update_row )
{
svi318_state *state = device->machine().driver_data<svi318_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
for( i = 0; i < x_count; i++ )

2
src/mess/video/bbc.c
View File

@ -165,7 +165,7 @@ WRITE8_MEMBER(bbc_state::bbc_videoULA_w)
static MC6845_UPDATE_ROW( vid_update_row )
{
bbc_state *state = device->machine().driver_data<bbc_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
if (state->m_videoULA_teletext_normal_select)
{

2
src/mess/video/dgn_beta.c
View File

@ -99,7 +99,7 @@ the access to the video memory is unclear to me at the moment.
static MC6845_UPDATE_ROW( dgnbeta_update_row )
{
dgn_beta_state *state = device->machine().driver_data<dgn_beta_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *videoram = state->m_videoram;
UINT32 *p = &bitmap.pix32(y);
int i;

4
src/mess/video/ef9345.c
View File

@ -206,7 +206,7 @@ void ef9345_device::draw_char_40(UINT8 *c, UINT16 x, UINT16 y)
if (y * 10 >= m_screen->height() || x * 8 >= m_screen->width())
return;
const rgb_t *palette = palette_entry_list_raw(m_screen_out.palette());
const rgb_t *palette = m_screen_out.palette()->entry_list_raw();
for(int i = 0; i < 10; i++)
for(int j = 0; j < 8; j++)
m_screen_out.pix32(y * 10 + i, x * 8 + j) = palette[c[8 * i + j] & 0x07];
@ -219,7 +219,7 @@ void ef9345_device::draw_char_80(UINT8 *c, UINT16 x, UINT16 y)
if (y * 10 >= m_screen->height() || x * 6 >= m_screen->width())
return;
const rgb_t *palette = palette_entry_list_raw(m_screen_out.palette());
const rgb_t *palette = m_screen_out.palette()->entry_list_raw();
for(int i = 0; i < 10; i++)
for(int j = 0; j < 6; j++)
m_screen_out.pix32(y * 10 + i, x * 6 + j) = palette[c[6 * i + j] & 0x07];

24
src/mess/video/isa_cga.c
View File

@ -841,7 +841,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -882,7 +882,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_comp_grey_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -922,7 +922,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_alt_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -962,7 +962,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -1007,7 +1007,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_update_row_si )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -1060,7 +1060,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_alt_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -1109,7 +1109,7 @@ static MC6845_UPDATE_ROW( cga_gfx_4bppl_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -1168,7 +1168,7 @@ static MC6845_UPDATE_ROW( cga_gfx_4bpph_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -1213,7 +1213,7 @@ static MC6845_UPDATE_ROW( cga_gfx_2bpp_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
int i;
running_machine &machine = device->machine();
@ -1250,7 +1250,7 @@ static MC6845_UPDATE_ROW( cga_gfx_1bpp_update_row )
isa8_cga_device *cga = downcast<isa8_cga_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 fg = cga->m_color_select & 0x0F;
int i;
running_machine &machine = device->machine();
@ -1720,7 +1720,7 @@ static MC6845_UPDATE_ROW( pc1512_gfx_4bpp_update_row )
isa8_cga_pc1512_device *cga = downcast<isa8_cga_pc1512_device *>(device->owner());
UINT8 *videoram = cga->m_vram + cga->m_start_offset;
UINT32 *p = &bitmap.pix32(y);
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT16 offset_base = ra << 13;
int j;
running_machine &machine = device->machine();
@ -2084,7 +2084,7 @@ void isa8_wyse700_device::device_reset()
UINT32 isa8_wyse700_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
if (m_control & 0x08) {
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 fg = m_color_select & 0x0F;
UINT32 addr = 0;
for (int y = 0; y < 800; y++) {

6
src/mess/video/isa_mda.c
View File

@ -211,7 +211,7 @@ void isa8_mda_device::device_reset()
static MC6845_UPDATE_ROW( mda_text_inten_update_row )
{
isa8_mda_device *mda = downcast<isa8_mda_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT16 chr_base = ( ra & 0x08 ) ? 0x800 | ( ra & 0x07 ) : ra;
int i;
@ -285,7 +285,7 @@ static MC6845_UPDATE_ROW( mda_text_inten_update_row )
static MC6845_UPDATE_ROW( mda_text_blink_update_row )
{
isa8_mda_device *mda = downcast<isa8_mda_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT16 chr_base = ( ra & 0x08 ) ? 0x800 | ( ra & 0x07 ) : ra;
int i;
@ -608,7 +608,7 @@ void isa8_hercules_device::device_reset()
static MC6845_UPDATE_ROW( hercules_gfx_update_row )
{
isa8_hercules_device *herc = downcast<isa8_hercules_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT16 gfx_base = ( ( herc->m_mode_control & 0x80 ) ? 0x8000 : 0x0000 ) | ( ( ra & 0x03 ) << 13 );
int i;

2
src/mess/video/kaypro.c
View File

@ -137,7 +137,7 @@ UINT32 kaypro_state::screen_update_kaypro2x(screen_device &screen, bitmap_rgb32
MC6845_UPDATE_ROW( kaypro2x_update_row )
{
kaypro_state *state = device->machine().driver_data<kaypro_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT16 x;
UINT8 gfx,fg,bg;

2
src/mess/video/mbc55x.c
View File

@ -90,7 +90,7 @@ static void video_debug(running_machine &machine, int ref, int params, const cha
static MC6845_UPDATE_ROW( vid_update_row )
{
mbc55x_state *mstate = device->machine().driver_data<mbc55x_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *ram = &mstate->m_ram->pointer()[0];
UINT8 *red = &mstate->m_video_mem[RED_PLANE_OFFSET];

6
src/mess/video/mbee.c
View File

@ -419,7 +419,7 @@ MC6845_ON_UPDATE_ADDR_CHANGED( mbee256_update_addr )
MC6845_UPDATE_ROW( mbee_update_row )
{
mbee_state *state = device->machine().driver_data<mbee_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);
@ -458,7 +458,7 @@ MC6845_UPDATE_ROW( mbee_update_row )
MC6845_UPDATE_ROW( mbeeic_update_row )
{
mbee_state *state = device->machine().driver_data<mbee_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,gfx,fg,bg;
UINT16 mem,x,col;
UINT16 colourm = (state->m_08 & 0x0e) << 7;
@ -502,7 +502,7 @@ MC6845_UPDATE_ROW( mbeeic_update_row )
MC6845_UPDATE_ROW( mbeeppc_update_row )
{
mbee_state *state = device->machine().driver_data<mbee_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 gfx,fg,bg;
UINT16 mem,x,col,chr;
UINT32 *p = &bitmap.pix32(y);

20
src/mess/video/pc_aga.c
View File

@ -124,7 +124,7 @@ static WRITE_LINE_DEVICE_HANDLER( aga_vsync_changed ) {
/* colors need fixing in the mda_text_* functions ! */
static MC6845_UPDATE_ROW( mda_text_inten_update_row ) {
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *videoram = aga.videoram;
UINT32 *p = &bitmap.pix32(y);
UINT16 chr_base = ( ra & 0x08 ) ? 0x800 | ( ra & 0x07 ) : ra;
@ -185,7 +185,7 @@ static MC6845_UPDATE_ROW( mda_text_inten_update_row ) {
static MC6845_UPDATE_ROW( mda_text_blink_update_row ) {
UINT8 *videoram = aga.videoram;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT16 chr_base = ( ra & 0x08 ) ? 0x800 | ( ra & 0x07 ) : ra;
int i;
@ -246,7 +246,7 @@ static MC6845_UPDATE_ROW( mda_text_blink_update_row ) {
static MC6845_UPDATE_ROW( cga_text_inten_update_row ) {
UINT8 *videoram = aga.videoram;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
int i;
@ -275,7 +275,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_update_row ) {
}
static MC6845_UPDATE_ROW( cga_text_inten_alt_update_row ) {
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *videoram = aga.videoram;
UINT32 *p = &bitmap.pix32(y);
int i;
@ -304,7 +304,7 @@ static MC6845_UPDATE_ROW( cga_text_inten_alt_update_row ) {
}
static MC6845_UPDATE_ROW( cga_text_blink_update_row ) {
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *videoram = aga.videoram;
UINT32 *p = &bitmap.pix32(y);
int i;
@ -337,7 +337,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_update_row ) {
}
static MC6845_UPDATE_ROW( cga_text_blink_alt_update_row ) {
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *videoram = aga.videoram;
UINT32 *p = &bitmap.pix32(y);
int i;
@ -372,7 +372,7 @@ static MC6845_UPDATE_ROW( cga_text_blink_alt_update_row ) {
}
static MC6845_UPDATE_ROW( cga_gfx_4bppl_update_row ) {
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 *videoram = aga.videoram;
UINT32 *p = &bitmap.pix32(y);
int i;
@ -398,7 +398,7 @@ static MC6845_UPDATE_ROW( cga_gfx_4bppl_update_row ) {
static MC6845_UPDATE_ROW( cga_gfx_4bpph_update_row ) {
UINT8 *videoram = aga.videoram;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
int i;
@ -431,7 +431,7 @@ static MC6845_UPDATE_ROW( cga_gfx_4bpph_update_row ) {
static MC6845_UPDATE_ROW( cga_gfx_2bpp_update_row ) {
UINT8 *videoram = aga.videoram;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
int i;
@ -456,7 +456,7 @@ static MC6845_UPDATE_ROW( cga_gfx_2bpp_update_row ) {
static MC6845_UPDATE_ROW( cga_gfx_1bpp_update_row ) {
UINT8 *videoram = aga.videoram;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT8 fg = aga.cga_color_select & 0x0F;
int i;

16
src/mess/video/pc_t1t.c
View File

@ -182,7 +182,7 @@ PALETTE_INIT_MEMBER( pc_t1t_device, pcjr )
static MC6845_UPDATE_ROW( t1000_text_inten_update_row )
{
pc_t1t_device *t1t = downcast<pc_t1t_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
int i;
@ -216,7 +216,7 @@ static MC6845_UPDATE_ROW( t1000_text_inten_update_row )
static MC6845_UPDATE_ROW( t1000_text_blink_update_row )
{
pc_t1t_device *t1t = downcast<pc_t1t_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
int i;
@ -258,7 +258,7 @@ static MC6845_UPDATE_ROW( t1000_text_blink_update_row )
static MC6845_UPDATE_ROW( pcjx_text_update_row )
{
pcvideo_pcjr_device *pcjx = downcast<pcvideo_pcjr_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
int i;
@ -300,7 +300,7 @@ static MC6845_UPDATE_ROW( pcjx_text_update_row )
static MC6845_UPDATE_ROW( t1000_gfx_4bpp_update_row )
{
pc_t1t_device *t1t = downcast<pc_t1t_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT8 *vid = t1t->m_displayram + ( ra << 13 );
int i;
@ -328,7 +328,7 @@ static MC6845_UPDATE_ROW( t1000_gfx_4bpp_update_row )
static MC6845_UPDATE_ROW( t1000_gfx_2bpp_update_row )
{
pc_t1t_device *t1t = downcast<pc_t1t_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT8 *vid = t1t->m_displayram + ( ra << 13 );
int i;
@ -356,7 +356,7 @@ static MC6845_UPDATE_ROW( t1000_gfx_2bpp_update_row )
static MC6845_UPDATE_ROW( pcjr_gfx_2bpp_high_update_row )
{
pcvideo_pcjr_device *pcjr = downcast<pcvideo_pcjr_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT8 *vid = pcjr->m_displayram + ( ra << 13 );
int i;
@ -382,7 +382,7 @@ static MC6845_UPDATE_ROW( pcjr_gfx_2bpp_high_update_row )
static MC6845_UPDATE_ROW( t1000_gfx_2bpp_tga_update_row )
{
pc_t1t_device *t1t = downcast<pc_t1t_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT8 *vid = t1t->m_displayram + ( ra << 13 );
int i;
@ -410,7 +410,7 @@ static MC6845_UPDATE_ROW( t1000_gfx_2bpp_tga_update_row )
static MC6845_UPDATE_ROW( t1000_gfx_1bpp_update_row )
{
pc_t1t_device *t1t = downcast<pc_t1t_device *>(device->owner());
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(y);
UINT8 *vid = t1t->m_displayram + ( ra << 13 );
UINT8 fg = t1t->m_palette_base + t1t->m_reg.data[0x11];

6
src/mess/video/poisk1.c
View File

@ -184,7 +184,7 @@ void p1_state::set_palette_luts(void)
POISK1_UPDATE_ROW( p1_state::cga_gfx_2bpp_update_row )
{
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(ra);
UINT16 odd, offset;
int i;
@ -211,7 +211,7 @@ POISK1_UPDATE_ROW( p1_state::cga_gfx_2bpp_update_row )
POISK1_UPDATE_ROW( p1_state::cga_gfx_1bpp_update_row )
{
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(ra);
UINT8 fg = 15, bg = BG_COLOR(m_video.color_select_68);
UINT16 odd, offset;
@ -243,7 +243,7 @@ POISK1_UPDATE_ROW( p1_state::cga_gfx_1bpp_update_row )
POISK1_UPDATE_ROW( p1_state::poisk1_gfx_1bpp_update_row )
{
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT32 *p = &bitmap.pix32(ra);
UINT8 fg, bg = BG_COLOR(m_video.color_select_68);
UINT16 odd, offset;

8
src/mess/video/radio86.c
View File

@ -15,7 +15,7 @@ I8275_DISPLAY_PIXELS(radio86_display_pixels)
{
radio86_state *state = device->machine().driver_data<radio86_state>();
int i;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
const UINT8 *charmap = state->m_charmap;
UINT8 pixels = charmap[(linecount & 7) + (charcode << 3)] ^ 0xff;
if (vsp) {
@ -37,7 +37,7 @@ I8275_DISPLAY_PIXELS(mikrosha_display_pixels)
{
radio86_state *state = device->machine().driver_data<radio86_state>();
int i;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
const UINT8 *charmap = state->m_charmap + (state->m_mikrosha_font_page & 1) * 0x400;
UINT8 pixels = charmap[(linecount & 7) + (charcode << 3)] ^ 0xff;
if (vsp) {
@ -58,7 +58,7 @@ I8275_DISPLAY_PIXELS(apogee_display_pixels)
{
radio86_state *state = device->machine().driver_data<radio86_state>();
int i;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
const UINT8 *charmap = state->m_charmap + (gpa & 1) * 0x400;
UINT8 pixels = charmap[(linecount & 7) + (charcode << 3)] ^ 0xff;
if (vsp) {
@ -79,7 +79,7 @@ I8275_DISPLAY_PIXELS(partner_display_pixels)
{
radio86_state *state = device->machine().driver_data<radio86_state>();
int i;
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
const UINT8 *charmap = state->m_charmap + 0x400 * (gpa * 2 + hlgt);
UINT8 pixels = charmap[(linecount & 7) + (charcode << 3)] ^ 0xff;
if (vsp) {

2
src/mess/video/super80.c
View File

@ -389,7 +389,7 @@ UINT32 super80_state::screen_update_super80v(screen_device &screen, bitmap_rgb32
MC6845_UPDATE_ROW( super80v_update_row )
{
super80_state *state = device->machine().driver_data<super80_state>();
const rgb_t *palette = palette_entry_list_raw(bitmap.palette());
const rgb_t *palette = bitmap.palette()->entry_list_raw();
UINT8 chr,col,gfx,fg,bg=0;
UINT16 mem,x;
UINT32 *p = &bitmap.pix32(y);