rj.rs

extern mod sdl;

use std::libc::{c_int, c_void};
use std::rt::comm;
use std::rt::io::extensions::*;
use std::rt::io::io_error;
use std::rt::io::net::ip::{IpAddr, Ipv4Addr, Port, SocketAddr};
use std::rt::io::net::tcp::TcpStream;
use std::task;
use std::vec;

static DEFAULT_RJ_IP:   IpAddr = Ipv4Addr(127, 0, 0, 1);
static DEFAULT_RJ_PORT:   Port = 10004;
static JOY_MAGIC:          u32 = 0x909ACCEF;

struct JoyHeader {
    magic: u32,     // JOY_MAGIC
    mode: i32,      // Image mode (0-3)
    size: u32,      // Size of payload
    vcount: u32     // sceDisplayGetVcount
}

struct ScreenBuffer {
    head: JoyHeader,
    surface: ~sdl::video::Surface,
    pixels: ~[u8],
    width: uint,
    height: uint
}

fn write_joyevent(wr: &mut TcpStream, t: i32, v: u32) {
    // Write the magic
    wr.write_le_u32(JOY_MAGIC);

    // Next the event kind
    wr.write_le_i32(t);

    // And finally the value
    wr.write_le_u32(v);
}

// Takes a TcpStream and tries to read in
// and populate a `JoyHeader`.
fn read_head(rdr: &mut TcpStream) -> JoyHeader {
    let head = JoyHeader {
        magic: (*rdr).read_le_u32(),
        mode: (*rdr).read_le_i32(),
        size: (*rdr).read_le_u32(),
        vcount: (*rdr).read_le_u32()
    };

    assert_eq!(head.magic, JOY_MAGIC);

    head
}

// Connects to the RemoteJoy API endpoint
// and continuously reads in frames
// which it sends back through the given
// chan, `c`.
fn remote_joy(c: comm::Chan<ScreenBuffer>) {
    let addr = SocketAddr {
        ip: DEFAULT_RJ_IP,
        port: DEFAULT_RJ_PORT
    };

    // Connect
    let mut sock = do io_error::cond.trap(|_| {
        fail!("Unable to connect to %s.", addr.to_str());
    }).inside {
        TcpStream::connect(addr).unwrap()
    };

    // Now just perpetually read everything in!
    loop {

        let head = read_head(&mut sock);

        if head.mode < 0 {

            // Enable Screen
            write_joyevent(&mut sock, 5, 1);

        } else if head.mode > 3 {
            // Something about flushing here
        } else {

            // Read in the next screen frame
            let screen = sock.read_bytes(head.size as uint);
            let width = 480u;
            let height = 272u;
            let (bpp, rmask, gmask, bmask) = match head.mode {
                3 => (32, 0xFF, 0xFF00, 0xFF0000),
                2 => (16, 0xF, 0xF0, 0xF00),
                1 => (16, 0x1F, 0x1F << 5, 0x1F << 10),
                0 => (16, 0x1F, 0x3F << 5, 0x1F << 11),
                _ => fail!("Invalid mode.")
            };

            // Create the SDL surface
            let pixels = vec::raw::to_ptr(screen) as *c_void;
            let raw = unsafe {
                sdl::video::ll::SDL_CreateRGBSurfaceFrom(
                    pixels, width as c_int, height as c_int,
                    bpp as i32, (width * (bpp / 8)) as i32,
                    rmask, gmask, bmask, 0)
            };

            let s = ScreenBuffer {
                head: head,
                surface: ~sdl::video::Surface {
                    raw: raw,
                    owned: true
                },
                pixels: screen,
                width: width,
                height: height
            };
            
            // Now send it off
            c.send(s);

        }

    }

}

#[start]
fn start(argc: int, argv: **u8, crate_map: *u8) -> int {
    std::rt::start_on_main_thread(argc, argv, crate_map, main)
}

fn main() {

    do sdl::start {
        // Init SDL
        sdl::init([sdl::InitVideo]);
        sdl::wm::set_caption("RemoteJoy", "RemoteJoy");

        // Now let's set up a surface to render to
        let screen = match sdl::video::set_video_mode(480, 272, 32,
                                                      [sdl::video::HWSurface],
                                                      [sdl::video::DoubleBuf]) {
            Ok(screen) => screen,
            Err(e) => fail!("Unabled to set video mode: %s", e)
        };

        // Let's create a chan/port pair to
        // communicate with the net task
        let (nport, nchan) = comm::stream();

        // Start the remote joy net task and give it its chan
        let mut net_task = task::task();
        net_task.sched_mode(task::SingleThreaded);
        net_task.spawn_with(nchan, remote_joy);

        // Start the main loop!
        'main: loop {

            // And our event loop
            'event: loop {
                match sdl::event::poll_event() {
                    sdl::event::QuitEvent => break 'main,
                    sdl::event::NoEvent => break 'event,
                    sdl::event::KeyEvent(k, _, _, _)
                        if k == sdl::event::EscapeKey
                            => break 'main,
                    _ => {}
                }
            }

            // Anything from the net task?
            if nport.peek() {

                // Render the new frame
                let frame = nport.recv();
                screen.blit(frame.surface);

            }

            screen.flip();
        }
        sdl::quit();
    }
}