hal_audio.h

/* Copyright Statement:
 *
 * (C) 2005-2016  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 __HAL_AUDIO_H__
#define __HAL_AUDIO_H__
#include "hal_platform.h"

#ifdef HAL_AUDIO_MODULE_ENABLED

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif


typedef enum {
    HAL_AUDIO_STATUS_INVALID_PARAMETER = -2,  
    HAL_AUDIO_STATUS_ERROR             = -1,  
    HAL_AUDIO_STATUS_OK                =  0   
} hal_audio_status_t;

typedef enum {
    HAL_AUDIO_EVENT_ERROR               = -1, 
    HAL_AUDIO_EVENT_NONE                =  0, 
    HAL_AUDIO_EVENT_UNDERFLOW           =  1, 
    HAL_AUDIO_EVENT_DATA_REQUEST        =  2, 
    HAL_AUDIO_EVENT_DATA_NOTIFICATION   =  3, 
    HAL_AUDIO_EVENT_END                 =  4  
} hal_audio_event_t;

typedef enum {
    HAL_AUDIO_DEVICE_NONE               = 0x0000,  
    HAL_AUDIO_DEVICE_MAIN_MIC           = 0x0001,  
    HAL_AUDIO_DEVICE_HEADSET_MIC        = 0x0002,  
    HAL_AUDIO_DEVICE_HANDSET            = 0x0004,  
    HAL_AUDIO_DEVICE_HANDS_FREE_MONO    = 0x0008,  
    HAL_AUDIO_DEVICE_HANDS_FREE_STEREO  = 0x0010,  
    HAL_AUDIO_DEVICE_HEADSET            = 0x0020,  
    HAL_AUDIO_DEVICE_HEADSET_MONO       = 0x0040,  
    HAL_AUDIO_DEVICE_LINE_IN            = 0x0080,  
    HAL_AUDIO_DEVICE_DUAL_DIGITAL_MIC   = 0x0100,  
    HAL_AUDIO_DEVICE_SINGLE_DIGITAL_MIC = 0x0200   
} hal_audio_device_t;

typedef enum {
    HAL_AUDIO_MUTE_MAIN_MIC    = 0x0001, 
    HAL_AUDIO_MUTE_EAR_MIC     = 0x0002, 
    HAL_AUDIO_MUTE_HANDSET     = 0x0004, 
    HAL_AUDIO_MUTE_HANDS_FREE  = 0x0008, 
    HAL_AUDIO_MUTE_HEADSET     = 0x0010, 
    HAL_AUDIO_MUTE_LINE_IN     = 0x0020  
} hal_audio_mute_t;

typedef enum {
    HAL_AUDIO_MUTE_FUNCTION_NONE  = 0,   
    HAL_AUDIO_MUTE_FUNCTION_PCM   = 1    
} hal_audio_mute_function_t;

typedef enum {
    HAL_AUDIO_SAMPLING_RATE_8KHZ      = 0, 
    HAL_AUDIO_SAMPLING_RATE_11_025KHZ = 1, 
    HAL_AUDIO_SAMPLING_RATE_12KHZ     = 2, 
    HAL_AUDIO_SAMPLING_RATE_16KHZ     = 3, 
    HAL_AUDIO_SAMPLING_RATE_22_05KHZ  = 4, 
    HAL_AUDIO_SAMPLING_RATE_24KHZ     = 5, 
    HAL_AUDIO_SAMPLING_RATE_32KHZ     = 6, 
    HAL_AUDIO_SAMPLING_RATE_44_1KHZ   = 7, 
    HAL_AUDIO_SAMPLING_RATE_48KHZ     = 8, 
    HAL_AUDIO_SAMPLING_RATE_96KHZ     = 9  
} hal_audio_sampling_rate_t;

typedef enum {
    HAL_AUDIO_BITS_PER_SAMPLING_16    = 0, 
    HAL_AUDIO_BITS_PER_SAMPLING_24    = 1  
} hal_audio_bits_per_sample_t;

typedef enum {
    HAL_AUDIO_MONO                  = 0, 
    HAL_AUDIO_STEREO                = 1, 
    HAL_AUDIO_STEREO_BOTH_L_CHANNEL = 2, 
    HAL_AUDIO_STEREO_BOTH_R_CHANNEL = 3, 
    HAL_AUDIO_STEREO_BOTH_L_R_SWAP  = 4  
} hal_audio_channel_number_t;

typedef enum {
    HAL_AUDIO_PLAYBACK_MUSIC     = 0, 
    HAL_AUDIO_PLAYBACK_VOICE     = 1, 
    HAL_AUDIO_RECORD_VOICE       = 2, 
    HAL_AUDIO_TWO_WAY_VOICE      = 3, 
    HAL_AUDIO_PLAYBACK_MUSIC_RECORD_VOICE = 4  
} hal_audio_active_type_t;


typedef struct {
    hal_audio_sampling_rate_t   stream_sampling_rate;  
    hal_audio_bits_per_sample_t stream_bit_rate;       
    hal_audio_channel_number_t  stream_channel;         
    hal_audio_device_t          audio_device;          
    uint32_t                    digital_gain_index;    
    uint32_t                    analog_gain_index;     
} hal_audio_stream_mode_t;

typedef struct {
    hal_audio_stream_mode_t     stream_in;               
    hal_audio_stream_mode_t     stream_out;              
    hal_audio_active_type_t     audio_path_type;         
    hal_audio_mute_t            mute_device;             
    bool                        loopback;                
} hal_audio_stream_t;


typedef struct {
    void*                       user_data;              
    uint8_t                     *buffer;                
    uint32_t                    buffer_size;            
    uint32_t                    sample_rate;            
    uint32_t                    channel;                
} hal_audio_copy_stream_t;

typedef void (*hal_audio_stream_out_callback_t)(hal_audio_event_t event, void *user_data);

typedef void (*hal_audio_stream_in_callback_t)(hal_audio_event_t event, void *user_data);

typedef void (*hal_audio_stream_copy_callback_t)(hal_audio_event_t event, hal_audio_copy_stream_t *user_data);

hal_audio_status_t hal_audio_init(void);

hal_audio_status_t hal_audio_deinit(void);

hal_audio_status_t hal_audio_register_copied_stream_out_callback(hal_audio_stream_copy_callback_t callback, void *user_data);

hal_audio_status_t hal_audio_set_stream_out_sampling_rate(hal_audio_sampling_rate_t sample_rate);

hal_audio_status_t hal_audio_set_stream_out_channel_number(hal_audio_channel_number_t channel_number);

hal_audio_status_t hal_audio_start_stream_out(hal_audio_active_type_t active_type);

void hal_audio_stop_stream_out(void);

hal_audio_status_t hal_audio_set_stream_out_volume(uint32_t digital_volume_index, uint32_t analog_volume_index);

void hal_audio_mute_stream_out(bool mute);

hal_audio_status_t hal_audio_set_stream_out_device(hal_audio_device_t device);

hal_audio_status_t hal_audio_write_stream_out(const void *buffer, uint32_t size);

hal_audio_status_t hal_audio_get_stream_out_sample_count(uint32_t *sample_count);

hal_audio_status_t hal_audio_register_stream_out_callback(hal_audio_stream_out_callback_t callback, void *user_data);

hal_audio_status_t hal_audio_set_stream_in_sampling_rate(hal_audio_sampling_rate_t sample_rate);

hal_audio_status_t hal_audio_set_stream_in_channel_number(hal_audio_channel_number_t channel_number);

hal_audio_status_t hal_audio_start_stream_in(hal_audio_active_type_t active_type);

void hal_audio_stop_stream_in(void);

hal_audio_status_t hal_audio_set_stream_in_volume(uint32_t digital_volume_index, uint32_t analog_volume_index);

void hal_audio_mute_stream_in(bool mute);

hal_audio_status_t hal_audio_set_stream_in_device(hal_audio_device_t device);

hal_audio_status_t hal_audio_read_stream_in(void *buffer, uint32_t sample_count);

hal_audio_status_t hal_audio_get_stream_in_sample_count(uint32_t *sample_count);

hal_audio_status_t hal_audio_register_stream_in_callback(hal_audio_stream_in_callback_t callback, void *user_data);

hal_audio_status_t hal_audio_get_memory_size(uint32_t *memory_size);

hal_audio_status_t hal_audio_set_memory(void *memory);

hal_audio_status_t hal_audio_get_audio_clock(uint32_t *sample_count);

#ifdef __cplusplus
}
#endif

#endif /*HAL_AUDIO_MODULE_ENABLED*/
#endif /*__HAL_AUDIO_H__*/