main.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
//#include <threads.h>
 
#include <libdragon.h>
 
#include "config.h"
 
#include "qoi_enc_n64.h"
#include "colorconv.h"

#define ENC_BUFFER_SIZE 4096

enum whichScreenshotType {
    SCREENSHOT_NEVER_TAKEN,
    SCREENSHOT_TYPE_NULL,
    SCREENSHOT_TYPE_RAW,
    SCREENSHOT_TYPE_QOI,
    SCREENSHOT_FRAME_CAPTURED,
    SCREENSHOT_NO_SD_CARD
} whichScreenshotType;


bool save_screenshot(surface_t* disp, const char* filename, uint32_t *bytesWritten) {
 
    FILE* fp;
 
    // Get the framebuffer data
    uint16_t* framebuffer = (uint16_t*)disp->buffer;
 
    qoi_desc_t desc;
    qoi_enc_t enc;
    
    uint8_t header[14];
    uint8_t enc_buffer[ENC_BUFFER_SIZE];
 
    if (disp == NULL || bytesWritten == NULL) return false;
 
    qoi_set_dimensions(&desc, 320, 240); // Resolution of the N64 framebuffer
 
    qoi_set_channels(&desc, 4); // RGBA format because the N64 framebuffer does have an alpha channel
    
    qoi_set_colorspace(&desc, QOI_SRGB); // The N64 framebuffer uses sRGB color space
 
    qoi_enc_init(&desc, &enc); // Initialize the encoder with the descriptor
 
    fp = fopen(filename, "wb");
 
    if (!fp) return false;
    
    // Write the QOI header to SD card
    write_qoi_header(&desc, header);
    fwrite(header, 1, sizeof(header), fp);
    
    qoi_enc_set_buffer(&enc, enc_buffer, ENC_BUFFER_SIZE, false);
    //qoi_enc_alloc_buffer(&enc, ENC_BUFFER_SIZE);
 
    *bytesWritten = 22; // 14+8=22
 
    // Encode the pixel data
    for (uint32_t px = 0; px < enc.len; px++)
    {
        uint32_t rgba = n64_color16_to_rgba32(read_be_u16(framebuffer[px]));
        qoi_encode_chunk(&desc, &enc, &rgba);
 
        if (enc.pixels_written >= enc.len) {
            fwrite(enc.enc_buffer, 1, enc.buffer_offset, fp);
            *bytesWritten += enc.buffer_offset;
            break;
        };
 
        // Write the buffer to the file when it is almost full,
        // leaving space for the padding bytes at the end of the file
        if (enc.buffer_offset >= enc.buffer_len-8) { 
            fwrite(enc.enc_buffer, 1, enc.buffer_offset, fp);
            *bytesWritten += enc.buffer_offset;
            qoi_enc_reset_buffer(&enc);
        }
        
    }
 
    fwrite(QOI_PADDING, sizeof(uint8_t), 8, fp); // Write the padding bytes
 
    //qoi_enc_free_buffer(&enc);
 
    fclose(fp);
 
    return true;
}

