1 /*
2 * Copyright (C) 2003 - 2016 Sony Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "ldaclib.h"
18 #include "ldac.h"
19
20 #define LDACLIB_MAJOR_VERSION 01
21 #define LDACLIB_MINOR_VERSION 00
22 #define LDACLIB_BRANCH_VERSION 00
23
24 /***************************************************************************************************
25 Local Assert Functions
26 ***************************************************************************************************/
ldaclib_assert_sampling_rate_index(int smplrate_id)27 static int ldaclib_assert_sampling_rate_index(
28 int smplrate_id)
29 {
30 if ((LDAC_SMPLRATEID_0 <= smplrate_id) && (smplrate_id < LDAC_NSMPLRATEID)) {
31 return LDAC_TRUE;
32 }
33 else {
34 return LDAC_FALSE;
35 }
36 }
37
ldaclib_assert_supported_sampling_rate_index(int smplrate_id)38 static int ldaclib_assert_supported_sampling_rate_index(
39 int smplrate_id)
40 {
41 if ((LDAC_SMPLRATEID_0 <= smplrate_id) && (smplrate_id < LDAC_NSUPSMPLRATEID)) {
42 return LDAC_TRUE;
43 }
44 else {
45 return LDAC_FALSE;
46 }
47 }
48
ldaclib_assert_channel_config_index(int chconfig_id)49 static int ldaclib_assert_channel_config_index(
50 int chconfig_id)
51 {
52 if ((chconfig_id == LDAC_CHCONFIGID_MN)
53 || (chconfig_id == LDAC_CHCONFIGID_DL) || (chconfig_id == LDAC_CHCONFIGID_ST)) {
54 return LDAC_TRUE;
55 }
56 else {
57 return LDAC_FALSE;
58 }
59 }
60
ldaclib_assert_channel(int ch)61 static int ldaclib_assert_channel(
62 int ch)
63 {
64 if ((ch == LDAC_CHANNEL_1CH) || (ch == LDAC_CHANNEL_2CH)) {
65 return LDAC_TRUE;
66 }
67 else {
68 return LDAC_FALSE;
69 }
70 }
71
ldaclib_assert_frame_length(int frame_length)72 static int ldaclib_assert_frame_length(
73 int frame_length)
74 {
75 if ((0 < frame_length) && (frame_length <= LDAC_MAXNBYTES)) {
76 return LDAC_TRUE;
77 }
78 else {
79 return LDAC_FALSE;
80 }
81 }
82
ldaclib_assert_supported_frame_length(int frame_length,int chconfig_id)83 static int ldaclib_assert_supported_frame_length(
84 int frame_length,
85 int chconfig_id)
86 {
87 if (chconfig_id == LDAC_CHCONFIGID_MN) {
88 if ((LDAC_MINSUPNBYTES/2 <= frame_length) && (frame_length <= LDAC_MAXSUPNBYTES/2)) {
89 return LDAC_TRUE;
90 }
91 else {
92 return LDAC_FALSE;
93 }
94 }
95 else if ((chconfig_id == LDAC_CHCONFIGID_DL) || (chconfig_id == LDAC_CHCONFIGID_ST)) {
96 if ((LDAC_MINSUPNBYTES <= frame_length) && (frame_length <= LDAC_MAXSUPNBYTES)) {
97 return LDAC_TRUE;
98 }
99 else {
100 return LDAC_FALSE;
101 }
102 }
103 else {
104 return LDAC_FALSE;
105 }
106 }
107
ldaclib_assert_frame_status(int frame_status)108 static int ldaclib_assert_frame_status(
109 int frame_status)
110 {
111 if ((LDAC_FRMSTAT_LEV_0 <= frame_status) && (frame_status <= LDAC_FRMSTAT_LEV_3)) {
112 return LDAC_TRUE;
113 }
114 else {
115 return LDAC_FALSE;
116 }
117 }
118
ldaclib_assert_nlnn_shift(int nlnn_shift)119 static int ldaclib_assert_nlnn_shift(
120 int nlnn_shift)
121 {
122 if ((-2 <= nlnn_shift) && (nlnn_shift < LDAC_NSFTSTEP-2)) {
123 return LDAC_TRUE;
124 }
125 else {
126 return LDAC_FALSE;
127 }
128 }
129
ldaclib_assert_sample_format(LDAC_SMPL_FMT_T sample_format)130 static int ldaclib_assert_sample_format(
131 LDAC_SMPL_FMT_T sample_format)
132 {
133 #ifndef _32BIT_FIXED_POINT
134 if ((LDAC_SMPL_FMT_S16 <= sample_format) && (sample_format <= LDAC_SMPL_FMT_F32)) {
135 #else /* _32BIT_FIXED_POINT */
136 if ((LDAC_SMPL_FMT_S16 <= sample_format) && (sample_format <= LDAC_SMPL_FMT_S32)) {
137 #endif /* _32BIT_FIXED_POINT */
138 return LDAC_TRUE;
139 }
140 else {
141 return LDAC_FALSE;
142 }
143 }
144
145
146 /***************************************************************************************************
147 Common API Functions
148 ***************************************************************************************************/
149
150 /***************************************************************************************************
151 Get Library Version
152 ***************************************************************************************************/
153 DECLSPEC int ldaclib_get_version(void) {
154 return (LDACLIB_MAJOR_VERSION<<16) | (LDACLIB_MINOR_VERSION<<8) | LDACLIB_BRANCH_VERSION;
155 }
156
157 DECLSPEC int ldaclib_get_major_version(void) {
158 return LDACLIB_MAJOR_VERSION;
159 }
160
161 DECLSPEC int ldaclib_get_minor_version(void) {
162 return LDACLIB_MINOR_VERSION;
163 }
164
165 DECLSPEC int ldaclib_get_branch_version(void) {
166 return LDACLIB_BRANCH_VERSION;
167 }
168
169 /***************************************************************************************************
170 Get Basic Parameters
171 ***************************************************************************************************/
172 DECLSPEC LDAC_RESULT ldaclib_get_sampling_rate_index(
173 int smplrate,
174 int *p_smplrate_id)
175 {
176 if (smplrate == 44100) {
177 *p_smplrate_id = LDAC_SMPLRATEID_0;
178 }
179 else if (smplrate == 48000) {
180 *p_smplrate_id = LDAC_SMPLRATEID_1;
181 }
182 else if (smplrate == 88200) {
183 *p_smplrate_id = LDAC_SMPLRATEID_2;
184 }
185 else if (smplrate == 96000) {
186 *p_smplrate_id = LDAC_SMPLRATEID_3;
187 }
188 else {
189 return LDAC_E_FAIL;
190 }
191
192 return LDAC_S_OK;
193 }
194
195 DECLSPEC LDAC_RESULT ldaclib_get_sampling_rate(
196 int smplrate_id,
197 int *p_smplrate)
198 {
199 if (!ldaclib_assert_sampling_rate_index(smplrate_id)) {
200 return LDAC_E_FAIL;
201 }
202 if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) {
203 return LDAC_E_FAIL;
204 }
205
206 *p_smplrate = ga_smplrate_ldac[smplrate_id];
207
208 return LDAC_S_OK;
209 }
210
211 DECLSPEC LDAC_RESULT ldaclib_get_frame_samples(
212 int smplrate_id,
213 int *p_framesmpls)
214 {
215 if (!ldaclib_assert_sampling_rate_index(smplrate_id)) {
216 return LDAC_E_FAIL;
217 }
218 if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) {
219 return LDAC_E_FAIL;
220 }
221
222 *p_framesmpls = ga_framesmpls_ldac[smplrate_id];
223
224 return LDAC_S_OK;
225 }
226
227 DECLSPEC LDAC_RESULT ldaclib_get_nlnn(
228 int smplrate_id,
229 int *p_nlnn)
230 {
231 if (!ldaclib_assert_sampling_rate_index(smplrate_id)) {
232 return LDAC_E_FAIL;
233 }
234 if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) {
235 return LDAC_E_FAIL;
236 }
237
238 *p_nlnn = ga_ln_framesmpls_ldac[smplrate_id];
239
240 return LDAC_S_OK;
241 }
242
243 DECLSPEC LDAC_RESULT ldaclib_get_channel(
244 int chconfig_id,
245 int *p_ch)
246 {
247 if (!ldaclib_assert_channel_config_index(chconfig_id)) {
248 return LDAC_E_FAIL;
249 }
250
251 *p_ch = ga_ch_ldac[chconfig_id];
252
253 return LDAC_S_OK;
254 }
255
256 DECLSPEC LDAC_RESULT ldaclib_get_channel_config_index(
257 int ch,
258 int *p_chconfig_id)
259 {
260 if (!ldaclib_assert_channel(ch)) {
261 return LDAC_E_FAIL;
262 }
263
264 *p_chconfig_id = ga_chconfig_id_ldac[ch];
265
266 return LDAC_S_OK;
267 }
268
269 DECLSPEC LDAC_RESULT ldaclib_check_nlnn_shift(
270 int smplrate_id,
271 int nlnn_shift)
272 {
273 if (!ldaclib_assert_sampling_rate_index(smplrate_id)) {
274 return LDAC_E_FAIL;
275 }
276 if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) {
277 return LDAC_E_FAIL;
278 }
279 if (!ldaclib_assert_nlnn_shift(nlnn_shift)) {
280 return LDAC_E_FAIL;
281 }
282
283 if (gaa_nlnn_shift_ldac[smplrate_id][nlnn_shift+2] < 0) {
284 return LDAC_E_FAIL;
285 }
286
287 return LDAC_S_OK;
288 }
289
290 /***************************************************************************************************
291 Get Handle
292 ***************************************************************************************************/
293 DECLSPEC HANDLE_LDAC ldaclib_get_handle(
294 void)
295 {
296 HANDLE_LDAC hData;
297
298 hData = (HANDLE_LDAC)malloc(sizeof(HANDLE_LDAC_STRUCT));
299 if (hData != (HANDLE_LDAC)NULL) {
300 clear_data_ldac(hData, sizeof(HANDLE_LDAC_STRUCT));
301 hData->sfinfo.p_mempos = (char *)NULL;
302 hData->error_code = LDAC_ERR_NONE;
303 }
304
305 return hData;
306 }
307
308 /***************************************************************************************************
309 Free Handle
310 ***************************************************************************************************/
311 DECLSPEC LDAC_RESULT ldaclib_free_handle(
312 HANDLE_LDAC hData)
313 {
314 if (hData != (HANDLE_LDAC)NULL) {
315 if (hData->sfinfo.p_mempos != (char *)NULL) {
316 return LDAC_S_OK;
317 }
318
319 free(hData);
320 }
321
322 return LDAC_S_OK;
323 }
324
325 /***************************************************************************************************
326 Set Configuration Information
327 ***************************************************************************************************/
328 DECLSPEC LDAC_RESULT ldaclib_set_config_info(
329 HANDLE_LDAC hData,
330 int smplrate_id,
331 int chconfig_id,
332 int frame_length,
333 int frame_status)
334 {
335 CFG *p_cfg = &hData->sfinfo.cfg;
336
337 if (!ldaclib_assert_sampling_rate_index(smplrate_id)) {
338 hData->error_code = LDAC_ERR_ASSERT_SAMPLING_RATE;
339 return LDAC_E_FAIL;
340 }
341
342 if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) {
343 hData->error_code = LDAC_ERR_ASSERT_SUP_SAMPLING_RATE;
344 return LDAC_E_FAIL;
345 }
346
347 if (!ldaclib_assert_channel_config_index(chconfig_id)) {
348 hData->error_code = LDAC_ERR_ASSERT_CHANNEL_CONFIG;
349 return LDAC_E_FAIL;
350 }
351
352 if (!ldaclib_assert_frame_length(frame_length)) {
353 hData->error_code = LDAC_ERR_ASSERT_FRAME_LENGTH;
354 return LDAC_E_FAIL;
355 }
356
357 if (!ldaclib_assert_supported_frame_length(frame_length, chconfig_id)) {
358 hData->error_code = LDAC_ERR_ASSERT_SUP_FRAME_LENGTH;
359 return LDAC_E_FAIL;
360 }
361
362 if (!ldaclib_assert_frame_status(frame_status)) {
363 hData->error_code = LDAC_ERR_ASSERT_FRAME_STATUS;
364 return LDAC_E_FAIL;
365 }
366
367 p_cfg->smplrate_id = smplrate_id;
368 p_cfg->chconfig_id = chconfig_id;
369 p_cfg->frame_length = frame_length;
370 p_cfg->frame_status = frame_status;
371
372 ldaclib_get_channel(chconfig_id, &p_cfg->ch);
373
374 return LDAC_S_OK;
375 }
376
377 /***************************************************************************************************
378 Get Configuration Information
379 ***************************************************************************************************/
380 DECLSPEC LDAC_RESULT ldaclib_get_config_info(
381 HANDLE_LDAC hData,
382 int *p_smplrate_id,
383 int *p_chconfig_id,
384 int *p_frame_length,
385 int *p_frame_status)
386 {
387 CFG *p_cfg = &hData->sfinfo.cfg;
388
389 *p_smplrate_id = p_cfg->smplrate_id;
390 *p_chconfig_id = p_cfg->chconfig_id;
391 *p_frame_length = p_cfg->frame_length;
392 *p_frame_status = p_cfg->frame_status;
393
394 return LDAC_S_OK;
395 }
396
397
398 /***************************************************************************************************
399 Set Frame Header
400 ***************************************************************************************************/
401 DECLSPEC LDAC_RESULT ldaclib_set_frame_header(
402 HANDLE_LDAC hData,
403 unsigned char *p_stream,
404 int smplrate_id,
405 int chconfig_id,
406 int frame_length,
407 int frame_status)
408 {
409 if (!ldaclib_assert_sampling_rate_index(smplrate_id)) {
410 hData->error_code = LDAC_ERR_ASSERT_SAMPLING_RATE;
411 return LDAC_E_FAIL;
412 }
413
414 if (!ldaclib_assert_supported_sampling_rate_index(smplrate_id)) {
415 hData->error_code = LDAC_ERR_ASSERT_SUP_SAMPLING_RATE;
416 return LDAC_E_FAIL;
417 }
418
419 if (!ldaclib_assert_channel_config_index(chconfig_id)) {
420 hData->error_code = LDAC_ERR_ASSERT_CHANNEL_CONFIG;
421 return LDAC_E_FAIL;
422 }
423
424 if (!ldaclib_assert_frame_length(frame_length)) {
425 hData->error_code = LDAC_ERR_ASSERT_FRAME_LENGTH;
426 return LDAC_E_FAIL;
427 }
428
429 if (!ldaclib_assert_supported_frame_length(frame_length, chconfig_id)) {
430 hData->error_code = LDAC_ERR_ASSERT_SUP_FRAME_LENGTH;
431 return LDAC_E_FAIL;
432 }
433
434 if (!ldaclib_assert_frame_status(frame_status)) {
435 hData->error_code = LDAC_ERR_ASSERT_FRAME_STATUS;
436 return LDAC_E_FAIL;
437 }
438
439 pack_frame_header_ldac(smplrate_id, chconfig_id, frame_length, frame_status,
440 (STREAM *)p_stream);
441
442 return LDAC_S_OK;
443 }
444
445
446 /***************************************************************************************************
447 Encoder API Functions
448 ***************************************************************************************************/
449
450 /***************************************************************************************************
451 Get Encoder Setting
452 ***************************************************************************************************/
453 #define LDAC_ENC_NSETTING 15
454 #define LDAC_ENC_NPROPERTY 9
455
456 static const int saa_encode_setting_ldac[LDAC_ENC_NSETTING][LDAC_ENC_NPROPERTY] = {
457 {0, 512, 17, 0, 28, 44, 8, 24, 0},
458 {0, 256, 17, 0, 28, 44, 6, 22, 0},
459 #ifdef MODIFY_LDAC_ENC_SETTING_FOR_ABR_DEBUG // See file "ldacBT_abr.h" for description
460 {0, 164, 16, 0, 18, 32, 7, 23, 0},
461 {0, 110, 8, 0, 16, 32, 10, 31, 0},
462 {0, 82, 6, 0, 16, 32, 12, 31, 0},
463 {0, 66, 4, 0, 14, 26, 12, 31, 0},
464 {0, 54, 2, 0, 14, 26, 12, 31, 0},
465 {0, 46, 2, 1, 10, 26, 12, 31, 0},
466 {0, 40, 2, 2, 10, 26, 12, 31, 0},
467 {0, 36, 2, 2, 8, 26, 12, 31, 0},
468 {0, 32, 2, 2, 8, 26, 16, 31, 0},
469 {0, 30, 2, 2, 4, 26, 16, 31, 0},
470 {0, 26, 2, 3, 4, 26, 16, 31, 0},
471 {0, 24, 2, 3, 4, 26, 16, 31, 0},
472 #else
473 {0, 164, 16, 0, 18, 32, 7, 23, 0},
474 {0, 110, 13, 0, 16, 32, 10, 31, 0},
475 {0, 82, 12, 0, 16, 32, 12, 31, 0},
476 {0, 66, 11, 0, 14, 26, 12, 31, 0},
477 {0, 54, 10, 0, 14, 26, 12, 31, 0},
478 {0, 46, 9, 1, 10, 26, 12, 31, 0},
479 {0, 40, 8, 2, 10, 26, 12, 31, 0},
480 {0, 36, 7, 2, 8, 26, 12, 31, 0},
481 {0, 32, 6, 2, 8, 26, 16, 31, 0},
482 {0, 30, 5, 2, 4, 26, 16, 31, 0},
483 {0, 26, 4, 3, 4, 26, 16, 31, 0},
484 {0, 24, 3, 3, 4, 26, 16, 31, 0},
485 #endif
486 {0, 22, 2, 3, 4, 26, 16, 31, 0},
487 };
488
489 DECLSPEC LDAC_RESULT ldaclib_get_encode_setting(
490 int nbytes_ch,
491 int smplrate_id,
492 int *p_nbands,
493 int *p_grad_mode,
494 int *p_grad_qu_l,
495 int *p_grad_qu_h,
496 int *p_grad_os_l,
497 int *p_grad_os_h,
498 int *p_abc_status)
499 {
500 int i, id;
501
502 id = LDAC_ENC_NSETTING-1;
503 for (i = LDAC_ENC_NSETTING-1; i >= 0; i--) {
504 if (nbytes_ch >= saa_encode_setting_ldac[i][1]) {
505 id = i;
506 }
507 }
508
509 *p_nbands = min_ldac(saa_encode_setting_ldac[id][2], ga_max_nbands_ldac[smplrate_id]);
510 *p_grad_mode = saa_encode_setting_ldac[id][3];
511 *p_grad_qu_l = saa_encode_setting_ldac[id][4];
512 *p_grad_qu_h = saa_encode_setting_ldac[id][5];
513 *p_grad_os_l = saa_encode_setting_ldac[id][6];
514 *p_grad_os_h = saa_encode_setting_ldac[id][7];
515 *p_abc_status = saa_encode_setting_ldac[id][8];
516
517 return LDAC_S_OK;
518 }
519
520 /***************************************************************************************************
521 Set Frame Length
522 ***************************************************************************************************/
523 DECLSPEC LDAC_RESULT ldaclib_set_encode_frame_length(
524 HANDLE_LDAC hData,
525 int frame_length)
526 {
527 CFG *p_cfg = &hData->sfinfo.cfg;
528
529 if (!ldaclib_assert_frame_length(frame_length)) {
530 hData->error_code = LDAC_ERR_ASSERT_FRAME_LENGTH;
531 return LDAC_E_FAIL;
532 }
533
534 if (!ldaclib_assert_supported_frame_length(frame_length, p_cfg->chconfig_id)) {
535 hData->error_code = LDAC_ERR_ASSERT_SUP_FRAME_LENGTH;
536 return LDAC_E_FAIL;
537 }
538
539 p_cfg->frame_length = frame_length;
540
541 calc_initial_bits_ldac(&hData->sfinfo);
542
543 return LDAC_S_OK;
544 }
545
546 /***************************************************************************************************
547 Get Frame Length
548 ***************************************************************************************************/
549 DECLSPEC LDAC_RESULT ldaclib_get_encode_frame_length(
550 HANDLE_LDAC hData,
551 int *p_frame_length)
552 {
553 CFG *p_cfg = &hData->sfinfo.cfg;
554
555 *p_frame_length = p_cfg->frame_length;
556
557 return LDAC_S_OK;
558 }
559
560 /***************************************************************************************************
561 Set Information
562 ***************************************************************************************************/
563 DECLSPEC LDAC_RESULT ldaclib_set_encode_info(
564 HANDLE_LDAC hData,
565 int nbands,
566 int grad_mode,
567 int grad_qu_l,
568 int grad_qu_h,
569 int grad_os_l,
570 int grad_os_h,
571 int abc_status)
572 {
573 if ((nbands < LDAC_BAND_OFFSET) ||
574 (ga_max_nbands_ldac[hData->sfinfo.cfg.smplrate_id] < nbands)) {
575 hData->error_code = LDAC_ERR_ENC_ILL_NBANDS;
576 return LDAC_E_FAIL;
577 }
578
579 if ((grad_mode < LDAC_MODE_0) || (LDAC_MODE_3 < grad_mode)) {
580 hData->error_code = LDAC_ERR_ENC_ILL_GRADMODE;
581 return LDAC_E_FAIL;
582 }
583
584 if (grad_mode == LDAC_MODE_0) {
585 if ((grad_qu_l < 0) || (LDAC_MAXGRADQU <= grad_qu_l)) {
586 hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_A;
587 return LDAC_E_FAIL;
588 }
589
590 if ((grad_qu_h < 1) || (LDAC_MAXGRADQU+1 <= grad_qu_h) || (grad_qu_h < grad_qu_l)) {
591 hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_B;
592 return LDAC_E_FAIL;
593 }
594
595 if ((grad_os_h < 0) || (LDAC_NIDSF <= grad_os_h)) {
596 hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_C;
597 return LDAC_E_FAIL;
598 }
599 }
600 else {
601 if ((grad_qu_l < 0) || (LDAC_DEFGRADQUH < grad_qu_l)) {
602 hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_A;
603 return LDAC_E_FAIL;
604 }
605 }
606
607 if ((grad_os_l < 0) || (LDAC_NIDSF <= grad_os_l)) {
608 hData->error_code = LDAC_ERR_ENC_ILL_GRADPAR_D;
609 return LDAC_E_FAIL;
610 }
611
612 hData->nbands = nbands;
613 hData->grad_mode = grad_mode;
614 hData->grad_qu_l = grad_qu_l;
615 hData->grad_os_l = grad_os_l;
616 if (grad_mode == LDAC_MODE_0) {
617 hData->grad_qu_h = grad_qu_h;
618 hData->grad_os_h = grad_os_h;
619 }
620 else {
621 hData->grad_qu_h = LDAC_DEFGRADQUH;
622 hData->grad_os_h = LDAC_DEFGRADOSH;
623 }
624 hData->abc_status = abc_status;
625
626 return LDAC_S_OK;
627 }
628
629 /***************************************************************************************************
630 Initialize
631 ***************************************************************************************************/
632 DECLSPEC LDAC_RESULT ldaclib_init_encode(
633 HANDLE_LDAC hData)
634 {
635 SFINFO *p_sfinfo = &hData->sfinfo;
636 LDAC_RESULT result;
637
638
639 ldaclib_get_nlnn(p_sfinfo->cfg.smplrate_id, &hData->nlnn);
640
641 set_mdct_table_ldac(hData->nlnn);
642
643 result = init_encode_ldac(p_sfinfo);
644 if (result != LDAC_S_OK) {
645 hData->error_code = LDAC_ERR_ENC_INIT_ALLOC;
646 return LDAC_E_FAIL;
647 }
648
649 return LDAC_S_OK;
650 }
651
652 /***************************************************************************************************
653 Free
654 ***************************************************************************************************/
655 DECLSPEC LDAC_RESULT ldaclib_free_encode(
656 HANDLE_LDAC hData)
657 {
658 if (hData->sfinfo.p_mempos == NULL) {
659 free_encode_ldac(&hData->sfinfo);
660 }
661
662 return LDAC_S_OK;
663 }
664
665 /***************************************************************************************************
666 Encode
667 ***************************************************************************************************/
668 DECLSPEC LDAC_RESULT ldaclib_encode(
669 HANDLE_LDAC hData,
670 char *ap_pcm[],
671 LDAC_SMPL_FMT_T sample_format,
672 unsigned char *p_stream,
673 int *p_nbytes_used)
674 {
675 SFINFO *p_sfinfo = &hData->sfinfo;
676 int loc = 0;
677 int error_code;
678 int frame_length;
679
680
681 if (!ldaclib_assert_sample_format(sample_format)) {
682 hData->error_code = LDAC_ERR_ILL_SMPL_FORMAT;
683 return LDAC_E_FAIL;
684 }
685
686 frame_length = p_sfinfo->cfg.frame_length;
687 clear_data_ldac(p_stream, frame_length*sizeof(unsigned char));
688
689 set_input_pcm_ldac(p_sfinfo, ap_pcm, sample_format, hData->nlnn);
690
691 proc_mdct_ldac(p_sfinfo, hData->nlnn);
692
693 p_sfinfo->cfg.frame_status = ana_frame_status_ldac(p_sfinfo, hData->nlnn);
694
695 error_code = encode_ldac(p_sfinfo, hData->nbands, hData->grad_mode,
696 hData->grad_qu_l, hData->grad_qu_h, hData->grad_os_l, hData->grad_os_h,
697 hData->abc_status);
698 if (LDAC_ERROR(error_code) && !LDAC_FATAL_ERROR(error_code)) {
699 int error_code2;
700 error_code2 = pack_null_data_frame_ldac(p_sfinfo, (STREAM *)p_stream, &loc, p_nbytes_used);
701 if (LDAC_FATAL_ERROR(error_code2)) {
702 clear_data_ldac(p_stream, frame_length*sizeof(unsigned char));
703 hData->error_code = error_code2;
704 return LDAC_E_FAIL;
705 }
706 hData->error_code = error_code;
707 return LDAC_S_FALSE;
708 }
709
710 error_code = pack_raw_data_frame_ldac(p_sfinfo, (STREAM *)p_stream, &loc, p_nbytes_used);
711 if (LDAC_FATAL_ERROR(error_code)) {
712 int error_code2;
713 loc = 0;
714 clear_data_ldac(p_stream, frame_length*sizeof(unsigned char));
715 error_code2 = pack_null_data_frame_ldac(p_sfinfo, (STREAM *)p_stream, &loc, p_nbytes_used);
716 if (LDAC_FATAL_ERROR(error_code2)) {
717 clear_data_ldac(p_stream, frame_length*sizeof(unsigned char));
718 hData->error_code = error_code2;
719 return LDAC_E_FAIL;
720 }
721 hData->error_code = error_code;
722 return LDAC_E_FAIL;
723 }
724
725 return LDAC_S_OK;
726 }
727
728 /***************************************************************************************************
729 Flush Encode
730 ***************************************************************************************************/
731 DECLSPEC LDAC_RESULT ldaclib_flush_encode(
732 HANDLE_LDAC hData,
733 LDAC_SMPL_FMT_T sample_format,
734 unsigned char *p_stream,
735 int *p_nbytes_used)
736 {
737 LDAC_RESULT result;
738 int ich;
739 char *ap_buf[LDAC_PRCNCH];
740 int a_buf[LDAC_MAXLSU*LDAC_PRCNCH];
741
742 if (!ldaclib_assert_sample_format(sample_format)) {
743 hData->error_code = LDAC_ERR_ILL_SMPL_FORMAT;
744 return LDAC_E_FAIL;
745 }
746
747 clear_data_ldac(a_buf, (LDAC_MAXLSU*LDAC_PRCNCH)*sizeof(int));
748
749 for (ich = 0; ich < LDAC_PRCNCH; ich++) {
750 ap_buf[ich] = (char *)(a_buf + ich * LDAC_MAXLSU);
751 }
752
753 result = ldaclib_encode(hData, ap_buf, sample_format, p_stream, p_nbytes_used);
754
755 return result;
756 }
757
758
759
760
761 /***************************************************************************************************
762 Error Code Dispatch
763 ***************************************************************************************************/
764
765 /***************************************************************************************************
766 Clear Error Code at Handle Level
767 ***************************************************************************************************/
768 DECLSPEC LDAC_RESULT ldaclib_clear_error_code(
769 HANDLE_LDAC hData)
770 {
771 hData->error_code = LDAC_ERR_NONE;
772
773 return LDAC_S_OK;
774 }
775
776 /***************************************************************************************************
777 Get Error Code at Handle Level
778 ***************************************************************************************************/
779 DECLSPEC LDAC_RESULT ldaclib_get_error_code(
780 HANDLE_LDAC hData,
781 int *p_error_code)
782 {
783 *p_error_code = hData->error_code;
784
785 return LDAC_S_OK;
786 }
787
788 /***************************************************************************************************
789 Clear Error Code at Internal Block Level
790 ***************************************************************************************************/
791 DECLSPEC LDAC_RESULT ldaclib_clear_internal_error_code(
792 HANDLE_LDAC hData)
793 {
794 hData->sfinfo.error_code = LDAC_ERR_NONE;
795
796 return LDAC_S_OK;
797 }
798
799 /***************************************************************************************************
800 Get Error Code at Internal Block Level
801 ***************************************************************************************************/
802 DECLSPEC LDAC_RESULT ldaclib_get_internal_error_code(
803 HANDLE_LDAC hData,
804 int *p_error_code)
805 {
806 *p_error_code = hData->sfinfo.error_code;
807
808 return LDAC_S_OK;
809 }
810
811