camlib.h

Go to the documentation of this file.

 
// Main header file for Camlib
// Copyright 2022 by Daniel C (https://github.com/petabyt/camlib)
#ifndef PTP_LIB_H
#define PTP_LIB_H
 
#include <stdio.h>
#include <stdint.h>
#include <pthread.h>
 
#include "ptp.h"
 
// Max timeout for command read/writes
#define PTP_TIMEOUT 1000
 
// How much ms to wait for r->wait_for_response
#define CAMLIB_WAIT_MS 1000
 
// Conforms to POSIX 2001, some compilers may not have it
#ifndef CAMLIB_SLEEP
    #include <unistd.h>
    //int usleep(unsigned int usec);
    #define CAMLIB_SLEEP(ms) usleep(ms * 1000)
#endif
 
// Logging+panic mechanism, define it yourself or link in log.c
void ptp_verbose_log(char *fmt, ...);
__attribute__ ((noreturn)) void ptp_panic(char *fmt, ...);
 
// 1mb default buffer size
#define CAMLIB_DEFAULT_SIZE 1000000
 
enum PtpGeneralError {
    PTP_OK = 0,
    PTP_NO_DEVICE = -1,
    PTP_NO_PERM = -2,
    PTP_OPEN_FAIL = -3,
    PTP_OUT_OF_MEM = -4,
    PTP_IO_ERR = -5,
    PTP_RUNTIME_ERR = -6,
    PTP_UNSUPPORTED = -7,
    PTP_CHECK_CODE = -8,
    PTP_CANCELED = -9,
};
 
const char *ptp_perror(int rc);
 
enum PtpLiveViewType {
    PTP_LV_NONE = 0,
    PTP_LV_EOS = 1,
    PTP_LV_CANON = 2,
    PTP_LV_ML = 3, // ptplv v1
    PTP_LV_EOS_ML_BMP = 4, // ptplv v2
};
 
enum PtpVendors {
    PTP_DEV_EMPTY = 0,
    PTP_DEV_EOS = 1,
    PTP_DEV_CANON = 2,
    PTP_DEV_NIKON = 3,
    PTP_DEV_SONY = 4,
    PTP_DEV_FUJI = 5,
    PTP_DEV_PANASONIC = 6,
};
 
// Wrapper types for vendor specific capture modes
enum ImageFormats {
    IMG_FORMAT_ETC = 0,
    IMG_FORMAT_RAW = 1,
    IMG_FORMAT_STD = 2,
    IMG_FORMAT_HIGH = 3,
    IMG_FORMAT_RAW_JPEG = 4,
};
 
enum PtpConnType {
    PTP_IP = (1 << 0),
    PTP_IP_USB = (1 << 1), // TCP-based, but using USB-style packets (Fujifilm)
    PTP_USB = (1 << 2),
};
 
struct PtpPropAvail {
    void *next;
    void *prev;
    int code;
    int memb_size;
    int memb_cnt;
    void *data;
};
 
struct PtpRuntime {
    uint8_t io_kill_switch;
 
    uint8_t connection_type;
 
    int transaction;
    int session;
 
    uint8_t *data;
    int data_length;
 
    int max_packet_size;
 
    struct PtpDeviceInfo *di;
    int device_type;
 
    int data_phase_length;
 
    void *comm_backend;
 
    void *userdata;
 
    pthread_mutex_t *mutex;
 
    uint8_t wait_for_response;
 
    uint8_t response_wait_default;
 
    struct PtpPropAvail *avail;
};
 
struct PtpGenericEvent {
    uint16_t code;
    const char *name;
    int value;
    const char *str_value;
};
 
struct PtpCommand {
    uint16_t code;
    uint32_t params[5];
    int param_length;
    int data_length;
};
 
struct PtpArray {
    uint32_t length;
    uint32_t data[];
};
 
int ptp_get_return_code(struct PtpRuntime *r);
 
int ptp_get_param_length(struct PtpRuntime *r);
 
uint32_t ptp_get_param(struct PtpRuntime *r, int i);
 
int ptp_get_last_transaction_id(struct PtpRuntime *r);
 
uint8_t *ptp_get_payload(struct PtpRuntime *r);
 
int ptp_get_payload_length(struct PtpRuntime *r);
 
