ltc.h

Go to the documentation of this file.

 
#ifndef LTC_H
#define LTC_H 1
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined _WIN32 && !defined(__LITTLE_ENDIAN__)
#define __LITTLE_ENDIAN__
#endif
 
#ifdef __BIG_ENDIAN__
# define LTC_BIG_ENDIAN
#elif defined _BIG_ENDIAN
# define LTC_BIG_ENDIAN
#elif defined __BYTE_ORDER__
# if __BYTE_ORDER__ ==  __ORDER_BIG_ENDIAN__
#  define LTC_BIG_ENDIAN
# endif
#elif !defined __LITTLE_ENDIAN__
# include <endian.h> // machine/endian.h
# if (defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__ && __BYTE_ORDER__ ==  __ORDER_BIG_ENDIAN__)
#  define LTC_BIG_ENDIAN
# endif
#endif
 
#if defined(__GNUC__) && __GNUC__ >= 4
# define DEPRECATED_EXPORT __attribute__((__deprecated__))
#else
# define DEPRECATED_EXPORT
#endif
 
#include <stddef.h> /* size_t */
 
#ifndef DOXYGEN_IGNORE
/* libltc version */
#define LIBLTC_VERSION "1.3.2"
#define LIBLTC_VERSION_MAJOR  1
#define LIBLTC_VERSION_MINOR  3
#define LIBLTC_VERSION_MICRO  2
 
/* interface revision number
 * http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
 */
#define LIBLTC_CUR 13
#define LIBLTC_REV  0
#define LIBLTC_AGE  2
#endif /* end DOXYGEN_IGNORE */
 
typedef unsigned char ltcsnd_sample_t;
 
typedef long long int ltc_off_t;
 
#define LTC_FRAME_BIT_COUNT     80
 
#if (defined LTC_BIG_ENDIAN && !defined DOXYGEN_IGNORE)
// Big Endian version, bytes are "upside down"
struct LTCFrame {
        unsigned int user1:4;
        unsigned int frame_units:4;
 
        unsigned int user2:4;
        unsigned int col_frame:1;
        unsigned int dfbit:1;
        unsigned int frame_tens:2;
 
        unsigned int user3:4;
        unsigned int secs_units:4;
 
        unsigned int user4:4;
        unsigned int biphase_mark_phase_correction:1;
        unsigned int secs_tens:3;
 
        unsigned int user5:4;
        unsigned int mins_units:4;
 
        unsigned int user6:4;
        unsigned int binary_group_flag_bit0:1;
        unsigned int mins_tens:3;
 
        unsigned int user7:4;
        unsigned int hours_units:4;
 
        unsigned int user8:4;
        unsigned int binary_group_flag_bit2:1;
        unsigned int binary_group_flag_bit1:1;
        unsigned int hours_tens:2;
 
        unsigned int sync_word:16;
};
#else
/* Little Endian version -- and doxygen doc */
struct LTCFrame {
        unsigned int frame_units:4; 
        unsigned int user1:4;
 
        unsigned int frame_tens:2; 
        unsigned int dfbit:1; 
        unsigned int col_frame:1; 
        unsigned int user2:4;
 
        unsigned int secs_units:4; 
        unsigned int user3:4;
 
        unsigned int secs_tens:3; 
        unsigned int biphase_mark_phase_correction:1; 
        unsigned int user4:4;
 
        unsigned int mins_units:4; 
        unsigned int user5:4;
 
        unsigned int mins_tens:3; 
        unsigned int binary_group_flag_bit0:1; 
        unsigned int user6:4;
 
        unsigned int hours_units:4; 
        unsigned int user7:4;
 
        unsigned int hours_tens:2; 
        unsigned int binary_group_flag_bit1:1; 
        unsigned int binary_group_flag_bit2:1; 
        unsigned int user8:4;
 
        unsigned int sync_word:16;
};
#endif
 
enum LTC_TV_STANDARD {
        LTC_TV_525_60, 
        LTC_TV_625_50, 
        LTC_TV_1125_60,
        LTC_TV_FILM_24 
};
 
enum LTC_BG_FLAGS {
        LTC_USE_DATE  = 1, 
        LTC_TC_CLOCK  = 2,
        LTC_BGF_DONT_TOUCH = 4, 
        LTC_NO_PARITY = 8 
};
 
typedef struct LTCFrame LTCFrame;
 
struct LTCFrameExt {
        LTCFrame ltc; 
        ltc_off_t off_start; 
        ltc_off_t off_end; 
        int reverse; 
        float biphase_tics[LTC_FRAME_BIT_COUNT]; 
        ltcsnd_sample_t sample_min; 
        ltcsnd_sample_t sample_max; 
        double volume; 
};
 
typedef struct LTCFrameExt LTCFrameExt;
 
struct SMPTETimecode {
        char timezone[6];   
        unsigned char years; 
        unsigned char months; 
        unsigned char days; 
 
