Confronta il testo

Trova la differenza tra due file di testo

Visualizzazione

Layout

Editor liveNascondi spazi bianchiComprimi invariateSenza a capo

Livello di dettaglio

Sintassi

Elaborazione

Diffchecker Desktop Il modo più sicuro per usare Diffchecker. Ottieni l'app Diffchecker Desktop: i tuoi diff non lasciano mai il tuo computer!Ottieni Desktop

Untitled diff

Creato 12 anni faIl diff non scade mai

1 rimozione

Linee
Totale
Rimosso

Caratteri
Totale
Rimosso

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

401 linee

3 aggiunte

Linee
Totale
Aggiunto

Caratteri
Totale
Aggiunto

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

403 linee

// 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 *

Diff salvati

Testo originale

Apri 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");
    }

Testo modificato

Apri 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");
    }