自学教程：C++ C_PARAMS函数代码示例

/** * /brief Retrieve the camera abilities of entry with supplied index number. * * /param list a CameraAbilitiesList * /param index index * /param abilities pointer to CameraAbilities for returned data. * /return a gphoto2 error code * * Retrieves the camera abilities of entry with supplied * index number. Typically, you would call gp_camera_set_abilities() * afterwards in order to prepare the initialization of a camera. */intgp_abilities_list_get_abilities (CameraAbilitiesList *list, int index,				 CameraAbilities *abilities){	C_PARAMS (list && abilities);	C_PARAMS (0 <= index && index < list->count);	memcpy (abilities, &list->abilities[index], sizeof (CameraAbilities));	return (GP_OK);}

/** * /brief Count the entries in the supplied list. * /param list a #CameraAbilitiesList * /returns The number of entries or a gphoto2 error code */intgp_abilities_list_count (CameraAbilitiesList *list){	C_PARAMS (list);	return (list->count);}

/** * /brief Check for interrupt without wait * /param port a GPPort * /param data a pointer to an allocated buffer * /param size the number of bytes that should be read * * Reads a specified number of bytes from the inerrupt endpoint * into the supplied buffer. * Function waits 50 miliseconds for data on interrupt endpoint. * * /return a gphoto2 error code **/intgp_port_check_int_fast (GPPort *port, char *data, int size){        int retval;        gp_log (GP_LOG_DATA, __func__, "Reading %i = 0x%x bytes from interrupt endpoint...", size, size);	C_PARAMS (port);	CHECK_INIT (port);	/* Check if we read as many bytes as expected */	CHECK_SUPP (port, "check_int", port->pc->ops->check_int);	retval = port->pc->ops->check_int (port, data, size, FAST_TIMEOUT);	CHECK_RESULT (retval);#ifdef IGNORE_EMPTY_INTR_READS	/* For Canon cameras, we will make lots of	   reads that will return zero length. Don't	   bother to log them as errors. */	if (retval != 0 )#endif		LOG_DATA (data, retval, size, "Read   ", "from interrupt endpoint (fast):");	return (retval);}

/**  * Retrieve the current speed. * * @param camera a #Camera * @return The current speed or a gphoto2 error code * */intgp_camera_get_port_speed (Camera *camera){	C_PARAMS (camera);	return (camera->pc->speed);}

/** * Set the camera speed. * * @param camera a #Camera * @param speed the speed * @return a gphoto2 error code * * This function is typically used prior first initialization  * using #gp_camera_init for debugging purposes. Normally, a camera driver * will try to figure out the current speed of the camera and set the speed * to the optimal one automatically. Note that this function only works with  * serial ports. In other words, you have to set the camera's port to a  * serial one (using #gp_camera_set_port_path or #gp_camera_set_port_name) * prior calling this function. * */intgp_camera_set_port_speed (Camera *camera, int speed){	GPPortSettings settings;	C_PARAMS (camera);	C_PARAMS_MSG (camera->port,		      "You need to set a port prior trying to set the speed");	C_PARAMS_MSG (camera->port->type == GP_PORT_SERIAL,		      "You can specify a speed only with serial ports");	/*	 * If the camera is currently initialized, terminate that connection.	 * We don't care if we are successful or not.	 */	if (camera->pc->lh)		gp_camera_exit (camera, NULL);	CR (camera, gp_port_get_settings (camera->port, &settings), NULL);	settings.serial.speed = speed;	CR (camera, gp_port_set_settings (camera->port, settings), NULL);	camera->pc->speed = speed;	return (GP_OK);}

static intgp_libusb1_clear_halt_lib(GPPort *port, int ep){	unsigned char internal_ep;	C_PARAMS (port && port->pl->dh);	switch (ep) {	case GP_PORT_USB_ENDPOINT_IN :		internal_ep = port->settings.usb.inep;		break;	case GP_PORT_USB_ENDPOINT_OUT :		internal_ep = port->settings.usb.outep;		break;	case GP_PORT_USB_ENDPOINT_INT :		internal_ep = port->settings.usb.intep;		break;	default:		gp_port_set_error (port, "bad EndPoint argument 0x%x", ep);		return GP_ERROR_BAD_PARAMETERS;	}	C_LIBUSB (libusb_clear_halt(port->pl->dh, internal_ep), GP_ERROR_IO_USB_CLEAR_HALT);	return GP_OK;}

static intgp_libusb1_check_int (GPPort *port, char *bytes, int size, int timeout){	int 		ret;	struct timeval	tv;	C_PARAMS (port && port->pl->dh && timeout >= 0);	if (port->pl->nrofirqs)		goto handleirq;	tv.tv_sec = timeout/1000;	tv.tv_usec = (timeout%1000)*1000;	ret = LOG_ON_LIBUSB_E (libusb_handle_events_timeout(port->pl->ctx, &tv));	if (port->pl->nrofirqs)		goto handleirq;	if (ret < LIBUSB_SUCCESS)		return translate_libusb_error(ret, GP_ERROR_IO_READ);	return GP_ERROR_TIMEOUT;handleirq:	if (size > port->pl->irqlens[0])		size = port->pl->irqlens[0];	memcpy(bytes, port->pl->irqs[0], size);	memmove(port->pl->irqs,port->pl->irqs+1,sizeof(port->pl->irqs[0])*(port->pl->nrofirqs-1));	memmove(port->pl->irqlens,port->pl->irqlens+1,sizeof(port->pl->irqlens[0])*(port->pl->nrofirqs-1));	port->pl->nrofirqs--;        return size;}

/** * Allocates the memory for a #Camera. * * @param camera the #Camera object to initialize. * @return a gphoto2 error code * */intgp_camera_new (Camera **camera){	int result;	C_PARAMS (camera);        C_MEM (*camera = calloc (1, sizeof (Camera)));        (*camera)->functions = calloc (1, sizeof (CameraFunctions));        (*camera)->pc        = calloc (1, sizeof (CameraPrivateCore));	if (!(*camera)->functions || !(*camera)->pc) {		result = GP_ERROR_NO_MEMORY;		goto error;	}        (*camera)->pc->ref_count = 1;	/* Create the filesystem */	result = gp_filesystem_new (&(*camera)->fs);	if (result < GP_OK)		goto error;	/* Create the port */	result = gp_port_new (&(*camera)->port);	if (result < GP_OK)		goto error;        return(GP_OK);error:	gp_camera_free (*camera);	return result;}

/** * @param camera a #Camera * @param timeout number of seconds that should pass between each call to * 	     /c func * @param func the function that should be called each /c timeout seconds * @return The id of the background process or a gphoto2 error code * * This function should be called by the camera driver during camera_init() * if the camera needs to be sent messages periodically in order to prevent * it from shutting down. * */intgp_camera_start_timeout (Camera *camera, unsigned int timeout,			 CameraTimeoutFunc func){	int id;	C_PARAMS (camera && camera->pc);	if (!camera->pc->timeout_start_func)		return (GP_ERROR_NOT_SUPPORTED);	/*	 * We remember the id here in order to automatically remove	 * the timeout on gp_camera_exit.	 */	C_MEM (camera->pc->timeout_ids =			realloc (camera->pc->timeout_ids, sizeof (int) *					(camera->pc->timeout_ids_len + 1)));	id = camera->pc->timeout_start_func (camera, timeout, func,					     camera->pc->timeout_data);	if (id < 0)		return (id);	camera->pc->timeout_ids[camera->pc->timeout_ids_len] = id;	camera->pc->timeout_ids_len++;	return (id);}

/** * Reads a file partially from the #Camera. * * @param camera a #Camera * @param folder a folder * @param file the name of a file * @param type the #CameraFileType * @param offset the offset into the camera file * @param data the buffer receiving the data * @param size the size to be read and that was read * @param context a #GPContext * @return a gphoto2 error code * **/intgp_camera_file_read (Camera *camera, const char *folder, const char *file,		    CameraFileType type,		    uint64_t offset, char *buf, uint64_t *size,		    GPContext *context){	GP_LOG_D ("Getting file '%s' in folder '%s'...", file, folder);	C_PARAMS (camera && folder && file && buf && size);	CHECK_INIT (camera, context);	/* Did we get reasonable foldername/filename? */	if (strlen (folder) == 0) {		CAMERA_UNUSED (camera, context);		return (GP_ERROR_DIRECTORY_NOT_FOUND);	}	if (strlen (file) == 0) {		CAMERA_UNUSED (camera, context);		return (GP_ERROR_FILE_NOT_FOUND);	}  	CHECK_RESULT_OPEN_CLOSE (camera, gp_filesystem_read_file (camera->fs,			folder, file, type, offset, buf, size, context), context);	CAMERA_UNUSED (camera, context);	return (GP_OK);}

/** * Captures a preview that won't be stored on the camera but returned in  * supplied file.  * * @param camera a #Camera * @param file a #CameraFile * @param context a #GPContext * @return a gphoto2 error code * * For example, you could use gp_capture_preview() for taking some sample * pictures before calling gp_capture(). * **/intgp_camera_capture_preview (Camera *camera, CameraFile *file, GPContext *context){	char *xname;	C_PARAMS (camera && file);	CHECK_INIT (camera, context);	CR (camera, gp_file_clean (file), context);	if (!camera->functions->capture_preview) {		gp_context_error (context, _("This camera can "			"not capture previews."));		CAMERA_UNUSED (camera, context);                return (GP_ERROR_NOT_SUPPORTED);	}	CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->capture_preview (					camera, file, context), context);	gp_file_get_name_by_type (file, "capture_preview", GP_FILE_TYPE_NORMAL, &xname);	/* FIXME: Marcus ... will go away, just keep compatible now. */	gp_file_set_name (file, xname);	free (xname);	CAMERA_UNUSED (camera, context);	return (GP_OK);}

