| /* | |
| * 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; | |
| } | |