libfreenect.h

Go to the documentation of this file.

/*
 * This file is part of the OpenKinect Project. http://www.openkinect.org
 *
 * Copyright (c) 2010 individual OpenKinect contributors. See the CONTRIB file
 * for details.
 *
 * This code is licensed to you under the terms of the Apache License, version
 * 2.0, or, at your option, the terms of the GNU General Public License,
 * version 2.0. See the APACHE20 and GPL2 files for the text of the licenses,
 * or the following URLs:
 * http://www.apache.org/licenses/LICENSE-2.0
 * http://www.gnu.org/licenses/gpl-2.0.txt
 *
 * If you redistribute this file in source form, modified or unmodified, you
 * may:
 *   1) Leave this header intact and distribute it under the same terms,
 *      accompanying it with the APACHE20 and GPL20 files, or
 *   2) Delete the Apache 2.0 clause and accompany it with the GPL2 file, or
 *   3) Delete the GPL v2 clause and accompany it with the APACHE20 file
 * In all cases you must keep the copyright notice intact and include a copy
 * of the CONTRIB file.
 *
 * Binary distributions must follow the binary distribution requirements of
 * either License.
 */

#pragma once

#include <stdint.h>

/* We need struct timeval */
#ifdef _WIN32
#include <winsock.h>
#else
#include <sys/time.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#define FREENECT_COUNTS_PER_G 819 
#define FREENECT_DEPTH_MM_MAX_VALUE 10000
#define FREENECT_DEPTH_MM_NO_VALUE 0
#define FREENECT_DEPTH_RAW_MAX_VALUE 2048
#define FREENECT_DEPTH_RAW_NO_VALUE 2047

typedef enum {
        FREENECT_DEVICE_MOTOR  = 0x01,
        FREENECT_DEVICE_CAMERA = 0x02,
        FREENECT_DEVICE_AUDIO  = 0x04,
} freenect_device_flags;

struct freenect_device_attributes
{
        struct freenect_device_attributes *next; // Next device in the linked list
        const char* camera_serial;               // Serial number of camera or audio subdevice
};

typedef enum {
        FREENECT_RESOLUTION_LOW    = 0, 
        FREENECT_RESOLUTION_MEDIUM = 1, 
        FREENECT_RESOLUTION_HIGH   = 2, 
        FREENECT_RESOLUTION_DUMMY  = 2147483647, 
} freenect_resolution;

typedef enum {
        FREENECT_VIDEO_RGB             = 0, 
        FREENECT_VIDEO_BAYER           = 1, 
        FREENECT_VIDEO_IR_8BIT         = 2, 
        FREENECT_VIDEO_IR_10BIT        = 3, 
        FREENECT_VIDEO_IR_10BIT_PACKED = 4, 
        FREENECT_VIDEO_YUV_RGB         = 5, 
        FREENECT_VIDEO_YUV_RAW         = 6, 
        FREENECT_VIDEO_DUMMY           = 2147483647, 
} freenect_video_format;

typedef enum {
        FREENECT_DEPTH_11BIT        = 0, 
        FREENECT_DEPTH_10BIT        = 1, 
        FREENECT_DEPTH_11BIT_PACKED = 2, 
        FREENECT_DEPTH_10BIT_PACKED = 3, 
        FREENECT_DEPTH_REGISTERED   = 4, 
        FREENECT_DEPTH_MM           = 5, 
        FREENECT_DEPTH_DUMMY        = 2147483647, 
} freenect_depth_format;

typedef enum {
        // values written to the CMOS register
        FREENECT_AUTO_EXPOSURE      = 1 << 14,
        FREENECT_AUTO_WHITE_BALANCE = 1 << 1,
        FREENECT_RAW_COLOR          = 1 << 4,
        // arbitrary bitfields to support flag combination
        FREENECT_MIRROR_DEPTH       = 1 << 16,
        FREENECT_MIRROR_VIDEO       = 1 << 17,
} freenect_flag;

typedef enum {
        FREENECT_OFF = 0,
        FREENECT_ON  = 1,
} freenect_flag_value;

typedef struct {
        uint32_t reserved;              
        freenect_resolution resolution; 
        union {
                int32_t dummy;
                freenect_video_format video_format;
                freenect_depth_format depth_format;
        };                              
        int32_t bytes;                  
        int16_t width;                  
        int16_t height;                 
        int8_t data_bits_per_pixel;     
        int8_t padding_bits_per_pixel;  
        int8_t framerate;               
        int8_t is_valid;                
} freenect_frame_mode;

typedef enum {
        LED_OFF              = 0, 
        LED_GREEN            = 1, 
        LED_RED              = 2, 
        LED_YELLOW           = 3, 
        LED_BLINK_GREEN      = 4, 
        // 5 is same as 4, LED blink Green
        LED_BLINK_RED_YELLOW = 6, 
} freenect_led_options;


typedef enum {
        TILT_STATUS_STOPPED = 0x00, 
        TILT_STATUS_LIMIT   = 0x01, 
        TILT_STATUS_MOVING  = 0x04, 
} freenect_tilt_status_code;

typedef struct {
        int16_t                   accelerometer_x; 
        int16_t                   accelerometer_y; 
        int16_t                   accelerometer_z; 
        int8_t                    tilt_angle;      
        freenect_tilt_status_code tilt_status;     
} freenect_raw_tilt_state;

struct _freenect_context;
typedef struct _freenect_context freenect_context; 
struct _freenect_device;
typedef struct _freenect_device freenect_device; 
// usb backend specific section
typedef void freenect_usb_context; 
//

#ifndef _WIN32
  #define FREENECTAPI 