static intgp_port_vusb_clear_halt_lib(GPPort *port, int ep){        unsigned char internal_ep;	gp_log(GP_LOG_DEBUG,__FUNCTION__,"()");        C_PARAMS (port && port->pl);        switch (ep) {        case GP_PORT_USB_ENDPOINT_IN :                internal_ep = port->settings.usb.inep;                break;        case GP_PORT_USB_ENDPOINT_OUT :                internal_ep = port->settings.usb.outep;                break;        case GP_PORT_USB_ENDPOINT_INT :                internal_ep = port->settings.usb.intep;                break;        default:                gp_port_set_error (port, "Bad EndPoint argument 0x%x", ep);                return GP_ERROR_BAD_PARAMETERS;        }	gp_log(GP_LOG_DEBUG,"gp_port_vusb_clear_halt_lib","clearing halt on ep 0x%x", internal_ep);	/* now clear halt */        return GP_OK;}

static intgp_abilities_list_sort (CameraAbilitiesList *list){	C_PARAMS (list);	qsort (list->abilities, list->count, sizeof(CameraAbilities), cmp_abilities);	return (GP_OK);}

static intgp_port_vusb_check_int (GPPort *port, char *bytes, int size, int timeout){	gp_log(GP_LOG_DEBUG,__FUNCTION__,"()");        C_PARAMS (port && port->pl && timeout >= 0);	return port->pl->vcamera->readint(port->pl->vcamera, (unsigned char*)bytes, size, timeout);}