struct PtpRuntime *ptp_new(int options);
 
void ptp_reset(struct PtpRuntime *r);
 
void ptp_init(struct PtpRuntime *r);
 
void ptp_close(struct PtpRuntime *r);
 
int ptp_send(struct PtpRuntime *r, struct PtpCommand *cmd);
 
int ptp_send_data(struct PtpRuntime *r, struct PtpCommand *cmd, void *data, int length);
 
int ptp_get_event(struct PtpRuntime *r, struct PtpEventContainer *ec);
 
void ptp_mutex_unlock(struct PtpRuntime *r);
 
void ptp_mutex_keep_locked(struct PtpRuntime *r);
 
void ptp_mutex_lock(struct PtpRuntime *r);
 
int ptp_device_type(struct PtpRuntime *r);
 
int ptp_check_opcode(struct PtpRuntime *r, int opcode);
 
int ptp_check_prop(struct PtpRuntime *r, int code);
 
int ptp_buffer_resize(struct PtpRuntime *r, size_t size);
 
int ptp_write_unicode_string(char *dat, char *string);
int ptp_read_unicode_string(char *buffer, char *dat, int max);
int ptp_read_utf8_string(void *dat, char *string, int max);
int ptp_read_string(uint8_t *dat, char *string, int max);
int ptp_write_string(uint8_t *dat, char *string);
int ptp_write_utf8_string(void *dat, char *string);
int ptp_read_uint16_array(uint8_t *dat, uint16_t *buf, int max, int *length);
int ptp_read_uint16_array_s(uint8_t *bs, uint8_t *be, uint16_t *buf, int max, int *length);
inline static int ptp_write_u8 (void *buf, uint8_t out) { ((uint8_t *)buf)[0] = out; return 1; }
inline static int ptp_write_u16(void *buf, uint16_t out) { ((uint16_t *)buf)[0] = out; return 2; }
inline static int ptp_write_u32(void *buf, uint32_t out) { ((uint32_t *)buf)[0] = out; return 4; }
inline static int ptp_read_u32 (void *buf, uint32_t *out) { *out = ((uint32_t *)buf)[0]; return 4; }
inline static int ptp_read_u16 (void *buf, uint16_t *out) { *out = ((uint16_t *)buf)[0]; return 2; }
inline static int ptp_read_u8  (void *buf, uint8_t *out) { *out = ((uint8_t *)buf)[0]; return 1; }
 
// Build a new PTP/IP or PTP/USB command packet in r->data
int ptp_new_cmd_packet(struct PtpRuntime *r, struct PtpCommand *cmd);
 
// Only for PTP_USB or PTP_USB_IP use
int ptp_new_data_packet(struct PtpRuntime *r, struct PtpCommand *cmd, void *data, int data_length);
 
// Only use for PTP_IP
int ptpip_data_start_packet(struct PtpRuntime *r, int data_length);
int ptpip_data_end_packet(struct PtpRuntime *r, void *data, int data_length);
 
// Used only by ptp_open_session
void ptp_update_transaction(struct PtpRuntime *r, int t);
 
// Set avail info for prop
void ptp_set_prop_avail_info(struct PtpRuntime *r, int code, int memb_size, int cnt, void *data);
 
void *ptp_dup_payload(struct PtpRuntime *r);
 
// Write r->data to a file called DUMP
int ptp_dump(struct PtpRuntime *r);
 
#define CAMLIB_INCLUDE_IMPL
#include "cl_data.h"
#include "cl_backend.h"
#include "cl_ops.h"
#include "cl_enum.h"
#include "cl_bind.h"
 
// Backwards compatibility (mostly renamed functions)
#ifndef CAMLIB_NO_COMPAT
    #define ptp_get_last_transaction(...) ptp_get_last_transaction_id(__VA_ARGS__)
    #define ptp_generic_new(...) ptp_new(__VA_ARGS__)
    #define ptp_generic_close(...) ptp_close(__VA_ARGS__)
    #define ptp_generic_reset(...) ptp_reset(__VA_ARGS__)
    #define ptp_generic_init(...) ptp_init(__VA_ARGS__)
    #define ptp_generic_send(...) ptp_send(__VA_ARGS__)
    #define ptp_generic_send_data(...) ptp_send_data(__VA_ARGS__)
#endif
 
#endif