diff options
Diffstat (limited to 'distrib/sdl-1.2.15/src/video/ps3/SDL_ps3video.c')
| -rw-r--r-- | distrib/sdl-1.2.15/src/video/ps3/SDL_ps3video.c | 621 |
1 files changed, 621 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/src/video/ps3/SDL_ps3video.c b/distrib/sdl-1.2.15/src/video/ps3/SDL_ps3video.c new file mode 100644 index 0000000..d5519e0 --- /dev/null +++ b/distrib/sdl-1.2.15/src/video/ps3/SDL_ps3video.c @@ -0,0 +1,621 @@ +/* + * SDL - Simple DirectMedia Layer + * CELL BE Support for PS3 Framebuffer + * Copyright (C) 2008, 2009 International Business Machines Corporation + * + * This library is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 + * USA + * + * Martin Lowinski <lowinski [at] de [dot] ibm [ibm] com> + * Dirk Herrendoerfer <d.herrendoerfer [at] de [dot] ibm [dot] com> + * SPE code based on research by: + * Rene Becker + * Thimo Emmerich + */ + +#include "SDL_config.h" + +#include "SDL_video.h" +#include "../SDL_sysvideo.h" +#include "SDL_ps3events_c.h" +#include "SDL_ps3video.h" +#include "SDL_ps3yuv_c.h" +#include "spulibs/spu_common.h" + +#include <fcntl.h> +#include <stdlib.h> +#include <sys/ioctl.h> +#include <linux/kd.h> +#include <sys/mman.h> + +#include <linux/fb.h> +#include <asm/ps3fb.h> +#include <libspe2.h> +#include <malloc.h> + +/* SDL_VideoDevice functions */ +static int PS3_Available(); +static SDL_VideoDevice *PS3_CreateDevice(int devindex); +static int PS3_VideoInit(_THIS, SDL_PixelFormat * vformat); +static void PS3_VideoQuit(_THIS); +static void PS3_DeleteDevice(SDL_VideoDevice * device); +static SDL_Surface *PS3_SetVideoMode(_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags); +static SDL_Rect **PS3_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags); + +/* Hardware surface functions */ +static int PS3_AllocHWSurface(_THIS, SDL_Surface * surface); +static void PS3_FreeHWSurface(_THIS, SDL_Surface * surface); +static int PS3_LockHWSurface(_THIS, SDL_Surface * surface); +static void PS3_UnlockHWSurface(_THIS, SDL_Surface * surface); +static int PS3_FlipDoubleBuffer(_THIS, SDL_Surface * surface); +static void PS3_DoubleBufferUpdate(_THIS, int numrects, SDL_Rect * rects); + +/* SPU specific functions */ +int SPE_Start(_THIS, spu_data_t * spe_data); +int SPE_Stop(_THIS, spu_data_t * spe_data); +int SPE_Boot(_THIS, spu_data_t * spe_data); +int SPE_Shutdown(_THIS, spu_data_t * spe_data); +int SPE_SendMsg(_THIS, spu_data_t * spe_data, unsigned int msg); +int SPE_WaitForMsg(_THIS, spu_data_t * spe_data, unsigned int msg); +void SPE_RunContext(void *thread_argp); + +/* Helpers */ +void enable_cursor(int enable); + +/* Stores the SPE executable name of fb_writer_spu */ +extern spe_program_handle_t fb_writer_spu; + +/* SDL PS3 bootstrap function for checking availability */ +static int PS3_Available() +{ + return 1; +} + +/* SDL PS3 bootstrap function for creating the device */ +static SDL_VideoDevice *PS3_CreateDevice(int devindex) +{ + SDL_VideoDevice *this; + + /* Initialise SDL_VideoDevice */ + this = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice)); + if (this) { + memset(this, 0, sizeof *this); + this->hidden = (struct SDL_PrivateVideoData *) + SDL_malloc(sizeof(struct SDL_PrivateVideoData)); + } + /* Error handling */ + if ((this == NULL) || (this->hidden == NULL)) { + SDL_OutOfMemory(); + if (this) + SDL_free(this); + return 0; + } + memset(this->hidden, 0, sizeof(struct SDL_PrivateVideoData)); + + /* Set the function pointers */ + this->VideoInit = PS3_VideoInit; + this->ListModes = PS3_ListModes; + this->SetVideoMode = PS3_SetVideoMode; + this->SetColors = 0; + this->CreateYUVOverlay = PS3_CreateYUVOverlay; + this->UpdateRects = 0; + this->VideoQuit = PS3_VideoQuit; + this->AllocHWSurface = PS3_AllocHWSurface; + this->CheckHWBlit = 0; + this->FillHWRect = 0; + this->SetHWColorKey = 0; + this->SetHWAlpha = 0; + this->LockHWSurface = PS3_LockHWSurface; + this->UnlockHWSurface = PS3_UnlockHWSurface; + this->FlipHWSurface = PS3_FlipDoubleBuffer; + this->FreeHWSurface = PS3_FreeHWSurface; + this->SetCaption = 0; + this->SetIcon = 0; + this->IconifyWindow = 0; + this->GrabInput = 0; + this->GetWMInfo = 0; + this->InitOSKeymap = PS3_InitOSKeymap; + this->PumpEvents = PS3_PumpEvents; + + this->free = PS3_DeleteDevice; + + return this; +} + + +/* Bootstraping (see SDL_sysvideo.h) */ +VideoBootStrap PS3_bootstrap = { + "ps3", "PS3 Cell SPU Driver", + PS3_Available, PS3_CreateDevice +}; + + +/* Delete the device */ +static void PS3_DeleteDevice(SDL_VideoDevice * device) +{ + free(device->hidden); + free(device); +} + + +/* Initialise the PS3 video device */ +static int PS3_VideoInit(_THIS, SDL_PixelFormat * vformat) +{ + /* Hide the cursor */ + enable_cursor(0); + + /* Create SPU fb_parms and thread structure */ + fb_parms = (struct fb_writer_parms_t *) + memalign(16, sizeof(struct fb_writer_parms_t)); + fb_thread_data = (spu_data_t *) malloc(sizeof(spu_data_t)); + if (fb_parms == NULL || fb_thread_data == NULL) { + SDL_OutOfMemory(); + return -1; + } + fb_thread_data->program = fb_writer_spu; + fb_thread_data->program_name = "fb_writer_spu"; + fb_thread_data->argp = (void *)fb_parms; + fb_thread_data->keepalive = 1; + fb_thread_data->booted = 0; + + SPE_Start(this, fb_thread_data); + + /* Open the device */ + fb_dev_fd = open(PS3_DEV_FB, O_RDWR); + if (fb_dev_fd < 0) { + SDL_SetError("[PS3] Unable to open device %s", PS3_DEV_FB); + return -1; + } + + /* Get vscreeninfo */ + if (ioctl(fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo)) { + SDL_SetError("[PS3] Can't get VSCREENINFO"); + if (fb_dev_fd >= 0) + close(fb_dev_fd); + fb_dev_fd = -1; + return -1; + } + + /* Fill in our hardware acceleration capabilities */ + this->info.current_w = fb_vinfo.xres; + this->info.current_h = fb_vinfo.yres; + this->info.wm_available = 0; + this->info.hw_available = 1; + + /* Backup the original vinfo to restore later */ + fb_orig_vinfo = fb_vinfo; + + /* 16 and 15 bpp is reported as 16 bpp */ + fb_bits_per_pixel = fb_vinfo.bits_per_pixel; + if (fb_bits_per_pixel == 16) + fb_bits_per_pixel = + fb_vinfo.red.length + fb_vinfo.green.length + + fb_vinfo.blue.length; + + /* Set SDL_PixelFormat */ + vformat->BitsPerPixel = fb_vinfo.bits_per_pixel; + + fb_vinfo.xres_virtual = fb_vinfo.xres; + fb_vinfo.yres_virtual = fb_vinfo.yres; + + /* Put vscreeninfo */ + if (ioctl(fb_dev_fd, FBIOPUT_VSCREENINFO, &fb_vinfo)) { + SDL_SetError("[PS3] Can't put VSCREENINFO"); + if (fb_dev_fd >= 0) + close(fb_dev_fd); + fb_dev_fd = -1; + return -1; + } + + s_fb_pixel_size = fb_vinfo.bits_per_pixel / 8; + + s_writeable_width = fb_vinfo.xres; + s_writeable_height = fb_vinfo.yres; + + /* Get ps3 screeninfo */ + if (ioctl(fb_dev_fd, PS3FB_IOCTL_SCREENINFO, (unsigned long)&res) < 0) { + SDL_SetError("[PS3] PS3FB_IOCTL_SCREENINFO failed"); + } + deprintf(1, "[PS3] xres:%d yres:%d xoff:%d yoff:%d\n", res.xres, res.yres, res.xoff, res.yoff); + + /* Only use double buffering if enough fb memory is available */ + if (res.num_frames < 2) { + double_buffering = 0; + } else { + double_buffering = 1; + } + + real_width = res.xres; + real_height = res.yres; + + /* + * Take control of frame buffer from kernel, for details see + * http://felter.org/wesley/files/ps3/linux-20061110-docs/ApplicationProgrammingEnvironment.html + * kernel will no longer flip the screen itself + */ + ioctl(fb_dev_fd, PS3FB_IOCTL_ON, 0); + + /* Unblank screen */ + ioctl(fb_dev_fd, FBIOBLANK, 0); + + return 0; +} + + +/* List available PS3 resolutions */ +static SDL_Rect **PS3_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags) +{ + /* A list of video resolutions that we query for (sorted largest to + * smallest) + */ + static SDL_Rect PS3_resolutions[] = { + {0, 0, 1920, 1080}, // 1080p 16:9 HD + {0, 0, 1600, 1200}, // WUXGA + {0, 0, 1280, 1024}, // SXGA + {0, 0, 1280, 720}, // 720p 16:9 HD + {0, 0, 1024, 768}, // WXGA + {0, 0, 1024, 576}, // 576p 16:9 + {0, 0, 853, 480}, // 480p 16:9 + {0, 0, 720, 576}, // 576p 4:3 (PAL) + {0, 0, 720, 480}, // 480p 16:9 (NTSC) + }; + static SDL_Rect *PS3_modes[] = { + &PS3_resolutions[0], + &PS3_resolutions[1], + &PS3_resolutions[2], + &PS3_resolutions[3], + &PS3_resolutions[4], + &PS3_resolutions[5], + &PS3_resolutions[6], + &PS3_resolutions[7], + &PS3_resolutions[8], + NULL + }; + SDL_Rect **modes = PS3_modes; + + return modes; +} + + +/* Get a list of the available display modes */ +static SDL_Surface *PS3_SetVideoMode(_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags) +{ + s_bounded_input_width = width < s_writeable_width ? width : s_writeable_width; + s_bounded_input_height = height < s_writeable_height ? height : s_writeable_height; + s_bounded_input_width_offset = (s_writeable_width - s_bounded_input_width) >> 1; + s_bounded_input_height_offset = (s_writeable_height - s_bounded_input_height) >> 1; + s_input_line_length = width * s_fb_pixel_size; + + current->flags |= flags; + + if (ioctl(fb_dev_fd, FBIOGET_FSCREENINFO, &fb_finfo)) { + SDL_SetError("[PS3] Can't get fixed screeninfo"); + return NULL; + } + + if (fb_finfo.type != FB_TYPE_PACKED_PIXELS) { + SDL_SetError("[PS3] type %s not supported", + fb_finfo.type); + return NULL; + } + + /* Note: on PS3, fb_finfo.smem_len is enough for double buffering */ + if ((frame_buffer = + (uint8_t *) mmap(0, fb_finfo.smem_len, + PROT_READ | PROT_WRITE, MAP_SHARED, + fb_dev_fd, 0)) == (uint8_t *) - 1) { + SDL_SetError("[PS3] Can't mmap for %s", PS3_DEV_FB); + return NULL; + } else { + current->flags |= SDL_DOUBLEBUF; + } + if (!SDL_ReallocFormat(current, fb_bits_per_pixel, 0, 0, 0, 0)) { + return (NULL); + } + + /* Blank screen */ + memset(frame_buffer, 0x00, fb_finfo.smem_len); + + /* Centering */ + s_center[0] = + frame_buffer + s_bounded_input_width_offset * s_fb_pixel_size + + s_bounded_input_height_offset * fb_finfo.line_length; + s_center[1] = s_center[0] + real_height * fb_finfo.line_length; + s_center_index = 0; + + current->flags |= SDL_FULLSCREEN; + current->w = width; + current->h = height; + current->pitch = SDL_CalculatePitch(current); + + /* Alloc aligned mem for current->pixels */ + s_pixels = memalign(16, current->h * current->pitch); + current->pixels = (void *)s_pixels; + if (!current->pixels) { + SDL_OutOfMemory(); + return NULL; + } + + /* Set the update rectangle function */ + this->UpdateRects = PS3_DoubleBufferUpdate; + + return current; +} + + +/* Copy screen to framebuffer and flip */ +void PS3_DoubleBufferUpdate(_THIS, int numrects, SDL_Rect * rects) +{ + if (converter_thread_data && converter_thread_data->booted) + SPE_WaitForMsg(this, converter_thread_data, SPU_FIN); + + /* Adjust centering */ + s_bounded_input_width_offset = (s_writeable_width - s_bounded_input_width) >> 1; + s_bounded_input_height_offset = (s_writeable_height - s_bounded_input_height) >> 1; + s_center[0] = frame_buffer + s_bounded_input_width_offset * s_fb_pixel_size + + s_bounded_input_height_offset * fb_finfo.line_length; + s_center[1] = s_center[0] + real_height * fb_finfo.line_length; + + /* Set SPU parms for copying the surface to framebuffer */ + fb_parms->data = (unsigned char *)s_pixels; + fb_parms->center = s_center[s_center_index]; + fb_parms->out_line_stride = fb_finfo.line_length; + fb_parms->in_line_stride = s_input_line_length; + fb_parms->bounded_input_height = s_bounded_input_height; + fb_parms->bounded_input_width = s_bounded_input_width; + fb_parms->fb_pixel_size = s_fb_pixel_size; + + deprintf(3, "[PS3->SPU] fb_thread_data->argp = 0x%x\n", fb_thread_data->argp); + + /* Copying.. */ + SPE_SendMsg(this, fb_thread_data, SPU_START); + SPE_SendMsg(this, fb_thread_data, (unsigned int)fb_thread_data->argp); + + SPE_WaitForMsg(this, fb_thread_data, SPU_FIN); + + /* Flip the pages */ + if (double_buffering) + s_center_index = s_center_index ^ 0x01; + PS3_FlipDoubleBuffer(this, this->screen); +} + + +/* Enable/Disable cursor */ +void enable_cursor(int enable) +{ + int fd = open("/dev/console", O_RDWR | O_NONBLOCK); + if (fd >= 0) { + ioctl(fd, KDSETMODE, enable ? KD_TEXT : KD_GRAPHICS); + close(fd); + } +} + + +static int PS3_AllocHWSurface(_THIS, SDL_Surface * surface) +{ + return -1; +} + + +static void PS3_FreeHWSurface(_THIS, SDL_Surface * surface) +{ + return; +} + + +static int PS3_LockHWSurface(_THIS, SDL_Surface * surface) +{ + return 0; +} + + +static void PS3_UnlockHWSurface(_THIS, SDL_Surface * surface) +{ + return; +} + + +/* Blit/Flip buffer to the screen. Must be called after each frame! */ +int PS3_FlipDoubleBuffer(_THIS, SDL_Surface * surface) +{ + unsigned long crt = 0; + /* Wait for vsync */ + deprintf(1, "[PS3] Wait for vsync\n"); + ioctl(fb_dev_fd, FBIO_WAITFORVSYNC, &crt); + /* Page flip */ + deprintf(1, "[PS3] Page flip to buffer #%u 0x%x\n", s_center_index, s_center[s_center_index]); + ioctl(fb_dev_fd, PS3FB_IOCTL_FSEL, (unsigned long)&s_center_index); + return 1; +} + + +/* Start the SPE thread */ +int SPE_Start(_THIS, spu_data_t * spe_data) +{ + deprintf(2, "[PS3->SPU] Start SPE: %s\n", spe_data->program_name); + if (!(spe_data->booted)) + SPE_Boot(this, spe_data); + + /* To allow re-running of context, spe_ctx_entry has to be set before each call */ + spe_data->entry = SPE_DEFAULT_ENTRY; + spe_data->error_code = 0; + + /* Create SPE thread and run */ + deprintf(2, "[PS3->SPU] Create Thread: %s\n", spe_data->program_name); + if (pthread_create + (&spe_data->thread, NULL, (void *)&SPE_RunContext, (void *)spe_data)) { + deprintf(2, "[PS3->SPU] Could not create pthread for spe: %s\n", spe_data->program_name); + SDL_SetError("[PS3->SPU] Could not create pthread for spe"); + return -1; + } + + if (spe_data->keepalive) + SPE_WaitForMsg(this, spe_data, SPU_READY); +} + + +/* Stop the SPE thread */ +int SPE_Stop(_THIS, spu_data_t * spe_data) +{ + deprintf(2, "[PS3->SPU] Stop SPE: %s\n", spe_data->program_name); + /* Wait for SPE thread to complete */ + deprintf(2, "[PS3->SPU] Wait for SPE thread to complete: %s\n", spe_data->program_name); + if (pthread_join(spe_data->thread, NULL)) { + deprintf(2, "[PS3->SPU] Failed joining the thread: %s\n", spe_data->program_name); + SDL_SetError("[PS3->SPU] Failed joining the thread"); + return -1; + } + + return 0; +} + + +/* Create SPE context and load program */ +int SPE_Boot(_THIS, spu_data_t * spe_data) +{ + /* Create SPE context */ + deprintf(2, "[PS3->SPU] Create SPE Context: %s\n", spe_data->program_name); + spe_data->ctx = spe_context_create(0, NULL); + if (spe_data->ctx == NULL) { + deprintf(2, "[PS3->SPU] Failed creating SPE context: %s\n", spe_data->program_name); + SDL_SetError("[PS3->SPU] Failed creating SPE context"); + return -1; + } + + /* Load SPE object into SPE local store */ + deprintf(2, "[PS3->SPU] Load Program into SPE: %s\n", spe_data->program_name); + if (spe_program_load(spe_data->ctx, &spe_data->program)) { + deprintf(2, "[PS3->SPU] Failed loading program into SPE context: %s\n", spe_data->program_name); + SDL_SetError + ("[PS3->SPU] Failed loading program into SPE context"); + return -1; + } + spe_data->booted = 1; + deprintf(2, "[PS3->SPU] SPE boot successful\n"); + + return 0; +} + +/* (Stop and) shutdown the SPE */ +int SPE_Shutdown(_THIS, spu_data_t * spe_data) +{ + if (spe_data->keepalive && spe_data->booted) { + SPE_SendMsg(this, spe_data, SPU_EXIT); + SPE_Stop(this, spe_data); + } + + /* Destroy SPE context */ + deprintf(2, "[PS3->SPU] Destroy SPE context: %s\n", spe_data->program_name); + if (spe_context_destroy(spe_data->ctx)) { + deprintf(2, "[PS3->SPU] Failed destroying context: %s\n", spe_data->program_name); + SDL_SetError("[PS3->SPU] Failed destroying context"); + return -1; + } + deprintf(2, "[PS3->SPU] SPE shutdown successful: %s\n", spe_data->program_name); + return 0; +} + + +/* Send message to the SPE via mailboxe */ +int SPE_SendMsg(_THIS, spu_data_t * spe_data, unsigned int msg) +{ + deprintf(2, "[PS3->SPU] Sending message %u to %s\n", msg, spe_data->program_name); + /* Send one message, block until message was sent */ + unsigned int spe_in_mbox_msgs[1]; + spe_in_mbox_msgs[0] = msg; + int in_mbox_write = spe_in_mbox_write(spe_data->ctx, spe_in_mbox_msgs, 1, SPE_MBOX_ALL_BLOCKING); + + if (1 > in_mbox_write) { + deprintf(2, "[PS3->SPU] No message could be written to %s\n", spe_data->program_name); + SDL_SetError("[PS3->SPU] No message could be written"); + return -1; + } + return 0; +} + + +/* Read 1 message from SPE, block until at least 1 message was received */ +int SPE_WaitForMsg(_THIS, spu_data_t * spe_data, unsigned int msg) +{ + deprintf(2, "[PS3->SPU] Waiting for message from %s\n", spe_data->program_name); + unsigned int out_messages[1]; + while (!spe_out_mbox_status(spe_data->ctx)); + int mbox_read = spe_out_mbox_read(spe_data->ctx, out_messages, 1); + deprintf(2, "[PS3->SPU] Got message from %s, message was %u\n", spe_data->program_name, out_messages[0]); + if (out_messages[0] == msg) + return 0; + else + return -1; +} + + +/* Re-runnable invocation of the spe_context_run call */ +void SPE_RunContext(void *thread_argp) +{ + /* argp is the pointer to argument to be passed to the SPE program */ + spu_data_t *args = (spu_data_t *) thread_argp; + deprintf(3, "[PS3->SPU] void* argp=0x%x\n", (unsigned int)args->argp); + + /* Run it.. */ + deprintf(2, "[PS3->SPU] Run SPE program: %s\n", args->program_name); + if (spe_context_run + (args->ctx, &args->entry, 0, (void *)args->argp, NULL, + NULL) < 0) { + deprintf(2, "[PS3->SPU] Failed running SPE context: %s\n", args->program_name); + SDL_SetError("[PS3->SPU] Failed running SPE context: %s", args->program_name); + exit(1); + } + + pthread_exit(NULL); +} + + +/* Quits the video driver */ +static void PS3_VideoQuit(_THIS) +{ + if (fb_dev_fd > 0) { + /* Restore the original video mode */ + if (ioctl(fb_dev_fd, FBIOPUT_VSCREENINFO, &fb_orig_vinfo)) + SDL_SetError("[PS3] Can't restore original fb_var_screeninfo"); + + /* Give control of frame buffer to kernel */ + ioctl(fb_dev_fd, PS3FB_IOCTL_OFF, 0); + close(fb_dev_fd); + fb_dev_fd = -1; + } + + if (frame_buffer) { + munmap(frame_buffer, fb_finfo.smem_len); + frame_buffer = 0; + } + + if (fb_parms) + free((void *)fb_parms); + if (fb_thread_data) { + SPE_Shutdown(this, fb_thread_data); + free((void *)fb_thread_data); + } + + if (this->screen) { + if (double_buffering && this->screen->pixels) { + free(this->screen->pixels); + } + this->screen->pixels = NULL; + } + + enable_cursor(1); + deprintf(1, "[PS3] VideoQuit\n"); +} + |