types.h

Go to the documentation of this file.

/*
    Copyright (C) 2001-2013

    Developers:

    Paul Davis
    Jack O'Quin
    Steve Harris
    Rui Nuno Capela
    Devin Anderson
    Kai Vehmanen
    Ian Esten
    Dmitry Baikov
    Torben Hohn
    Rohan Drape
    Stephane Letz
    Christian Schoenebeck

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

    You are permitted to statically link against a binary version of
    the JACK library obtained from

        http://jackaudio.org/downloads/JackiOS-SDK.zip

    and distribute the resulting application without complying with section 6
    (requiring recipients of your application to be able to relink against
    modified versions of libjack).

    This permission is granted if and ONLY if the resulting application binary
    issue is intended for execution in any one of the following environments:

        * Apple Inc. iOS

    Additional environments may be added to this list in the future.
    All other terms of the LGPL continue to apply.

*/

#ifndef __jack_types_h__
#define __jack_types_h__

#include <jack/systemdeps.h>

typedef int32_t jack_shmsize_t;

typedef uint32_t        jack_nframes_t;

#define JACK_MAX_FRAMES (4294967295U)   /* This should be UINT32_MAX, but C++ has a problem with that. */

typedef uint64_t jack_time_t;

#define JACK_LOAD_INIT_LIMIT 1024

typedef uint64_t jack_intclient_t;

typedef struct _jack_port jack_port_t;

typedef struct _jack_client jack_client_t;

typedef uint32_t jack_port_id_t;

typedef uint32_t jack_port_type_id_t;

enum JackOptions {

    JackNullOption = 0x00,

    JackNoStartServer = 0x01,

    JackUseExactName = 0x02,

    JackServerName = 0x04,

    JackLoadName = 0x08,

    JackLoadInit = 0x10,

    JackSessionID = 0x20,
    
    JackNoBackground = 0x40
};

#define JackOpenOptions (JackSessionID | JackServerName | JackNoStartServer | JackUseExactName | JackNoBackground)

#define JackLoadOptions (JackLoadInit | JackLoadName | JackUseExactName)

typedef enum JackOptions jack_options_t;

enum JackStatus {

    JackFailure = 0x01,

    JackInvalidOption = 0x02,

    JackNameNotUnique = 0x04,

    JackServerStarted = 0x08,

    JackServerFailed = 0x10,

    JackServerError = 0x20,

    JackNoSuchClient = 0x40,

    JackLoadFailure = 0x80,

    JackInitFailure = 0x100,

    JackShmFailure = 0x200,

    JackVersionError = 0x400,

    JackBackendError = 0x800,

    JackClientZombie = 0x1000,
    
    JackBackgroundFailure = 0x2000,
    
    JackClientKilled = 0x4000
};

typedef enum JackStatus jack_status_t;

enum JackLatencyCallbackMode {

     JackCaptureLatency,

     JackPlaybackLatency

};

typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;


enum JackCustomChange {
    
    JackCustomRemoved,
  
    JackCustomAdded,
    
    JackCustomReplaced
    
};

typedef enum JackCustomChange jack_custom_change_t;

typedef enum JackRegisterFlags {
    JackRegisterDefaults,

    JackRegisterPrompt,

} jack_register_flags_t;

typedef void (*JackLatencyCallback)(jack_latency_callback_mode_t mode, void *arg);

PRE_PACKED_STRUCTURE
struct _jack_latency_range
{
    jack_nframes_t min;
    jack_nframes_t max;
} POST_PACKED_STRUCTURE;

typedef struct _jack_latency_range jack_latency_range_t;

typedef int (*JackProcessCallback)(jack_nframes_t nframes, void *arg);

typedef void *(*JackThreadCallback)(void* arg);

typedef void (*JackThreadInitCallback)(void *arg);

typedef int (*JackGraphOrderCallback)(void *arg);

typedef int (*JackXRunCallback)(void *arg);

typedef int (*JackBufferSizeCallback)(jack_nframes_t nframes, void *arg);

typedef int (*JackSampleRateCallback)(jack_nframes_t nframes, void *arg);

typedef void (*JackPortRegistrationCallback)(jack_port_id_t port, int register, void *arg);

