Compare text

Find the difference between two text files

Real-time editor

Hide whitespace changes

Hide unchanged lines

Disable line wrap

Layout

Diff precision

Text styles

Syntax highlighting

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 11 years agoDiff never expires

1 removal

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

401 lines

3 additions

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

403 lines

// good

// bad

* 1394-Based Digital Camera Control Library

* IIDC-over-USB using libusb backend for dc1394

* Written by David Moore <dcm@acm.org>

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <inttypes.h>

#include "config.h"

#include "platform.h"

#include "internal.h"

#include "usb.h"

static platform_t *

dc1394_usb_new (void)

{

libusb_context *context;

if (libusb_init(&context) != 0)

return NULL;

platform_t * p = calloc (1, sizeof (platform_t));

p->context = context;

return p;

}

static void

dc1394_usb_free (platform_t * p)

{

if (p->context)

libusb_exit(p->context);

p->context = NULL;

free (p);

}

struct _platform_device_t {

libusb_device * dev;

};

typedef struct _usb_device_list_t {

platform_device_list_t list;

libusb_device ** libusb_list;

} usb_device_list_t;

/* This is the list of USB vendor/products that we know support

* IIDC-over-USB. Currently, this is the only mechanism of detecting

* such cameras. */

static struct _vendor_product_t {

uint16_t vendor;

uint16_t product;

} usb_products[] = {

{ 0x1e10, 0x2000 }, // Point Grey Firefly MV Color

{ 0x1e10, 0x2001 }, // Point Grey Firefly MV Mono

{ 0x1e10, 0x2002 }, // Point Grey High Res Firefly MV Color

{ 0x1e10, 0x2003 }, // Point Grey High Res Firefly MV Mono

{ 0x1e10, 0x2004 }, // Point Grey Chameleon Color

{ 0x1e10, 0x2005 }, // Point Grey Chameleon Mono

{ 0x1e10, 0x3000 }, // Point Grey Flea 3

{ 0x1e10, 0x3005 }, // Point Grey Flea 3 (FL3-U3-13Y3M)

{ 0x1e10, 0x3006 }, // Point Grey Flea 3 (FL3-U3-13S2C)

{ 0x1e10, 0x3008 }, // Point Grey Flea 3 (FL3-U3-88S2C)

{ 0x1e10, 0x300a }, // Point Grey Flea 3 (FL3-U3-13E4C)

{ 0x1e10, 0x300b }, // Point Grey Flea 3 (FL3-U3-13E4M with 1.43.3.2 FW)

{ 0x1e10, 0x3300 }, // Point Grey Flea 3 (FL3-U3-13E4M with 2.7.3.0 FW)

{ 0, 0 }

};

static int

is_device_iidc (uint16_t vendor, uint16_t product)

{

int j = 0;

while (usb_products[j].vendor != 0 && usb_products[j].product != 0) {

if (usb_products[j].vendor == vendor &&

usb_products[j].product == product)

return 1;

j++;

}

return 0;

}

static platform_device_list_t *

dc1394_usb_get_device_list (platform_t * p)

{

usb_device_list_t * list;

libusb_device * dev;

int i;

list = calloc (1, sizeof (usb_device_list_t));

if (!list)

return NULL;

if (libusb_get_device_list (p->context, &list->libusb_list) < 0)

return NULL;

dev = list->libusb_list[0];

for (i=0, dev = list->libusb_list[0]; dev; dev = list->libusb_list[++i]) {

struct libusb_device_descriptor desc;

if (libusb_get_device_descriptor (dev, &desc) != 0) {

dc1394_log_warning ("usb: Failed to get descriptor for device %d",

i);

continue;

}

if (!is_device_iidc (desc.idVendor, desc.idProduct))

continue;

list->list.num_devices++;

list->list.devices = realloc (list->list.devices,

list->list.num_devices * sizeof (platform_device_t *));

platform_device_t * pdev = malloc(sizeof(platform_device_t));

pdev->dev = dev;

list->list.devices[list->list.num_devices-1] = pdev;

dc1394_log_debug ("usb: Found vendor:prod %x:%x at address %x:%x",

desc.idVendor, desc.idProduct,

libusb_get_bus_number (dev), libusb_get_device_address (dev));

}

return &list->list;

}

static void

dc1394_usb_free_device_list (platform_device_list_t * d)

{

usb_device_list_t * list = (usb_device_list_t *) d;

int i;

for (i = 0; i < d->num_devices; i++)

free (d->devices[i]);

free (d->devices);

libusb_free_device_list (list->libusb_list, 1);

free (d);

}

/* The high 16 bits of the IEEE 1394 address space are mapped to the request

* byte of USB control transfers. Only a discrete set addresses are

* currently supported, as mapped by this function. */

static int

address_to_request (uint64_t address)