static intgp_port_vusb_reset(GPPort *port){	gp_log(GP_LOG_DEBUG,__FUNCTION__,"()");        C_PARAMS (port && port->pl);        return GP_OK;}

static intgp_port_vusb_write (GPPort *port, const char *bytes, int size){	gp_log(GP_LOG_DEBUG,__FUNCTION__,"()");	C_PARAMS (port && port->pl && port->pl->vcamera);	return port->pl->vcamera->write(port->pl->vcamera, 0x02, (unsigned char*)bytes, size);}

/** * /brief Retreives information about the port. * * Retrieves the informations set by gp_port_set_info(). * * /param port a GPPort * /param info GPPortInfo * /return a gphoto2 error code **/intgp_port_get_info (GPPort *port, GPPortInfo *info){	C_PARAMS (port && info);	*info = &port->pc->info;	return (GP_OK);}

static intgp_port_usbscsi_find_device(GPPort *port, int idvendor, int idproduct){    unsigned short vendor_id, product_id;    const char *sg;    C_PARAMS (port);    sg = strrchr (port->settings.usbscsi.path, '/');    C_PARAMS (sg);    sg++;    CHECK (gp_port_usbscsi_get_usb_id (sg, &vendor_id, &product_id))    if (vendor_id != idvendor || product_id != idproduct)        return GP_ERROR_IO_USB_FIND;    return GP_OK;}

