ra8_usb_haud.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "ra8_err.h"
#include "ra8_usb.h"
 
/* =============================================================================
 * Constants
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_haud_pipe_iso_in  = 1U, 
  k_ra8_haud_pipe_iso_out = 2U, 
} ra8_usb_haud_pipe_t;

typedef enum : uint8_t {
  k_ra8_haud_class_audio             = 0x01U, 
  k_ra8_haud_subclass_undefined      = 0x00U, 
  k_ra8_haud_subclass_audiocontrol   = 0x01U, 
  k_ra8_haud_subclass_audiostreaming = 0x02U, 
  k_ra8_haud_subclass_midistreaming  = 0x03U, 
} ra8_usb_haud_class_t;

typedef enum : uint8_t {
  k_ra8_haud_cs_desc_undefined = 0x20U, 
  k_ra8_haud_cs_desc_device    = 0x21U, 
  k_ra8_haud_cs_desc_config    = 0x22U, 
  k_ra8_haud_cs_desc_string    = 0x23U, 
  k_ra8_haud_cs_desc_interface = 0x24U, 
  k_ra8_haud_cs_desc_endpoint  = 0x25U, 
} ra8_usb_haud_cs_desc_t;

typedef enum : uint8_t {
  k_ra8_haud_ac_header          = 0x01U, 
  k_ra8_haud_ac_input_terminal  = 0x02U, 
  k_ra8_haud_ac_output_terminal = 0x03U, 
  k_ra8_haud_ac_mixer_unit      = 0x04U, 
  k_ra8_haud_ac_selector_unit   = 0x05U, 
  k_ra8_haud_ac_feature_unit    = 0x06U, 
  k_ra8_haud_ac_processing_unit = 0x07U, 
  k_ra8_haud_ac_extension_unit  = 0x08U, 
} ra8_usb_haud_ac_subtype_t;

typedef enum : uint8_t {
  k_ra8_haud_as_general         = 0x01U, 
  k_ra8_haud_as_format_type     = 0x02U, 
  k_ra8_haud_as_format_specific = 0x03U, 
} ra8_usb_haud_as_subtype_t;

typedef enum : uint8_t {
  k_ra8_haud_format_type_undefined = 0x00U, 
  k_ra8_haud_format_type_i         = 0x01U, 
  k_ra8_haud_format_type_ii        = 0x02U, 
  k_ra8_haud_format_type_iii       = 0x03U, 
} ra8_usb_haud_format_type_t;

typedef enum : uint8_t {
  k_ra8_haud_req_undefined = 0x00U, 
  k_ra8_haud_req_set_cur   = 0x01U, 
  k_ra8_haud_req_get_cur   = 0x81U, 
  k_ra8_haud_req_set_min   = 0x02U, 
  k_ra8_haud_req_get_min   = 0x82U, 
  k_ra8_haud_req_set_max   = 0x03U, 
  k_ra8_haud_req_get_max   = 0x83U, 
  k_ra8_haud_req_set_res   = 0x04U, 
  k_ra8_haud_req_get_res   = 0x84U, 
} ra8_usb_haud_request_t;

typedef enum : uint8_t {
  k_ra8_haud_fu_control_undefined  = 0x00U, 
  k_ra8_haud_fu_control_mute       = 0x01U, 
  k_ra8_haud_fu_control_volume     = 0x02U, 
  k_ra8_haud_fu_control_bass       = 0x03U, 
  k_ra8_haud_fu_control_mid        = 0x04U, 
  k_ra8_haud_fu_control_treble     = 0x05U, 
  k_ra8_haud_fu_control_graphic_eq = 0x06U, 
  k_ra8_haud_fu_control_auto_gain  = 0x07U, 
  k_ra8_haud_fu_control_delay      = 0x08U, 
  k_ra8_haud_fu_control_bass_boost = 0x09U, 
  k_ra8_haud_fu_control_loudness   = 0x0AU, 
} ra8_usb_haud_fu_control_t;

typedef enum : uint8_t {
  k_ra8_haud_ep_control_undefined     = 0x00U, 
  k_ra8_haud_ep_control_sampling_freq = 0x01U, 
  k_ra8_haud_ep_control_pitch         = 0x02U, 
} ra8_usb_haud_ep_control_t;

typedef enum : int32_t {
  k_ra8_haud_volume_silence = (int32_t)0x8000, 
  k_ra8_haud_volume_min_db  = (int32_t)-32768, 
  k_ra8_haud_volume_max_db  = (int32_t)32767,  
} ra8_usb_haud_volume_t;

typedef enum : uint16_t {
  k_ra8_haud_iso_max_packet_default = 192U,  
  k_ra8_haud_iso_max_packet_fs      = 1023U, 
  k_ra8_haud_iso_max_packet_hs      = 1024U, 
} ra8_usb_haud_packet_t;

typedef enum : uint32_t {
  k_ra8_haud_default_sample_rate_hz = 48000U, 
  k_ra8_haud_default_channels       = 2U,     
  k_ra8_haud_default_bits           = 16U,    
} ra8_usb_haud_default_t;

typedef enum : uint32_t {
  k_ra8_haud_min_channels       = 1U,      
  k_ra8_haud_max_channels       = 8U,      
  k_ra8_haud_min_bits           = 8U,      
  k_ra8_haud_max_bits           = 32U,     
  k_ra8_haud_min_sample_rate_hz = 8000U,   
  k_ra8_haud_max_sample_rate_hz = 192000U, 
} ra8_usb_haud_format_limit_t;

typedef struct {
  uint8_t  device_address;     
  uint8_t  ac_interface;       
  uint8_t  as_interface;       
  uint8_t  feature_unit_id;    
  uint8_t  iso_in_ep;          
  uint8_t  iso_out_ep;         
  uint8_t  channel_count;      
  uint8_t  bits_per_sample;    
  uint16_t iso_in_max_packet;  
  uint16_t iso_out_max_packet; 
  uint16_t vendor_id;          
  uint16_t product_id;         
  uint32_t sample_rate_min_hz; 
  uint32_t sample_rate_max_hz; 
} ra8_usb_haud_device_t;

typedef void (*ra8_usb_haud_attach_fn_t)(void* ctx, const ra8_usb_haud_device_t* device);
 
/* =============================================================================
 * Lifecycle
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_usb_haud_init(ra8_usb_speed_t speed);

[[nodiscard]] ra8_err_t ra8_usb_haud_close(void);
 
/* =============================================================================
 * Attach callback
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_usb_haud_attach_callback(ra8_usb_haud_attach_fn_t on_attach, void* ctx);
 
/* =============================================================================
 * Class control transfers
 * =============================================================================
 */

[[nodiscard]] ra8_err_t
ra8_usb_haud_set_format(uint8_t channel_count, uint8_t bits_per_sample, uint32_t sample_rate_hz);

[[nodiscard]] ra8_err_t ra8_usb_haud_set_volume(uint8_t channel, int16_t volume);

[[nodiscard]] ra8_err_t ra8_usb_haud_set_mute(uint8_t channel, bool mute);
 
/* =============================================================================
 * Isochronous data transfer
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_usb_haud_send_samples(const uint8_t* buf, uint16_t len_bytes);

[[nodiscard]] ra8_err_t
ra8_usb_haud_recv_samples(uint8_t* buf, uint16_t max_len_bytes, uint16_t* got_len_bytes);
 
/* =============================================================================
 * Test / introspection helpers
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_usb_haud_step(void);
 
#ifdef __cplusplus
}
#endif