{

switch (address >> 32) {

case 0xffff:

return 0x7f;

case 0xd000:

return 0x80;

case 0xd0001:

return 0x81;

}

dc1394_log_error("usb: Invalid high address %x for request",

address >> 32);

return -1;

}

#define REQUEST_TIMEOUT_MS 1000

static int

do_read (libusb_device_handle * handle, uint64_t address, uint32_t * quads,

int num_quads)

{

int request = address_to_request (address);

if (request < 0)

return -1;

unsigned char buf[num_quads*4];

/* IEEE 1394 address reads are mapped to USB control transfers as

* shown here. */

int ret = libusb_control_transfer (handle, 0xc0, request,

address & 0xffff, (address >> 16) & 0xffff,

buf, num_quads * 4, REQUEST_TIMEOUT_MS);

if (ret < 0)

return -1;

int i;

int ret_quads = (ret + 3) / 4;

/* Convert from little-endian to host-endian */

for (i = 0; i < ret_quads; i++) {

quads[i] = (buf[4*i+3] << 24) | (buf[4*i+2] << 16)

| (buf[4*i+1] << 8) | buf[4*i];

}

return ret_quads;

}

static int

do_write (libusb_device_handle * handle, uint64_t address,

const uint32_t * quads, int num_quads)

{

int request = address_to_request (address);

if (request < 0)

return -1;

unsigned char buf[num_quads*4];

int i;

/* Convert from host-endian to little-endian */

for (i = 0; i < num_quads; i++) {

buf[4*i] = quads[i] & 0xff;

buf[4*i+1] = (quads[i] >> 8) & 0xff;

buf[4*i+2] = (quads[i] >> 16) & 0xff;

buf[4*i+3] = (quads[i] >> 24) & 0xff;

}

/* IEEE 1394 address writes are mapped to USB control transfers as

* shown here. */

int ret = libusb_control_transfer (handle, 0x40, request,

address & 0xffff, (address >> 16) & 0xffff,

buf, num_quads * 4, REQUEST_TIMEOUT_MS);

if (ret < 0)

return -1;

return ret / 4;

}

static int

dc1394_usb_device_get_config_rom (platform_device_t * device,

uint32_t * quads, int * num_quads)

{

libusb_device_handle * handle;

if (libusb_open (device->dev, &handle) < 0) {

dc1394_log_warning ("usb: Failed to open device for config ROM");

return DC1394_FAILURE;

}

if (*num_quads > 256)

*num_quads = 256;

/* Read the config ROM one quad at a time because a read longer than

* the length of the ROM will fail. */

int i;

for (i = 0; i < *num_quads; i++) {

int ret = do_read (handle, CONFIG_ROM_BASE + 0x400 + 4*i,

quads + i, 1);

if (ret < 1)

break;

}

if (i == 0) {

dc1394_log_error ("usb: Failed to read config ROM");

libusb_close (handle);

return -1;

}

*num_quads = i;

libusb_close (handle);

return 0;

}

static platform_camera_t *

dc1394_usb_camera_new (platform_t * p, platform_device_t * device,

uint32_t unit_directory_offset)

{

libusb_device_handle * handle;

platform_camera_t * camera;

if (libusb_open (device->dev, &handle) < 0) {

dc1394_log_error ("usb: Failed to open device");

return NULL;

}

if (libusb_set_configuration (handle, 1) < 0) {

dc1394_log_error ("usb: Failed to set configuration 1 after open");

libusb_close (handle);

return NULL;

}

camera = calloc (1, sizeof (platform_camera_t));

camera->handle = handle;

return camera;

}

static void dc1394_usb_camera_free (platform_camera_t * cam)

{

libusb_close (cam->handle);

cam->handle = NULL;

free (cam);

}

static void

dc1394_usb_camera_set_parent (platform_camera_t * cam, dc1394camera_t * parent)

{

cam->camera = parent;

}

static dc1394error_t

dc1394_usb_camera_print_info (platform_camera_t * camera, FILE *fd)

{

libusb_device *dev = libusb_get_device (camera->handle);

struct libusb_device_descriptor desc;

libusb_get_device_descriptor (dev, &desc);

fprintf(fd,"------ Camera platform-specific information ------\n");

fprintf(fd,"USB Bus Number : %d\n",

libusb_get_bus_number (dev));

fprintf(fd,"USB Device Address : %d\n",

libusb_get_device_address (dev));

fprintf(fd,"Vendor ID : 0x%x\n",

desc.idVendor);

fprintf(fd,"Product ID : 0x%x\n",

desc.idProduct);

return DC1394_SUCCESS;

}

static dc1394error_t

dc1394_usb_camera_read (platform_camera_t * cam, uint64_t offset,

uint32_t * quads, int num_quads)

{

if (do_read (cam->handle, CONFIG_ROM_BASE + offset, quads,

num_quads) != num_quads)

return DC1394_FAILURE;

return DC1394_SUCCESS;

}

