Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Made backgrounds runtime optional in SDL sim. Use --background to turn them on. Also removed two unneeded files.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@8642 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Dan Everton 2006-02-09 11:17:52 +00:00
parent 0cca6caa8a
commit ee2019d591
5 changed files with 72 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
uisimulator/sdl/lcd-sdl.c
View file

@ -94,7 +94,11 @@ void lcd_update_rect(int x_start, int y_start, int width, int height)
SDL_Rect src = {x_start, y_start, xmax, ymax};
SDL_Rect dest = {UI_LCD_POSX + x_start, UI_LCD_POSY + y_start, xmax, ymax};
if (!background) {
dest.x -= UI_LCD_POSX;
dest.y -= UI_LCD_POSY;
}
SDL_BlitSurface(lcd_surface, &src, gui_surface, &dest);
SDL_UpdateRect(gui_surface, dest.x, dest.y, dest.w, dest.h);
SDL_Flip(gui_surface);
@ -141,6 +145,12 @@ void lcd_remote_update_rect(int x_start, int y_start,
SDL_Rect src = {x_start, y_start, xmax, ymax};
SDL_Rect dest = {UI_REMOTE_POSX + x_start, UI_REMOTE_POSY + y_start, xmax, ymax};
if (!background) {
dest.x -= UI_REMOTE_POSX;
dest.y -= UI_REMOTE_POSY;
dest.y += UI_LCD_HEIGHT;
}
SDL_BlitSurface(remote_surface, &src, gui_surface, &dest);
SDL_UpdateRect(gui_surface, dest.x, dest.y, dest.w, dest.h);
SDL_Flip(gui_surface);
@ -176,12 +186,19 @@ void lcd_update(void)
}
}
}
if (changed)
{
if (!background) {
dest.x -= UI_LCD_POSX;
dest.y -= UI_LCD_POSY;
}
SDL_BlitSurface(lcd_surface, NULL, gui_surface, &dest);
SDL_UpdateRect(gui_surface, dest.x, dest.y, dest.w, dest.h);
SDL_Flip(gui_surface);
}
lcd_display_redraw = false;
}

144
uisimulator/sdl/thread.c
View file

@ -1,144 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 Daniel Stenberg
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "autoconf.h"
#include <stdio.h>
/* SDL threading wrapper */
#include <SDL.h>
#include <SDL_thread.h>
#include "kernel.h"
#include <sys/time.h>
#ifdef ROCKBOX_HAS_SIMSOUND
#include "sound.h"
#endif
long current_tick = 0;
extern void sim_tick_tasks(void);
static void msleep(int msec)
{
struct timeval delay;
delay.tv_sec = msec / 1000;
delay.tv_usec = (msec % 1000) * 1000;
select(0, NULL, NULL, NULL, &delay); /* portable sub-second sleep */
}
/*
* This is not a target thread, so it does not fall under the 1 thread at a
* time thing.
*/
static int update_tick_thread(void* p)
{
struct timeval start, now;
long new_tick;
(void)p;
gettimeofday(&start, NULL);
while (1)
{
msleep(5); /* check twice per simulated target tick */
gettimeofday(&now, NULL);
new_tick = (now.tv_sec - start.tv_sec) * HZ
+ (now.tv_usec - start.tv_usec) / (1000000/HZ);
if (new_tick > current_tick)
{
sim_tick_tasks();
current_tick = new_tick;
}
}
}
/*
* We emulate the target threads by using SDL threads. We have a mutex
* that only allows one thread at a time to execute. It forces each
* thread to yield() for the other(s) to run.
*/
SDL_mutex * mp;
void init_threads(void)
{
SDL_Thread *tick_tid;
mp=SDL_CreateMutex();
/* get mutex to only allow one thread running at a time */
SDL_mutexP(mp);
/* start a tick thread */
tick_tid=SDL_CreateThread(update_tick_thread, NULL);
#ifdef ROCKBOX_HAS_SIMSOUND /* start thread that plays PCM data */
{
SDL_Thread *sound_tid;
sound_tid = SDL_CreateThread(sound_playback_thread, NULL);
}
#endif
}
void yield(void)
{
SDL_mutexV(mp); /* return */
msleep(1); /* prevent busy loop */
SDL_mutexP(mp); /* get it again */
}
void newfunc(void (*func)(void))
{
SDL_mutexP(mp);
func();
SDL_mutexV(mp);
}
int create_thread(void (*fp)(void), void* sp, int stk_size)
{
SDL_Thread * tid;
int i;
int error;
/* we really don't care about these arguments */
(void)sp;
(void)stk_size;
tid = SDL_CreateThread(
(int(*)(void *))newfunc, /* function to start */
fp /* start argument */);
if(0 == tid) /* don't really have an error number here. */
fprintf(stderr, "Couldn't run thread number %d\n", i);
else
fprintf(stderr, "Thread %d is running\n", (int)SDL_GetThreadID(tid));
yield();
return error;
}
void sim_sleep(int ticks)
{
SDL_mutexV(mp); /* return */
msleep((1000/HZ) * ticks);
SDL_mutexP(mp); /* get it again */
}

