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