bt_codec.h

/* Copyright Statement:
 *
 * (C) 2005-2017 MediaTek Inc. All rights reserved.
 *
 * This software/firmware and related documentation ("MediaTek Software") are
 * protected under relevant copyright laws. The information contained herein
 * is confidential and proprietary to MediaTek Inc. ("MediaTek") and/or its licensors.
 * Without the prior written permission of MediaTek and/or its licensors,
 * any reproduction, modification, use or disclosure of MediaTek Software,
 * and information contained herein, in whole or in part, shall be strictly prohibited.
 * You may only use, reproduce, modify, or distribute (as applicable) MediaTek Software
 * if you have agreed to and been bound by the applicable license agreement with
 * MediaTek ("License Agreement") and been granted explicit permission to do so within
 * the License Agreement ("Permitted User"). If you are not a Permitted User,
 * please cease any access or use of MediaTek Software immediately.
 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
 * THAT MEDIATEK SOFTWARE RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES
 * ARE PROVIDED TO RECEIVER ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
 * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
 * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
 * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
 * SUPPLIED WITH MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
 * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
 * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
 * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
 * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
 * CUMULATIVE LIABILITY WITH RESPECT TO MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
 * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE MEDIATEK SOFTWARE AT ISSUE,
 * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
 * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
 */

#ifndef __BT_CODEC_H__
#define __BT_CODEC_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include <stdbool.h>
#include "bt_hfp.h"
#include "bt_a2dp.h"

#define BT_CODEC_MEDIA_EVENT_START    (120)     
typedef enum {
    BT_CODEC_STATE_IDLE,      
    BT_CODEC_STATE_READY,     
    BT_CODEC_STATE_PLAY,      
    BT_CODEC_STATE_ERROR,     
    BT_CODEC_STATE_STOP       
} bt_codec_state_t;


typedef enum {
    BT_CODEC_MEDIA_ERROR = BT_CODEC_MEDIA_EVENT_START,          
    BT_CODEC_MEDIA_OK,                                    
    BT_CODEC_MEDIA_UNDERFLOW,                             
    BT_CODEC_MEDIA_REQUEST,                               
    BT_CODEC_MEDIA_DATA_NOTIFICATION,                     
    BT_CODEC_MEDIA_TERMINATED,                           
    BT_CODEC_MEDIA_AWS_CHECK_UNDERFLOW,                         
    BT_CODEC_MEDIA_AWS_CHECK_CLOCK_SKEW,                         
    BT_CODEC_MEDIA_GET_PAYLOAD                            
} bt_codec_media_event_t;


typedef enum {
    BT_CODEC_MEDIA_STATUS_BASE = -0x1B00,                     
    BT_CODEC_MEDIA_STATUS_OK = 0,                             
    BT_CODEC_MEDIA_STATUS_ERROR = -0x1B01,                    
    BT_CODEC_MEDIA_STATUS_INVALID_PARAM = -0x1B02,            
    BT_CODEC_MEDIA_STATUS_END                                 
} bt_codec_media_status_t;

typedef enum {
    BT_CODEC_AWS_CLOCK_SKEW_STATUS_IDLE,    
    BT_CODEC_AWS_CLOCK_SKEW_STATUS_BUSY     
} bt_codec_aws_clock_skew_status_t;


typedef enum {
    BT_CODEC_MEDIA_HFP_MIX_STREAM_OUT_METHOD_NO_MIX = 0,      
    BT_CODEC_MEDIA_HFP_MIX_STREAM_OUT_METHOD_REPLACE,         
    BT_CODEC_MEDIA_HFP_MIX_STREAM_OUT_METHOD_WEIGHTED_MEAN    
} bt_codec_media_hfp_mix_stream_out_method_t;


typedef enum {
    BT_CODEC_HFP_DEVICE_PATH_INTERNAL = 0,                
    BT_CODEC_HFP_DEVICE_PATH_MASTER_I2S,                  
    BT_CODEC_HFP_DEVICE_PATH_SLAVE_I2S,                   
} bt_codec_hfp_device_path_t;

typedef struct {
    uint8_t         *buffer_base;         
    int32_t         buffer_size;          
    int32_t         write;                
    int32_t         read;                 
    void            *param;               
} bt_audio_buffer_t;

typedef int32_t (*bt_codec_get_data)(volatile uint16_t *buf, uint32_t len);

typedef int32_t (*bt_codec_get_data_count)(void);


