Overview

Audio Software Codec middleware enables encoding and decoding for audio compression for a given streaming media coding format, which reduces throughput, storage and RAM resources. These codecs are used to decode audio from cloud services, stored files or external peripherals. The user can choose what kind of encoding and decoding scheme to use from the list of supported audio codecs.

Prerequisite

Please refer to README.md for quick start on platforms

Code Snippets

Code Snippet 1: Encoder app example

This code snippet demonstrates how to initialize the codec middleware for encoder with configuration for OPUS , SBC codec and get the encoded data back

 
#ifdef ENABLE_SBC_ENCODE
cy_asc_sbc_encode_config_t get_sbc_config( bool wide_band, uint8_t quality, uint32_t n_channels, uint32_t sample_rate );
#endif
 
cy_rslt_t snippet_encoder_app_example(void)
{
    cy_audio_sw_codec_encode_config_t   enc_config = {0};
    cy_audio_sw_codec_t                 enc_handle = NULL;
    cy_rslt_t                           result;
    uint32_t                            recommended_in_size = 0;
    uint32_t                            min_out_size = 0;
    uint32_t                            in_size = 0;
    uint32_t                            out_size = 0;
    uint8_t                             *input_buff = NULL;
    uint8_t                             *output_buff = NULL;
 
    enc_config.bitwidth      = CY_AUDIO_CODEC_BITWIDTH_16;
    enc_config.channel       = CY_AUDIO_CODEC_CHANNEL_STEREO;
    enc_config.sampling_rate = CY_AUDIO_CODEC_SAMPLING_RATE_16000HZ;
 
    enc_config.bitrate       = CY_AUDIO_CODEC_BITRATE_96kbps;
    enc_config.frame_ms      = CY_AUDIO_CODEC_FRAME_MS_20;
 
#ifdef ENABLE_OPUS_ENCODE
    enc_config.codec_type    = CY_AUDIO_CODEC_TYPE_OPUS;
#elif ENABLE_SBC_ENCODE
    enc_config.codec_type    = CY_AUDIO_CODEC_TYPE_SBC;
    enc_config.codec_specific_config.sbc = get_sbc_config( false, 0, 2, 16000 );
#endif
 
    do
    {
 
        result =  cy_audio_sw_codec_init(
                            CY_AUDIO_CODEC_OPERATION_ENCODE,
                            (void *)&enc_config,
                            &enc_handle);
        if(CY_RSLT_SUCCESS != result)
        {
            printf("Sw encoder init failed\n");
            break;
        }
 
        result = cy_audio_sw_codec_get_encoder_recommended_inbuf_size(enc_handle, &recommended_in_size);
        if(CY_RSLT_SUCCESS != result)
        {
            printf("failed to get recommended input buf sz.\n");
            break;
        }
 
        result = cy_audio_sw_codec_get_encoder_recommended_outbuf_size(enc_handle, recommended_in_size, &min_out_size);
        if(CY_RSLT_SUCCESS != result)
        {
            printf("failed to get recommended output buf sz.\n");
            break;
        }
 
        input_buff = (uint8_t*)malloc(recommended_in_size);
        if(NULL == input_buff)
        {
            result = CY_RSLT_ASC_OUT_OF_MEMORY;
            printf("out of memory.\n");
            break;
        }
 
        output_buff = (uint8_t*)malloc(min_out_size);
        if(NULL == output_buff)
        {
            result = CY_RSLT_ASC_OUT_OF_MEMORY;
            printf("out of memory.\n");
            break;
        }
 
        /* Encoding Loop */
        while(true)
        {
            result = cy_audio_sw_codec_encode(enc_handle, (uint8_t *)input_buff, &in_size, (uint8_t *)output_buff, &out_size);
            if(CY_RSLT_SUCCESS != result)
            {
                printf("Encode failed\n");
                break;
            }
 
        }
 
    }while(false);
 
    result = cy_audio_sw_codec_deinit(&enc_handle);
    if(CY_RSLT_SUCCESS != result)
    {
        printf("sw encoder deinit failed\n");
    }
 
    if(input_buff)
    {
        free(input_buff);
        input_buff = NULL;
    }
 
    if(output_buff)
    {
        free(output_buff);
        output_buff = NULL;
    }
 
    return result;
}
 
#ifdef ENABLE_SBC_ENCODE
cy_asc_sbc_encode_config_t get_sbc_config( bool wide_band, uint8_t quality, uint32_t n_channels, uint32_t sample_rate )
{
    cy_asc_sbc_encode_config_t sbc_config;
    if(true == wide_band)
    {
        sbc_config.sbc_mode = 1;
        sbc_config.uui_id = 2;
    }
    else
    {
        //A2DP
        sbc_config.allocation_method = 0;
        sbc_config.sbc_mode = 0;
        sbc_config.sub_blocks = 16;
        sbc_config.sub_bands = 8;
        if(0 == quality) // Medium
        {
            if(1 == n_channels && sample_rate == 48000)
            {
                sbc_config.bit_pool = 18;
                sbc_config.channel_mode = 0;
            }
            else if(1 == n_channels && sample_rate == 44100)
            {
                sbc_config.bit_pool = 19;
                sbc_config.channel_mode = 0;
            }
            else if(2 == n_channels && sample_rate == 48000)
            {
                sbc_config.bit_pool = 33;
                sbc_config.channel_mode = 3;
            }
            else if(2 == n_channels && sample_rate == 44100)
            {
                sbc_config.bit_pool = 35;
                sbc_config.channel_mode = 3;
            }
        }
        else if(1 == quality) // High
        {
            if(1 == n_channels && sample_rate == 48000)
            {
                sbc_config.bit_pool = 29;
                sbc_config.channel_mode = 0;
            }
            else if(1 == n_channels && sample_rate == 44100)
            {
                sbc_config.bit_pool = 31;
                sbc_config.channel_mode = 0;
            }
            else if(2 == n_channels && sample_rate == 48000)
            {
                sbc_config.bit_pool = 51;
                sbc_config.channel_mode = 3;
            }
            else if(2 == n_channels && sample_rate == 44100)
            {
                sbc_config.bit_pool = 53;
                sbc_config.channel_mode = 3;
            }
        }
    }
 
    return sbc_config;
}
#endif