#else

  #ifdef __cplusplus
    #define FREENECTAPI extern "C" __declspec(dllexport)
  #else
    // this is required when building from a Win32 port of gcc without being
    // forced to compile all of the library files (.c) with g++...
    #define FREENECTAPI __declspec(dllexport)
  #endif
#endif

typedef enum {
        FREENECT_LOG_FATAL = 0,     
        FREENECT_LOG_ERROR,         
        FREENECT_LOG_WARNING,       
        FREENECT_LOG_NOTICE,        
        FREENECT_LOG_INFO,          
        FREENECT_LOG_DEBUG,         
        FREENECT_LOG_SPEW,          
        FREENECT_LOG_FLOOD,         
} freenect_loglevel;

FREENECTAPI int freenect_init(freenect_context **ctx, freenect_usb_context *usb_ctx);

FREENECTAPI int freenect_shutdown(freenect_context *ctx);

typedef void (*freenect_log_cb)(freenect_context *dev, freenect_loglevel level, const char *msg);

FREENECTAPI void freenect_set_log_level(freenect_context *ctx, freenect_loglevel level);

FREENECTAPI void freenect_set_log_callback(freenect_context *ctx, freenect_log_cb cb);

FREENECTAPI int freenect_process_events(freenect_context *ctx);

FREENECTAPI int freenect_process_events_timeout(freenect_context *ctx, struct timeval* timeout);

FREENECTAPI int freenect_num_devices(freenect_context *ctx);

FREENECTAPI int freenect_list_device_attributes(freenect_context *ctx, struct freenect_device_attributes** attribute_list);

FREENECTAPI void freenect_free_device_attributes(struct freenect_device_attributes* attribute_list);

FREENECTAPI int freenect_supported_subdevices(void);

FREENECTAPI void freenect_select_subdevices(freenect_context *ctx, freenect_device_flags subdevs);

FREENECTAPI freenect_device_flags freenect_enabled_subdevices(freenect_context *ctx);

FREENECTAPI int freenect_open_device(freenect_context *ctx, freenect_device **dev, int index);

FREENECTAPI int freenect_open_device_by_camera_serial(freenect_context *ctx, freenect_device **dev, const char* camera_serial);

FREENECTAPI int freenect_close_device(freenect_device *dev);

FREENECTAPI void freenect_set_user(freenect_device *dev, void *user);

FREENECTAPI void *freenect_get_user(freenect_device *dev);

typedef void (*freenect_depth_cb)(freenect_device *dev, void *depth, uint32_t timestamp);
typedef void (*freenect_video_cb)(freenect_device *dev, void *video, uint32_t timestamp);
typedef void (*freenect_chunk_cb)(void *buffer, void *pkt_data, int pkt_num, int datalen, void *user_data);


FREENECTAPI void freenect_set_depth_callback(freenect_device *dev, freenect_depth_cb cb);

FREENECTAPI void freenect_set_video_callback(freenect_device *dev, freenect_video_cb cb);

FREENECTAPI void freenect_set_depth_chunk_callback(freenect_device *dev, freenect_chunk_cb cb);

FREENECTAPI void freenect_set_video_chunk_callback(freenect_device *dev, freenect_chunk_cb cb);

FREENECTAPI int freenect_set_depth_buffer(freenect_device *dev, void *buf);

FREENECTAPI int freenect_set_video_buffer(freenect_device *dev, void *buf);

FREENECTAPI int freenect_start_depth(freenect_device *dev);

FREENECTAPI int freenect_start_video(freenect_device *dev);

FREENECTAPI int freenect_stop_depth(freenect_device *dev);

FREENECTAPI int freenect_stop_video(freenect_device *dev);

FREENECTAPI int freenect_update_tilt_state(freenect_device *dev);

FREENECTAPI freenect_raw_tilt_state* freenect_get_tilt_state(freenect_device *dev);

FREENECTAPI double freenect_get_tilt_degs(freenect_raw_tilt_state *state);

FREENECTAPI int freenect_set_tilt_degs(freenect_device *dev, double angle);

FREENECTAPI freenect_tilt_status_code freenect_get_tilt_status(freenect_raw_tilt_state *state);

FREENECTAPI int freenect_set_led(freenect_device *dev, freenect_led_options option);

FREENECTAPI void freenect_get_mks_accel(freenect_raw_tilt_state *state, double* x, double* y, double* z);

FREENECTAPI int freenect_get_video_mode_count();

FREENECTAPI freenect_frame_mode freenect_get_video_mode(int mode_num);

FREENECTAPI freenect_frame_mode freenect_get_current_video_mode(freenect_device *dev);

FREENECTAPI freenect_frame_mode freenect_find_video_mode(freenect_resolution res, freenect_video_format fmt);

FREENECTAPI int freenect_set_video_mode(freenect_device* dev, freenect_frame_mode mode);

FREENECTAPI int freenect_get_depth_mode_count();

FREENECTAPI freenect_frame_mode freenect_get_depth_mode(int mode_num);

FREENECTAPI freenect_frame_mode freenect_get_current_depth_mode(freenect_device *dev);

FREENECTAPI freenect_frame_mode freenect_find_depth_mode(freenect_resolution res, freenect_depth_format fmt);

FREENECTAPI int freenect_set_depth_mode(freenect_device* dev, const freenect_frame_mode mode);

FREENECTAPI int freenect_set_flag(freenect_device *dev, freenect_flag flag, freenect_flag_value value);


FREENECTAPI void freenect_set_fw_address_nui(freenect_context * ctx, unsigned char * fw_ptr, unsigned int num_bytes);

FREENECTAPI void freenect_set_fw_address_k4w(freenect_context * ctx, unsigned char * fw_ptr, unsigned int num_bytes);


#ifdef __cplusplus
}
#endif