typedef struct _bt_media_handle_t {
    bt_codec_state_t      state;          
    bt_audio_buffer_t     buffer_info;    
    bool                  underflow;      
    bool                  waiting;        
    uint16_t              audio_id;       
    void (*handler)(struct _bt_media_handle_t *handle, bt_codec_media_event_t event_id);                           
    void (*set_buffer)(struct _bt_media_handle_t *handle, uint8_t  *buffer, uint32_t  length);                     
    void (*set_get_data_function)(struct _bt_media_handle_t *handle, bt_codec_get_data func);                      
    void (*set_get_data_count_function)(struct _bt_media_handle_t *handle, bt_codec_get_data_count func);          
    void (*get_write_buffer)(struct _bt_media_handle_t *handle, uint8_t **buffer, uint32_t *length);               
    void (*get_read_buffer)(struct _bt_media_handle_t *handle, uint8_t **buffer, uint32_t *length);                
    void (*write_data_done)(struct _bt_media_handle_t *handle, uint32_t length);                                   
    void (*finish_write_data)(struct _bt_media_handle_t *handle);                                                  
    void (*reset_share_buffer)(struct _bt_media_handle_t *handle);                                                 
    void (*read_data_done)(struct _bt_media_handle_t *handle, uint32_t length);                                    
    int32_t (*get_free_space)(struct _bt_media_handle_t *handle);                                                  
    int32_t (*get_data_count)(struct _bt_media_handle_t *handle);                                                  
    bt_codec_get_data directly_access_dsp_function;                                                                
    bt_codec_get_data_count get_data_count_function;                                                               
    uint32_t (*query_memory_size)(struct _bt_media_handle_t *handle);                                                           
    uint32_t (*set_bit_rate)(struct _bt_media_handle_t *handle, uint32_t bit_rate);                                             
    uint32_t (*get_payload)(struct _bt_media_handle_t *handle, uint8_t *buffer, uint32_t buffer_size, uint32_t *sample_count);  
    void     (*get_payload_done)(struct _bt_media_handle_t *handle);                                                            
    void     (*query_payload_size)(struct _bt_media_handle_t *handle, uint32_t *minimum, uint32_t *total);                      
    bt_codec_media_status_t (*play)(struct _bt_media_handle_t *handle);                           
    bt_codec_media_status_t (*process)(struct _bt_media_handle_t *handle, bt_codec_media_event_t event_id);   
    bt_codec_media_status_t (*stop)(struct _bt_media_handle_t *handle);                           
} bt_media_handle_t;


typedef struct {
    uint8_t min_bit_pool;       
    uint8_t max_bit_pool;       
    uint8_t block_length;       
    uint8_t subband_num;        
    uint8_t alloc_method;       
    uint8_t sample_rate;        
    uint8_t channel_mode;       
} bt_codec_sbc_t;

typedef struct {
    bool vbr;                   
    uint8_t object_type;        
    uint8_t channels;           
    uint16_t sample_rate;       
    uint32_t bit_rate;          
} bt_codec_aac_t;

typedef union {
    bt_codec_sbc_t sbc;    
    bt_codec_aac_t aac;    
} bt_codec_t;

typedef struct {
    bt_a2dp_codec_type_t type;  
    bt_codec_t codec;      
} bt_codec_capability_t;


typedef struct {
    bt_codec_capability_t codec_cap;  
    bt_a2dp_role_t             role;       
} bt_codec_a2dp_audio_t;

typedef struct {
    bt_hfp_audio_codec_type_t type;   
} bt_codec_hfp_audio_t;

typedef struct {
    uint32_t sample_count;  
    uint32_t sampling_rate; 
} bt_codec_a2dp_data_count_t;

typedef struct {
    uint32_t sample_count;  
    uint32_t byte_count;    
} bt_codec_a2dp_bitstream_t;

typedef struct {
    uint8_t *buffer;        
    uint32_t byte_count;    
} bt_codec_a2dp_buffer_t;

typedef void (*bt_codec_a2dp_callback_t)(bt_media_handle_t *handle, bt_codec_media_event_t event_id);


typedef void (*bt_codec_hfp_mix_stream_out_data_callback_t)(bt_codec_media_event_t event, void *user_data);


typedef void (*bt_codec_hfp_get_stream_in_data_callback_t)(bt_codec_media_event_t event, void *user_data);
typedef void (*bt_codec_hfp_get_stream_out_data_callback_t)(bt_codec_media_event_t event, void *user_data);

typedef void (*bt_codec_hfp_customer_enhancement_function_callback_t)(void *user_data);

typedef void (*bt_codec_hfp_callback_t)(bt_media_handle_t *handle, bt_codec_media_event_t event_id);