static dc1394error_t

dc1394_usb_camera_write (platform_camera_t * cam, uint64_t offset,

const uint32_t * quads, int num_quads)

{

if (do_write (cam->handle, CONFIG_ROM_BASE + offset, quads,

num_quads) != num_quads)

return DC1394_FAILURE;

return DC1394_SUCCESS;

}

static dc1394error_t

dc1394_usb_camera_get_node(platform_camera_t *cam, uint32_t *node,

uint32_t * generation)

{

/* Since node/generation doesn't really apply to USB, we instead

* put the device address in the "node" argument and "bus number"

* in the generation argument. */

if (node)

*node = libusb_get_device_address (libusb_get_device (cam->handle));

if (generation)

*generation = libusb_get_bus_number (libusb_get_device (cam->handle));

return DC1394_SUCCESS;

}

static dc1394error_t

dc1394_usb_reset_bus (platform_camera_t * cam)

{

int ret = libusb_reset_device (cam->handle);

if (ret == 0 || ret == LIBUSB_ERROR_NOT_FOUND)

return DC1394_SUCCESS;

return DC1394_FAILURE;

}

static platform_dispatch_t

usb_dispatch = {

.platform_new = dc1394_usb_new,

.platform_free = dc1394_usb_free,

.get_device_list = dc1394_usb_get_device_list,

.free_device_list = dc1394_usb_free_device_list,

.device_get_config_rom = dc1394_usb_device_get_config_rom,

.camera_new = dc1394_usb_camera_new,

.camera_free = dc1394_usb_camera_free,

.camera_set_parent = dc1394_usb_camera_set_parent,

.camera_print_info = dc1394_usb_camera_print_info,

.camera_get_node = dc1394_usb_camera_get_node,

.reset_bus = dc1394_usb_reset_bus,

.camera_read = dc1394_usb_camera_read,

.camera_write = dc1394_usb_camera_write,

.capture_setup = dc1394_usb_capture_setup,

.capture_stop = dc1394_usb_capture_stop,

.capture_dequeue = dc1394_usb_capture_dequeue,

.capture_enqueue = dc1394_usb_capture_enqueue,

.capture_get_fileno = dc1394_usb_capture_get_fileno,

.capture_is_frame_corrupt = dc1394_usb_capture_is_frame_corrupt,

#ifdef HAVE_MACOSX

.capture_set_callback = dc1394_usb_capture_set_callback,

.capture_schedule_with_runloop = dc1394_usb_capture_schedule_with_runloop,

#else

.capture_set_callback = NULL,

.capture_schedule_with_runloop = NULL,

#endif

};

void

dc1394_usb_init(dc1394_t * d)

{

register_platform (d, &usb_dispatch, "usb");

}

Saved diffs

Original text

Open file

// good