65
uisimulator/sdl/uisdl.c
View file

@ -18,6 +18,7 @@
****************************************************************************/
#include <stdlib.h>
#include <string.h>
#include "autoconf.h"
#include "uisdl.h"
#include "button.h"
@ -34,6 +35,7 @@ extern void sim_tick_tasks(void);
void button_event(int key, bool pressed);
SDL_Surface *gui_surface;
bool background = false; /* Don't use backgrounds by default */
SDL_Thread *gui_thread;
SDL_TimerID tick_timer_id;
@ -94,6 +96,7 @@ void gui_message_loop(void)
bool gui_startup()
{
SDL_Surface *picture_surface;
int width, height;
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_TIMER)) {
fprintf(stderr, "fatal: %s", SDL_GetError());
@ -102,25 +105,47 @@ bool gui_startup()
atexit(SDL_Quit);
if ((gui_surface = SDL_SetVideoMode(UI_WIDTH, UI_HEIGHT, 24, SDL_HWSURFACE|SDL_DOUBLEBUF)) == NULL) {
fprintf(stderr, "fatal: %s", SDL_GetError());
/* Try and load the background image. If it fails go without */
if (background) {
picture_surface = SDL_LoadBMP("UI256.bmp");
if (picture_surface == NULL) {
background = false;
fprintf(stderr, "warn: %s", SDL_GetError());
}
}
/* Set things up */
if (background) {
width = UI_WIDTH;
height = UI_HEIGHT;
} else {
#ifdef HAVE_REMOTE_LCD
width = UI_LCD_WIDTH > UI_REMOTE_WIDTH ? UI_LCD_WIDTH : UI_REMOTE_WIDTH;
height = UI_LCD_HEIGHT + UI_REMOTE_HEIGHT;
#else
width = UI_LCD_WIDTH;
height = UI_LCD_HEIGHT;
#endif
}
if ((gui_surface = SDL_SetVideoMode(width, height, 24, SDL_HWSURFACE|SDL_DOUBLEBUF)) == NULL) {
fprintf(stderr, "fatal: %s\n", SDL_GetError());
return false;
}
SDL_WM_SetCaption(UI_TITLE, NULL);
simlcdinit();
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
picture_surface = SDL_LoadBMP("UI256.bmp");
if (picture_surface == NULL) {
fprintf(stderr, "warn: %s", SDL_GetError());
} else {
if (background && picture_surface != NULL) {
SDL_BlitSurface(picture_surface, NULL, gui_surface, NULL);
SDL_UpdateRect(gui_surface, 0, 0, 0, 0);
}
}
start_tick = SDL_GetTicks();
return true;
@ -156,8 +181,24 @@ int sim_app_main(void *param)
int main(int argc, char *argv[])
{
(void)argc;
(void)argv;
if (argc >= 1) {
int x;
for (x = 1; x < argc; x++) {
if (!strcmp("--background", argv[x])) {
background = true;
printf("Using background image.\n");
} else if (!strcmp("--old_lcd", argv[x])) {
having_new_lcd = false;
printf("Using old LCD layout.\n");
} else {
printf("rockboxui\n");
printf("Arguments:\n");
printf(" --background \t Use background image of hardware\n");
printf(" --old_lcd \t [Player] simulate old playermodel (ROM version<4.51)\n");
exit(0);
}
}
}
if (!gui_startup())
return -1;

1
uisimulator/sdl/uisdl.h
View file

@ -175,6 +175,7 @@
#endif
extern SDL_Surface *gui_surface;
extern bool background; /* True if the background image is enabled */
#endif // #ifndef __UISDL_H__

1
uisimulator/sdl/version.h
View file

@ -1 +0,0 @@
#define ROCKBOXUI_VERSION "0.2"