main.c

#include "image_view.c"
#include "capture_mmap.c"
#include "jpeg_blockdiff.c"
#include <stdlib.h>

// Global buffers to store previous and current frames
static unsigned char* prev_frame_buffer = NULL;
static unsigned long prev_frame_size = 0;
static unsigned char* temp_rgba_buffer = NULL;
static int first_frame = 1;

// Function to display camera feed in the image viewer window with difference highlighting
void display_camera_frame(Buffer* buffer, uint8_t t) {
    // Request a new frame from camera
    n_iv_cap_request(NULL);  // NULL since we'll use the global buffer
    
    // Allocate the temp RGBA buffer if not already done
    if (!temp_rgba_buffer) {
        temp_rgba_buffer = malloc(buffer->length);
        if (!temp_rgba_buffer) {
            fprintf(stderr, "Failed to allocate RGBA buffer\n");
            return;
        }
    }
    
    // Clear output buffer to transparent black
    memset(buffer->start, 0, buffer->length);
    
    if (buf.bytesused > 0 && bufs[buf.index].start) {
        // First frame - just store it
        if (first_frame) {
            if (prev_frame_buffer) {
                free(prev_frame_buffer);
            }
            prev_frame_buffer = malloc(buf.bytesused);
            if (prev_frame_buffer) {
                memcpy(prev_frame_buffer, bufs[buf.index].start, buf.bytesused);
                prev_frame_size = buf.bytesused;
                first_frame = 0;
            }
            
            // For the first frame, we can't do a comparison, so just show something
            memcpy(buffer->start, bufs[buf.index].start, 
                  buffer->length > buf.bytesused ? buf.bytesused : buffer->length);
        } else {
            // Compare current frame with previous frame
            int w = 640;  // Assuming 640x480 - get these from the image viewer size
            int h = 480;
            
            if (jpeg_compare_diff(
                prev_frame_buffer, prev_frame_size,
                bufs[buf.index].start, buf.bytesused,
                buffer->start, w, h) != 0) {
                fprintf(stderr, "JPEG comparison failed\n");
            }
            
            // Store current frame as previous for next iteration
            if (prev_frame_buffer) {
                if (prev_frame_size != buf.bytesused) {
                    free(prev_frame_buffer);
                    prev_frame_buffer = malloc(buf.bytesused);
                }
                if (prev_frame_buffer) {
                    memcpy(prev_frame_buffer, bufs[buf.index].start, buf.bytesused);
                    prev_frame_size = buf.bytesused;
                }
            }
        }
    }
}

int main(int argc, char **argv)
{
    // Check if camera device number is provided
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <camera_device_number>\n", argv[0]);
        return 1;
    }
    
    int camera_num = atoi(argv[1]);
    
    // Initialize the camera
    if (n_iv_cap_open(camera_num) != 0) {
        fprintf(stderr, "Failed to open camera %d\n", camera_num);
        return 1;
    }
    
    if (n_iv_cap_init_buffers() != 0) {
        fprintf(stderr, "Failed to initialize camera buffers\n");
        n_iv_cap_close();
        return 1;
    }
    
    // Initialize the image viewer
    if (n_iv_init() < 0) {
        fprintf(stderr, "Failed to initialize image viewer\n");
        n_iv_cap_close();
        return 1;
    }

    printf("Displaying camera motion detection. Press any key to exit.\n");
    
    // Main loop - display camera frames
    for (uint8_t t = 0;; ++t)
    {
        // Update the display with camera feed highlighting differences
        if (n_iv_updateframe(display_camera_frame, t)) break;
    }

    // Cleanup
    if (prev_frame_buffer) {
        free(prev_frame_buffer);
        prev_frame_buffer = NULL;
    }
    
    if (temp_rgba_buffer) {
        free(temp_rgba_buffer);
        temp_rgba_buffer = NULL;
    }
    
    n_iv_cap_close();
    n_iv_quit();
    
    return 0;
}