        unsigned char hours; 
        unsigned char mins; 
        unsigned char secs; 
        unsigned char frame; 
};
 
typedef struct SMPTETimecode SMPTETimecode;
 
 
typedef struct LTCDecoder LTCDecoder;
 
typedef struct LTCEncoder LTCEncoder;
 
void ltc_frame_to_time(SMPTETimecode* stime, LTCFrame* frame, int flags);
 
void ltc_time_to_frame(LTCFrame* frame, SMPTETimecode* stime, enum LTC_TV_STANDARD standard, int flags);
 
void ltc_frame_reset(LTCFrame* frame);
 
int ltc_frame_increment(LTCFrame* frame, int fps, enum LTC_TV_STANDARD standard, int flags);
 
int ltc_frame_decrement(LTCFrame* frame, int fps, enum LTC_TV_STANDARD standard, int flags);
 
LTCDecoder * ltc_decoder_create(int apv, int queue_size);
 
 
int ltc_decoder_free(LTCDecoder *d);
 
void ltc_decoder_write(LTCDecoder *d,
                ltcsnd_sample_t *buf, size_t size,
                ltc_off_t posinfo);
 
void ltc_decoder_write_double(LTCDecoder *d, double *buf, size_t size, ltc_off_t posinfo);
 
void ltc_decoder_write_float(LTCDecoder *d, float *buf, size_t size, ltc_off_t posinfo);
 
void ltc_decoder_write_s16(LTCDecoder *d, short *buf, size_t size, ltc_off_t posinfo);
 
void ltc_decoder_write_u16(LTCDecoder *d, unsigned short *buf, size_t size, ltc_off_t posinfo);
 
int ltc_decoder_read(LTCDecoder *d, LTCFrameExt *frame);
 
void ltc_decoder_queue_flush(LTCDecoder* d);
 
int ltc_decoder_queue_length(LTCDecoder* d);
 
 
 
LTCEncoder* ltc_encoder_create(double sample_rate, double fps, enum LTC_TV_STANDARD standard, int flags);
 
void ltc_encoder_free(LTCEncoder *e);
 
void ltc_encoder_set_timecode(LTCEncoder *e, SMPTETimecode *t);
 
void ltc_encoder_get_timecode(LTCEncoder *e, SMPTETimecode *t);
 
void ltc_encoder_set_user_bits(LTCEncoder *e, unsigned long data);
 
unsigned long ltc_frame_get_user_bits(LTCFrame *f);
 
int ltc_encoder_inc_timecode(LTCEncoder *e);
 
int ltc_encoder_dec_timecode(LTCEncoder *e);
 
void ltc_encoder_set_frame(LTCEncoder *e, LTCFrame *f);
 
void ltc_encoder_get_frame(LTCEncoder *e, LTCFrame *f);
 
int ltc_encoder_get_buffer(LTCEncoder *e, ltcsnd_sample_t *buf) DEPRECATED_EXPORT;
 
int ltc_encoder_copy_buffer(LTCEncoder *e, ltcsnd_sample_t *buf);
 
ltcsnd_sample_t *ltc_encoder_get_bufptr(LTCEncoder *e, int *size, int flush) DEPRECATED_EXPORT;
 
int ltc_encoder_get_bufferptr(LTCEncoder *e, ltcsnd_sample_t **buf, int flush);
 
void ltc_encoder_buffer_flush(LTCEncoder *e);
 
size_t ltc_encoder_get_buffersize(LTCEncoder *e);
 
int ltc_encoder_reinit(LTCEncoder *e, double sample_rate, double fps, enum LTC_TV_STANDARD standard, int flags);
 
void ltc_encoder_reset(LTCEncoder *e);
 
int ltc_encoder_set_bufsize(LTCEncoder *e, double sample_rate, double fps) DEPRECATED_EXPORT;
 
int ltc_encoder_set_buffersize(LTCEncoder *e, double sample_rate, double fps);
 
double ltc_encoder_get_volume(LTCEncoder *e);
 
int ltc_encoder_set_volume(LTCEncoder *e, double dBFS);
 
double ltc_encoder_get_filter(LTCEncoder *e);
 
void ltc_encoder_set_filter(LTCEncoder *e, double rise_time);
 
int ltc_encoder_encode_byte(LTCEncoder *e, int byte, double speed);
 
int ltc_encoder_end_encode(LTCEncoder *e);
 
void ltc_encoder_encode_frame(LTCEncoder *e);
 
void ltc_encoder_encode_reversed_frame(LTCEncoder *e);
 
void ltc_frame_set_parity(LTCFrame *frame, enum LTC_TV_STANDARD standard);
 
int ltc_frame_parse_bcg_flags(LTCFrame *frame, enum LTC_TV_STANDARD standard);
 
ltc_off_t ltc_frame_alignment(double samples_per_frame, enum LTC_TV_STANDARD standard);
 
#ifdef __cplusplus
}
#endif
 
#endif