BluetoothA2DPSink.h

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
 
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Copyright 2020 Phil Schatzmann
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
 
#pragma once
 
#include "BluetoothA2DPCommon.h"
#include "freertos/ringbuf.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define APP_SIG_WORK_DISPATCH (0x01)
 
#ifndef BT_AV_TAG
#define BT_AV_TAG               "BT_AV"
#endif
 
/* @brief event for handler "bt_av_hdl_stack_up */
enum {
    BT_APP_EVT_STACK_UP = 0,
};
 
extern "C" void ccall_app_a2d_callback(esp_a2d_cb_event_t event, esp_a2d_cb_param_t *param);
extern "C" void ccall_app_rc_ct_callback(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t *param);
extern "C" void ccall_app_gap_callback(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param);
extern "C" void ccall_app_task_handler(void *arg);
extern "C" void ccall_i2s_task_handler(void *arg);
extern "C" void ccall_audio_data_callback(const uint8_t *data, uint32_t len);
extern "C" void ccall_av_hdl_stack_evt(uint16_t event, void *p_param);
extern "C" void ccall_av_hdl_a2d_evt(uint16_t event, void *p_param);
extern "C" void ccall_av_hdl_avrc_evt(uint16_t event, void *p_param);
 
#ifdef ESP_IDF_4
extern "C" void ccall_app_rc_tg_callback(esp_avrc_tg_cb_event_t event, esp_avrc_tg_cb_param_t *param);
extern "C" void ccall_av_hdl_avrc_tg_evt(uint16_t event, void *p_param);
#endif    
 
// defines the mechanism to confirm a pin request
enum PinCodeRequest {Undefined, Confirm, Reply};
 
class BluetoothA2DPSink : public BluetoothA2DPCommon {
 
    friend void ccall_app_a2d_callback(esp_a2d_cb_event_t event, esp_a2d_cb_param_t *param);
    friend void ccall_app_rc_ct_callback(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t *param);
    friend void ccall_app_gap_callback(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param);
    friend void ccall_app_task_handler(void *arg);
    friend void ccall_i2s_task_handler(void *arg);
    friend void ccall_audio_data_callback(const uint8_t *data, uint32_t len);
    friend void ccall_av_hdl_stack_evt(uint16_t event, void *p_param);
    friend void ccall_av_hdl_a2d_evt(uint16_t event, void *p_param);
    friend void ccall_av_hdl_avrc_evt(uint16_t event, void *p_param);
 
#ifdef ESP_IDF_4
 
    friend void ccall_app_rc_tg_callback(esp_avrc_tg_cb_event_t event, esp_avrc_tg_cb_param_t *param);
    /* avrc TG event handler */
    friend void ccall_av_hdl_avrc_tg_evt(uint16_t event, void *p_param);
 
#endif    
 
  public: 
    BluetoothA2DPSink();
    virtual ~BluetoothA2DPSink();
    virtual void set_pin_config(i2s_pin_config_t pin_config);
   
    virtual void set_i2s_port(i2s_port_t i2s_num);
   
    virtual void set_i2s_config(i2s_config_t i2s_config);
 
    virtual void start(const char* name, bool auto_reconect);
 
    virtual void start(const char* name);
 
    virtual void end(bool release_memory=false);
    
    virtual bool is_connected();
 
    virtual esp_a2d_mct_t get_audio_type();
 
    virtual void set_avrc_metadata_callback(void (*callback)(uint8_t, const uint8_t*)) {
      this->avrc_metadata_callback = callback;
    }
 
    virtual void set_sample_rate_callback(void (*callback)(uint16_t rate)) {
      this->sample_rate_callback = callback;
    }
 
    virtual void set_stream_reader(void (*callBack)(const uint8_t*, uint32_t), bool i2s_output=true);
 
    virtual void set_raw_stream_reader(void (*callBack)(const uint8_t*, uint32_t));
 
    virtual void set_on_data_received(void (*callBack)());
    
    virtual void set_address_validator(bool (*callBack)(esp_bd_addr_t remote_bda)){
        address_validator = callBack;
    }
 
    virtual void set_volume(uint8_t volume);
    
    virtual int get_volume();
 
    virtual void set_on_volumechange(void (*callBack)(int));
 
