| /* |
| * Copyright (C) 2003 - 2016 Sony Corporation |
| * |
| * 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. |
| */ |
| |
| #include "ldaclib.h" |
| #include "ldac.h" |
| |
| #define LDACLIB_MAJOR_VERSION 01 |
| #define LDACLIB_MINOR_VERSION 00 |
| #define LDACLIB_BRANCH_VERSION 00 |
| |
| /*************************************************************************************************** |
| Local Assert Functions |
| ***************************************************************************************************/ |
| static int ldaclib_assert_sampling_rate_index( |
| int smplrate_id) |
| { |
| if ((LDAC_SMPLRATEID_0 <= smplrate_id) && (smplrate_id < LDAC_NSMPLRATEID)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_supported_sampling_rate_index( |
| int smplrate_id) |
| { |
| if ((LDAC_SMPLRATEID_0 <= smplrate_id) && (smplrate_id < LDAC_NSUPSMPLRATEID)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_channel_config_index( |
| int chconfig_id) |
| { |
| if ((chconfig_id == LDAC_CHCONFIGID_MN) |
| || (chconfig_id == LDAC_CHCONFIGID_DL) || (chconfig_id == LDAC_CHCONFIGID_ST)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_channel( |
| int ch) |
| { |
| if ((ch == LDAC_CHANNEL_1CH) || (ch == LDAC_CHANNEL_2CH)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_frame_length( |
| int frame_length) |
| { |
| if ((0 < frame_length) && (frame_length <= LDAC_MAXNBYTES)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_supported_frame_length( |
| int frame_length, |
| int chconfig_id) |
| { |
| if (chconfig_id == LDAC_CHCONFIGID_MN) { |
| if ((LDAC_MINSUPNBYTES/2 <= frame_length) && (frame_length <= LDAC_MAXSUPNBYTES/2)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| else if ((chconfig_id == LDAC_CHCONFIGID_DL) || (chconfig_id == LDAC_CHCONFIGID_ST)) { |
| if ((LDAC_MINSUPNBYTES <= frame_length) && (frame_length <= LDAC_MAXSUPNBYTES)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_frame_status( |
| int frame_status) |
| { |
| if ((LDAC_FRMSTAT_LEV_0 <= frame_status) && (frame_status <= LDAC_FRMSTAT_LEV_3)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_nlnn_shift( |
| int nlnn_shift) |
| { |
| if ((-2 <= nlnn_shift) && (nlnn_shift < LDAC_NSFTSTEP-2)) { |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| static int ldaclib_assert_sample_format( |
| LDAC_SMPL_FMT_T sample_format) |
| { |
| #ifndef _32BIT_FIXED_POINT |
| if ((LDAC_SMPL_FMT_S16 <= sample_format) && (sample_format <= LDAC_SMPL_FMT_F32)) { |
| #else /* _32BIT_FIXED_POINT */ |
| if ((LDAC_SMPL_FMT_S16 <= sample_format) && (sample_format <= LDAC_SMPL_FMT_S32)) { |
| #endif /* _32BIT_FIXED_POINT */ |
| return LDAC_TRUE; |
| } |
| else { |
| return LDAC_FALSE; |
| } |
| } |
| |
| |
| /*************************************************************************************************** |
| Common API Functions |
| ***************************************************************************************************/ |
| |
| /*************************************************************************************************** |
| Get Library Version |
| ***************************************************************************************************/ |
| DECLSPEC int ldaclib_get_version(void) { |
| return (LDACLIB_MAJOR_VERSION<<16) | (LDACLIB_MINOR_VERSION<<8) | LDACLIB_BRANCH_VERSION; |
| } |
| |
| DECLSPEC int ldaclib_get_major_version(void) { |
| return LDACLIB_MAJOR_VERSION; |
| } |
| |
| DECLSPEC int ldaclib_get_minor_version(void) { |
| return LDACLIB_MINOR_VERSION; |
| } |
| |
| DECLSPEC int ldaclib_get_branch_version(void) { |
| return LDACLIB_BRANCH_VERSION; |
| } |
| |
| /*************************************************************************************************** |
| Get Basic Parameters |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_get_sampling_rate_index( |
| int smplrate, |
| int *p_smplrate_id) |
| { |
| if (smplrate == 44100) { |
| *p_smplrate_id = LDAC_SMPLRATEID_0; |
| } |
| else if (smplrate == 48000) { |
| *p_smplrate_id = LDAC_SMPLRATEID_1; |
| } |
| else if (smplrate == 88200) { |
| *p_smplrate_id = LDAC_SMPLRATEID_2; |
| } |
| else if (smplrate == 96000) { |
| *p_smplrate_id = LDAC_SMPLRATEID_3; |
| } |
| else { |
| return LDAC_E_FAIL; |
| } |
| |
| return LDAC_S_OK; |
| } |
| |
| DECLSPEC LDAC_RESULT ldaclib_get_sampling_rate( |
| int smplrate_id, |
| int *p_smplrate) |
| { |
| if (!ldaclib_assert_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| |
| *p_smplrate = ga_smplrate_ldac[smplrate_id]; |
| |
| return LDAC_S_OK; |
| } |
| |
| DECLSPEC LDAC_RESULT ldaclib_get_frame_samples( |
| int smplrate_id, |
| int *p_framesmpls) |
| { |
| if (!ldaclib_assert_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| |
| *p_framesmpls = ga_framesmpls_ldac[smplrate_id]; |
| |
| return LDAC_S_OK; |
| } |
| |
| DECLSPEC LDAC_RESULT ldaclib_get_nlnn( |
| int smplrate_id, |
| int *p_nlnn) |
| { |
| if (!ldaclib_assert_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| |
| *p_nlnn = ga_ln_framesmpls_ldac[smplrate_id]; |
| |
| return LDAC_S_OK; |
| } |
| |
| DECLSPEC LDAC_RESULT ldaclib_get_channel( |
| int chconfig_id, |
| int *p_ch) |
| { |
| if (!ldaclib_assert_channel_config_index(chconfig_id)) { |
| return LDAC_E_FAIL; |
| } |
| |
| *p_ch = ga_ch_ldac[chconfig_id]; |
| |
| return LDAC_S_OK; |
| } |
| |
| DECLSPEC LDAC_RESULT ldaclib_get_channel_config_index( |
| int ch, |
| int *p_chconfig_id) |
| { |
| if (!ldaclib_assert_channel(ch)) { |
| return LDAC_E_FAIL; |
| } |
| |
| *p_chconfig_id = ga_chconfig_id_ldac[ch]; |
| |
| return LDAC_S_OK; |
| } |
| |
| DECLSPEC LDAC_RESULT ldaclib_check_nlnn_shift( |
| int smplrate_id, |
| int nlnn_shift) |
| { |
| if (!ldaclib_assert_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) { |
| return LDAC_E_FAIL; |
| } |
| if (!ldaclib_assert_nlnn_shift(nlnn_shift)) { |
| return LDAC_E_FAIL; |
| } |
| |
| if (gaa_nlnn_shift_ldac[smplrate_id][nlnn_shift+2] < 0) { |
| return LDAC_E_FAIL; |
| } |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Get Handle |
| ***************************************************************************************************/ |
| DECLSPEC HANDLE_LDAC ldaclib_get_handle( |
| void) |
| { |
| HANDLE_LDAC hData; |
| |
| hData = (HANDLE_LDAC)malloc(sizeof(HANDLE_LDAC_STRUCT)); |
| if (hData != (HANDLE_LDAC)NULL) { |
| clear_data_ldac(hData, sizeof(HANDLE_LDAC_STRUCT)); |
| hData->sfinfo.p_mempos = (char *)NULL; |
| hData->error_code = LDAC_ERR_NONE; |
| } |
| |
| return hData; |
| } |
| |
| /*************************************************************************************************** |
| Free Handle |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_free_handle( |
| HANDLE_LDAC hData) |
| { |
| if (hData != (HANDLE_LDAC)NULL) { |
| if (hData->sfinfo.p_mempos != (char *)NULL) { |
| return LDAC_S_OK; |
| } |
| |
| free(hData); |
| } |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Set Configuration Information |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_set_config_info( |
| HANDLE_LDAC hData, |
| int smplrate_id, |
| int chconfig_id, |
| int frame_length, |
| int frame_status) |
| { |
| CFG *p_cfg = &hData->sfinfo.cfg; |
| |
| if (!ldaclib_assert_sampling_rate_index(smplrate_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_SAMPLING_RATE; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_SUP_SAMPLING_RATE; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_channel_config_index(chconfig_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_CHANNEL_CONFIG; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_frame_length(frame_length)) { |
| hData->error_code = LDAC_ERR_ASSERT_FRAME_LENGTH; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_supported_frame_length(frame_length, chconfig_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_SUP_FRAME_LENGTH; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_frame_status(frame_status)) { |
| hData->error_code = LDAC_ERR_ASSERT_FRAME_STATUS; |
| return LDAC_E_FAIL; |
| } |
| |
| p_cfg->smplrate_id = smplrate_id; |
| p_cfg->chconfig_id = chconfig_id; |
| p_cfg->frame_length = frame_length; |
| p_cfg->frame_status = frame_status; |
| |
| ldaclib_get_channel(chconfig_id, &p_cfg->ch); |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Get Configuration Information |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_get_config_info( |
| HANDLE_LDAC hData, |
| int *p_smplrate_id, |
| int *p_chconfig_id, |
| int *p_frame_length, |
| int *p_frame_status) |
| { |
| CFG *p_cfg = &hData->sfinfo.cfg; |
| |
| *p_smplrate_id = p_cfg->smplrate_id; |
| *p_chconfig_id = p_cfg->chconfig_id; |
| *p_frame_length = p_cfg->frame_length; |
| *p_frame_status = p_cfg->frame_status; |
| |
| return LDAC_S_OK; |
| } |
| |
| |
| /*************************************************************************************************** |
| Set Frame Header |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_set_frame_header( |
| HANDLE_LDAC hData, |
| unsigned char *p_stream, |
| int smplrate_id, |
| int chconfig_id, |
| int frame_length, |
| int frame_status) |
| { |
| if (!ldaclib_assert_sampling_rate_index(smplrate_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_SAMPLING_RATE; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_SUP_SAMPLING_RATE; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_channel_config_index(chconfig_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_CHANNEL_CONFIG; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_frame_length(frame_length)) { |
| hData->error_code = LDAC_ERR_ASSERT_FRAME_LENGTH; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_supported_frame_length(frame_length, chconfig_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_SUP_FRAME_LENGTH; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_frame_status(frame_status)) { |
| hData->error_code = LDAC_ERR_ASSERT_FRAME_STATUS; |
| return LDAC_E_FAIL; |
| } |
| |
| pack_frame_header_ldac(smplrate_id, chconfig_id, frame_length, frame_status, |
| (STREAM *)p_stream); |
| |
| return LDAC_S_OK; |
| } |
| |
| |
| /*************************************************************************************************** |
| Encoder API Functions |
| ***************************************************************************************************/ |
| |
| /*************************************************************************************************** |
| Get Encoder Setting |
| ***************************************************************************************************/ |
| #define LDAC_ENC_NSETTING 15 |
| #define LDAC_ENC_NPROPERTY 9 |
| |
| static const int saa_encode_setting_ldac[LDAC_ENC_NSETTING][LDAC_ENC_NPROPERTY] = { |
| {0, 512, 17, 0, 28, 44, 8, 24, 0}, |
| {0, 256, 17, 0, 28, 44, 6, 22, 0}, |
| #ifdef MODIFY_LDAC_ENC_SETTING_FOR_ABR_DEBUG // See file "ldacBT_abr.h" for description |
| {0, 164, 16, 0, 18, 32, 7, 23, 0}, |
| {0, 110, 8, 0, 16, 32, 10, 31, 0}, |
| {0, 82, 6, 0, 16, 32, 12, 31, 0}, |
| {0, 66, 4, 0, 14, 26, 12, 31, 0}, |
| {0, 54, 2, 0, 14, 26, 12, 31, 0}, |
| {0, 46, 2, 1, 10, 26, 12, 31, 0}, |
| {0, 40, 2, 2, 10, 26, 12, 31, 0}, |
| {0, 36, 2, 2, 8, 26, 12, 31, 0}, |
| {0, 32, 2, 2, 8, 26, 16, 31, 0}, |
| {0, 30, 2, 2, 4, 26, 16, 31, 0}, |
| {0, 26, 2, 3, 4, 26, 16, 31, 0}, |
| {0, 24, 2, 3, 4, 26, 16, 31, 0}, |
| #else |
| {0, 164, 16, 0, 18, 32, 7, 23, 0}, |
| {0, 110, 13, 0, 16, 32, 10, 31, 0}, |
| {0, 82, 12, 0, 16, 32, 12, 31, 0}, |
| {0, 66, 11, 0, 14, 26, 12, 31, 0}, |
| {0, 54, 10, 0, 14, 26, 12, 31, 0}, |
| {0, 46, 9, 1, 10, 26, 12, 31, 0}, |
| {0, 40, 8, 2, 10, 26, 12, 31, 0}, |
| {0, 36, 7, 2, 8, 26, 12, 31, 0}, |
| {0, 32, 6, 2, 8, 26, 16, 31, 0}, |
| {0, 30, 5, 2, 4, 26, 16, 31, 0}, |
| {0, 26, 4, 3, 4, 26, 16, 31, 0}, |
| {0, 24, 3, 3, 4, 26, 16, 31, 0}, |
| #endif |
| {0, 22, 2, 3, 4, 26, 16, 31, 0}, |
| }; |
| |
| DECLSPEC LDAC_RESULT ldaclib_get_encode_setting( |
| int nbytes_ch, |
| int smplrate_id, |
| int *p_nbands, |
| int *p_grad_mode, |
| int *p_grad_qu_l, |
| int *p_grad_qu_h, |
| int *p_grad_os_l, |
| int *p_grad_os_h, |
| int *p_abc_status) |
| { |
| int i, id; |
| |
| id = LDAC_ENC_NSETTING-1; |
| for (i = LDAC_ENC_NSETTING-1; i >= 0; i--) { |
| if (nbytes_ch >= saa_encode_setting_ldac[i][1]) { |
| id = i; |
| } |
| } |
| |
| *p_nbands = min_ldac(saa_encode_setting_ldac[id][2], ga_max_nbands_ldac[smplrate_id]); |
| *p_grad_mode = saa_encode_setting_ldac[id][3]; |
| *p_grad_qu_l = saa_encode_setting_ldac[id][4]; |
| *p_grad_qu_h = saa_encode_setting_ldac[id][5]; |
| *p_grad_os_l = saa_encode_setting_ldac[id][6]; |
| *p_grad_os_h = saa_encode_setting_ldac[id][7]; |
| *p_abc_status = saa_encode_setting_ldac[id][8]; |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Set Frame Length |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_set_encode_frame_length( |
| HANDLE_LDAC hData, |
| int frame_length) |
| { |
| CFG *p_cfg = &hData->sfinfo.cfg; |
| |
| if (!ldaclib_assert_frame_length(frame_length)) { |
| hData->error_code = LDAC_ERR_ASSERT_FRAME_LENGTH; |
| return LDAC_E_FAIL; |
| } |
| |
| if (!ldaclib_assert_supported_frame_length(frame_length, p_cfg->chconfig_id)) { |
| hData->error_code = LDAC_ERR_ASSERT_SUP_FRAME_LENGTH; |
| return LDAC_E_FAIL; |
| } |
| |
| p_cfg->frame_length = frame_length; |
| |
| calc_initial_bits_ldac(&hData->sfinfo); |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Get Frame Length |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_get_encode_frame_length( |
| HANDLE_LDAC hData, |
| int *p_frame_length) |
| { |
| CFG *p_cfg = &hData->sfinfo.cfg; |
| |
| *p_frame_length = p_cfg->frame_length; |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Set Information |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_set_encode_info( |
| HANDLE_LDAC hData, |
| int nbands, |
| int grad_mode, |
| int grad_qu_l, |
| int grad_qu_h, |
| int grad_os_l, |
| int grad_os_h, |
| int abc_status) |
| { |
| if ((nbands < LDAC_BAND_OFFSET) || |
| (ga_max_nbands_ldac[hData->sfinfo.cfg.smplrate_id] < nbands)) { |
| hData->error_code = LDAC_ERR_ENC_ILL_NBANDS; |
| return LDAC_E_FAIL; |
| } |
| |
| if ((grad_mode < LDAC_MODE_0) || (LDAC_MODE_3 < grad_mode)) { |
| hData->error_code = LDAC_ERR_ENC_ILL_GRADMODE; |
| return LDAC_E_FAIL; |
| } |
| |
| if (grad_mode == LDAC_MODE_0) { |
| if ((grad_qu_l < 0) || (LDAC_MAXGRADQU <= grad_qu_l)) { |
| hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_A; |
| return LDAC_E_FAIL; |
| } |
| |
| if ((grad_qu_h < 1) || (LDAC_MAXGRADQU+1 <= grad_qu_h) || (grad_qu_h < grad_qu_l)) { |
| hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_B; |
| return LDAC_E_FAIL; |
| } |
| |
| if ((grad_os_h < 0) || (LDAC_NIDSF <= grad_os_h)) { |
| hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_C; |
| return LDAC_E_FAIL; |
| } |
| } |
| else { |
| if ((grad_qu_l < 0) || (LDAC_DEFGRADQUH < grad_qu_l)) { |
| hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_A; |
| return LDAC_E_FAIL; |
| } |
| } |
| |
| if ((grad_os_l < 0) || (LDAC_NIDSF <= grad_os_l)) { |
| hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_D; |
| return LDAC_E_FAIL; |
| } |
| |
| hData->nbands = nbands; |
| hData->grad_mode = grad_mode; |
| hData->grad_qu_l = grad_qu_l; |
| hData->grad_os_l = grad_os_l; |
| if (grad_mode == LDAC_MODE_0) { |
| hData->grad_qu_h = grad_qu_h; |
| hData->grad_os_h = grad_os_h; |
| } |
| else { |
| hData->grad_qu_h = LDAC_DEFGRADQUH; |
| hData->grad_os_h = LDAC_DEFGRADOSH; |
| } |
| hData->abc_status = abc_status; |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Initialize |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_init_encode( |
| HANDLE_LDAC hData) |
| { |
| SFINFO *p_sfinfo = &hData->sfinfo; |
| LDAC_RESULT result; |
| |
| |
| ldaclib_get_nlnn(p_sfinfo->cfg.smplrate_id, &hData->nlnn); |
| |
| set_mdct_table_ldac(hData->nlnn); |
| |
| result = init_encode_ldac(p_sfinfo); |
| if (result != LDAC_S_OK) { |
| hData->error_code = LDAC_ERR_ENC_INIT_ALLOC; |
| return LDAC_E_FAIL; |
| } |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Free |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_free_encode( |
| HANDLE_LDAC hData) |
| { |
| if (hData->sfinfo.p_mempos == NULL) { |
| free_encode_ldac(&hData->sfinfo); |
| } |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Encode |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_encode( |
| HANDLE_LDAC hData, |
| char *ap_pcm[], |
| LDAC_SMPL_FMT_T sample_format, |
| unsigned char *p_stream, |
| int *p_nbytes_used) |
| { |
| SFINFO *p_sfinfo = &hData->sfinfo; |
| int loc = 0; |
| int error_code; |
| int frame_length; |
| |
| |
| if (!ldaclib_assert_sample_format(sample_format)) { |
| hData->error_code = LDAC_ERR_ILL_SMPL_FORMAT; |
| return LDAC_E_FAIL; |
| } |
| |
| frame_length = p_sfinfo->cfg.frame_length; |
| clear_data_ldac(p_stream, frame_length*sizeof(unsigned char)); |
| |
| set_input_pcm_ldac(p_sfinfo, ap_pcm, sample_format, hData->nlnn); |
| |
| proc_mdct_ldac(p_sfinfo, hData->nlnn); |
| |
| p_sfinfo->cfg.frame_status = ana_frame_status_ldac(p_sfinfo, hData->nlnn); |
| |
| error_code = encode_ldac(p_sfinfo, hData->nbands, hData->grad_mode, |
| hData->grad_qu_l, hData->grad_qu_h, hData->grad_os_l, hData->grad_os_h, |
| hData->abc_status); |
| if (LDAC_ERROR(error_code) && !LDAC_FATAL_ERROR(error_code)) { |
| int error_code2; |
| error_code2 = pack_null_data_frame_ldac(p_sfinfo, (STREAM *)p_stream, &loc, p_nbytes_used); |
| if (LDAC_FATAL_ERROR(error_code2)) { |
| clear_data_ldac(p_stream, frame_length*sizeof(unsigned char)); |
| hData->error_code = error_code2; |
| return LDAC_E_FAIL; |
| } |
| hData->error_code = error_code; |
| return LDAC_S_FALSE; |
| } |
| |
| error_code = pack_raw_data_frame_ldac(p_sfinfo, (STREAM *)p_stream, &loc, p_nbytes_used); |
| if (LDAC_FATAL_ERROR(error_code)) { |
| int error_code2; |
| loc = 0; |
| clear_data_ldac(p_stream, frame_length*sizeof(unsigned char)); |
| error_code2 = pack_null_data_frame_ldac(p_sfinfo, (STREAM *)p_stream, &loc, p_nbytes_used); |
| if (LDAC_FATAL_ERROR(error_code2)) { |
| clear_data_ldac(p_stream, frame_length*sizeof(unsigned char)); |
| hData->error_code = error_code2; |
| return LDAC_E_FAIL; |
| } |
| hData->error_code = error_code; |
| return LDAC_E_FAIL; |
| } |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Flush Encode |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_flush_encode( |
| HANDLE_LDAC hData, |
| LDAC_SMPL_FMT_T sample_format, |
| unsigned char *p_stream, |
| int *p_nbytes_used) |
| { |
| LDAC_RESULT result; |
| int ich; |
| char *ap_buf[LDAC_PRCNCH]; |
| int a_buf[LDAC_MAXLSU*LDAC_PRCNCH]; |
| |
| if (!ldaclib_assert_sample_format(sample_format)) { |
| hData->error_code = LDAC_ERR_ILL_SMPL_FORMAT; |
| return LDAC_E_FAIL; |
| } |
| |
| clear_data_ldac(a_buf, (LDAC_MAXLSU*LDAC_PRCNCH)*sizeof(int)); |
| |
| for (ich = 0; ich < LDAC_PRCNCH; ich++) { |
| ap_buf[ich] = (char *)(a_buf + ich * LDAC_MAXLSU); |
| } |
| |
| result = ldaclib_encode(hData, ap_buf, sample_format, p_stream, p_nbytes_used); |
| |
| return result; |
| } |
| |
| |
| |
| |
| /*************************************************************************************************** |
| Error Code Dispatch |
| ***************************************************************************************************/ |
| |
| /*************************************************************************************************** |
| Clear Error Code at Handle Level |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_clear_error_code( |
| HANDLE_LDAC hData) |
| { |
| hData->error_code = LDAC_ERR_NONE; |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Get Error Code at Handle Level |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_get_error_code( |
| HANDLE_LDAC hData, |
| int *p_error_code) |
| { |
| *p_error_code = hData->error_code; |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Clear Error Code at Internal Block Level |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_clear_internal_error_code( |
| HANDLE_LDAC hData) |
| { |
| hData->sfinfo.error_code = LDAC_ERR_NONE; |
| |
| return LDAC_S_OK; |
| } |
| |
| /*************************************************************************************************** |
| Get Error Code at Internal Block Level |
| ***************************************************************************************************/ |
| DECLSPEC LDAC_RESULT ldaclib_get_internal_error_code( |
| HANDLE_LDAC hData, |
| int *p_error_code) |
| { |
| *p_error_code = hData->sfinfo.error_code; |
| |
| return LDAC_S_OK; |
| } |
| |