bt_media_handle_t *bt_codec_a2dp_open(bt_codec_a2dp_callback_t callback, const bt_codec_a2dp_audio_t *param);

bt_codec_media_status_t bt_codec_a2dp_close(bt_media_handle_t *handle);



bt_codec_media_status_t bt_codec_hfp_mix_stream_out(bt_codec_media_hfp_mix_stream_out_method_t mix_method, void *buffer, uint32_t sample_count);


bt_codec_media_status_t bt_codec_hfp_get_mix_stream_out_sample_count(uint32_t *sample_count);



bt_codec_media_status_t bt_codec_hfp_unregister_mix_stream_out_data_callback(void);


bt_codec_media_status_t bt_codec_hfp_register_mix_stream_out_data_callback(bt_codec_hfp_mix_stream_out_data_callback_t callback, void *user_data);



bt_codec_media_status_t bt_codec_hfp_read_stream_in(void *buffer, uint32_t sample_count);


bt_codec_media_status_t bt_codec_hfp_get_stream_in_sample_count(uint32_t *sample_count);

bt_codec_media_status_t bt_codec_hfp_unregister_get_stream_in_data_callback(void);

bt_codec_media_status_t bt_codec_hfp_register_get_stream_in_data_callback(bt_codec_hfp_get_stream_in_data_callback_t callback, void *user_data);

bt_codec_media_status_t bt_codec_hfp_read_stream_out(void *buffer, uint32_t sample_count);


bt_codec_media_status_t bt_codec_hfp_get_stream_out_sample_count(uint32_t *sample_count);

bt_codec_media_status_t bt_codec_hfp_unregister_get_stream_out_data_callback(void);

bt_codec_media_status_t bt_codec_hfp_register_get_stream_out_data_callback(bt_codec_hfp_get_stream_out_data_callback_t callback, void *user_data);



bt_codec_media_status_t bt_codec_hfp_set_customer_enhanced_stream_in_data(void *buffer, uint32_t sample_count);


bt_codec_media_status_t bt_codec_hfp_get_customer_enhanced_stream_in_sample_count(uint32_t *sample_count);



bt_codec_media_status_t bt_codec_hfp_unregister_customer_enhancement_function_callback(void);

bt_codec_media_status_t bt_codec_hfp_register_customer_enhancement_function_callback(bt_codec_hfp_customer_enhancement_function_callback_t callback, void *user_data);



bt_codec_media_status_t bt_codec_hfp_set_device_path(bt_codec_hfp_device_path_t device_path);

bt_media_handle_t *bt_codec_hfp_open(bt_codec_hfp_callback_t callback, const bt_codec_hfp_audio_t *param);

bt_codec_media_status_t bt_codec_hfp_close(bt_media_handle_t *handle);

bt_codec_media_status_t bt_codec_a2dp_aws_set_flag(bt_media_handle_t *handle, bool flag);

bt_codec_media_status_t bt_codec_a2dp_aws_set_initial_sync(bt_media_handle_t *handle);

bt_codec_media_status_t bt_codec_a2dp_aws_get_consumed_data_count(bt_media_handle_t *handle, bt_codec_a2dp_data_count_t *information);

bt_codec_media_status_t bt_codec_a2dp_aws_get_silence_frame_information(bt_media_handle_t *handle, bt_codec_a2dp_bitstream_t *information);

bt_codec_media_status_t bt_codec_a2dp_aws_fill_silence_frame(bt_media_handle_t *handle, bt_codec_a2dp_buffer_t *data, uint32_t frame_count);

bt_codec_media_status_t bt_codec_a2dp_aws_parse_data_information(bt_media_handle_t *handle, bt_codec_a2dp_buffer_t *data, bt_codec_a2dp_bitstream_t *information);

bt_codec_media_status_t bt_codec_a2dp_aws_get_clock_skew_status(bt_media_handle_t *handle, bt_codec_aws_clock_skew_status_t *status);

bt_codec_media_status_t bt_codec_a2dp_aws_set_clock_skew_compensation_value(bt_media_handle_t *handle, int32_t sample_count);

bt_codec_media_status_t bt_codec_a2dp_aws_get_audio_latency(bt_media_handle_t *handle, uint32_t sampling_rate, uint32_t *latency_us);


bt_codec_media_status_t bt_codec_a2dp_set_sw_aac_flag(bool flag);

bool bt_codec_a2dp_get_sw_aac_flag(void);

bt_codec_media_status_t bt_codec_a2dp_aws_set_clock_skew(bool flag);

#ifdef __cplusplus
}
#endif

#endif /* __BT_CODEC_H__ */