    virtual void play();
    virtual void pause();
    virtual void stop();
    virtual void next();
    virtual void previous();
    virtual void fast_forward();
    virtual void rewind();
    
    virtual void set_channels(i2s_channel_t channels) {
        set_mono_downmix(channels==I2S_CHANNEL_MONO);
    }
    virtual void set_mono_downmix(bool enabled) {
        volume_control()->set_mono_downmix(enabled);
    }
    virtual void set_bits_per_sample(int bps) { i2s_config.bits_per_sample = (i2s_bits_per_sample_t) bps; }
    
    virtual uint16_t sample_rate();
    
    virtual esp_err_t i2s_mclk_pin_select(const uint8_t pin);
    
    virtual void activate_pin_code(bool active);
 
    virtual void confirm_pin_code();
 
    virtual void confirm_pin_code(int code);
 
    virtual int pin_code() {
        return pin_code_int;
    }
 
    virtual void set_avrc_metadata_attribute_mask(int flags){
        avrc_metadata_flags = flags;
    }
 
    virtual void set_swap_lr_channels(bool swap){
        swap_left_right = swap;
    }
 
    virtual void set_auto_reconnect(bool reconnect, int count=AUTOCONNECT_TRY_NUM ){
        reconnect_status = reconnect ? AutoReconnect : NoReconnect;
        try_reconnect_max_count = count;
    }
 
    virtual esp_bd_addr_t* get_current_peer_address() {
        return &peer_bd_addr;
    }
 
 
    void set_rssi_active(bool active){
        rssi_active = active;
    }
 
    esp_bt_gap_cb_param_t::read_rssi_delta_param get_last_rssi() {
        return last_rssi_delta;
    }
 
    void set_rssi_callback(void (*callback)(esp_bt_gap_cb_param_t::read_rssi_delta_param &rssi)){
        rssi_callbak = callback;
    }
 
    void set_reconnect_delay(int delay){
        reconnect_delay = delay;
    }
 
 #ifdef ESP_IDF_4
    virtual const char* get_connected_source_name();
    bool is_avrc_peer_rn_cap(esp_avrc_rn_event_ids_t cmd) {
        return esp_avrc_rn_evt_bit_mask_operation(ESP_AVRC_BIT_MASK_OP_TEST, &s_avrc_peer_rn_cap, cmd);
    }
    bool is_avrc_peer_rn_cap_available() {
        return s_avrc_peer_rn_cap.bits != 0;
    }
 #endif
 
  protected:
    // protected data
    xQueueHandle app_task_queue = nullptr;
    xTaskHandle app_task_handle = nullptr;
 
    i2s_config_t i2s_config;
    i2s_pin_config_t pin_config;    
    const char * bt_name = nullptr;
    uint32_t m_pkt_cnt = 0;
    //esp_a2d_audio_state_t m_audio_state = ESP_A2D_AUDIO_STATE_STOPPED;
    esp_a2d_mct_t audio_type;
    char pin_code_str[20] = {0};
    bool is_i2s_output = true;
    bool player_init = false;
    i2s_channel_t i2s_channels = I2S_CHANNEL_STEREO;
    i2s_port_t i2s_port = I2S_NUM_0; 
    int connection_rety_count = 0;
    static const esp_spp_mode_t esp_spp_mode = ESP_SPP_MODE_CB;
    _lock_t s_volume_lock;
    uint8_t s_volume = 0;
    bool s_volume_notify;
    int pin_code_int = 0;
    PinCodeRequest pin_code_request = Undefined;
    bool is_pin_code_active = false;
    int avrc_metadata_flags = ESP_AVRC_MD_ATTR_TITLE | ESP_AVRC_MD_ATTR_ARTIST | ESP_AVRC_MD_ATTR_ALBUM | ESP_AVRC_MD_ATTR_TRACK_NUM | ESP_AVRC_MD_ATTR_NUM_TRACKS | ESP_AVRC_MD_ATTR_GENRE;
    void (*bt_volumechange)(int) = nullptr;
    void (*bt_dis_connected)() = nullptr;
    void (*bt_connected)() = nullptr;
    void (*data_received)() = nullptr;
    void (*stream_reader)(const uint8_t*, uint32_t) = nullptr;
    void (*raw_stream_reader)(const uint8_t*, uint32_t) = nullptr;
    void (*avrc_metadata_callback)(uint8_t, const uint8_t*) = nullptr;
    bool (*address_validator)(esp_bd_addr_t remote_bda) = nullptr;
    void (*sample_rate_callback)(uint16_t rate)=nullptr;
    bool swap_left_right = false;
    bool is_i2s_active = false;
    int try_reconnect_max_count = AUTOCONNECT_TRY_NUM;
   