/** * Retrieve the /c abilities of the /c camera.  * * @param camera a #Camera * @param abilities * @return a gphoto2 error code * */intgp_camera_get_abilities (Camera *camera, CameraAbilities *abilities){	C_PARAMS (camera && abilities);	memcpy (abilities, &camera->pc->a, sizeof (CameraAbilities));	return (GP_OK);}

intgp_camera_get_port_info (Camera *camera, GPPortInfo *info){	C_PARAMS (camera && info);	CR (camera, gp_port_get_info (camera->port, info), NULL);	return (GP_OK);}

/** * /brief Get the current port settings. * /param port a #GPPort * /param settings pointer to the retrieved settings * * Retreives the current settings of a port. * * /return a gphoto2 error code **/intgp_port_get_settings (GPPort *port, GPPortSettings *settings){	C_PARAMS (port);        memcpy (settings, &(port->settings), sizeof (gp_port_settings));        return GP_OK;}

/** * Increment the reference count of a /c camera. * * @param camera a #Camera * @return a gphoto2 error code * */intgp_camera_ref (Camera *camera){	C_PARAMS (camera);	camera->pc->ref_count += 1;	return (GP_OK);}

static intgp_port_usbscsi_update (GPPort *port){    C_PARAMS (port);    memcpy (&port->settings, &port->settings_pending,            sizeof (port->settings));    return GP_OK;}

static intgp_port_usbscsi_exit (GPPort *port){    C_PARAMS (port);    free (port->pl);    port->pl = NULL;    return GP_OK;}

static intgp_port_usbdiskdirect_find_device(GPPort *port, int idvendor, int idproduct){	unsigned short vendor_id, product_id;	const char *disk;	C_PARAMS (port);	disk = strrchr (port->settings.usbdiskdirect.path, '/');	C_PARAMS (disk);	disk++;	CHECK (gp_port_usbdiskdirect_get_usb_id (disk,						 &vendor_id, &product_id))	if (vendor_id != idvendor || product_id != idproduct)		return GP_ERROR_IO_USB_FIND;	return GP_OK;}

/** * /brief Get the current port timeout. * /param port a #GPPort * /param timeout pointer to timeout * * Retreives the current timeout of the port. * * /return a gphoto2 error code **/intgp_port_get_timeout (GPPort *port, int *timeout){	C_PARAMS (port);	GP_LOG_D ("Current port timeout is %i milliseconds.", port->timeout);        *timeout = port->timeout;        return GP_OK;}

/** * /brief Set timeout of port  * /param port a #GPPort * /param timeout the timeout * * Sets the timeout of a port. #gp_port_read will wait timeout milliseconds * for data. If no data will be received in that period, %GP_ERROR_TIMEOUT * will be returned. * * /return a gphoto2 error code **/intgp_port_set_timeout (GPPort *port, int timeout){	C_PARAMS (port);        GP_LOG_D ("Setting port timeout to %i milliseconds.", timeout);        port->timeout = timeout;        return GP_OK;}

/** * /brief Find USB device by interface class * * /param port a GPPort * /param mainclass the USB interface class * /param subclass the USB interface subclass * /param protocol the USB interface protocol * * Find the USB device with the specified vendor:product id pair. * * /return a gphoto2 error code */intgp_port_usb_find_device_by_class (GPPort *port, int mainclass, int subclass, int protocol){	C_PARAMS (port);	CHECK_INIT (port);	CHECK_SUPP (port, "find_device_by_class", port->pc->ops->find_device_by_class);	CHECK_RESULT (port->pc->ops->find_device_by_class (port, mainclass, subclass, protocol));        return (GP_OK);}

/** * /brief Find USB device by vendor/product * * /param port a GPPort * /param idvendor USB vendor id * /param idproduct USB product id * * Find the USB device with the specified vendor:product id pair. * * /return a gphoto2 error code */intgp_port_usb_find_device (GPPort *port, int idvendor, int idproduct){	C_PARAMS (port);	CHECK_INIT (port);	CHECK_SUPP (port, "find_device", port->pc->ops->find_device);	CHECK_RESULT (port->pc->ops->find_device (port, idvendor, idproduct));        return (GP_OK);}

static intgp_port_exit (GPPort *port){	C_PARAMS (port);	CHECK_INIT (port);	if (port->pc->ops->exit)		CHECK_RESULT (port->pc->ops->exit (port));	return (GP_OK);}