bool save_screenshot_null(surface_t* disp, uint32_t *bytesWritten) {
    uint16_t* framebuffer;
    
    qoi_desc_t desc;
    qoi_enc_t enc;
 
    uint8_t header[14];
    uint8_t enc_buffer[ENC_BUFFER_SIZE];
 
    if (disp == NULL || bytesWritten == NULL) return false;
 
    // Get the framebuffer data
    framebuffer = (uint16_t*)disp->buffer;
 
    *bytesWritten = 22;
 
    qoi_set_dimensions(&desc, 320, 240); // Resolution of the N64 framebuffer
 
    qoi_set_channels(&desc, 4); // RGBA format because the N64 framebuffer does have an alpha channel
    
    qoi_set_colorspace(&desc, QOI_SRGB); // The N64 framebuffer uses sRGB color space
 
    qoi_enc_init(&desc, &enc); // Initialize the encoder with the descriptor
 
    // Write the QOI header to buffer
    write_qoi_header(&desc, header);
 
    qoi_enc_set_buffer(&enc, enc_buffer, ENC_BUFFER_SIZE, false);
    //qoi_enc_alloc_buffer(&enc, ENC_BUFFER_SIZE, false);
 
    // Encode the pixel data
    for (uint32_t px = 0; px < enc.len; px++)
    {
        uint32_t rgba = n64_color16_to_rgba32(read_be_u16(framebuffer[px]));
        qoi_encode_chunk(&desc, &enc, &rgba);
 
        if (enc.pixels_written >= enc.len) {
            *bytesWritten += enc.buffer_offset;
            break;
            
        };
 
        // Write the buffer to the file when it is almost full,
        // leaving space for the padding bytes at the end of the file
        if (enc.buffer_offset >= enc.buffer_len-8) { 
            *bytesWritten += enc.buffer_offset;
            qoi_enc_reset_buffer(&enc);
        }
        
    }
 
    //qoi_enc_free_buffer(&enc);
 
    return true;
}

bool save_screenshot_raw(surface_t* disp, const char* filename, uint32_t *bytesWritten) {
    uint16_t* framebuffer;
    FILE* fp;
    
    if (disp == NULL || bytesWritten == NULL || filename == NULL) return false;
 
    // Get the framebuffer data
    framebuffer = (uint16_t*)disp->buffer;
    *bytesWritten = 0;
 
    fp = fopen(filename, "wb");
    if (!fp) return false;
    
    // Write the raw pixel data to the file
    fwrite(framebuffer, sizeof(uint16_t), 320 * 240, fp);
    *bytesWritten = 320 * 240 * sizeof(uint16_t);
    
    fclose(fp);
 
    return true;
}

