static int iPod_VideoInit (_THIS, SDL_PixelFormat * vformat);

static SDL_Rect **iPod_ListModes (_THIS, SDL_PixelFormat * format,

                                  Uint32 flags);

static SDL_Surface *iPod_SetVideoMode (_THIS, SDL_Surface * current,

                                       int width, int height, int bpp,

                                       Uint32 flags);

static int iPod_SetColors (_THIS, int firstcolor, int ncolors,

                           SDL_Color * colors);

static void iPod_UpdateRects (_THIS, int nrects, SDL_Rect * rects);

static long iPod_GetGeneration ();

static long

iPod_GetGeneration ()

    if ((file = fopen ("/proc/cpuinfo", "r")) != NULL) {

        while (fgets (cpuinfo, sizeof (cpuinfo), file) != NULL)

            if (SDL_strncmp (cpuinfo, "Revision", 8) == 0)

                break;

        fclose (file);

    for (i = 0; !isspace (cpuinfo[i]); i++);

    for (; isspace (cpuinfo[i]); i++);

    return SDL_strtol (ptr, NULL, 10);

static int

iPod_Available ()

static void

iPod_DeleteDevice (SDL_VideoDevice * device)

void

iPod_InitOSKeymap (_THIS)

{

}

static SDL_VideoDevice *

iPod_CreateDevice (int devindex)

    this = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice));

        memset (this, 0, sizeof *this);

        this->hidden = (struct SDL_PrivateVideoData *)

            SDL_malloc (sizeof (struct SDL_PrivateVideoData));

        SDL_OutOfMemory ();

        if (this)

            SDL_free (this);

        return 0;

    memset (this->hidden, 0, sizeof (struct SDL_PrivateVideoData));

    generation = iPod_GetGeneration ();

static int

iPod_VideoInit (_THIS, SDL_PixelFormat * vformat)

        /*** Code adapted/copied from SDL fbcon driver. ***/

        static const char *const tty0[] = { "/dev/tty0", "/dev/vc/0", 0 };

        static const char *const vcs[] = { "/dev/vc/%d", "/dev/tty%d", 0 };

        int i, tty0_fd;

        dbgout =

            fdopen (open ("/etc/sdlpod.log", O_WRONLY | O_SYNC | O_APPEND),

                    "a");

        if (dbgout) {

            setbuf (dbgout, 0);

            fprintf (dbgout, "--> Started SDL <--\n");

        }

        // Try to query for a free VT

        tty0_fd = -1;

        for (i = 0; tty0[i] && (tty0_fd < 0); ++i) {

            tty0_fd = open (tty0[i], O_WRONLY, 0);

        }

        if (tty0_fd < 0) {

            tty0_fd = dup (0);  /* Maybe stdin is a VT? */

        }

        ioctl (tty0_fd, VT_OPENQRY, &curvt);

        close (tty0_fd);

        tty0_fd = open ("/dev/tty", O_RDWR, 0);

        if (tty0_fd >= 0) {

            ioctl (tty0_fd, TIOCNOTTY, 0);

            close (tty0_fd);

        }

        if ((geteuid () == 0) && (curvt > 0)) {

            for (i = 0; vcs[i] && (kbfd < 0); ++i) {

                char vtpath[12];

                SDL_snprintf (vtpath, SDL_arraysize (vtpath), vcs[i], curvt);

                kbfd = open (vtpath, O_RDWR);

            }

        }

        if (kbfd < 0) {

            if (dbgout)

                fprintf (dbgout, "Couldn't open any VC\n");

            return -1;

        }

        if (dbgout)

            fprintf (stderr, "Current VT: %d\n", curvt);

        if (kbfd >= 0) {

            /* Switch to the correct virtual terminal */

            if (curvt > 0) {

                struct vt_stat vtstate;

                if (ioctl (kbfd, VT_GETSTATE, &vtstate) == 0) {

                    oldvt = vtstate.v_active;

                }

                if (ioctl (kbfd, VT_ACTIVATE, curvt) == 0) {

                    if (dbgout)

                        fprintf (dbgout, "Waiting for switch to this VT... ");

                    ioctl (kbfd, VT_WAITACTIVE, curvt);

                    if (dbgout)

                        fprintf (dbgout, "done!\n");

                }

            }

            // Set terminal input mode

            if (tcgetattr (kbfd, &old_termios) < 0) {

                if (dbgout)

                    fprintf (dbgout, "Can't get termios\n");

                return -1;

            }

            cur_termios = old_termios;

            //      cur_termios.c_iflag &= ~(ICRNL | INPCK | ISTRIP | IXON);

            //      cur_termios.c_iflag |= (BRKINT);

            //      cur_termios.c_lflag &= ~(ICANON | ECHO | ISIG | IEXTEN);

            //      cur_termios.c_oflag &= ~(OPOST);

            //      cur_termios.c_oflag |= (ONOCR | ONLRET);

            cur_termios.c_lflag &= ~(ICANON | ECHO | ISIG);

            cur_termios.c_iflag &=

                ~(ISTRIP | IGNCR | ICRNL | INLCR | IXOFF | IXON);

            cur_termios.c_cc[VMIN] = 0;

            cur_termios.c_cc[VTIME] = 0;

            if (tcsetattr (kbfd, TCSAFLUSH, &cur_termios) < 0) {

                if (dbgout)

                    fprintf (dbgout, "Can't set termios\n");

                return -1;

            }

            if (ioctl (kbfd, KDSKBMODE, K_MEDIUMRAW) < 0) {

                if (dbgout)

                    fprintf (dbgout, "Can't set medium-raw mode\n");

                return -1;

            }

            if (ioctl (kbfd, KDSETMODE, KD_GRAPHICS) < 0) {

                if (dbgout)

                    fprintf (dbgout, "Can't set graphics\n");

                return -1;

            }

        }

        // Open the framebuffer

        if ((fbfd = open ("/dev/fb0", O_RDWR)) < 0) {

            if (dbgout)

                fprintf (dbgout, "Can't open framebuffer\n");

            return -1;

        } else {

            struct fb_var_screeninfo vinfo;

            if (dbgout)

                fprintf (dbgout, "Generation: %ld\n", generation);

            if (generation >= 40000) {

                lcd_base = IPOD_NEW_LCD_BASE;

            } else {

                lcd_base = IPOD_OLD_LCD_BASE;

            }

            ioctl (fbfd, FBIOGET_VSCREENINFO, &vinfo);

            close (fbfd);

            if (lcd_base == IPOD_OLD_LCD_BASE)

                lcd_rtc = IPOD_OLD_LCD_RTC;

            else if (lcd_base == IPOD_NEW_LCD_BASE)

                lcd_rtc = IPOD_NEW_LCD_RTC;

            else {

                SDL_SetError ("Unknown iPod version");

                return -1;

            }

            lcd_width = vinfo.xres;

            lcd_height = vinfo.yres;

            if (dbgout)

                fprintf (dbgout, "LCD is %dx%d\n", lcd_width, lcd_height);

        }

        fcntl (kbfd, F_SETFL, O_RDWR | O_NONBLOCK);

        /* Determine the current screen size */

        this->info.current_w = lcd_width;

        this->info.current_h = lcd_height;

        if ((generation >= 60000) && (generation < 70000)) {

            vformat->BitsPerPixel = 16;

            vformat->Rmask = 0xF800;

            vformat->Gmask = 0x07E0;

            vformat->Bmask = 0x001F;

        } else {

            vformat->BitsPerPixel = 8;

            vformat->Rmask = vformat->Gmask = vformat->Bmask = 0;

        }

        initd = 1;

        if (dbgout)

            fprintf (dbgout, "Initialized.\n\n");

