int video_init(void)
{
osd_create_params params;
artwork_callbacks *artcallbacks;
int bmwidth = Machine->drv->screen_width;
int bmheight = Machine->drv->screen_height;
movie_file = NULL;
movie_frame = 0;
add_pause_callback(video_pause);
add_exit_callback(video_exit);
/* first allocate the necessary palette structures */
if (palette_start())
return 1;
#ifndef NEW_RENDER
/* if we're a vector game, override the screen width and height */
if (Machine->drv->video_attributes & VIDEO_TYPE_VECTOR)
scale_vectorgames(options.vector_width, options.vector_height, &bmwidth, &bmheight);
/* compute the visible area for raster games */
if (!(Machine->drv->video_attributes & VIDEO_TYPE_VECTOR))
{
params.width = Machine->drv->default_visible_area.max_x - Machine->drv->default_visible_area.min_x + 1;
params.height = Machine->drv->default_visible_area.max_y - Machine->drv->default_visible_area.min_y + 1;
}
else
{
params.width = bmwidth;
params.height = bmheight;
}
/* fill in the rest of the display parameters */
compute_aspect_ratio(Machine->drv, ¶ms.aspect_x, ¶ms.aspect_y);
params.depth = Machine->color_depth;
params.colors = palette_get_total_colors_with_ui();
params.fps = Machine->drv->frames_per_second;
params.video_attributes = Machine->drv->video_attributes;
#ifdef MESS
artcallbacks = &mess_artwork_callbacks;
#else
artcallbacks = &mame_artwork_callbacks;
#endif
/* initialize the display through the artwork (and eventually the OSD) layer */
if (artwork_create_display(¶ms, direct_rgb_components, artcallbacks))
return 1;
/* the create display process may update the vector width/height, so recompute */
if (Machine->drv->video_attributes & VIDEO_TYPE_VECTOR)
scale_vectorgames(options.vector_width, options.vector_height, &bmwidth, &bmheight);
/* now allocate the screen bitmap */
scrbitmap[0] = auto_bitmap_alloc_depth(bmwidth, bmheight, Machine->color_depth);
if (!scrbitmap[0])
return 1;
#endif
/* set the default refresh rate */
set_refresh_rate(Machine->drv->frames_per_second);
/* set the default visible area */
set_visible_area(0,1,0,1); // make sure everything is recalculated on multiple runs
set_visible_area(
Machine->drv->default_visible_area.min_x,
Machine->drv->default_visible_area.max_x,
Machine->drv->default_visible_area.min_y,
Machine->drv->default_visible_area.max_y);
/* create spriteram buffers if necessary */
if (Machine->drv->video_attributes & VIDEO_BUFFERS_SPRITERAM)
if (init_buffered_spriteram())
return 1;
#ifndef NEW_RENDER
#if defined(MAME_DEBUG) && !defined(NEW_DEBUGGER)
/* if the debugger is enabled, initialize its bitmap and font */
if (Machine->debug_mode)
{
int depth = options.debug_depth ? options.debug_depth : Machine->color_depth;
/* first allocate the debugger bitmap */
Machine->debug_bitmap = auto_bitmap_alloc_depth(options.debug_width, options.debug_height, depth);
if (!Machine->debug_bitmap)
return 1;
/* then create the debugger font */
Machine->debugger_font = build_debugger_font();
if (Machine->debugger_font == NULL)
return 1;
}
#endif
#endif
/* convert the gfx ROMs into character sets. This is done BEFORE calling the driver's */
/* palette_init() routine because it might need to check the Machine->gfx[] data */
if (Machine->drv->gfxdecodeinfo)
if (allocate_graphics(Machine->drv->gfxdecodeinfo))
return 1;
/* initialize the palette - must be done after osd_create_display() */
if (palette_init())
return 1;
/* force the first update to be full */
set_vh_global_attribute(NULL, 0);
/* actually decode the graphics */
if (Machine->drv->gfxdecodeinfo)
decode_graphics(Machine->drv->gfxdecodeinfo);
/* reset performance data */
last_fps_time = osd_cycles();
rendered_frames_since_last_fps = frames_since_last_fps = 0;
performance.game_speed_percent = 100;
performance.frames_per_second = Machine->refresh_rate;
performance.vector_updates_last_second = 0;
/* reset video statics and get out of here */
pdrawgfx_shadow_lowpri = 0;
leds_status = 0;
/* initialize tilemaps */
if (tilemap_init() != 0)
fatalerror("tilemap_init failed");
return 0;
}
static int vh_open(void)
{
int i;
int width,height;
for (i = 0;i < MAX_GFX_ELEMENTS;i++) Machine->gfx[i] = 0;
Machine->uifont = 0;
if (palette_start() != 0)
{
vh_close();
return 1;
}
/* convert the gfx ROMs into character sets. This is done BEFORE calling the driver's */
/* convert_color_prom() routine (in palette_init()) because it might need to check the */
/* Machine->gfx[] data */
if (drv->gfxdecodeinfo)
{
for (i = 0;i < MAX_GFX_ELEMENTS && drv->gfxdecodeinfo[i].memory_region != -1;i++)
{
int reglen = 8*memory_region_length(drv->gfxdecodeinfo[i].memory_region);
struct GfxLayout glcopy;
int j;
memcpy(&glcopy,drv->gfxdecodeinfo[i].gfxlayout,sizeof(glcopy));
if (IS_FRAC(glcopy.total))
glcopy.total = reglen / glcopy.charincrement * FRAC_NUM(glcopy.total) / FRAC_DEN(glcopy.total);
for (j = 0;j < MAX_GFX_PLANES;j++)
{
if (IS_FRAC(glcopy.planeoffset[j]))
{
glcopy.planeoffset[j] = FRAC_OFFSET(glcopy.planeoffset[j]) +
reglen * FRAC_NUM(glcopy.planeoffset[j]) / FRAC_DEN(glcopy.planeoffset[j]);
}
}
for (j = 0;j < MAX_GFX_SIZE;j++)
{
if (IS_FRAC(glcopy.xoffset[j]))
{
glcopy.xoffset[j] = FRAC_OFFSET(glcopy.xoffset[j]) +
reglen * FRAC_NUM(glcopy.xoffset[j]) / FRAC_DEN(glcopy.xoffset[j]);
}
if (IS_FRAC(glcopy.yoffset[j]))
{
glcopy.yoffset[j] = FRAC_OFFSET(glcopy.yoffset[j]) +
reglen * FRAC_NUM(glcopy.yoffset[j]) / FRAC_DEN(glcopy.yoffset[j]);
}
}
if ((Machine->gfx[i] = decodegfx(memory_region(drv->gfxdecodeinfo[i].memory_region)
+ drv->gfxdecodeinfo[i].start,
&glcopy)) == 0)
{
vh_close();
bailing = 1;
printf("Out of memory decoding gfx\n");
return 1;
}
if (Machine->remapped_colortable)
Machine->gfx[i]->colortable = &Machine->remapped_colortable[drv->gfxdecodeinfo[i].color_codes_start];
Machine->gfx[i]->total_colors = drv->gfxdecodeinfo[i].total_color_codes;
}
}
width = drv->screen_width;
height = drv->screen_height;
if (Machine->drv->video_attributes & VIDEO_TYPE_VECTOR)
scale_vectorgames(options.vector_width,options.vector_height,&width,&height);
Machine->scrbitmap = bitmap_alloc_depth(width,height,Machine->color_depth);
if (!Machine->scrbitmap)
{
vh_close();
return 1;
}
if (!(Machine->drv->video_attributes & VIDEO_TYPE_VECTOR))
{
width = drv->default_visible_area.max_x - drv->default_visible_area.min_x + 1;
height = drv->default_visible_area.max_y - drv->default_visible_area.min_y + 1;
}
if (Machine->orientation & ORIENTATION_SWAP_XY)
{
int temp;
temp = width; width = height; height = temp;
}
/* create the display bitmap, and allocate the palette */
if (osd_create_display(width,height,Machine->color_depth,
drv->frames_per_second,drv->video_attributes,Machine->orientation))
{
vh_close();
return 1;
}
set_visible_area(
drv->default_visible_area.min_x,
drv->default_visible_area.max_x,
drv->default_visible_area.min_y,
drv->default_visible_area.max_y);
/* create spriteram buffers if necessary */
if (drv->video_attributes & VIDEO_BUFFERS_SPRITERAM) {
if (spriteram_size!=0) {
buffered_spriteram= (unsigned char *) malloc(spriteram_size);
if (!buffered_spriteram) { vh_close(); return 1; }
if (spriteram_2_size!=0) buffered_spriteram_2 = (unsigned char *) malloc(spriteram_2_size);
if (spriteram_2_size && !buffered_spriteram_2) { vh_close(); return 1; }
} else {
logerror("vh_open(): Video buffers spriteram but spriteram_size is 0\n");
buffered_spriteram=NULL;
buffered_spriteram_2=NULL;
}
}
/* build our private user interface font */
/* This must be done AFTER osd_create_display() so the function knows the */
/* resolution we are running at and can pick a different font depending on it. */
/* It must be done BEFORE palette_init() because that will also initialize */
/* (through osd_allocate_colors()) the uifont colortable. */
if ((Machine->uifont = builduifont()) == 0)
{
vh_close();
return 1;
}
/* initialize the palette - must be done after osd_create_display() */
if (palette_init())
{
vh_close();
return 1;
}
return 0;
}
