void PSL1GHT_InitModes(_THIS) { deprintf(1, "+PSL1GHT_InitModes()\n"); SDL_DisplayMode mode; PSL1GHT_DisplayModeData *modedata; videoState state; modedata = (PSL1GHT_DisplayModeData *) SDL_malloc(sizeof(*modedata)); if (!modedata) { return; } assert(videoGetState(0, 0, &state) == 0); // Get the state of the display assert(state.state == 0); // Make sure display is enabled // Get the current resolution videoResolution res; assert(videoGetResolution(state.displayMode.resolution, &res) == 0); /* Setting up the DisplayMode based on current settings */ mode.format = SDL_PIXELFORMAT_ARGB8888; mode.refresh_rate = 0; mode.w = res.width; mode.h = res.height; modedata->vconfig.resolution = state.displayMode.resolution; modedata->vconfig.format = VIDEO_BUFFER_FORMAT_XRGB; modedata->vconfig.pitch = res.width * 4; mode.driverdata = modedata; /* Setup the display to it's default mode */ assert(videoConfigure(0, &modedata->vconfig, NULL, 1) == 0); // Wait until RSX is ready do{ SDL_Delay(10); assert( videoGetState(0, 0, &state) == 0); }while ( state.state == 3); /* Set display's videomode and add it */ SDL_AddBasicVideoDisplay(&mode); deprintf(1, "-PSL1GHT_InitModes()\n"); }
void init_screen(void *host_addr,u32 size) { printf("initializing screen....\n"); context = rsxInit(CB_SIZE,size,host_addr); videoState state; videoGetState(0,0,&state); videoGetResolution(state.displayMode.resolution,&res); videoConfiguration vconfig; memset(&vconfig,0,sizeof(videoConfiguration)); vconfig.resolution = state.displayMode.resolution; vconfig.format = VIDEO_BUFFER_FORMAT_XRGB; vconfig.pitch = res.width*sizeof(u32); waitRSXIdle(); videoConfigure(0,&vconfig,NULL,0); videoGetState(0,0,&state); gcmSetFlipMode(GCM_FLIP_VSYNC); display_width = res.width; display_height = res.height; color_pitch = display_width*sizeof(u32); color_buffer[0] = (u32*)rsxMemalign(64,(display_height*color_pitch)); color_buffer[1] = (u32*)rsxMemalign(64,(display_height*color_pitch)); rsxAddressToOffset(color_buffer[0],&color_offset[0]); rsxAddressToOffset(color_buffer[1],&color_offset[1]); gcmSetDisplayBuffer(0,color_offset[0],color_pitch,display_width,display_height); gcmSetDisplayBuffer(1,color_offset[1],color_pitch,display_width,display_height); depth_pitch = display_width*sizeof(u32); depth_buffer = (u32*)rsxMemalign(64,(display_height*depth_pitch)*2); rsxAddressToOffset(depth_buffer,&depth_offset); printf("screen initialized....\n"); }
// Initilize everything. You can probally skip over this function. void init_screen() { // Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX. void *host_addr = memalign(1024*1024, 1024*1024); assert(host_addr != NULL); // Initilise Reality, which sets up the command buffer and shared IO memory context = realityInit(0x10000, 1024*1024, host_addr); assert(context != NULL); VideoState state; assert(videoGetState(0, 0, &state) == 0); // Get the state of the display assert(state.state == 0); // Make sure display is enabled // Get the current resolution assert(videoGetResolution(state.displayMode.resolution, &res) == 0); // Configure the buffer format to xRGB VideoConfiguration vconfig; memset(&vconfig, 0, sizeof(VideoConfiguration)); vconfig.resolution = state.displayMode.resolution; vconfig.format = VIDEO_BUFFER_FORMAT_XRGB; vconfig.pitch = res.width * 4; assert(videoConfigure(0, &vconfig, NULL, 0) == 0); assert(videoGetState(0, 0, &state) == 0); s32 buffer_size = 4 * res.width * res.height; // each pixel is 4 bytes printf("buffers will be 0x%x bytes\n", buffer_size); gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip // Allocate two buffers for the RSX to draw to the screen (double buffering) makeBuffer(0, buffer_size); makeBuffer(1, buffer_size); gcmResetFlipStatus(); flip(1); }
int initScreen (void *host_addr, u32 size) { /* gcmContextData *context = NULL; */ /* Context to keep track of the RSX * buffer. */ videoState state; videoConfiguration vconfig; videoResolution res; /* Screen Resolution */ /* Initilise Reality, which sets up the command buffer and shared IO memory */ context = rsxInit (CB_SIZE, size, host_addr); if (context == NULL) goto error; /* Get the state of the display */ if (videoGetState (0, 0, &state) != 0) goto error; /* Make sure display is enabled */ if (state.state != 0) goto error; /* Get the current resolution */ if (videoGetResolution (state.displayMode.resolution, &res) != 0) goto error; /* Configure the buffer format to xRGB */ memset (&vconfig, 0, sizeof (videoConfiguration)); vconfig.resolution = state.displayMode.resolution; vconfig.format = VIDEO_BUFFER_FORMAT_XRGB; vconfig.pitch = res.width * sizeof (u32); vconfig.aspect = state.displayMode.aspect; waitRSXIdle (context); if (videoConfigure (0, &vconfig, NULL, 0) != 0) goto error; if (videoGetState (0, 0, &state) != 0) goto error; gcmSetFlipMode (GCM_FLIP_VSYNC); /* Wait for VSYNC to flip */ depth_pitch = res.width * sizeof (u32); depth_buffer = (u32 *) rsxMemalign (64, (res.height * depth_pitch) * 2); rsxAddressToOffset (depth_buffer, &depth_offset); gcmResetFlipStatus (); return 0; error: if (context) rsxFinish (context, 0); if (host_addr) free (host_addr); return 1; }
// Initilize and rsx void init_screen(int command_buffer, int z_method) { // Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX. void *host_addr = memalign(1024*1024, command_buffer); assert(host_addr != NULL); if(z_method) zformat = REALITY_TARGET_FORMAT_ZETA_Z24S8; else zformat = REALITY_TARGET_FORMAT_ZETA_Z16; // Initilise Reality, which sets up the command buffer and shared IO memory context = realityInit(0x10000, command_buffer, host_addr); assert(context != NULL); VideoState state; assert(videoGetState(0, 0, &state) == 0); // Get the state of the display assert(state.state == 0); // Make sure display is enabled // Get the current resolution assert(videoGetResolution(state.displayMode.resolution, &Video_Resolution) == 0); Video_pitch = 4 * ((Video_Resolution.width + 15)/16) * 16; // each pixel is 4 bytes if(!z_method) // 16 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen depth_pitch = 2 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+31)/32)*32) : 1920); else // 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen depth_pitch = 4 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+15)/16)*16) : 1920); // Configure the buffer format to xRGB VideoConfiguration vconfig; memset(&vconfig, 0, sizeof(VideoConfiguration)); vconfig.resolution = state.displayMode.resolution; vconfig.format = VIDEO_BUFFER_FORMAT_XRGB; vconfig.pitch = Video_pitch; Video_aspect=vconfig.aspect=state.displayMode.aspect; assert(videoConfigure(0, &vconfig, NULL, 0) == 0); assert(videoGetState(0, 0, &state) == 0); s32 buffer_size = Video_pitch * Video_Resolution.height; s32 depth_buffer_size; if(!z_method) // 16 bit float. Note it uses 1088 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+31)/32)*32) : 1088); else // 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+15)/16)*16) : 1088); printf("buffers will be 0x%x bytes\n", buffer_size); gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip // Allocate two buffers for the RSX to draw to the screen (double buffering) Video_buffer[0] = rsxMemAlign(64, buffer_size); Video_buffer[1] = rsxMemAlign(64, buffer_size); assert(Video_buffer[0] != NULL && Video_buffer[1] != NULL); depth_buffer = rsxMemAlign(64, depth_buffer_size); assert(realityAddressToOffset(Video_buffer[0], &offset[0]) == 0); assert(realityAddressToOffset(Video_buffer[1], &offset[1]) == 0); // Setup the display buffers assert(gcmSetDisplayBuffer(0, offset[0], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0); assert(gcmSetDisplayBuffer(1, offset[1], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0); assert(realityAddressToOffset(depth_buffer, &depth_offset) == 0); gcmResetFlipStatus(); flip(1); waitFlip(); }
void MmeGrabber::startup() { MMRESULT s; int size; /* fprintf(stderr, "vic: Called MmeGrabber::startup\n"); */ if (running_) return; if(port_) { s=videoSetPortNum(handle_,port_); if (mme_error(s, "couldn't configure mme")) goto bail; } if(standard_) { s=videoSetStandard(handle_,standard_); if (mme_error(s, "couldn't configure mme")) goto bail; } s = videoConfigure(handle_, DVM_FORMAT, VIDEO_CONFIGURE_GET|VIDEO_CONFIGURE_MIN, 0, bmh, sizeof(*bmh), 0, 0); size = bmh->b.bmi.biSizeImage;/*XXX ridiculously large*/ s = videoConfigure(handle_, DVM_FORMAT, VIDEO_CONFIGURE_SET, 0, bmh, sizeof(*bmh), 0, 0); if (mme_error(s, "couldn't configure mme")) goto bail; #ifdef notdef size = 320 * 240 * 3; #endif vh_->lpData = (LPSTR)mmeAllocBuffer(size); if (vh_->lpData == 0) { fprintf(stderr, "vic: couldn't allocate mme frame memory\n"); goto bail; } vh_->dwBufferLength = size; s = videoStreamInit(handle_, 1000000 /*10fps - ignored */, mme_callback, 0, CALLBACK_FUNCTION); if (mme_error(s, "couldn't initialize mme stream\n")) return; s = videoStreamPrepareHeader(handle_, vh_, sizeof(*vh_)); if (mme_error(s, "couldn't prepare mme video hdr")) return; s = videoStreamStart(handle_); if (mme_error(s, "couldn't start mme video stream\n")) return; running_ = 1; frameclock_ = gettimeofday_usecs(); outstanding_ = 0; last_grab_ = 0; grab(); return; bail: mmeFreeMem(bmh); bmh = 0; videoClose(handle_); vh_ = 0; valid_ = 0; }
static void init_screen(glw_ps3_t *gp) { // Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX. void *host_addr = memalign(1024*1024, 1024*1024); assert(host_addr != NULL); // Initilise Reality, which sets up the command buffer and shared IO memory gp->gr.gr_be.be_ctx = realityInit(0x10000, 1024*1024, host_addr); assert(gp->gr.gr_be.be_ctx != NULL); gcmConfiguration config; gcmGetConfiguration(&config); TRACE(TRACE_INFO, "RSX", "memory @ 0x%x size = %d\n", config.localAddress, config.localSize); hts_mutex_init(&gp->gr.gr_be.be_mempool_lock); gp->gr.gr_be.be_mempool = extent_create(0, config.localSize >> 4); gp->gr.gr_be.be_rsx_address = (void *)(uint64_t)config.localAddress; VideoState state; videoGetState(0, 0, &state); // Get the current resolution videoGetResolution(state.displayMode.resolution, &gp->res); int num = gp->res.width; int den = gp->res.height; switch(state.displayMode.aspect) { case VIDEO_ASPECT_4_3: num = 4; den = 3; break; case VIDEO_ASPECT_16_9: num = 16; den = 9; break; } gp->scale = (float)(num * gp->res.height) / (float)(den * gp->res.width); TRACE(TRACE_INFO, "RSX", "Video resolution %d x %d aspect=%d, pixel wscale=%f", gp->res.width, gp->res.height, state.displayMode.aspect, gp->scale); gp->framebuffer_pitch = 4 * gp->res.width; // each pixel is 4 bytes gp->depthbuffer_pitch = 4 * gp->res.width; // And each value in the depth buffer is a 16 bit float // Configure the buffer format to xRGB VideoConfiguration vconfig; memset(&vconfig, 0, sizeof(VideoConfiguration)); vconfig.resolution = state.displayMode.resolution; vconfig.format = VIDEO_BUFFER_FORMAT_XRGB; vconfig.pitch = gp->framebuffer_pitch; videoConfigure(0, &vconfig, NULL, 0); videoGetState(0, 0, &state); const s32 buffer_size = gp->framebuffer_pitch * gp->res.height; const s32 depth_buffer_size = gp->depthbuffer_pitch * gp->res.height; TRACE(TRACE_INFO, "RSX", "Buffer will be %d bytes", buffer_size); gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip // Allocate two buffers for the RSX to draw to the screen (double buffering) gp->framebuffer[0] = rsx_alloc(&gp->gr, buffer_size, 16); gp->framebuffer[1] = rsx_alloc(&gp->gr, buffer_size, 16); TRACE(TRACE_INFO, "RSX", "Buffers at 0x%x 0x%x\n", gp->framebuffer[0], gp->framebuffer[1]); gp->depthbuffer = rsx_alloc(&gp->gr, depth_buffer_size * 4, 16); // Setup the display buffers gcmSetDisplayBuffer(0, gp->framebuffer[0], gp->framebuffer_pitch, gp->res.width, gp->res.height); gcmSetDisplayBuffer(1, gp->framebuffer[1], gp->framebuffer_pitch, gp->res.width, gp->res.height); gcmResetFlipStatus(); flip(gp, 1); }