int main(void) {
 
    float x = 0.0f;
    float y = 0.0f;
 
    float speed = 0.1f;
 
    bool sdCardExists;
 
    bool toRight = true;
    bool toDown = true;
 
    bool showInfo = true;
    bool showLogo = true;
 
    uint64_t start, end;
 
    float encodedTime = 0.0f;
 
    float delta = 0.0f;
 
    enum whichScreenshotType scrType = SCREENSHOT_NEVER_TAKEN;
    bool successfulSave = false;
    surface_t lastSavedFrame = surface_alloc(FMT_RGBA16, 320, 240);
 
    uint32_t bytesWritten = 0;
 
    rdpq_font_t *font;
    sprite_t* background, *logo;
 
    //thrd_t thread;
    //mtx_t mutex;
 
    //mtx_init(&mutex, mtx_plain);
 
    // Initialize libdragon subsystems
    debug_init_emulog();
    //console_init();
 
    debug_init_usblog();
    //console_set_debug(true);
 
    timer_init();
    joypad_init();
 
    dfs_init(DFS_DEFAULT_LOCATION);
 
    display_init(RESOLUTION_320x240, DEPTH_16_BPP, 2, GAMMA_NONE, FILTERS_RESAMPLE);
 
    rdpq_init();
 
    font = rdpq_font_load_builtin(FONT_BUILTIN_DEBUG_MONO);
    rdpq_text_register_font(1, font);
 
    logo = sprite_load("rom:/n64brew.sprite");
    background = sprite_load("rom:/pm5544.sprite");
    start = timer_ticks(), end = timer_ticks();
 
    sdCardExists = debug_init_sdfs("sd:/", -1);
    
    while (1) {
        // Start drawing to the screen
        surface_t* disp;
 
        joypad_port_t port = JOYPAD_PORT_1;
        joypad_buttons_t pressed, held;
 
        joypad_poll();
 
        pressed = joypad_get_buttons_pressed(port);
        held = joypad_get_buttons_held(port);
 
        end = timer_ticks();
        delta = TIMER_MICROS(end - start) / 1000.0f; // Convert to milseconds
        start = end;
 
        while(!(disp = display_try_get())) {;}
 
        if (showLogo) {
            // Move the logo around the screen like a DVD logo to
            // show that the screen is being updated and to have something to screenshot. 
            // The logo will bounce around the screen and change direction when it hits the edge of the screen.
            if (toDown) {
                if (y < 240.0f - (logo->height * 0.5f)) {
                    y += speed * delta;
                }
                else {
                    toDown = false;
                }
            }
            else {
                if (y > 0.0f) {
                    y -= speed * delta;
                }
                else {
                    toDown = true;
                }    
            }
 
            if (toRight) {
                if (x < 320.0f - (logo->width * 0.5f)) {
                    x += speed * delta;
                }
                else {
                    toRight = false;
                }
            }
            else {
                if (x > 0.0f) {
                    x -= speed * delta;
                }
                else {
                    toRight = true;
                }
            }
        }
 
 
        rdpq_attach(disp, NULL);
 
        rdpq_set_mode_copy(true);
        rdpq_sprite_blit(background, 0, 0, NULL);
 
        if (showLogo) {
            rdpq_set_mode_copy(true);
            rdpq_sprite_blit(logo, (int)x, (int)y, &( rdpq_blitparms_t ) {
                .scale_x = 0.5f,
                .scale_y = 0.5f
            });
        }
 
 
        rdpq_set_mode_standard();
 
        if (showInfo) {
 
            //mutex_lock(&mutex);
            rdpq_text_printf(&(rdpq_textparms_t) {
                    .width = 320-32,
                    .align = ALIGN_LEFT,
                    .wrap = WRAP_WORD,
                }, 1, 32, 32, "Encoded in %.8f ms\nBytes written: %lu bytes", encodedTime, bytesWritten);
                
            rdpq_text_printf(&(rdpq_textparms_t) {
                .width = 320-32,
                .align = ALIGN_LEFT,
                .wrap = WRAP_WORD,
            }, 1, 32, 60, "State: %s", scrType == SCREENSHOT_NEVER_TAKEN ? "No screenshot taken" : 
                scrType == SCREENSHOT_TYPE_NULL ? "Saved to null" :
                scrType == SCREENSHOT_TYPE_RAW ? "Saved as raw" :
                scrType == SCREENSHOT_TYPE_QOI ? "Saved as QOI" :
                scrType == SCREENSHOT_FRAME_CAPTURED ? "Frame captured, not saved" :
                scrType == SCREENSHOT_NO_SD_CARD ? "No SD card found" :
                "Unknown"
            );
 
            rdpq_text_printf(&(rdpq_textparms_t) {
                .width = 320-32,
                .align = ALIGN_LEFT,
                .wrap = WRAP_WORD,
            }, 1, 32, 72, "Save successful: %s", successfulSave ? "Yes" : "No");
 
            rdpq_text_printf(&(rdpq_textparms_t) {
                .width = 320-32,
                .align = ALIGN_LEFT,
                .wrap = WRAP_WORD,
            }, 1, 32, 200, "Version: %s\nRevision date: %s",
            QOI_ENC_VERSION,
            QOI_ENC_REVISION_DATE);
            //mutex_unlock(&mutex);
        }
        if (pressed.start) {
            showInfo ^= true;
        }
 
        if (pressed.d_down) {
            showLogo ^= true;
        }
        
        if (pressed.z) {
 
            // capture the current frame into a buffer for testing
            rdpq_attach(&lastSavedFrame, NULL);
            rdpq_set_mode_copy(false);
            rdpq_tex_blit(disp, 0, 0, NULL);
            rdpq_detach();
 
            //mutex_lock(&mutex[0]);
            
            scrType = SCREENSHOT_FRAME_CAPTURED;
            successfulSave = true;
 
            //mutex_unlock(&mutex[0]);
            
        }
        
        if (held.d_left) {
            rdpq_set_mode_copy(true);
            rdpq_tex_blit(&lastSavedFrame, 0, 0, NULL);
        }
 
        if (pressed.b) {
            if (!sdCardExists) {
                //mutex_lock(&mutex);
 
                scrType = SCREENSHOT_NO_SD_CARD;
                bytesWritten = 0;
                encodedTime = 0.0f;
                successfulSave = false;
 
                //mutex_unlock(&mutex);
            }
            else {
                surface_t img = surface_alloc(FMT_RGBA16, 320, 240);
 
                float startEncode, endEncode;
                //bool successfulScreenshot = false;
 
                rdpq_attach(&img, NULL);
                rdpq_set_mode_copy(false);
                rdpq_tex_blit(disp, 0, 0, NULL);
                rdpq_detach();
 
                startEncode = timer_ticks();
 
                //thrd_create(&thread, (thrd_start_t)save_screenshot_raw, &img, "sd:/screenshot.raw", &bytesWritten);
                successfulSave = save_screenshot_raw(&img, "sd:/screenshot.raw", &bytesWritten);
                //thrd_join(thread, &successfulScreenshot);
                
                endEncode = timer_ticks();
 
                //mutex_lock(&mutex);
 
                //successfulSave = successfulScreenshot;
 
                encodedTime = TIMER_MICROS(endEncode - startEncode) / 1000.0f; // Convert to milliseconds
 
                scrType = SCREENSHOT_TYPE_RAW;

 
                surface_free(&img);
            }
 
            
        }
        else if (pressed.a) {
            
            if (!sdCardExists) {
                //mutex_lock(&mutex);
 
                scrType = SCREENSHOT_NO_SD_CARD;
                bytesWritten = 0;
                encodedTime = 0.0f;
                successfulSave = false;
 
                //mutex_unlock(&mutex);
            }
            else {
                surface_t img = surface_alloc(FMT_RGBA16, 320, 240);
 
                float startEncode, endEncode;
                //bool successfulScreenshot = false;
 
                rdpq_attach(&img, NULL);
                rdpq_set_mode_copy(false);
                rdpq_tex_blit(disp, 0, 0, NULL);
                rdpq_detach();
 
                startEncode = timer_ticks();
 
                //thrd_create(&thread, (thrd_start_t)save_screenshot, &img, "sd:/screenshot.qoi", &bytesWritten);
                successfulSave = save_screenshot(&img, "sd:/screenshot.qoi", &bytesWritten);
                //thrd_join(thread, &successfulScreenshot);
 
                endEncode = timer_ticks();
 
                //mutex_lock(&mutex);
 
                //successfulSave = successfulScreenshot;
 
                encodedTime = TIMER_MICROS(endEncode - startEncode) / 1000.0f; // Convert to milliseconds
 
                scrType = SCREENSHOT_TYPE_QOI;
 
                //mutex_unlock(&mutex);
                
                surface_free(&img);
            }
        }
        else if (pressed.d_up) {
            surface_t img = surface_alloc(FMT_RGBA16, 320, 240);
 
            float startEncode, endEncode;
            //bool successfulScreenshot = false;
 
            rdpq_attach(&img, NULL);
            rdpq_set_mode_copy(false);
            rdpq_tex_blit(disp, 0, 0, NULL);
            rdpq_detach();
 
            startEncode = timer_ticks();
            //thrd_create(&thread, (thrd_start_t)save_screenshot_null, &img, &bytesWritten);
            successfulSave = save_screenshot_null(&img, &bytesWritten);
            endEncode = timer_ticks();
            //thrd_join(thread, &successfulScreenshot);
 
            //mutex_lock(&mutex);
 
            //successfulSave = successfulScreenshot;
 
            encodedTime = TIMER_MICROS(endEncode - startEncode) / 1000.0f; // Convert to milliseconds
 
            scrType = SCREENSHOT_TYPE_NULL;
 
            //mutex_unlock(&mutex);
 
            surface_free(&img);
 
        }
 
        rdpq_detach_show();
 
    }
 
    return 0;
}