Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-05 13:54:42 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

- the public screen_state is made to only contain items that are currently accessed by drivers

Browse Source 
- populating screen_state is moved from mame.c to video.c
- defstate is gone -- the default screen parameters live in screen_config directly
This commit is contained in:
Zsolt Vasvari 2008-03-07 12:53:00 +00:00
parent 9ad9532722
commit d0f5196025
11 changed files with 102 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/emu/emupal.c
View File

@ -96,7 +96,18 @@ static void configure_rgb_shadows(running_machine *machine, int mode, float fact
void palette_init(running_machine *machine) void palette_init(running_machine *machine)
{ {
int format;
palette_private *palette = auto_malloc(sizeof(*palette)); palette_private *palette = auto_malloc(sizeof(*palette));
const device_config *device = video_screen_first(machine->config);
/* get the format from the first screen, or use BITMAP_FORMAT_INVALID, if screenless */
if (device != NULL)
{
screen_config *config = device->inline_config;
format = config->format;
}
else
format = BITMAP_FORMAT_INVALID;
/* request cleanup */ /* request cleanup */
machine->palette_data = palette; machine->palette_data = palette;
@ -104,10 +115,10 @@ void palette_init(running_machine *machine)
/* reset all our data */ /* reset all our data */
memset(palette, 0, sizeof(*palette)); memset(palette, 0, sizeof(*palette));
palette->format = machine->screen[0].format; palette->format = format;
/* determine the color mode */ /* determine the color mode */
switch (palette->format) switch (format)
{ {
case BITMAP_FORMAT_INDEXED16: case BITMAP_FORMAT_INDEXED16:
case BITMAP_FORMAT_RGB15: case BITMAP_FORMAT_RGB15:

23
src/emu/info.c
View File

@ -730,30 +730,29 @@ static void print_game_display(FILE *out, const game_driver *game, const machine
/* output width and height only for games that are not vector */ /* output width and height only for games that are not vector */
if (scrconfig->type != SCREEN_TYPE_VECTOR) if (scrconfig->type != SCREEN_TYPE_VECTOR)
{ {
int dx = scrconfig->defstate.visarea.max_x - scrconfig->defstate.visarea.min_x + 1; int dx = scrconfig->visarea.max_x - scrconfig->visarea.min_x + 1;
int dy = scrconfig->defstate.visarea.max_y - scrconfig->defstate.visarea.min_y + 1; int dy = scrconfig->visarea.max_y - scrconfig->visarea.min_y + 1;
fprintf(out, " width=\"%d\"", dx); fprintf(out, " width=\"%d\"", dx);
fprintf(out, " height=\"%d\"", dy); fprintf(out, " height=\"%d\"", dy);
} }
/* output refresh rate */ /* output refresh rate */
fprintf(out, " refresh=\"%f\"", ATTOSECONDS_TO_HZ(scrconfig->defstate.refresh)); fprintf(out, " refresh=\"%f\"", ATTOSECONDS_TO_HZ(scrconfig->refresh));
/* output raw video parameters only for games that are not vector */ /* output raw video parameters only for games that are not vector */
/* and had raw parameters specified */ /* and had raw parameters specified */
if ((scrconfig->type != SCREEN_TYPE_VECTOR) && !scrconfig->defstate.oldstyle_vblank_supplied) if ((scrconfig->type != SCREEN_TYPE_VECTOR) && !scrconfig->oldstyle_vblank_supplied)
{ {
int pixclock = scrconfig->defstate.width * scrconfig->defstate.height int pixclock = scrconfig->width * scrconfig->height * ATTOSECONDS_TO_HZ(scrconfig->refresh);
* ATTOSECONDS_TO_HZ(scrconfig->defstate.refresh);
fprintf(out, " pixclock=\"%d\"", pixclock); fprintf(out, " pixclock=\"%d\"", pixclock);
fprintf(out, " htotal=\"%d\"", scrconfig->defstate.width); fprintf(out, " htotal=\"%d\"", scrconfig->width);
fprintf(out, " hbend=\"%d\"", scrconfig->defstate.visarea.min_x); fprintf(out, " hbend=\"%d\"", scrconfig->visarea.min_x);
fprintf(out, " hbstart=\"%d\"", scrconfig->defstate.visarea.max_x+1); fprintf(out, " hbstart=\"%d\"", scrconfig->visarea.max_x+1);
fprintf(out, " vtotal=\"%d\"", scrconfig->defstate.height); fprintf(out, " vtotal=\"%d\"", scrconfig->height);
fprintf(out, " vbend=\"%d\"", scrconfig->defstate.visarea.min_y); fprintf(out, " vbend=\"%d\"", scrconfig->visarea.min_y);
fprintf(out, " vbstart=\"%d\"", scrconfig->defstate.visarea.max_y+1); fprintf(out, " vbstart=\"%d\"", scrconfig->visarea.max_y+1);
} }
fprintf(out, " />\n"); fprintf(out, " />\n");
} }

4
src/emu/inptport.c
View File

@ -2904,11 +2904,7 @@ profiler_mark(PROFILER_INPUT);
portinfo->vblank = 0; portinfo->vblank = 0;
for (bitnum = 0, info = &portinfo->bit[0]; bitnum < MAX_BITS_PER_PORT && info->port; bitnum++, info++) for (bitnum = 0, info = &portinfo->bit[0]; bitnum < MAX_BITS_PER_PORT && info->port; bitnum++, info++)
if (info->port->type == IPT_VBLANK) if (info->port->type == IPT_VBLANK)
{
portinfo->vblank ^= info->port->mask; portinfo->vblank ^= info->port->mask;
if (machine->screen[0].vblank == 0)
logerror("Warning: you are using IPT_VBLANK with vblank_time = 0. You need to increase vblank_time for IPT_VBLANK to work.\n");
}
/* now loop back and modify based on the inputs */ /* now loop back and modify based on the inputs */
portinfo->digital = 0; portinfo->digital = 0;

10
src/emu/mame.c
View File

@ -1451,18 +1451,10 @@ error:
static void prepare_machine(running_machine *machine) static void prepare_machine(running_machine *machine)
{ {
const device_config *device;
/* reset most portions of the machine */ /* reset most portions of the machine */
/* video-related information */ /* graphics layout */
memset(machine->gfx, 0, sizeof(machine->gfx)); memset(machine->gfx, 0, sizeof(machine->gfx));
for (device = video_screen_first(machine->config); device != NULL; device = video_screen_next(device))
{
int scrnum = device_list_index(machine->config->devicelist, VIDEO_SCREEN, device->tag);
const screen_config *scrconfig = device->inline_config;
machine->screen[scrnum] = scrconfig->defstate;
}
/* palette-related information */ /* palette-related information */
machine->pens = NULL; machine->pens = NULL;

36
src/emu/mconfig.h
View File

@ -378,37 +378,37 @@ union _machine_config_token
MDRV_DEVICE_MODIFY(_tag, VIDEO_SCREEN) MDRV_DEVICE_MODIFY(_tag, VIDEO_SCREEN)
#define MDRV_SCREEN_FORMAT(_format) \ #define MDRV_SCREEN_FORMAT(_format) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.format, _format) MDRV_DEVICE_CONFIG_DATA32(screen_config, format, _format)
#define MDRV_SCREEN_TYPE(_type) \ #define MDRV_SCREEN_TYPE(_type) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, type, SCREEN_TYPE_##_type) MDRV_DEVICE_CONFIG_DATA32(screen_config, type, SCREEN_TYPE_##_type)
#define MDRV_SCREEN_RAW_PARAMS(_pixclock, _htotal, _hbend, _hbstart, _vtotal, _vbend, _vbstart) \ #define MDRV_SCREEN_RAW_PARAMS(_pixclock, _htotal, _hbend, _hbstart, _vtotal, _vbend, _vbstart) \
MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.refresh, HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) \ MDRV_DEVICE_CONFIG_DATA64(screen_config, refresh, HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) \
MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.vblank, ((HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) / (_vtotal)) * ((_vtotal) - ((_vbstart) - (_vbend)))) \ MDRV_DEVICE_CONFIG_DATA64(screen_config, vblank, ((HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) / (_vtotal)) * ((_vtotal) - ((_vbstart) - (_vbend)))) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.width, _htotal) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, width, _htotal) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.height, _vtotal) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, height, _vtotal) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_x, _hbend) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.min_x, _hbend) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_x, (_hbstart) - 1) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.max_x, (_hbstart) - 1) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_y, _vbend) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.min_y, _vbend) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_y, (_vbstart) - 1) MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.max_y, (_vbstart) - 1)
#define MDRV_SCREEN_REFRESH_RATE(_rate) \ #define MDRV_SCREEN_REFRESH_RATE(_rate) \
MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.refresh, HZ_TO_ATTOSECONDS(_rate)) MDRV_DEVICE_CONFIG_DATA64(screen_config, refresh, HZ_TO_ATTOSECONDS(_rate))
#define MDRV_SCREEN_VBLANK_TIME(_time) \ #define MDRV_SCREEN_VBLANK_TIME(_time) \
MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.vblank, _time) \ MDRV_DEVICE_CONFIG_DATA64(screen_config, vblank, _time) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.oldstyle_vblank_supplied, TRUE) MDRV_DEVICE_CONFIG_DATA32(screen_config, oldstyle_vblank_supplied, TRUE)
#define MDRV_SCREEN_SIZE(_width, _height) \ #define MDRV_SCREEN_SIZE(_width, _height) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.width, _width) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, width, _width) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.height, _height) MDRV_DEVICE_CONFIG_DATA32(screen_config, height, _height)
#define MDRV_SCREEN_VISIBLE_AREA(_minx, _maxx, _miny, _maxy) \ #define MDRV_SCREEN_VISIBLE_AREA(_minx, _maxx, _miny, _maxy) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_x, _minx) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.min_x, _minx) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_x, _maxx) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.max_x, _maxx) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_y, _miny) \ MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.min_y, _miny) \
MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_y, _maxy) MDRV_DEVICE_CONFIG_DATA32(screen_config, visarea.max_y, _maxy)
#define MDRV_SCREEN_DEFAULT_POSITION(_xscale, _xoffs, _yscale, _yoffs) \ #define MDRV_SCREEN_DEFAULT_POSITION(_xscale, _xoffs, _yscale, _yoffs) \
MDRV_DEVICE_CONFIG_DATAFP32(screen_config, xoffset, _xoffs, 24) \ MDRV_DEVICE_CONFIG_DATAFP32(screen_config, xoffset, _xoffs, 24) \