    // RSSI support
    esp_bt_gap_cb_param_t::read_rssi_delta_param last_rssi_delta;
    bool rssi_active = false;
    void (*rssi_callbak)(esp_bt_gap_cb_param_t::read_rssi_delta_param &rssi) = nullptr;
    int reconnect_delay = 1000;
 
#ifdef ESP_IDF_4
    esp_avrc_rn_evt_cap_mask_t s_avrc_peer_rn_cap;
    char remote_name[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
#endif
 
    // protected methods
    virtual int init_bluetooth();
    virtual void init_i2s();
    virtual void app_task_start_up(void);
    virtual void app_task_shut_down(void);
    virtual bool app_send_msg(app_msg_t *msg);
    virtual bool app_work_dispatch(app_callback_t p_cback, uint16_t event, void *p_params, int param_len);
    virtual void app_work_dispatched(app_msg_t *msg);
    virtual void app_alloc_meta_buffer(esp_avrc_ct_cb_param_t *param);
    virtual void av_new_track();
    virtual void init_nvs();
    // execute AVRC command
    virtual void execute_avrc_command(int cmd);
 
    virtual const char* last_bda_nvs_name() {
        return "last_bda";
    }
 
    virtual bool is_reconnect(esp_a2d_disc_rsn_t type) {
        bool result = is_autoreconnect_allowed && (reconnect_status==AutoReconnect || reconnect_status==IsReconnecting) && has_last_connection();
        ESP_LOGI(BT_AV_TAG,"is_reconnect: %s", result ? "true":"false");
        return result;
    }
 
    // task handler
    virtual void app_task_handler(void *arg);
    // a2d callback
    virtual void app_a2d_callback(esp_a2d_cb_event_t event, esp_a2d_cb_param_t *param);
    // GAP callback
    virtual void app_gap_callback(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param);
    // avrc callback
    virtual void app_rc_ct_callback(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t *param);
    // Callback for music stream 
    virtual void audio_data_callback(const uint8_t *data, uint32_t len);
    // av event handler
    virtual void av_hdl_stack_evt(uint16_t event, void *p_param);
    // a2dp event handler 
    virtual void av_hdl_a2d_evt(uint16_t event, void *p_param);
    // avrc event handler 
    virtual void av_hdl_avrc_evt(uint16_t event, void *p_param);
 
    // split up long handlers
    virtual void handle_connection_state(uint16_t event, void *p_param);
    virtual void handle_audio_state(uint16_t event, void *p_param);
    virtual void handle_audio_cfg(uint16_t event, void *p_param);
 
 
#ifdef ESP_IDF_4
    virtual void volume_set_by_local_host(uint8_t volume);
    virtual void volume_set_by_controller(uint8_t volume);
    virtual void av_notify_evt_handler(uint8_t& event_id, esp_avrc_rn_param_t& event_parameter);
    virtual void app_rc_tg_callback(esp_avrc_tg_cb_event_t event, esp_avrc_tg_cb_param_t *param);
    virtual void av_hdl_avrc_tg_evt(uint16_t event, void *p_param);
#else
    virtual void av_notify_evt_handler(uint8_t event_id, uint32_t event_parameter);
#endif    
 
    virtual size_t write_audio(const uint8_t *data, size_t size){
        return i2s_write_data(data, size);
    }
 
    virtual void i2s_task_handler(void *arg) {}
    virtual void bt_i2s_task_start_up(void) {}
    virtual void bt_i2s_task_shut_down(void) {}
 
    size_t i2s_write_data(const uint8_t* data, size_t item_size);
 
    virtual esp_err_t esp_a2d_connect(esp_bd_addr_t peer) {
        return esp_a2d_sink_connect(peer);
    }
 
};
 
 
 
#ifdef __cplusplus
}
#endif