/*
     * 1394-Based Digital Camera Control Library
     *
     * IIDC-over-USB using libusb backend for dc1394
     *
     * Written by David Moore <dcm@acm.org>
     *
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Lesser General Public
     * License as published by the Free Software Foundation; either
     * version 2.1 of the License, or (at your option) any later version.
     *
     * This library is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     * Lesser General Public License for more details.
     *
     * You should have received a copy of the GNU Lesser General Public
     * License along with this library; if not, write to the Free Software
     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <inttypes.h>
    
    #include "config.h"
    #include "platform.h"
    #include "internal.h"
    #include "usb.h"
    
    
    static platform_t *
    dc1394_usb_new (void)
    {
        libusb_context *context;
        if (libusb_init(&context) != 0)
            return NULL;
    
        platform_t * p = calloc (1, sizeof (platform_t));
        p->context = context;
        return p;
    }
    static void
    dc1394_usb_free (platform_t * p)
    {
        if (p->context)
            libusb_exit(p->context);
        p->context = NULL;
        free (p);
    }
    
    struct _platform_device_t {
        libusb_device * dev;
    };
    
    typedef struct _usb_device_list_t {
        platform_device_list_t list;
        libusb_device ** libusb_list;
    } usb_device_list_t;
    
    /* This is the list of USB vendor/products that we know support
     * IIDC-over-USB.  Currently, this is the only mechanism of detecting
     * such cameras. */
    static struct _vendor_product_t {
        uint16_t vendor;
        uint16_t product;
    } usb_products[] = {
        { 0x1e10, 0x2000 }, // Point Grey Firefly MV Color
        { 0x1e10, 0x2001 }, // Point Grey Firefly MV Mono
        { 0x1e10, 0x2002 }, // Point Grey High Res Firefly MV Color
        { 0x1e10, 0x2003 }, // Point Grey High Res Firefly MV Mono
        { 0x1e10, 0x2004 }, // Point Grey Chameleon Color
        { 0x1e10, 0x2005 }, // Point Grey Chameleon Mono
        { 0x1e10, 0x3000 }, // Point Grey Flea 3
        { 0x1e10, 0x3005 }, // Point Grey Flea 3 (FL3-U3-13Y3M)
        { 0x1e10, 0x3006 }, // Point Grey Flea 3 (FL3-U3-13S2C)
        { 0x1e10, 0x3008 }, // Point Grey Flea 3 (FL3-U3-88S2C)
        { 0x1e10, 0x300a }, // Point Grey Flea 3 (FL3-U3-13E4C)
        { 0, 0 }
    };
    
    static int
    is_device_iidc (uint16_t vendor, uint16_t product)
    {
        int j = 0;
        while (usb_products[j].vendor != 0 && usb_products[j].product != 0) {
            if (usb_products[j].vendor == vendor &&
                    usb_products[j].product == product)
                return 1;
            j++;
        }
        return 0;
    }
    
    static platform_device_list_t *
    dc1394_usb_get_device_list (platform_t * p)
    {
        usb_device_list_t * list;
        libusb_device * dev;
        int i;
    
        list = calloc (1, sizeof (usb_device_list_t));
        if (!list)
            return NULL;
    
        if (libusb_get_device_list (p->context, &list->libusb_list) < 0)
            return NULL;
    
        dev = list->libusb_list[0];
        for (i=0, dev = list->libusb_list[0]; dev; dev = list->libusb_list[++i]) {
            struct libusb_device_descriptor desc;
            if (libusb_get_device_descriptor (dev, &desc) != 0) {
                dc1394_log_warning ("usb: Failed to get descriptor for device %d",
                        i);
                continue;
            }
    
            if (!is_device_iidc (desc.idVendor, desc.idProduct))
                continue;
    
            list->list.num_devices++;
            list->list.devices = realloc (list->list.devices,
                    list->list.num_devices * sizeof (platform_device_t *));
            platform_device_t * pdev = malloc(sizeof(platform_device_t));
            pdev->dev = dev;
            list->list.devices[list->list.num_devices-1] = pdev;
    
            dc1394_log_debug ("usb: Found vendor:prod %x:%x at address %x:%x",
                    desc.idVendor, desc.idProduct,
                    libusb_get_bus_number (dev), libusb_get_device_address (dev));
        }
    
        return &list->list;
    }
    
    static void
    dc1394_usb_free_device_list (platform_device_list_t * d)
    {
        usb_device_list_t * list = (usb_device_list_t *) d;
        int i;
        for (i = 0; i < d->num_devices; i++)
            free (d->devices[i]);
        free (d->devices);
        libusb_free_device_list (list->libusb_list, 1);
        free (d);
    }
    
    /* The high 16 bits of the IEEE 1394 address space are mapped to the request
     * byte of USB control transfers.  Only a discrete set addresses are
     * currently supported, as mapped by this function. */
    static int
    address_to_request (uint64_t address)
    {
        switch (address >> 32) {
            case 0xffff:
                return 0x7f;
            case 0xd000:
                return 0x80;
            case 0xd0001:
                return 0x81;
        }
        dc1394_log_error("usb: Invalid high address %x for request",
                address >> 32);
        return -1;
    }
    
    #define REQUEST_TIMEOUT_MS  1000
    
    static int
    do_read (libusb_device_handle * handle, uint64_t address, uint32_t * quads,
            int num_quads)
    {
        int request = address_to_request (address);
        if (request < 0)
            return -1;
    
        unsigned char buf[num_quads*4];
    
        /* IEEE 1394 address reads are mapped to USB control transfers as
         * shown here. */
        int ret = libusb_control_transfer (handle, 0xc0, request,
                address & 0xffff, (address >> 16) & 0xffff,
                buf, num_quads * 4, REQUEST_TIMEOUT_MS);
        if (ret < 0)
            return -1;
        int i;
        int ret_quads = (ret + 3) / 4;
        /* Convert from little-endian to host-endian */
        for (i = 0; i < ret_quads; i++) {
            quads[i] = (buf[4*i+3] << 24) | (buf[4*i+2] << 16)
                | (buf[4*i+1] << 8) | buf[4*i];
        }
        return ret_quads;
    }
    
    static int
    do_write (libusb_device_handle * handle, uint64_t address,
            const uint32_t * quads, int num_quads)
    {
        int request = address_to_request (address);
        if (request < 0)
            return -1;
    
        unsigned char buf[num_quads*4];
        int i;
        /* Convert from host-endian to little-endian */
        for (i = 0; i < num_quads; i++) {
            buf[4*i]   = quads[i] & 0xff;
            buf[4*i+1] = (quads[i] >> 8) & 0xff;
            buf[4*i+2] = (quads[i] >> 16) & 0xff;
            buf[4*i+3] = (quads[i] >> 24) & 0xff;
        }
        /* IEEE 1394 address writes are mapped to USB control transfers as
         * shown here. */
        int ret = libusb_control_transfer (handle, 0x40, request,
                address & 0xffff, (address >> 16) & 0xffff,
                buf, num_quads * 4, REQUEST_TIMEOUT_MS);
        if (ret < 0)
            return -1;
        return ret / 4;
    }
    
    static int
    dc1394_usb_device_get_config_rom (platform_device_t * device,
                                    uint32_t * quads, int * num_quads)
    {
        libusb_device_handle * handle;
        if (libusb_open (device->dev, &handle) < 0) {
            dc1394_log_warning ("usb: Failed to open device for config ROM");
            return DC1394_FAILURE;
        }
    
        if (*num_quads > 256)
            *num_quads = 256;
    
        /* Read the config ROM one quad at a time because a read longer than
         * the length of the ROM will fail. */
        int i;
        for (i = 0; i < *num_quads; i++) {
            int ret = do_read (handle, CONFIG_ROM_BASE + 0x400 + 4*i,
                    quads + i, 1);
            if (ret < 1)
                break;
        }
    
        if (i == 0) {
            dc1394_log_error ("usb: Failed to read config ROM");
            libusb_close (handle);
            return -1;
        }
    
        *num_quads = i;
        libusb_close (handle);
        return 0;
    }
    
    static platform_camera_t *
    dc1394_usb_camera_new (platform_t * p, platform_device_t * device,
            uint32_t unit_directory_offset)
    {
        libusb_device_handle * handle;
        platform_camera_t * camera;
    
        if (libusb_open (device->dev, &handle) < 0) {
            dc1394_log_error ("usb: Failed to open device");
            return NULL;
        }
    
        if (libusb_set_configuration (handle, 1) < 0) {
            dc1394_log_error ("usb: Failed to set configuration 1 after open");
            libusb_close (handle);
            return NULL;
        }
    
        camera = calloc (1, sizeof (platform_camera_t));
        camera->handle = handle;
        return camera;
    }
    
    static void dc1394_usb_camera_free (platform_camera_t * cam)
    {
        libusb_close (cam->handle);
        cam->handle = NULL;
        free (cam);
    }
    
    static void
    dc1394_usb_camera_set_parent (platform_camera_t * cam, dc1394camera_t * parent)
    {
        cam->camera = parent;
    }
    
    static dc1394error_t
    dc1394_usb_camera_print_info (platform_camera_t * camera, FILE *fd)
    {
        libusb_device *dev = libusb_get_device (camera->handle);
        struct libusb_device_descriptor desc;
        libusb_get_device_descriptor (dev, &desc);
        fprintf(fd,"------ Camera platform-specific information ------\n");
        fprintf(fd,"USB Bus Number                    :     %d\n",
                libusb_get_bus_number (dev));
        fprintf(fd,"USB Device Address                :     %d\n",
                libusb_get_device_address (dev));
        fprintf(fd,"Vendor ID                         :     0x%x\n",
                desc.idVendor);
        fprintf(fd,"Product ID                        :     0x%x\n",
                desc.idProduct);
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_camera_read (platform_camera_t * cam, uint64_t offset,
            uint32_t * quads, int num_quads)
    {
        if (do_read (cam->handle, CONFIG_ROM_BASE + offset, quads,
                    num_quads) != num_quads)
            return DC1394_FAILURE;
    
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_camera_write (platform_camera_t * cam, uint64_t offset,
            const uint32_t * quads, int num_quads)
    {
        if (do_write (cam->handle, CONFIG_ROM_BASE + offset, quads,
                    num_quads) != num_quads)
            return DC1394_FAILURE;
    
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_camera_get_node(platform_camera_t *cam, uint32_t *node,
            uint32_t * generation)
    {
        /* Since node/generation doesn't really apply to USB, we instead
         * put the device address in the "node" argument and "bus number"
         * in the generation argument. */
        if (node)
            *node = libusb_get_device_address (libusb_get_device (cam->handle));
        if (generation)
            *generation = libusb_get_bus_number (libusb_get_device (cam->handle));
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_reset_bus (platform_camera_t * cam)
    {
        int ret = libusb_reset_device (cam->handle);
        if (ret == 0 || ret == LIBUSB_ERROR_NOT_FOUND)
            return DC1394_SUCCESS;
    
        return DC1394_FAILURE;
    }
    
    static platform_dispatch_t
    usb_dispatch = {
        .platform_new = dc1394_usb_new,
        .platform_free = dc1394_usb_free,
    
        .get_device_list = dc1394_usb_get_device_list,
        .free_device_list = dc1394_usb_free_device_list,
        .device_get_config_rom = dc1394_usb_device_get_config_rom,
    
        .camera_new = dc1394_usb_camera_new,
        .camera_free = dc1394_usb_camera_free,
        .camera_set_parent = dc1394_usb_camera_set_parent,
    
        .camera_print_info = dc1394_usb_camera_print_info,
        .camera_get_node = dc1394_usb_camera_get_node,
        .reset_bus = dc1394_usb_reset_bus,
    
        .camera_read = dc1394_usb_camera_read,
        .camera_write = dc1394_usb_camera_write,
    
        .capture_setup = dc1394_usb_capture_setup,
        .capture_stop = dc1394_usb_capture_stop,
        .capture_dequeue = dc1394_usb_capture_dequeue,
        .capture_enqueue = dc1394_usb_capture_enqueue,
        .capture_get_fileno = dc1394_usb_capture_get_fileno,
        .capture_is_frame_corrupt = dc1394_usb_capture_is_frame_corrupt,
    
    #ifdef HAVE_MACOSX
        .capture_set_callback = dc1394_usb_capture_set_callback,
        .capture_schedule_with_runloop = dc1394_usb_capture_schedule_with_runloop,
    #else
        .capture_set_callback = NULL,
        .capture_schedule_with_runloop = NULL,
    #endif
    };
    
    void
    dc1394_usb_init(dc1394_t * d)
    {
        register_platform (d, &usb_dispatch, "usb");
    }

Changed text

Open file

// bad

/*
     * 1394-Based Digital Camera Control Library
     *
     * IIDC-over-USB using libusb backend for dc1394
     *
     * Written by David Moore <dcm@acm.org>
     *
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Lesser General Public
     * License as published by the Free Software Foundation; either
     * version 2.1 of the License, or (at your option) any later version.
     *
     * This library is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     * Lesser General Public License for more details.
     *
     * You should have received a copy of the GNU Lesser General Public
     * License along with this library; if not, write to the Free Software
     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <inttypes.h>
    
    #include "config.h"
    #include "platform.h"
    #include "internal.h"
    #include "usb.h"
    
    
    static platform_t *
    dc1394_usb_new (void)
    {
        libusb_context *context;
        if (libusb_init(&context) != 0)
            return NULL;
    
        platform_t * p = calloc (1, sizeof (platform_t));
        p->context = context;
        return p;
    }
    static void
    dc1394_usb_free (platform_t * p)
    {
        if (p->context)
            libusb_exit(p->context);
        p->context = NULL;
        free (p);
    }
    
    struct _platform_device_t {
        libusb_device * dev;
    };
    
    typedef struct _usb_device_list_t {
        platform_device_list_t list;
        libusb_device ** libusb_list;
    } usb_device_list_t;
    
    /* This is the list of USB vendor/products that we know support
     * IIDC-over-USB.  Currently, this is the only mechanism of detecting
     * such cameras. */
    static struct _vendor_product_t {
        uint16_t vendor;
        uint16_t product;
    } usb_products[] = {
        { 0x1e10, 0x2000 }, // Point Grey Firefly MV Color
        { 0x1e10, 0x2001 }, // Point Grey Firefly MV Mono
        { 0x1e10, 0x2002 }, // Point Grey High Res Firefly MV Color
        { 0x1e10, 0x2003 }, // Point Grey High Res Firefly MV Mono
        { 0x1e10, 0x2004 }, // Point Grey Chameleon Color
        { 0x1e10, 0x2005 }, // Point Grey Chameleon Mono
        { 0x1e10, 0x3000 }, // Point Grey Flea 3
        { 0x1e10, 0x3005 }, // Point Grey Flea 3 (FL3-U3-13Y3M)
        { 0x1e10, 0x3006 }, // Point Grey Flea 3 (FL3-U3-13S2C)
        { 0x1e10, 0x3008 }, // Point Grey Flea 3 (FL3-U3-88S2C)
        { 0x1e10, 0x300a }, // Point Grey Flea 3 (FL3-U3-13E4C)
        { 0x1e10, 0x300b }, // Point Grey Flea 3 (FL3-U3-13E4M with 1.43.3.2 FW)
        { 0x1e10, 0x3300 }, // Point Grey Flea 3 (FL3-U3-13E4M with 2.7.3.0 FW)
        { 0, 0 }
    };
    
    static int
    is_device_iidc (uint16_t vendor, uint16_t product)
    {
        int j = 0;
        while (usb_products[j].vendor != 0 && usb_products[j].product != 0) {
            if (usb_products[j].vendor == vendor &&
                    usb_products[j].product == product)
                return 1;
            j++;
        }
        return 0;
    }
    
    static platform_device_list_t *
    dc1394_usb_get_device_list (platform_t * p)
    {
        usb_device_list_t * list;
        libusb_device * dev;
        int i;
    
        list = calloc (1, sizeof (usb_device_list_t));
        if (!list)
            return NULL;
    
        if (libusb_get_device_list (p->context, &list->libusb_list) < 0)
            return NULL;
    
        dev = list->libusb_list[0];
        for (i=0, dev = list->libusb_list[0]; dev; dev = list->libusb_list[++i]) {
            struct libusb_device_descriptor desc;
            if (libusb_get_device_descriptor (dev, &desc) != 0) {
                dc1394_log_warning ("usb: Failed to get descriptor for device %d",
                        i);
                continue;
            }
    
            if (!is_device_iidc (desc.idVendor, desc.idProduct))
                continue;
    
            list->list.num_devices++;
            list->list.devices = realloc (list->list.devices,
                    list->list.num_devices * sizeof (platform_device_t *));
            platform_device_t * pdev = malloc(sizeof(platform_device_t));
            pdev->dev = dev;
            list->list.devices[list->list.num_devices-1] = pdev;
    
            dc1394_log_debug ("usb: Found vendor:prod %x:%x at address %x:%x",
                    desc.idVendor, desc.idProduct,
                    libusb_get_bus_number (dev), libusb_get_device_address (dev));
        }
    
        return &list->list;
    }
    
    static void
    dc1394_usb_free_device_list (platform_device_list_t * d)
    {
        usb_device_list_t * list = (usb_device_list_t *) d;
        int i;
        for (i = 0; i < d->num_devices; i++)
            free (d->devices[i]);
        free (d->devices);
        libusb_free_device_list (list->libusb_list, 1);
        free (d);
    }
    
    /* The high 16 bits of the IEEE 1394 address space are mapped to the request
     * byte of USB control transfers.  Only a discrete set addresses are
     * currently supported, as mapped by this function. */
    static int
    address_to_request (uint64_t address)
    {
        switch (address >> 32) {
            case 0xffff:
                return 0x7f;
            case 0xd000:
                return 0x80;
            case 0xd0001:
                return 0x81;
        }
        dc1394_log_error("usb: Invalid high address %x for request",
                address >> 32);
        return -1;
    }
    
    #define REQUEST_TIMEOUT_MS  1000
    
    static int
    do_read (libusb_device_handle * handle, uint64_t address, uint32_t * quads,
            int num_quads)
    {
        int request = address_to_request (address);
        if (request < 0)
            return -1;
    
        unsigned char buf[num_quads*4];
    
        /* IEEE 1394 address reads are mapped to USB control transfers as
         * shown here. */
        int ret = libusb_control_transfer (handle, 0xc0, request,
                address & 0xffff, (address >> 16) & 0xffff,
                buf, num_quads * 4, REQUEST_TIMEOUT_MS);
        if (ret < 0)
            return -1;
        int i;
        int ret_quads = (ret + 3) / 4;
        /* Convert from little-endian to host-endian */
        for (i = 0; i < ret_quads; i++) {
            quads[i] = (buf[4*i+3] << 24) | (buf[4*i+2] << 16)
                | (buf[4*i+1] << 8) | buf[4*i];
        }
        return ret_quads;
    }
    
    static int
    do_write (libusb_device_handle * handle, uint64_t address,
            const uint32_t * quads, int num_quads)
    {
        int request = address_to_request (address);
        if (request < 0)
            return -1;
    
        unsigned char buf[num_quads*4];
        int i;
        /* Convert from host-endian to little-endian */
        for (i = 0; i < num_quads; i++) {
            buf[4*i]   = quads[i] & 0xff;
            buf[4*i+1] = (quads[i] >> 8) & 0xff;
            buf[4*i+2] = (quads[i] >> 16) & 0xff;
            buf[4*i+3] = (quads[i] >> 24) & 0xff;
        }
        /* IEEE 1394 address writes are mapped to USB control transfers as
         * shown here. */
        int ret = libusb_control_transfer (handle, 0x40, request,
                address & 0xffff, (address >> 16) & 0xffff,
                buf, num_quads * 4, REQUEST_TIMEOUT_MS);
        if (ret < 0)
            return -1;
        return ret / 4;
    }
    
    static int
    dc1394_usb_device_get_config_rom (platform_device_t * device,
                                    uint32_t * quads, int * num_quads)
    {
        libusb_device_handle * handle;
        if (libusb_open (device->dev, &handle) < 0) {
            dc1394_log_warning ("usb: Failed to open device for config ROM");
            return DC1394_FAILURE;
        }
    
        if (*num_quads > 256)
            *num_quads = 256;
    
        /* Read the config ROM one quad at a time because a read longer than
         * the length of the ROM will fail. */
        int i;
        for (i = 0; i < *num_quads; i++) {
            int ret = do_read (handle, CONFIG_ROM_BASE + 0x400 + 4*i,
                    quads + i, 1);
            if (ret < 1)
                break;
        }
    
        if (i == 0) {
            dc1394_log_error ("usb: Failed to read config ROM");
            libusb_close (handle);
            return -1;
        }
    
        *num_quads = i;
        libusb_close (handle);
        return 0;
    }
    
    static platform_camera_t *
    dc1394_usb_camera_new (platform_t * p, platform_device_t * device,
            uint32_t unit_directory_offset)
    {
        libusb_device_handle * handle;
        platform_camera_t * camera;
    
        if (libusb_open (device->dev, &handle) < 0) {
            dc1394_log_error ("usb: Failed to open device");
            return NULL;
        }
    
        if (libusb_set_configuration (handle, 1) < 0) {
            dc1394_log_error ("usb: Failed to set configuration 1 after open");
            libusb_close (handle);
            return NULL;
        }
    
        camera = calloc (1, sizeof (platform_camera_t));
        camera->handle = handle;
        return camera;
    }
    
    static void dc1394_usb_camera_free (platform_camera_t * cam)
    {
        libusb_close (cam->handle);
        cam->handle = NULL;
        free (cam);
    }
    
    static void
    dc1394_usb_camera_set_parent (platform_camera_t * cam, dc1394camera_t * parent)
    {
        cam->camera = parent;
    }
    
    static dc1394error_t
    dc1394_usb_camera_print_info (platform_camera_t * camera, FILE *fd)
    {
        libusb_device *dev = libusb_get_device (camera->handle);
        struct libusb_device_descriptor desc;
        libusb_get_device_descriptor (dev, &desc);
        fprintf(fd,"------ Camera platform-specific information ------\n");
        fprintf(fd,"USB Bus Number                    :     %d\n",
                libusb_get_bus_number (dev));
        fprintf(fd,"USB Device Address                :     %d\n",
                libusb_get_device_address (dev));
        fprintf(fd,"Vendor ID                         :     0x%x\n",
                desc.idVendor);
        fprintf(fd,"Product ID                        :     0x%x\n",
                desc.idProduct);
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_camera_read (platform_camera_t * cam, uint64_t offset,
            uint32_t * quads, int num_quads)
    {
        if (do_read (cam->handle, CONFIG_ROM_BASE + offset, quads,
                    num_quads) != num_quads)
            return DC1394_FAILURE;
    
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_camera_write (platform_camera_t * cam, uint64_t offset,
            const uint32_t * quads, int num_quads)
    {
        if (do_write (cam->handle, CONFIG_ROM_BASE + offset, quads,
                    num_quads) != num_quads)
            return DC1394_FAILURE;
    
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_camera_get_node(platform_camera_t *cam, uint32_t *node,
            uint32_t * generation)
    {
        /* Since node/generation doesn't really apply to USB, we instead
         * put the device address in the "node" argument and "bus number"
         * in the generation argument. */
        if (node)
            *node = libusb_get_device_address (libusb_get_device (cam->handle));
        if (generation)
            *generation = libusb_get_bus_number (libusb_get_device (cam->handle));
        return DC1394_SUCCESS;
    }
    
    static dc1394error_t
    dc1394_usb_reset_bus (platform_camera_t * cam)
    {
        int ret = libusb_reset_device (cam->handle);
        if (ret == 0 || ret == LIBUSB_ERROR_NOT_FOUND)
            return DC1394_SUCCESS;
    
        return DC1394_FAILURE;
    }
    
    static platform_dispatch_t
    usb_dispatch = {
        .platform_new = dc1394_usb_new,
        .platform_free = dc1394_usb_free,
    
        .get_device_list = dc1394_usb_get_device_list,
        .free_device_list = dc1394_usb_free_device_list,
        .device_get_config_rom = dc1394_usb_device_get_config_rom,
    
        .camera_new = dc1394_usb_camera_new,
        .camera_free = dc1394_usb_camera_free,
        .camera_set_parent = dc1394_usb_camera_set_parent,
    
        .camera_print_info = dc1394_usb_camera_print_info,
        .camera_get_node = dc1394_usb_camera_get_node,
        .reset_bus = dc1394_usb_reset_bus,
    
        .camera_read = dc1394_usb_camera_read,
        .camera_write = dc1394_usb_camera_write,
    
        .capture_setup = dc1394_usb_capture_setup,
        .capture_stop = dc1394_usb_capture_stop,
        .capture_dequeue = dc1394_usb_capture_dequeue,
        .capture_enqueue = dc1394_usb_capture_enqueue,
        .capture_get_fileno = dc1394_usb_capture_get_fileno,
        .capture_is_frame_corrupt = dc1394_usb_capture_is_frame_corrupt,
    
    #ifdef HAVE_MACOSX
        .capture_set_callback = dc1394_usb_capture_set_callback,
        .capture_schedule_with_runloop = dc1394_usb_capture_schedule_with_runloop,
    #else
        .capture_set_callback = NULL,
        .capture_schedule_with_runloop = NULL,
    #endif
    };
    
    void
    dc1394_usb_init(dc1394_t * d)
    {
        register_platform (d, &usb_dispatch, "usb");
    }