Video Configuration

s32 videoConfigure(s32 videoOut, videoConfiguration *config, void *option, s32 blocking);

s32 videoGetState(s32 videoOut, s32 deviceIndex, videoState *state);

s32 videoGetResolution(s32 resolutionId, videoResolution *resolution);

s32 videoGetConfiguration(u32 videoOut, videoConfiguration *config, void *option);

s32 videoGetNumberOfDevice(u32 videoOut);

s32 videoGetDeviceInfo(u32 videoOut, u32 deviceIndex, videoDeviceInfo *info);

s32 videoGetResolutionAvailability(u32 videoOut, u32 resolutionId, u32 aspect, u32 option);

s32 videoRegisterCallback(u32 slot, videoCallback cbVideo, void *userData);

s32 videoUnregisterCallback(u32 slot);

s32 videoGetConvertCursorColorInfo(u8 *rgbOutputRange);

s32 videoDebugSetMonitorType(u32 videoOut, u32 monitorType);

typedef struct _videoconfig {
    u8 resolution;
    u8 format;
    u8 aspect;
    u8 padding[9];
    u32 pitch;
} videoConfiguration;

typedef struct _videostate {
    u8 state;
    u8 colorSpace;
    u8 padding[6];
    videoDisplayMode displayMode;
} videoState;

typedef struct _videodisplaymode {
    u8 resolution;
    u8 scanMode;
    u8 conversion;
    u8 aspect;
    u8 padding[2];
    u16 refreshRates;
} videoDisplayMode;

typedef struct _videoresolution {
    u16 width;
    u16 height;
} videoResolution;

typedef struct _videoDeviceInfo {
    u8 portType;
    u8 colorSpace;
    u16 latency;
    u8 availableModeCount;
    u8 state;
    u8 rgbOutputRange;
    u8 padding[5];
    videoColorInfo colorInfo;
    videoDisplayMode availableModes[32];
    videoKSVList ksvList;
} videoDeviceInfo;

typedef struct _videoColorInfo {
    u16 redX;
    u16 redY;
    u16 greenX;
    u16 greenY;
    u16 blueX;
    u16 blueY;
    u16 whiteX;
    u16 whiteY;
    u32 gamma;
} videoColorInfo;

typedef s32 (*videoCallback)(u32 slot, u32 videoOut, u32 deviceIndex, 
                             u32 event, videoDeviceInfo *info, void *userData);

#include <sysutil/video.h>
#include <stdio.h>

int main() {
    videoState state;
    videoResolution resolution;
    videoConfiguration config;
    
    // Get current video state
    if (videoGetState(VIDEO_PRIMARY, 0, &state) == 0) {
        printf("Video state: %d\n", state.state);
        printf("Resolution ID: %d\n", state.displayMode.resolution);
    }
    
    // Get resolution dimensions
    if (videoGetResolution(VIDEO_RESOLUTION_720, &resolution) == 0) {
        printf("720p resolution: %dx%d\n", resolution.width, resolution.height);
    }
    
    // Configure video output for 720p
    config.resolution = VIDEO_RESOLUTION_720;
    config.format = VIDEO_BUFFER_FORMAT_XRGB;
    config.aspect = VIDEO_ASPECT_16_9;
    config.pitch = resolution.width * 4;  // 4 bytes per pixel for XRGB
    
    if (videoConfigure(VIDEO_PRIMARY, &config, NULL, 1) == 0) {
        printf("Video configured successfully\n");
    }
    
    return 0;
}

#include <sysutil/video.h>
#include <stdio.h>

void checkAvailableResolutions() {
    videoDeviceInfo info;
    
    if (videoGetDeviceInfo(VIDEO_PRIMARY, 0, &info) == 0) {
        printf("Port type: 0x%x\n", info.portType);
        printf("Available modes: %d\n", info.availableModeCount);
        
        for (int i = 0; i < info.availableModeCount; i++) {
            videoResolution res;
            videoGetResolution(info.availableModes[i].resolution, &res);
            
            printf("Mode %d: %dx%d ", i, res.width, res.height);
            printf("Aspect: %d ", info.availableModes[i].aspect);
            printf("Scan: %s\n", 
                   info.availableModes[i].scanMode == VIDEO_SCANMODE_PROGRESSIVE 
                   ? "Progressive" : "Interlaced");
        }
    }
}

#include <sysutil/video.h>
#include <stdio.h>

s32 videoEventCallback(u32 slot, u32 videoOut, u32 deviceIndex,
                       u32 event, videoDeviceInfo *info, void *userData) {
    printf("Video event received\n");
    printf("Slot: %d, VideoOut: %d, Device: %d, Event: %d\n",
           slot, videoOut, deviceIndex, event);
    return 0;
}

int main() {
    // Register video callback
    videoRegisterCallback(0, videoEventCallback, NULL);
    
    // Your application code...
    
    // Cleanup
    videoUnregisterCallback(0);
    
    return 0;
}