int main(int argc, char *argv[]) {
Display *d = XOpenDisplay(NULL);
if (!d) {
printf("Unable to open display\n");
return;
}
#ifdef USB_PIXEL
usb_dev_handle *handle = NULL;
int usb_present = open_usb(&handle);
if (!handle) {
printf("Unable to open usb device, proceeding anyway...\n");
}
#endif
int radius = RADIUS;
init_shm(d, radius);
init_xinput(d);
int x = -1;
int y = -1;
int old_x = -1;
int old_y = -1;
struct rgb_color color;
color.alpha = 255;
uint8_t buf[3];
while(1) {
wait_for_movement(d, &x, &y);
if (x != old_x || y != old_y) {
refresh_image(d, x, y, radius);
get_pixel_color(d, x, y, &color, radius);
printf("%d/%d\t(%d/%d/%d)\n", x, y, color.red, color.green, color.blue);
#ifdef USB_PIXEL
if (usb_present) {
buf[0] = color.red;
buf[1] = color.green;
buf[2] = color.blue;
int8_t sent = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT, CUSTOM_RQ_SET_RGB, 0, 0, buf, 3, 100);
if (sent < 0) {
printf("Lost contact to USB device\n");
usb_present = 0;
handle = NULL;
}
}
#endif
old_x = x;
old_y = y;
}
}
XCloseDisplay(d);
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
producer_qimage self = mlt_properties_get_data( properties, "producer_qimage", NULL );
mlt_producer producer = &self->parent;
*width = mlt_properties_get_int( properties, "rescale_width" );
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( &self->parent ) );
// Refresh the image
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage = mlt_cache_item_data( self->qimage_cache, NULL );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.image" );
self->current_image = mlt_cache_item_data( self->image_cache, NULL );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha" );
self->current_alpha = mlt_cache_item_data( self->alpha_cache, NULL );
refresh_image( self, frame, *format, *width, *height );
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
*format = self->format;
// NB: Cloning is necessary with this producer (due to processing of images ahead of use)
// The fault is not in the design of mlt, but in the implementation of the qimage producer...
if ( self->current_image )
{
// Clone the image and the alpha
int image_size = mlt_image_format_size( self->format, self->current_width, self->current_height, NULL );
uint8_t *image_copy = mlt_pool_alloc( image_size );
memcpy( image_copy, self->current_image, image_size );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
mlt_log_debug( MLT_PRODUCER_SERVICE( &self->parent ), "%dx%d (%s)\n",
self->current_width, self->current_height, mlt_image_format_name( *format ) );
// Clone the alpha channel
if ( self->current_alpha )
{
image_copy = mlt_pool_alloc( self->current_width * self->current_height );
memcpy( image_copy, self->current_alpha, self->current_width * self->current_height );
mlt_frame_set_alpha( frame, image_copy, self->current_width * self->current_height, mlt_pool_release );
}
}
else
{
error = 1;
}
// Release references and locks
mlt_cache_item_close( self->qimage_cache );
mlt_cache_item_close( self->image_cache );
mlt_cache_item_close( self->alpha_cache );
mlt_service_unlock( MLT_PRODUCER_SERVICE( &self->parent ) );
return error;
}
