git.sesse.net Git - casparcg/blob - BluefishSDK_V5_8_0_31/Inc/BluefishApi.h

   1 // The following ifdef block is the standard way of creating macros which make exporting \r
   2 // from a DLL simpler. All files within this DLL are compiled with the BLUEC_API_EXPORTS\r
   3 // symbol defined on the command line. this symbol should not be defined on any project\r
   4 // that uses this DLL. This way any other project whose source files include this file see \r
   5 // BLUEC_API_API functions as being imported from a DLL, whereas this DLL sees symbols\r
   6 // defined with this macro as being exported.\r
   7 #ifdef BLUEFISH_EXPORTS\r
   8 #define BLUEFISH_API __declspec(dllexport)\r
   9 #else\r
  10 #define BLUEFISH_API __declspec(dllimport)\r
  11 #endif\r
  12 #include "BlueDriver_p.h"\r
  13 \r
  14 \r
  15 #define IGNORE_SYNC_WAIT_TIMEOUT_VALUE  (0xFFFFFFFF)\r
  16 typedef void * BLUEFISHAPI_HANDLE;\r
  17 typedef int BErr;\r
  18 \r
  19 extern "C" {\r
  20 \r
  21 \r
  22 struct bluefishapi_card_feature\r
  23 {\r
  24         BLUE_UINT32 card_id;\r
  25         BLUE_UINT32 video_output_channel;\r
  26         BLUE_UINT32 sdi_output_connector;\r
  27         BLUE_UINT32 output_analog_connector;\r
  28         BLUE_UINT32 no_video_input_channel;\r
  29         BLUE_UINT32 no_sdi_input_connector;\r
  30         BLUE_UINT32 input_analog_connector;\r
  31         BLUE_UINT32 digital_audio_output_connector;\r
  32         BLUE_UINT32 digital_audio_input_connector;\r
  33         BLUE_UINT32 analog_audio_output_connector;\r
  34         BLUE_UINT32 analog_audio_input_connector;\r
  35         BLUE_UINT32 pad[128];\r
  36 };\r
  37 \r
  38 BLUEFISH_API unsigned int bluefishapi_device_count();\r
  39 BLUEFISH_API void * bluefishapi_attach(int device_id,unsigned int *card_type);\r
  40 BLUEFISH_API BErr bluefishapi_detach(void ** device_handle);\r
  41 \r
  42 /**\r
  43  * These function can be used set/get various card property\r
  44  * Also the is_prop_supported function can be used to check if the particular property is \r
  45  * supported on that card or not.\r
  46  * This includes the video property and the video connection/routing property.\r
  47  */\r
  48 BLUEFISH_API BErr bluefishapi_set_card_property(BLUEFISHAPI_HANDLE  device_handle,unsigned int video_channel,int card_prop,void *value);\r
  49 BLUEFISH_API BErr bluefishapi_get_card_property(BLUEFISHAPI_HANDLE  device_handle,unsigned int video_channel,int card_prop,void *value);\r
  50 BLUEFISH_API bool bluefishapi_is_prop_supported(BLUEFISHAPI_HANDLE  device_handle,unsigned int video_channel,int card_prop,int *no_parameters,int *parameter_type);\r
  51 /*\r
  52 BLUEFISH_API BErr       bluefishapi_get_connector_property(BLUEFISHAPI_HANDLE device_handle,\r
  53                                                                                                 BLUE_UINT32 VideoChannel,\r
  54                                                                                                 BLUE_UINT32 *settingsCount,     // In: element count of settings array\r
  55                                                                                                                                 // Out: if settings is non-NULL, number of valid elements\r
  56                                                                                                                                 // Out: if settings is NULL, number of elements required\r
  57                                                                                                 EBlueConnectorPropertySetting *settings // Caller allocates/frees memory\r
  58                                                                                                 );\r
  59 \r
  60 BLUEFISH_API BErr       bluefishapi_set_connector_property(\r
  61                                                                                                 BLUEFISHAPI_HANDLE device_handle,\r
  62                                                                                                 BLUE_UINT32 settingsCount,\r
  63                                                                                                 EBlueConnectorPropertySetting *settings\r
  64                                                                                                 );\r
  65 */\r
  66 /**\r
  67  * These function can be used to transfer frames in and out of the \r
  68  * card using the DMA engine on the card.\r
  69  *\r
  70  * These functions are already there in BlueVelvet4.h , wanted to check if you are ok with this interface.\r
  71  * In BlueVelvet4.h instead of BLUE_DEVICE_HANDLE being passed as first parameter it is passing a pointer to\r
  72  * CBlueVelvet4.\r
  73  *\r
  74  */\r
  75 BLUEFISH_API BErr bluefishapi_dma_ex(   BLUEFISHAPI_HANDLE  device_handle,\r
  76                                                                                 BLUE_UINT32 dma_direction,\r
  77                                                                                 struct blue_dma_request_struct  *user_dma_request_ptr);\r
  78 \r
  79 BLUEFISH_API BErr bluefishapi_dma_async(        BLUEFISHAPI_HANDLE  device_handle,\r
  80                                                                                         BLUE_UINT32 dma_direction,\r
  81                                                                                         LPOVERLAPPED overlap_ptr,\r
  82                                                                                         struct blue_dma_request_struct  *user_dma_request_ptr);\r
  83 \r
  84 BErr bluefishapi_dma(   BLUEFISHAPI_HANDLE  device_handle,\r
  85                                                 BLUE_UINT32 dma_direction,\r
  86                                                 void * pFrameBuffer,\r
  87                                                 BLUE_UINT32 video_channel,\r
  88                                                 BLUE_UINT32 FrameSize,\r
  89                                                 BLUE_UINT32 BufferId,\r
  90                                                 BLUE_UINT32 BufferDataType,\r
  91                                                 BLUE_UINT32 FrameType,\r
  92                                                 BLUE_UINT32 CardFrameOffset);\r
  93 \r
  94 \r
  95 /**\r
  96  * wait for sync functions\r
  97  * \r
  98  * These functions are already there in BlueVelvet4.h , wanted to check if you are ok with this interface.\r
  99  * In BlueVelvet4.h instead of BLUE_DEVICE_HANDLE being passed as first parameter it is passing a pointer to\r
 100  * CBlueVelvet4.\r
 101  *\r
 102  * The rational for these function is it will help us pass more information with these function \r
 103  * in the future. The blue_video_sync_struct has a member called pad which can be used to add more member variables \r
 104  * with out changing the signature .\r
 105  */ \r
 106 \r
 107 \r
 108 BLUEFISH_API BErr bluefishapi_wait_video_sync_ex(BLUEFISHAPI_HANDLE device_handle,blue_video_sync_struct * sync_struct);\r
 109 \r
 110 BLUEFISH_API BErr bluefishapi_wait_video_sync_async(BLUEFISHAPI_HANDLE device_handle,\r
 111                                                                                                         LPOVERLAPPED overlap_ptr,\r
 112                                                                                                         blue_video_sync_struct * sync_struct);\r
 113 \r
 114 BLUEFISH_API BErr bluefishapi_wait_video_sync(          BLUEFISHAPI_HANDLE device_handle,\r
 115                                                                                                         BLUE_UINT32 video_channel,\r
 116                                                                                                         BLUE_UINT32 upd_type,\r
 117                                                                                                         BLUE_UINT32 *field_count);\r
 118 \r
 119 BLUEFISH_API BErr bluefishapi_complete_async_req(BLUEFISHAPI_HANDLE device_handle,LPOVERLAPPED overlap_ptr);\r
 120 \r
 121 \r
 122 /**\r
 123  * video fifo functions\r
 124  *\r
 125  * These are a one to one mapping of the C++ functions\r
 126  *\r
 127  */\r
 128 BLUEFISH_API BErr bluefishapi_set_video_engine(BLUEFISHAPI_HANDLE device_handle,\r
 129                                                                         BLUE_UINT32 video_channel,\r
 130                                                                         BLUE_UINT32 *video_engine ,\r
 131                                                                         BLUE_UINT32 has_playthru,\r
 132                                                                         BLUE_UINT32 playthru_video_channel);\r
 133 \r
 134 BLUEFISH_API BErr bluefishapi_get_free_playback_frame(void * device_handle,BLUE_UINT32  video_channel,BLUE_INT32 *BufferId,BLUE_UINT32 * Underrun);\r
 135 BLUEFISH_API BErr bluefishapi_present_playback_frame(   void * device_handle,\r
 136                                                                                         BLUE_UINT32  video_channel,\r
 137                                                                                         BLUE_UINT32 video_repeat_count,\r
 138                                                                                         BLUE_UINT32 video_frame_flag,\r
 139                                                                                         BLUE_INT32  BufferId,\r
 140                                                                                         BLUE_UINT32 FrameType,\r
 141                                                                                         BLUE_UINT32 * unique_id);\r
 142 \r
 143 \r
 144 BLUEFISH_API BErr       bluefishapi_video_playback_start(       BLUEFISHAPI_HANDLE device_handle,\r
 145                                                                                                                 int video_channel,              \r
 146                                                                                                                 int             Step,\r
 147                                                                                                                 int             Loop) ;\r
 148 \r
 149 BLUEFISH_API BErr       bluefishapi_video_playback_stop(        BLUEFISHAPI_HANDLE device_handle,\r
 150                                                                                         int video_channel,              \r
 151                                                                                         int             Wait,\r
 152                                                                                         int             Flush) ;\r
 153 \r
 154 BLUEFISH_API BErr video_capture_harvest(        BLUEFISHAPI_HANDLE device_handle,\r
 155                                                                                         int video_channel,\r
 156                                                                                         int     * BufferId,\r
 157                                                                                         unsigned int *  Count,\r
 158                                                                                         unsigned int*   Frames);\r
 159 \r
 160 BLUEFISH_API BErr       video_capture_start(    BLUEFISHAPI_HANDLE device_handle,\r
 161                                                                                         int video_channel);\r
 162 \r
 163 BLUEFISH_API BErr bluefishapi_get_capture_video_frame(  void * device_handle,\r
 164                                                                                         BLUE_UINT32  video_channel,\r
 165                                                                                         blue_videoframe_info_ex * frame_info,\r
 166                                                                                         BLUE_UINT32 *dropped_frame_count,\r
 167                                                                                         BLUE_UINT32 *current_fifo_size,\r
 168                                                                                         BLUE_UINT32 flag);\r
 169 \r
 170 BLUEFISH_API BErr       video_capture_stop(             BLUEFISHAPI_HANDLE device_handle,int video_channel);\r
 171 BLUEFISH_API BErr video_playback_flush( BLUEFISHAPI_HANDLE device_handle,int video_channel);\r
 172 \r
 173 \r
 174 /*audio capture*/\r
 175 BLUEFISH_API BErr       bluefishapi_start_audio_capture(BLUEFISHAPI_HANDLE device_handle,\r
 176                                                                                                         BLUE_UINT32  video_channel,\r
 177                                                                                                         BLUE_UINT32 sync_start_count);\r
 178 \r
 179 BLUEFISH_API BErr       bluefishapi_stop_audio_capture(BLUEFISHAPI_HANDLE device_handle,BLUE_UINT32  video_channel);\r
 180 \r
 181 BLUEFISH_API BErr       bluefishapi_wait_audio_input_interrupt(BLUEFISHAPI_HANDLE device_handle,\r
 182                                                                                                                    BLUE_UINT32 video_channel,\r
 183                                                                                                                    BLUE_UINT32 * queued_sample_count,\r
 184                                                                                                                    BLUE_UINT32 * free_sample_space);\r
 185 \r
 186 BLUEFISH_API BErr       bluefishapi_read_audio_sample(  BLUEFISHAPI_HANDLE device_handle,\r
 187                                                                                                         BLUE_UINT32 video_channel,\r
 188                                                                                                         void * pBuffer,\r
 189                                                                                                         BLUE_UINT32 read_sample_count,\r
 190                                                                                                         BLUE_UINT32 audio_channel_select_mask,\r
 191                                                                                                         BLUE_UINT32 audio_sample_flags);\r
 192 \r
 193 /*audio playback*/\r
 194 BLUEFISH_API BErr       bluefishapi_wait_audio_output_interrupt(BLUEFISHAPI_HANDLE device_handle,\r
 195                                                                                                                         BLUE_UINT32 video_channel,\r
 196                                                                                                                         BLUE_UINT32 * queued_sample_count,\r
 197                                                                                                                         BLUE_UINT32 * free_sample_space);\r
 198 \r
 199 BLUEFISH_API BErr   bluefishapi_open_playback_engine(BLUEFISHAPI_HANDLE device_handle);\r
 200 BLUEFISH_API BErr       bluefishapi_write_audio_sample( BLUEFISHAPI_HANDLE device_handle,\r
 201                                                                                                         BLUE_UINT32 video_channel,\r
 202                                                                                                         void * pBuffer,\r
 203                                                                                                         BLUE_UINT32 write_sample_count,\r
 204                                                                                                         BLUE_UINT32 audio_channel_select_mask,\r
 205                                                                                                         BLUE_UINT32 audio_sample_flags);\r
 206 \r
 207 BLUEFISH_API BErr   bluefishapi_close_playback_engine(BLUEFISHAPI_HANDLE device_handle);\r
 208 BLUEFISH_API BErr bluefishapi_start_audio_playback(     BLUEFISHAPI_HANDLE device_handle,int syncCount);\r
 209 BLUEFISH_API BErr bluefishapi_stop_audio_playback(      BLUEFISHAPI_HANDLE device_handle);\r
 210 \r
 211 BLUEFISH_API BErr bluefishapi_get_hancoutput_buffer(void * device_handle,UINT32 video_channel);\r
 212 BLUEFISH_API BErr bluefishapi_put_hancoutput_buffer(void * device_handle,int hanc_buffer_id,UINT32 video_channel);\r
 213 BLUEFISH_API BErr bluefishapi_hancoutput_fifo_control(void * device_handle,\r
 214                                                   UINT32 video_channel,\r
 215                                                   UINT32 control);\r
 216 BLUEFISH_API BErr blue_control_pciconfig_space(\r
 217                                                                                         void * device_handle,\r
 218                                                                                         BLUE_UINT32 configspace_offset,\r
 219                                                                                         BLUE_UINT32 * configspace_value,\r
 220                                                                                         BLUE_UINT32 bReadFlag);\r
 221 BLUEFISH_API BErr bluefishapi_control_pcicontrol_reg(\r
 222                                                                                         void * device_handle,\r
 223                                                                                         BLUE_UINT32 bar_id,\r
 224                                                                                         BLUE_UINT32 controlreg_offset,\r
 225                                                                                         BLUE_UINT32 * controlreg_value,\r
 226                                                                                         BLUE_UINT32 bReadFlag);\r
 227 }