Code Snippet 2: Decoder app example

This code snippet demonstrates how to initialize the codec middleware for decoder with configuration for SBC codec and get the encoded data back

 
cy_rslt_t cy_audio_sw_codec_decode_stream_info_cb(
        cy_audio_sw_codec_t handle,
        cy_audio_sw_codec_stream_info_t stream_info,
        void *callback_user_arg);
 
cy_rslt_t snippet_decoder_app_example(void)
{
    cy_audio_sw_codec_decode_config_t   dec_config = {0};
    cy_audio_sw_codec_t                 dec_handle = NULL;
    cy_audio_sw_codec_stream_info_t     stream_info = {0};
    cy_rslt_t                           result;
    uint32_t                            recommended_out_size;
    uint32_t                            in_size = 0;
    uint32_t                            out_size = 0;
    uint32_t                            size = 1024;
    uint8_t                             *input_buff = NULL;
    uint8_t                             *output_buff = NULL;
 
    dec_config.channel  = CY_AUDIO_CODEC_CHANNEL_STEREO;
    dec_config.bitwidth = CY_AUDIO_CODEC_BITWIDTH_16;
    dec_config.sampling_rate  = CY_AUDIO_CODEC_SAMPLING_RATE_16000HZ;
    stream_info.bitwidth = CY_AUDIO_CODEC_BITWIDTH_16;
    stream_info.channel = CY_AUDIO_CODEC_CHANNEL_STEREO;
    stream_info.sampling_rate = CY_AUDIO_CODEC_SAMPLING_RATE_16000HZ;
 
    dec_config.codec_type       = CY_AUDIO_CODEC_TYPE_SBC;
    dec_config.stream_info      = cy_audio_sw_codec_decode_stream_info_cb;
    dec_config.callback_user_arg = (void*)NULL;
 
#ifdef ENABLE_SBC_DECODE
    if(dec_config.codec_type  == CY_AUDIO_CODEC_TYPE_SBC)
    {
        dec_config.codec_specific_config.sbc.sbc_mode = 0;
    }
    /*
    {
        //Wide band mode
        dec_config.codec_specific_config.sbc.sbc_mode = 1;
        dec_config.codec_specific_config.sbc.uui_id = 2;
    }
    */
#endif
    do
    {
        result =  cy_audio_sw_codec_init(
                    CY_AUDIO_CODEC_OPERATION_DECODE,
                    (void *)&dec_config,
                    &dec_handle);
        if(CY_RSLT_SUCCESS != result)
        {
            printf("sw encoder init failed\n");
            break;
        }
 
        input_buff = (uint8_t*)malloc(size);
        if(NULL == input_buff)
        {
            result = CY_RSLT_ASC_OUT_OF_MEMORY;
            printf("out of memory.\n");
            break;
        }
 
         result = cy_audio_sw_codec_decode_stream_info_header(
                                                        dec_handle,
                                                        input_buff,
                                                        &in_size,
                                                        &stream_info);
        if(CY_RSLT_SUCCESS != result)
        {
            printf("Parse header failed.\n");
            break;
        }
 
        result = cy_audio_sw_codec_get_decoder_recommended_outbuf_size(
                                dec_handle,&stream_info, &recommended_out_size);
        if(CY_RSLT_SUCCESS != result)
        {
            printf("recommended size\n");
            break;
        }
 
        output_buff = (uint8_t *)malloc(sizeof(uint8_t)*recommended_out_size);
        if(NULL == output_buff)
        {
            result = CY_RSLT_ASC_OUT_OF_MEMORY;
            printf("out of memory - out buff\n");
            break;
        }
 
        while(true)
        {
            result = cy_audio_sw_codec_decode(dec_handle, input_buff, &in_size, output_buff, &out_size);
            if(CY_RSLT_SUCCESS != result)
            {
                printf("Decoding failed\n");
                break;
            }
 
        }
 
    }while(false);
 
        result = cy_audio_sw_codec_deinit(&dec_handle);
        if(CY_RSLT_SUCCESS != result)
        {
            printf("sw encoder deinit failed\n");
        }
 
        if(input_buff)
        {
            free(input_buff);
            input_buff = NULL;
        }
 
        if(output_buff)
        {
            free(output_buff);
            output_buff = NULL;
        }
 
    return result;
}
 
cy_rslt_t cy_audio_sw_codec_decode_stream_info_cb(
        cy_audio_sw_codec_t handle,
        cy_audio_sw_codec_stream_info_t stream_info,
        void *callback_user_arg)
{
    printf("StreamInfoCbk:: Hdl:%p StreamInfo{Bitwidth:%d,Ch:%d,SampleR:%d}"
                    ,handle,stream_info.bitwidth,stream_info.channel,stream_info.sampling_rate );
    return CY_RSLT_SUCCESS;
}