mp3_codec.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 __MP3_CODEC_H__
#define __MP3_CODEC_H__

#ifdef __cplusplus
extern "C" {
#endif

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

#if defined(MTK_AUDIO_MIXER_SUPPORT)
    #include "audio_mixer.h"
    #include "audio_mixer_internal.h"
#endif

typedef enum {
    MP3_CODEC_MEDIA_OK = 0,       
    MP3_CODEC_MEDIA_REQUEST,      
    MP3_CODEC_MEDIA_UNDERFLOW,    
    MP3_CODEC_MEDIA_JUMP_FILE_TO, 
    MP3_CODEC_AWS_CHECK_CLOCK_SKEW,
    MP3_CODEC_AWS_CHECK_UNDERFLOW,
    MP3_CODEC_MEDIA_BITSTREAM_END,
}
mp3_codec_event_t;

typedef enum {
    MP3_CODEC_STATE_ERROR = -1,     
    MP3_CODEC_STATE_IDLE,           
    MP3_CODEC_STATE_READY,          
    MP3_CODEC_STATE_PLAY,           
    MP3_CODEC_STATE_PAUSE,          
    MP3_CODEC_STATE_STOP,           
} mp3_codec_state_t;


typedef enum {
    MP3_CODEC_RETURN_ERROR = -1,            
    MP3_CODEC_RETURN_OK = 0,                
} mp3_codec_function_return_state_t;

typedef enum {
    MP3_CODEC_DATA_TYPE_AUDIO = 1,                  
    MP3_CODEC_DATA_TYPE_SAMPLES_PER_CHANNEL = 2,    
} mp3_codec_data_type_t;

typedef struct {
    uint8_t         *buffer_base;          
    uint32_t         buffer_size;          
    uint32_t         write;                
    uint32_t         read;                 
    void            *param;                
} mp3_codec_audio_buffer_t;


typedef struct {
    bool        has_id3v2;                  
    uint32_t    id3v2_tage_length;          
} mp3_codec_mp3_id3v2_information_t;

typedef struct {
    int32_t         frame_size;            
    uint8_t         *frame;                
    int32_t         sampling_rate;         
    void            *param;                
} silence_frame_information_t;

typedef struct mp3_media_handle_s mp3_codec_media_handle_t; 
struct mp3_media_handle_s {
    mp3_codec_state_t            state;          
    mp3_codec_audio_buffer_t     share_buff;     
    bool                         underflow;      
    bool                         waiting;        
    bool                         linear_buff;    
    uint16_t                     audio_id;       
    uint32_t                     jump_file_to_specified_position;    
    mp3_codec_mp3_id3v2_information_t  id3v2_information;
    int32_t                     flush_data_flag; 
    void                         *private_data;       
    void (*handler)(mp3_codec_media_handle_t *handle, mp3_codec_event_t event_id);                                  
    void (*set_share_buffer)(mp3_codec_media_handle_t *handle, uint8_t  *buffer, uint32_t  length);                 
    void (*get_write_buffer)(mp3_codec_media_handle_t *handle, uint8_t **buffer, uint32_t *length);                 
    void (*get_read_buffer)(mp3_codec_media_handle_t *handle, uint8_t **buffer, uint32_t *length);                  
    void (*write_data_done)(mp3_codec_media_handle_t *handle, uint32_t length);                                     
    void (*finish_write_data)(mp3_codec_media_handle_t *handle);                                                    
    void (*flush)(mp3_codec_media_handle_t *handle, int32_t flush_data_flag);                                       
    void (*reset_share_buffer)(mp3_codec_media_handle_t *handle);                                                   
    void (*read_data_done)(mp3_codec_media_handle_t *handle, uint32_t length);                                      
    int32_t (*get_free_space)(mp3_codec_media_handle_t *handle);                                                    
    int32_t (*get_data_count)(mp3_codec_media_handle_t *handle);                                                    
    void (*get_data_status)(mp3_codec_media_handle_t *handle, mp3_codec_data_type_t data_type, int32_t *data_status);          
    int32_t (*get_silence_frame_information)(mp3_codec_media_handle_t *handle, int32_t *byte_count);                
    int32_t (*set_silence_frame_information)(mp3_codec_media_handle_t *handle, silence_frame_information_t *frm_info);              
    int32_t (*fill_silence_frame)(mp3_codec_media_handle_t *handle, uint8_t *buffer);                                               
    mp3_codec_function_return_state_t (*play)(mp3_codec_media_handle_t *handle);                                                    
    mp3_codec_function_return_state_t (*pause)(mp3_codec_media_handle_t *handle);                                                   
    mp3_codec_function_return_state_t (*resume)(mp3_codec_media_handle_t *handle);                                                  
    mp3_codec_function_return_state_t (*process)(mp3_codec_media_handle_t *handle, mp3_codec_event_t event_id);                     
    mp3_codec_function_return_state_t (*stop)(mp3_codec_media_handle_t *handle);                                                    
    mp3_codec_function_return_state_t (*close_codec)(mp3_codec_media_handle_t *handle);                                             
    mp3_codec_function_return_state_t (*skip_id3v2_and_reach_next_frame)(mp3_codec_media_handle_t *handle, uint32_t file_size);     
    mp3_codec_function_return_state_t (*set_bitstream_buffer)(mp3_codec_media_handle_t *handle, uint8_t *bitstrean_buffer, uint32_t length);
#ifdef MTK_BT_AWS_ENABLE
    mp3_codec_function_return_state_t (*aws_init)(mp3_codec_media_handle_t *handle);                                                    
    mp3_codec_function_return_state_t (*aws_deinit)(mp3_codec_media_handle_t *handle);                                                  
    mp3_codec_function_return_state_t (*aws_set_clock_skew_compensation_value)(mp3_codec_media_handle_t *handle, int32_t sample_count); 
    mp3_codec_function_return_state_t (*aws_get_clock_skew_status)(mp3_codec_media_handle_t *handle, int32_t *aws_clock_skew_status);   
    mp3_codec_function_return_state_t (*aws_set_clock_skew)(mp3_codec_media_handle_t *handle, bool flag);                               
#endif
#if defined(MTK_AUDIO_MIXER_SUPPORT)
    audio_mixer_track_id_t      mixer_track_id;
    audio_mixer_role_t          mixer_track_role;
    void (*set_track_role)(mp3_codec_media_handle_t *handle, audio_mixer_role_t role);
#endif
};

typedef void (*mp3_codec_callback_t)(mp3_codec_media_handle_t *handle, mp3_codec_event_t event_id);


mp3_codec_function_return_state_t mp3_codec_get_memory_size(uint32_t *memory_size);

mp3_codec_function_return_state_t  mp3_codec_set_memory(uint8_t *memory);


#if defined(MTK_AUDIO_MIXER_SUPPORT)
mp3_codec_function_return_state_t mp3_codec_set_memory2(mp3_codec_media_handle_t *internal_handle);
#else
mp3_codec_function_return_state_t mp3_codec_set_memory2(void);
#endif

#if 0

mp3_codec_function_return_state_t mp3_codec_enter_resume(void);

mp3_codec_function_return_state_t mp3_codec_enter_suspend(void);
#endif

mp3_codec_media_handle_t *mp3_codec_open(mp3_codec_callback_t callback);

mp3_codec_function_return_state_t mp3_codec_close(mp3_codec_media_handle_t *handle);

mp3_codec_function_return_state_t mp3_codec_aws_set_flag(mp3_codec_media_handle_t *handle, bool flag);

mp3_codec_function_return_state_t mp3_codec_aws_set_initial_sync(mp3_codec_media_handle_t *handle);

#ifdef __cplusplus
}
#endif

#endif /* __MP3_CODEC_H__ */