static SDL_Rect **

iPod_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags)

        return 0;

        struct fb_var_screeninfo vinfo;

        ioctl (fbfd, FBIOGET_VSCREENINFO, &vinfo);

        close (fbfd);

        width = vinfo.xres;

        height = vinfo.yres;

static SDL_Surface *

iPod_SetVideoMode (_THIS, SDL_Surface * current, int width, int height,

                   int bpp, Uint32 flags)

        Rmask = 0xF800;

        Gmask = 0x07E0;

        Bmask = 0x001F;

        Rmask = Gmask = Bmask = 0;

    if (this->hidden->buffer)

        SDL_free (this->hidden->buffer);

        SDL_SetError ("Couldn't allocate buffer for requested mode");

        return 0;

        SDL_SetError ("Couldn't allocate new pixel format");

        SDL_free (this->hidden->buffer);

        this->hidden->buffer = 0;

        return 0;

        int i, j;

        for (i = 0; i < 256; i += 4) {

            for (j = 0; j < 4; j++) {

                current->format->palette->colors[i + j].r = 85 * j;

                current->format->palette->colors[i + j].g = 85 * j;

                current->format->palette->colors[i + j].b = 85 * j;

            }

        }

static int

iPod_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)

    if (SDL_VideoSurface && SDL_VideoSurface->format

        && SDL_VideoSurface->format->palette) {

        int i, j;

        for (i = 0; i < 256; i += 4) {

            for (j = 0; j < 4; j++) {

                SDL_VideoSurface->format->palette->colors[i + j].r = 85 * j;

                SDL_VideoSurface->format->palette->colors[i + j].g = 85 * j;

                SDL_VideoSurface->format->palette->colors[i + j].b = 85 * j;

            }

        }

static void

iPod_VideoQuit (_THIS)

        ioctl (kbfd, VT_ACTIVATE, oldvt);

        close (kbfd);

        fprintf (dbgout, "<-- Ended SDL -->\n");

        fclose (dbgout);

    0,                          /* 0 - no key */

    '[' - 0x40,                 /* ESC (Ctrl+[) */

    '\b', '\t',                 /* Backspace, Tab (Ctrl+H,Ctrl+I) */

    '\n', 0,                    /* Enter, Left CTRL */

    0, '\\',                    /* left shift, backslash */

    0, '*', 0, ' ', 0,          /* right shift, KP mul, left alt, space, capslock */

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* F1-10 */

    0, 0,                       /* numlock, scrollock */

    '7', '8', '9', '-', '4', '5', '6', '+', '1', '2', '3', '0', '.',    /* numeric keypad */

    0, 0,                       /* padding */

    0, 0, 0,                    /* "less" (?), F11, F12 */

    0, 0, 0, 0, 0, 0, 0,        /* padding */

    '\n', 0, '/', 0, 0,         /* KP enter, Rctrl, Ctrl, KP div, PrtSc, RAlt */

    0, 0, 0, 0, 0, 0, 0, 0, 0,  /* Break, Home, Up, PgUp, Left, Right, End, Down, PgDn */

    0, 0,                       /* Ins, Del */

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,      /* padding */

    0, 0,                       /* RWin, LWin */

    0                           /* no key */

static void

iPod_keyboard ()

    memset (&ev, 0, sizeof (SDL_Event));

        char ascii = iPod_SC_keymap[keybuf[i] & 0x7f];

        if (dbgout)

            fprintf (dbgout, "Key! %02x is %c %s", keybuf[i], ascii,

                     (keybuf[i] & 0x80) ? "up" : "down");

        keysym.sym = keysym.unicode = ascii;

        ev.type = (keybuf[i] & 0x80) ? SDL_KEYUP : SDL_KEYDOWN;

        ev.key.state = 0;

        ev.key.keysym = keysym;

        SDL_PushEvent (&ev);