2
src/emu/render.c
View File

@ -1379,7 +1379,7 @@ void render_target_get_minimum_size(render_target *target, INT32 *minwidth, INT3
else if (Machine->screen[item->index].visarea.max_x > Machine->screen[item->index].visarea.min_x) else if (Machine->screen[item->index].visarea.max_x > Machine->screen[item->index].visarea.min_x)
visarea = &Machine->screen[item->index].visarea; visarea = &Machine->screen[item->index].visarea;
else else
visarea = &scrconfig->defstate.visarea; visarea = &scrconfig->visarea;
/* apply target orientation to the bounds */ /* apply target orientation to the bounds */
bounds = item->bounds; bounds = item->bounds;

12
src/emu/rendlay.c
View File

@ -1361,8 +1361,8 @@ static int get_variable_value(const char *string, char **outputptr)
sprintf(temp, "~scr%dnativexaspect~", scrnum); sprintf(temp, "~scr%dnativexaspect~", scrnum);
if (!strncmp(string, temp, strlen(temp))) if (!strncmp(string, temp, strlen(temp)))
{ {
num = scrconfig->defstate.visarea.max_x + 1 - scrconfig->defstate.visarea.min_x; num = scrconfig->visarea.max_x + 1 - scrconfig->visarea.min_x;
den = scrconfig->defstate.visarea.max_y + 1 - scrconfig->defstate.visarea.min_y; den = scrconfig->visarea.max_y + 1 - scrconfig->visarea.min_y;
reduce_fraction(&num, &den); reduce_fraction(&num, &den);
*outputptr += sprintf(*outputptr, "%d", num); *outputptr += sprintf(*outputptr, "%d", num);
return strlen(temp); return strlen(temp);
@ -1372,8 +1372,8 @@ static int get_variable_value(const char *string, char **outputptr)
sprintf(temp, "~scr%dnativeyaspect~", scrnum); sprintf(temp, "~scr%dnativeyaspect~", scrnum);
if (!strncmp(string, temp, strlen(temp))) if (!strncmp(string, temp, strlen(temp)))
{ {
num = scrconfig->defstate.visarea.max_x + 1 - scrconfig->defstate.visarea.min_x; num = scrconfig->visarea.max_x + 1 - scrconfig->visarea.min_x;
den = scrconfig->defstate.visarea.max_y + 1 - scrconfig->defstate.visarea.min_y; den = scrconfig->visarea.max_y + 1 - scrconfig->visarea.min_y;
reduce_fraction(&num, &den); reduce_fraction(&num, &den);
*outputptr += sprintf(*outputptr, "%d", den); *outputptr += sprintf(*outputptr, "%d", den);
return strlen(temp); return strlen(temp);
@ -1383,7 +1383,7 @@ static int get_variable_value(const char *string, char **outputptr)
sprintf(temp, "~scr%dwidth~", scrnum); sprintf(temp, "~scr%dwidth~", scrnum);
if (!strncmp(string, temp, strlen(temp))) if (!strncmp(string, temp, strlen(temp)))
{ {
*outputptr += sprintf(*outputptr, "%d", scrconfig->defstate.visarea.max_x + 1 - scrconfig->defstate.visarea.min_x); *outputptr += sprintf(*outputptr, "%d", scrconfig->visarea.max_x + 1 - scrconfig->visarea.min_x);
return strlen(temp); return strlen(temp);
} }
@ -1391,7 +1391,7 @@ static int get_variable_value(const char *string, char **outputptr)
sprintf(temp, "~scr%dheight~", scrnum); sprintf(temp, "~scr%dheight~", scrnum);
if (!strncmp(string, temp, strlen(temp))) if (!strncmp(string, temp, strlen(temp)))
{ {
*outputptr += sprintf(*outputptr, "%d", scrconfig->defstate.visarea.max_y + 1 - scrconfig->defstate.visarea.min_y); *outputptr += sprintf(*outputptr, "%d", scrconfig->visarea.max_y + 1 - scrconfig->visarea.min_y);
return strlen(temp); return strlen(temp);
} }
} }

2
src/emu/ui.c
View File

@ -1736,7 +1736,7 @@ static INT32 slider_overclock(running_machine *machine, INT32 newval, char *buff
static INT32 slider_refresh(running_machine *machine, INT32 newval, char *buffer, int arg) static INT32 slider_refresh(running_machine *machine, INT32 newval, char *buffer, int arg)
{ {
const screen_config *scrconfig = device_list_find_by_index(Machine->config->devicelist, VIDEO_SCREEN, arg)->inline_config; const screen_config *scrconfig = device_list_find_by_index(Machine->config->devicelist, VIDEO_SCREEN, arg)->inline_config;
double defrefresh = ATTOSECONDS_TO_HZ(scrconfig->defstate.refresh); double defrefresh = ATTOSECONDS_TO_HZ(scrconfig->refresh);
double refresh; double refresh;
if (buffer != NULL) if (buffer != NULL)

20
src/emu/validity.c
View File

@ -830,7 +830,7 @@ static int validate_display(int drivnum, const machine_config *config)
const screen_config *scrconfig = device->inline_config; const screen_config *scrconfig = device->inline_config;
/* sanity check dimensions */ /* sanity check dimensions */
if ((scrconfig->defstate.width <= 0) || (scrconfig->defstate.height <= 0)) if ((scrconfig->width <= 0) || (scrconfig->height <= 0))
{ {
mame_printf_error("%s: %s screen \"%s\" has invalid display dimensions\n", driver->source_file, driver->name, device->tag); mame_printf_error("%s: %s screen \"%s\" has invalid display dimensions\n", driver->source_file, driver->name, device->tag);
error = TRUE; error = TRUE;
@ -839,29 +839,29 @@ static int validate_display(int drivnum, const machine_config *config)
/* sanity check display area */ /* sanity check display area */
if (scrconfig->type != SCREEN_TYPE_VECTOR) if (scrconfig->type != SCREEN_TYPE_VECTOR)
{ {
if ((scrconfig->defstate.visarea.max_x < scrconfig->defstate.visarea.min_x) if ((scrconfig->visarea.max_x < scrconfig->visarea.min_x) ||
|| (scrconfig->defstate.visarea.max_y < scrconfig->defstate.visarea.min_y) (scrconfig->visarea.max_y < scrconfig->visarea.min_y) ||
|| (scrconfig->defstate.visarea.max_x >= scrconfig->defstate.width) (scrconfig->visarea.max_x >= scrconfig->width) ||
|| (scrconfig->defstate.visarea.max_y >= scrconfig->defstate.height)) (scrconfig->visarea.max_y >= scrconfig->height))
{ {
mame_printf_error("%s: %s screen \"%s\" has an invalid display area\n", driver->source_file, driver->name, device->tag); mame_printf_error("%s: %s screen \"%s\" has an invalid display area\n", driver->source_file, driver->name, device->tag);
error = TRUE; error = TRUE;
} }
/* sanity check screen formats */ /* sanity check screen formats */
if (scrconfig->defstate.format != BITMAP_FORMAT_INDEXED16 && if (scrconfig->format != BITMAP_FORMAT_INDEXED16 &&
scrconfig->defstate.format != BITMAP_FORMAT_RGB15 && scrconfig->format != BITMAP_FORMAT_RGB15 &&
scrconfig->defstate.format != BITMAP_FORMAT_RGB32) scrconfig->format != BITMAP_FORMAT_RGB32)
{ {
mame_printf_error("%s: %s screen \"%s\" has unsupported format\n", driver->source_file, driver->name, device->tag); mame_printf_error("%s: %s screen \"%s\" has unsupported format\n", driver->source_file, driver->name, device->tag);
error = TRUE; error = TRUE;
} }
if (scrconfig->defstate.format == BITMAP_FORMAT_INDEXED16) if (scrconfig->format == BITMAP_FORMAT_INDEXED16)
palette_modes = TRUE; palette_modes = TRUE;
} }
/* check for zero frame rate */ /* check for zero frame rate */
if (scrconfig->defstate.refresh == 0) if (scrconfig->refresh == 0)
{ {
mame_printf_error("%s: %s screen \"%s\" has a zero refresh rate\n", driver->source_file, driver->name, device->tag); mame_printf_error("%s: %s screen \"%s\" has a zero refresh rate\n", driver->source_file, driver->name, device->tag);
error = TRUE; error = TRUE;

59
src/emu/video.c
View File

@ -57,15 +57,16 @@ struct _internal_screen_state
bitmap_t * bitmap[2]; /* 2x bitmaps for rendering */ bitmap_t * bitmap[2]; /* 2x bitmaps for rendering */
UINT8 curbitmap; /* current bitmap index */ UINT8 curbitmap; /* current bitmap index */
UINT8 curtexture; /* current texture index */ UINT8 curtexture; /* current texture index */
bitmap_format format; /* format of bitmap for this screen */ bitmap_format texture_format; /* texture format of bitmap for this screen */
UINT8 changed; /* has this bitmap changed? */ UINT8 changed; /* has this bitmap changed? */
INT32 last_partial_scan; /* scanline of last partial update */ INT32 last_partial_scan; /* scanline of last partial update */
UINT8 vblank_state; /* 1 = in VBLANK region, 0 = outside */
/* screen timing */ /* screen timing */
attoseconds_t scantime; /* attoseconds per scanline */ attoseconds_t scantime; /* attoseconds per scanline */
attoseconds_t pixeltime; /* attoseconds per pixel */ attoseconds_t pixeltime; /* attoseconds per pixel */
attoseconds_t vblank_period; /* attoseconds per VBLANK period */
attotime vblank_time; /* time of last VBLANK start */ attotime vblank_time; /* time of last VBLANK start */
UINT8 vblank_state; /* 1 = in VBLANK region, 0 = outside */
emu_timer * vblank_begin_timer; /* timer to signal VBLANK start */ emu_timer * vblank_begin_timer; /* timer to signal VBLANK start */
emu_timer * vblank_end_timer; /* timer to signal VBLANK end */ emu_timer * vblank_end_timer; /* timer to signal VBLANK end */
emu_timer * scanline0_timer; /* scanline 0 timer */ emu_timer * scanline0_timer; /* scanline 0 timer */
@ -312,17 +313,20 @@ void video_init(running_machine *machine)
/* request a callback upon exiting */ /* request a callback upon exiting */
add_exit_callback(machine, video_exit); add_exit_callback(machine, video_exit);
/* configure all of the screens */
for (device = video_screen_first(machine->config); device != NULL; device = video_screen_next(device)) for (device = video_screen_first(machine->config); device != NULL; device = video_screen_next(device))
{ {
char unique_tag[40];
int scrnum = device_list_index(machine->config->devicelist, VIDEO_SCREEN, device->tag); int scrnum = device_list_index(machine->config->devicelist, VIDEO_SCREEN, device->tag);
render_container *container = render_container_get_screen(scrnum); render_container *container = render_container_get_screen(scrnum);
screen_config *config = device->inline_config; screen_config *config = device->inline_config;
screen_state *state = &machine->screen[scrnum]; screen_state *state = &machine->screen[scrnum];
/* allocate the private state */ /* allocate the private state and hook it up to the public structure */
internal_screen_state *internal_state = auto_malloc(sizeof(*internal_state)); internal_screen_state *internal_state = auto_malloc(sizeof(*internal_state));
memset(internal_state, 0, sizeof(*internal_state)); memset(internal_state, 0, sizeof(*internal_state));
state->private_data = internal_state;
/* allocate the VBLANK timers */ /* allocate the VBLANK timers */
internal_state->vblank_begin_timer = timer_alloc(vblank_begin_callback, state); internal_state->vblank_begin_timer = timer_alloc(vblank_begin_callback, state);
@ -335,11 +339,9 @@ void video_init(running_machine *machine)
internal_state->scrnum = scrnum; internal_state->scrnum = scrnum;
internal_state->device = device; internal_state->device = device;
/* hook up our private state structure */
state->private_data = internal_state;
/* configure the screen with the default parameters */ /* configure the screen with the default parameters */
video_screen_configure(scrnum, state->width, state->height, &state->visarea, state->refresh); state->format = config->format;
video_screen_configure(scrnum, config->width, config->height, &config->visarea, config->refresh);
/* configure the default cliparea */ /* configure the default cliparea */
if (config->xoffset != 0) if (config->xoffset != 0)
@ -362,9 +364,12 @@ void video_init(running_machine *machine)
} }
/* register for save states */ /* register for save states */
state_save_register_item("video", scrnum, internal_state->vblank_time.seconds); assert(strlen(device->tag) < 30);
state_save_register_item("video", scrnum, internal_state->vblank_time.attoseconds); state_save_combine_module_and_tag(unique_tag, "video_screen", device->tag);
state_save_register_item("video", scrnum, internal_state->frame_number);
state_save_register_item(unique_tag, 0, internal_state->vblank_time.seconds);
state_save_register_item(unique_tag, 0, internal_state->vblank_time.attoseconds);
state_save_register_item(unique_tag, 0, internal_state->frame_number);
} }
/* create spriteram buffers if necessary */ /* create spriteram buffers if necessary */
@ -717,13 +722,12 @@ void video_screen_configure(int scrnum, int width, int height, const rectangle *
curwidth = MAX(width, curwidth); curwidth = MAX(width, curwidth);
curheight = MAX(height, curheight); curheight = MAX(height, curheight);
/* choose the texture format */ /* choose the texture format - convert the screen format to a texture format */
/* convert the screen format to a texture format */
switch (screen_format) switch (screen_format)
{ {
case BITMAP_FORMAT_INDEXED16: internal_state->format = TEXFORMAT_PALETTE16; break; case BITMAP_FORMAT_INDEXED16: internal_state->texture_format = TEXFORMAT_PALETTE16; break;
case BITMAP_FORMAT_RGB15: internal_state->format = TEXFORMAT_RGB15; break; case BITMAP_FORMAT_RGB15: internal_state->texture_format = TEXFORMAT_RGB15; break;
case BITMAP_FORMAT_RGB32: internal_state->format = TEXFORMAT_RGB32; break; case BITMAP_FORMAT_RGB32: internal_state->texture_format = TEXFORMAT_RGB32; break;
default: fatalerror("Invalid bitmap format!"); break; default: fatalerror("Invalid bitmap format!"); break;
} }
@ -735,9 +739,9 @@ void video_screen_configure(int scrnum, int width, int height, const rectangle *
/* allocate textures */ /* allocate textures */
internal_state->texture[0] = render_texture_alloc(NULL, NULL); internal_state->texture[0] = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(internal_state->texture[0], internal_state->bitmap[0], visarea, 0, internal_state->format); render_texture_set_bitmap(internal_state->texture[0], internal_state->bitmap[0], visarea, 0, internal_state->texture_format);
internal_state->texture[1] = render_texture_alloc(NULL, NULL); internal_state->texture[1] = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(internal_state->texture[1], internal_state->bitmap[1], visarea, 0, internal_state->format); render_texture_set_bitmap(internal_state->texture[1], internal_state->bitmap[1], visarea, 0, internal_state->texture_format);
} }
} }
@ -751,6 +755,13 @@ void video_screen_configure(int scrnum, int width, int height, const rectangle *
internal_state->scantime = refresh / height; internal_state->scantime = refresh / height;
internal_state->pixeltime = refresh / (height * width); internal_state->pixeltime = refresh / (height * width);
/* if there has been no VBLANK time specified in the MACHINE_DRIVER, compute it now
from the visible area, otherwise just used the supplied value */
if ((scrconfig->vblank == 0) && !scrconfig->oldstyle_vblank_supplied)
internal_state->vblank_period = (state->refresh / state->height) * (state->height - (state->visarea.max_y + 1 - state->visarea.min_y));
else
internal_state->vblank_period = scrconfig->vblank;
/* adjust speed if necessary */ /* adjust speed if necessary */
if (global.refresh_speed) if (global.refresh_speed)
{ {
@ -1239,7 +1250,6 @@ DEVICE_GET_INFO( video_screen )
static TIMER_CALLBACK( vblank_begin_callback ) static TIMER_CALLBACK( vblank_begin_callback )
{ {
int i; int i;
attoseconds_t vblank_period;
screen_state *state = ptr; screen_state *state = ptr;
internal_screen_state *internal_state = (internal_screen_state *)state->private_data; internal_screen_state *internal_state = (internal_screen_state *)state->private_data;
@ -1262,16 +1272,9 @@ static TIMER_CALLBACK( vblank_begin_callback )
if (!(machine->config->video_attributes & VIDEO_UPDATE_AFTER_VBLANK) && (internal_state->scrnum == 0)) if (!(machine->config->video_attributes & VIDEO_UPDATE_AFTER_VBLANK) && (internal_state->scrnum == 0))
video_frame_update(machine, FALSE); video_frame_update(machine, FALSE);
/* if there has been no VBLANK time specified in the MACHINE_DRIVER, compute it now
from the visible area, otherwise just used the supplied value */
if ((state->vblank == 0) && !state->oldstyle_vblank_supplied)
vblank_period = (state->refresh / state->height) * (state->height - (state->visarea.max_y + 1 - state->visarea.min_y));
else
vblank_period = state->vblank;
/* reset the timers */ /* reset the timers */
timer_adjust_oneshot(internal_state->vblank_begin_timer, attotime_make(0, state->refresh), 0); timer_adjust_oneshot(internal_state->vblank_begin_timer, attotime_make(0, state->refresh), 0);
timer_adjust_oneshot(internal_state->vblank_end_timer, attotime_make(0, vblank_period), 0); timer_adjust_oneshot(internal_state->vblank_end_timer, attotime_make(0, internal_state->vblank_period), 0);
} }
@ -1453,7 +1456,7 @@ static int finish_screen_updates(running_machine *machine)
rectangle fixedvis = machine->screen[scrnum].visarea; rectangle fixedvis = machine->screen[scrnum].visarea;
fixedvis.max_x++; fixedvis.max_x++;
fixedvis.max_y++; fixedvis.max_y++;
render_texture_set_bitmap(internal_state->texture[internal_state->curbitmap], bitmap, &fixedvis, 0, internal_state->format); render_texture_set_bitmap(internal_state->texture[internal_state->curbitmap], bitmap, &fixedvis, 0, internal_state->texture_format);
internal_state->curtexture = internal_state->curbitmap; internal_state->curtexture = internal_state->curbitmap;
internal_state->curbitmap = 1 - internal_state->curbitmap; internal_state->curbitmap = 1 - internal_state->curbitmap;
} }

17
src/emu/video.h
View File

@ -64,12 +64,10 @@ enum
typedef struct _screen_state screen_state; typedef struct _screen_state screen_state;
struct _screen_state struct _screen_state
{ {
int width, height; /* total width/height (HTOTAL, VTOTAL) */ int width, height; /* current total width/height (HTOTAL, VTOTAL) */
rectangle visarea; /* visible area (HBLANK end/start, VBLANK end/start) */ rectangle visarea; /* current visible area (HBLANK end/start, VBLANK end/start) */
UINT8 oldstyle_vblank_supplied; /* MDRV_SCREEN_VBLANK_TIME macro used */ attoseconds_t refresh; /* current refresh period */
attoseconds_t refresh; /* refresh period */ bitmap_format format; /* bitmap format (a copy of screen_config) */
attoseconds_t vblank; /* duration of a VBLANK */
bitmap_format format; /* bitmap format */
void * private_data; /* pointer to the private data structure */ void * private_data; /* pointer to the private data structure */
}; };
@ -83,7 +81,12 @@ typedef struct _screen_config screen_config;
struct _screen_config struct _screen_config
{ {
int type; /* type of screen */ int type; /* type of screen */
screen_state defstate; /* default state */ int width, height; /* default total width/height (HTOTAL, VTOTAL) */
rectangle visarea; /* default visible area (HBLANK end/start, VBLANK end/start) */
UINT8 oldstyle_vblank_supplied; /* MDRV_SCREEN_VBLANK_TIME macro used */
attoseconds_t refresh; /* default refresh period */
attoseconds_t vblank; /* duration of a VBLANK */
bitmap_format format; /* bitmap format */
float xoffset, yoffset; /* default X/Y offsets */ float xoffset, yoffset; /* default X/Y offsets */
float xscale, yscale; /* default X/Y scale factor */ float xscale, yscale; /* default X/Y scale factor */
}; };