libpict.h

Go to the documentation of this file.

// Copyright 2022 by Daniel C (https://github.com/petabyt/libpict)
#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
 
// Units of time in ms to sleep for r->wait_for_response
#define PTP_WAIT_MS 1000
 
// Conforms to POSIX 2001, some compilers may not have it
#ifndef PTP_SLEEP
    #include <unistd.h>
    //int usleep(unsigned int usec);
    #define PTP_SLEEP(ms) usleep((unsigned int)(ms) * 1000)
#endif
 
#ifdef WIN32
#define PUB __declspec(dllexport)
#else
#define PUB
#endif
 
// 1mb default buffer size
#define PTP_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,
    PTP_COMMAND_IGNORED = -10,
};

const char *ptp_perror(int rc);

enum PtpVendors {
    PTP_DEV_EMPTY = 0,
    PTP_DEV_EOS = 1, // EOS DSLR/Mirrorless systems
    PTP_DEV_CANON = 2, // Older powershot cameras
    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),
    PTP_BLE = (1 << 3), // I can only dream...
};

struct PtpPropAvail {
    void *next;
    void *prev;
    int code;
    unsigned int memb_size;
    unsigned int memb_cnt;
    void *data;
};

struct PtpRuntime {
    uint8_t io_kill_switch;

    uint8_t operation_kill_switch;

    uint8_t connection_type;

    int transaction;
    int session;

    uint8_t *data;
    unsigned int data_length;
    unsigned int data_filled_length;

    unsigned int max_packet_size;

    struct PtpDeviceInfo *di;

    unsigned int data_phase_length;

    struct PtpCommPriv *comm_priv;

    void *comm_backend;

    void (*report_read_progress)(struct PtpRuntime *r, unsigned int size);

    int (*set_extra_socket_settings)(struct PtpRuntime *r, int sockfd);

    void *userdata;

    struct PtpUserPriv *priv;

    pthread_mutex_t *mutex;

    uint8_t wait_for_response;

    uint8_t response_wait_default;

    struct PtpPropAvail *avail;

    FILE *comm_dump;
};
 
// Logging+panic mechanism, define it yourself or link in log.c
PUB void ptp_verbose_log(struct PtpRuntime *r, char *fmt, ...);
PUB void ptp_error_log(struct PtpRuntime *r, char *fmt, ...);
PUB __attribute__ ((noreturn)) void ptp_panic(char *fmt, ...);

struct PtpGenericEvent {
    uint16_t code;
    const char *name;
    int value;
    const char *str_value;
};

struct PtpEventReader {
    unsigned int data_of;
    unsigned int n_entries;
    unsigned int index;
    void *ptr;
};

struct PtpCommand {
    uint16_t code;
    uint32_t params[5];
    unsigned int param_length;
};

struct PtpArray {
    uint32_t length;
    uint32_t data[];
};

PUB int ptp_get_return_code(struct PtpRuntime *r);

PUB unsigned int ptp_get_param_length(struct PtpRuntime *r);

PUB uint32_t ptp_get_param(struct PtpRuntime *r, int i);

PUB int ptp_get_last_transaction_id(struct PtpRuntime *r);

PUB uint8_t *ptp_get_payload(struct PtpRuntime *r);

PUB unsigned int ptp_get_payload_length(struct PtpRuntime *r);

PUB struct PtpRuntime *ptp_new(int options);

PUB void ptp_reset(struct PtpRuntime *r);

PUB void ptp_init(struct PtpRuntime *r);

PUB void ptp_close(struct PtpRuntime *r);

PUB int ptp_send(struct PtpRuntime *r, struct PtpCommand *cmd);

PUB int ptp_send_data(struct PtpRuntime *r, const struct PtpCommand *cmd, const void *data, unsigned int length);

PUB int ptp_get_event(struct PtpRuntime *r, struct PtpEventContainer *ec);

PUB void ptp_mutex_unlock(struct PtpRuntime *r);

PUB void ptp_mutex_unlock_thread(struct PtpRuntime *r);

PUB void ptp_mutex_lock(struct PtpRuntime *r);

PUB int ptp_device_type(struct PtpRuntime *r);

PUB int ptp_check_opcode(struct PtpRuntime *r, int opcode);

PUB int ptp_check_prop(struct PtpRuntime *r, int code);

PUB int ptp_buffer_resize(struct PtpRuntime *r, size_t size);
 
// Data structure functions
PUB int ptp_write_unicode_string(char *dat, const char *string);
PUB int ptp_read_unicode_string(char *buffer, const char *dat, int max);
PUB int ptp_read_utf8_string(void *dat, char *string, int max);
PUB int ptp_read_string(uint8_t *dat, char *string, int max);
PUB int ptp_write_string(uint8_t *dat, const char *string);
PUB int ptp_write_utf8_string(void *dat, const char *string);
PUB int ptp_read_uint16_array(const uint8_t *dat, uint16_t *buf, int max, int *length);
PUB 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) {
    uint8_t *b = (uint8_t *)buf;
    b[0] = out & 0xFF;
    b[1] = (out >> 8) & 0xFF;
    return 2;
}
inline static int ptp_write_u32(void *buf, uint32_t out) {
    uint8_t *b = (uint8_t *)buf;
    b[0] = out & 0xFF;
    b[1] = (out >> 8) & 0xFF;
    b[2] = (out >> 16) & 0xFF;
    b[3] = (out >> 24) & 0xFF;
    return 4;
}
inline static int ptp_read_u8(const void *buf, uint8_t *out) {
    const uint8_t *b = (const uint8_t *)buf;
    *out = b[0];
    return 1;
}
inline static int ptp_read_u16(const void *buf, uint16_t *out) {
    const uint8_t *b = (const uint8_t *)buf;
    *out = (uint16_t)b[0] | ((uint16_t)b[1] << 8);
    return 2;
}
inline static int ptp_read_u32(const void *buf, uint32_t *out) {
    const uint8_t *b = (const uint8_t *)buf;
    *out = (uint32_t)b[0] | ((uint32_t)b[1] << 8) | ((uint32_t)b[2] << 16) | ((uint32_t)b[3] << 24);
    return 4;
}
inline static int ptp_read_u64(const void *buf, uint64_t *out) {
    uint32_t lo, hi;
    ptp_read_u32(buf, &lo);
    ptp_read_u32((const uint8_t *)buf + 4, &hi);
    *out = ((uint64_t)hi << 32) | lo;
    return 8;
}
 
// Build a new PTP/IP or PTP/USB command packet in r->data
unsigned int ptp_new_cmd_packet(struct PtpRuntime *r, const struct PtpCommand *cmd);
 
// Only for PTP_USB or PTP_USB_IP use
int ptpusb_new_data_packet(struct PtpRuntime *r, const struct PtpCommand *cmd, const void *data, unsigned int data_length);
 
// Only use for PTP_IP
unsigned int ptpip_data_start_packet(struct PtpRuntime *r, unsigned int data_length);
unsigned int ptpip_data_end_packet(struct PtpRuntime *r, const void *data, unsigned int data_length);
 
// Set avail info for prop
void ptp_set_prop_avail_info(struct PtpRuntime *r, int code, unsigned int memb_size, unsigned int cnt, void *data);

int ptp_dump(struct PtpRuntime *r);

int ptp_run_lua(const char *filename);
 
#include "cl_data.h"
#include "cl_backend.h"
#include "cl_ops.h"
#include "cl_enum.h"
#include "cl_bind.h"
 
#undef PUB // avoid conflict
 
#endif