test.c

/* test.c */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <setjmp.h>
#include <stdio.h>
#include <freerdp2/freerdp/server/rdpgfx.h>
#include <wlr/render/allocator.h>
#include <wlr/render/drm_format_set.h>
#include <wlr/types/wlr_buffer.h>
#include <wlr/util/log.h>
#include <drm/drm_fourcc.h>
#include "rdprail.h"

// Crash handling
static jmp_buf crash_recovery;
static void sigsegv_handler(int sig) {
    fprintf(stderr, "Caught segmentation fault at line: %d\n", __LINE__);
    longjmp(crash_recovery, 1);
}



static int mock_open_pool(struct _GfxRedirServerContext *ctx, GFXREDIR_OPEN_POOL_PDU *open_pool) {
    fprintf(stderr, "Mock OpenPool called\n");
    open_pool->poolId = 1;  // Assign a mock pool ID
    return 0;
}

static int mock_create_buffer(struct _GfxRedirServerContext *ctx, GFXREDIR_CREATE_BUFFER_PDU *create_buffer) {
    fprintf(stderr, "Mock CreateBuffer called\n");
    create_buffer->bufferId = 1;  // Assign a mock buffer ID
    return 0;
}

int main() {
    // Set up crash handler
    signal(SIGSEGV, sigsegv_handler);
    if (setjmp(crash_recovery) != 0) {
        fprintf(stderr, "Recovered from segmentation fault\n");
        return 1;
    }

    // Enable debug logging
    wlr_log_init(WLR_DEBUG, NULL);
    
    // Create mock RDP context
    struct _GfxRedirServerContext mock_ctx = {
        .OpenPool = mock_open_pool,
        .CreateBuffer = mock_create_buffer
    };
    
    // Create allocator
    fprintf(stderr, "Creating allocator...\n");
    struct wlr_allocator *alloc = wlr_rdp_allocator_create(&mock_ctx);
    if (!alloc) {
        fprintf(stderr, "Failed to create allocator\n");
        return 1;
    }
    
    // Create format
    struct wlr_drm_format format = {
        .format = DRM_FORMAT_ARGB8888,
        .len = 1,
        .modifiers = {DRM_FORMAT_MOD_LINEAR},
    };
    
    // Create buffer
    fprintf(stderr, "Creating buffer...\n");
    struct wlr_buffer *buffer = wlr_allocator_create_buffer(alloc, 
        640, 480, &format);
    if (!buffer) {
        fprintf(stderr, "Failed to create buffer\n");
        wlr_allocator_destroy(alloc);
        return 1;
    }
    
    // Inspect buffer structure
    fprintf(stderr, "Buffer structure details:\n");
    fprintf(stderr, "  Buffer width: %d\n", buffer->width);
    fprintf(stderr, "  Buffer height: %d\n", buffer->height);
    fprintf(stderr, "  Buffer impl: %p\n", (void*)buffer->impl);
    fprintf(stderr, "  Buffer dropped: %s\n", buffer->dropped ? "true" : "false");
    fprintf(stderr, "  Buffer locks: %zu\n", buffer->n_locks);
    fprintf(stderr, "  Buffer accessing data ptr: %s\n", 
        buffer->accessing_data_ptr ? "true" : "false");

    // Get buffer data
    fprintf(stderr, "Accessing buffer data...\n");
    void *data = NULL;
    uint32_t buffer_format = 0;
    size_t stride = 0;
    
    // Detailed access logging
    int access_result = wlr_buffer_begin_data_ptr_access(
        buffer, 
        WLR_BUFFER_DATA_PTR_ACCESS_WRITE,
        &data, 
        &buffer_format, 
        &stride
    );
    
    fprintf(stderr, "Access result: %d\n", access_result);
    fprintf(stderr, "Data pointer: %p\n", data);
    fprintf(stderr, "Buffer format: %u\n", buffer_format);
    fprintf(stderr, "Stride: %zu\n", stride);
    
    if (access_result) {
        fprintf(stderr, "Buffer data access successful\n");
        
        // Verify buffer structure again
        fprintf(stderr, "After data access:\n");
        fprintf(stderr, "  Buffer accessing data ptr: %s\n", 
            buffer->accessing_data_ptr ? "true" : "false");

        uint32_t *pixels = data;
        for (int i = 0; i < (640 * 480); i++) {
            pixels[i] = 0xFF0000FF; // Fill with red
        }
        
        // Verify data access again
        fprintf(stderr, "Data fill complete\n");
        
        wlr_buffer_end_data_ptr_access(buffer);
        fprintf(stderr, "Data access ended\n");
        printf("Buffer filled with red\n");
    } else {
        fprintf(stderr, "Failed to access buffer data\n");
    }
    
    // Cleanup
    wlr_buffer_drop(buffer);
    wlr_allocator_destroy(alloc);
    
    return 0;
}