typedef void (*JackClientRegistrationCallback)(const char* name, int register, void *arg);

typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);

typedef int (*JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void *arg);

typedef void (*JackFreewheelCallback)(int starting, void *arg);

typedef void (*JackShutdownCallback)(void *arg);

typedef void (*JackInfoShutdownCallback)(jack_status_t code, const char* reason, void *arg);

#define JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"

#define JACK_DEFAULT_MIDI_TYPE "8 bit raw midi"

typedef float jack_default_audio_sample_t;

enum JackPortFlags {

    JackPortIsInput = 0x1,

    JackPortIsOutput = 0x2,

    JackPortIsPhysical = 0x4,

    JackPortCanMonitor = 0x8,

    JackPortIsTerminal = 0x10,

};

typedef enum {

    /* the order matters for binary compatibility */
    JackTransportStopped = 0,       
    JackTransportRolling = 1,       
    JackTransportLooping = 2,       
    JackTransportStarting = 3,      
    JackTransportNetStarting = 4,       
} jack_transport_state_t;

typedef uint64_t jack_unique_t;         
typedef enum {

    JackPositionBBT = 0x10,     
    JackPositionTimecode = 0x20,        
    JackBBTFrameOffset =      0x40,     
    JackAudioVideoRatio =     0x80, 
    JackVideoFrameOffset =   0x100  
} jack_position_bits_t;

#define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode)
#define EXTENDED_TIME_INFO

PRE_PACKED_STRUCTURE
struct _jack_position {

    /* these four cannot be set from clients: the server sets them */
    jack_unique_t       unique_1;       
    jack_time_t         usecs;          
    jack_nframes_t      frame_rate;     
    jack_nframes_t      frame;          
    jack_position_bits_t valid;         
    /* JackPositionBBT fields: */
    int32_t             bar;            
    int32_t             beat;           
    int32_t             tick;           
    double              bar_start_tick;

    float               beats_per_bar;  
    float               beat_type;      
    double              ticks_per_beat;
    double              beats_per_minute;

    /* JackPositionTimecode fields:     (EXPERIMENTAL: could change) */
    double              frame_time;     
    double              next_time;      
    /* JackBBTFrameOffset fields: */
    jack_nframes_t      bbt_offset;     
    /* JACK video positional data (experimental) */

    float               audio_frames_per_video_frame; 
    jack_nframes_t      video_offset;   
    /* For binary compatibility, new fields should be allocated from
     * this padding area with new valid bits controlling access, so
     * the existing structure size and offsets are preserved. */
    int32_t             padding[7];

    /* When (unique_1 == unique_2) the contents are consistent. */
    jack_unique_t       unique_2;       
} POST_PACKED_STRUCTURE;

typedef struct _jack_position jack_position_t;

typedef int (*JackSyncCallback)(jack_transport_state_t state,
                                jack_position_t *pos,
                                void *arg);


typedef void (*JackTimebaseCallback)(jack_transport_state_t state,
                                     jack_nframes_t nframes,
                                     jack_position_t *pos,
                                     int new_pos,
                                     void *arg);

/*********************************************************************
    * The following interfaces are DEPRECATED.  They are only provided
    * for compatibility with the earlier JACK transport implementation.
    *********************************************************************/

typedef enum {

    JackTransportState = 0x1,   
    JackTransportPosition = 0x2,        
    JackTransportLoop = 0x4,    
    JackTransportSMPTE = 0x8,   
    JackTransportBBT = 0x10     
} jack_transport_bits_t;

typedef struct {

    /* these two cannot be set from clients: the server sets them */

    jack_nframes_t frame_rate;          
    jack_time_t usecs;          
    jack_transport_bits_t valid;        
    jack_transport_state_t transport_state;
    jack_nframes_t frame;
    jack_nframes_t loop_start;
    jack_nframes_t loop_end;

    long smpte_offset;  
    float smpte_frame_rate;     
    int bar;
    int beat;
    int tick;
    double bar_start_tick;

    float beats_per_bar;
    float beat_type;
    double ticks_per_beat;
    double beats_per_minute;

} jack_transport_info_t;


#endif /* __jack_types_h__ */