| /* | |
| * Siren Encoder/Decoder library | |
| * | |
| * @author: Youness Alaoui <kakaroto@kakaroto.homelinux.net> | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Library General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Library General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Library General Public | |
| * License along with this library; if not, write to the | |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
| * Boston, MA 02110-1301, USA. | |
| */ | |
| #include "siren7.h" | |
| int region_size; | |
| float region_size_inverse; | |
| float standard_deviation[64]; | |
| float deviation_inverse[64]; | |
| float region_power_table_boundary[63]; | |
| int expected_bits_table[8] = { 52, 47, 43, 37, 29, 22, 16, 0 }; | |
| int vector_dimension[8] = { 2, 2, 2, 4, 4, 5, 5, 1 }; | |
| int number_of_vectors[8] = { 10, 10, 10, 5, 5, 4, 4, 20 }; | |
| float dead_zone[8] = { 0.3f, 0.33f, 0.36f, 0.39f, 0.42f, 0.45f, 0.5f, 0.5f }; | |
| int max_bin[8] = { | |
| 13, | |
| 9, | |
| 6, | |
| 4, | |
| 3, | |
| 2, | |
| 1, | |
| 1 | |
| }; | |
| float step_size[8] = { | |
| 0.3536f, | |
| 0.5f, | |
| 0.70709997f, | |
| 1.0f, | |
| 1.4141999f, | |
| 2.0f, | |
| 2.8283999f, | |
| 2.8283999f | |
| }; | |
| float step_size_inverse[8]; | |
| static int siren_initialized = 0; | |
| /* | |
| STEPSIZE = 2.0 * log(sqrt(2)); | |
| */ | |
| #define STEPSIZE 0.3010299957 | |
| void | |
| siren_init (void) | |
| { | |
| int i; | |
| float region_power; | |
| if (siren_initialized == 1) | |
| return; | |
| region_size = 20; | |
| region_size_inverse = 1.0f / region_size; | |
| for (i = 0; i < 64; i++) { | |
| region_power = (float) pow (10, (i - 24) * STEPSIZE); | |
| standard_deviation[i] = (float) sqrt (region_power); | |
| deviation_inverse[i] = (float) 1.0 / standard_deviation[i]; | |
| } | |
| for (i = 0; i < 63; i++) | |
| region_power_table_boundary[i] = | |
| (float) pow (10, (i - 24 + 0.5) * STEPSIZE); | |
| for (i = 0; i < 8; i++) | |
| step_size_inverse[i] = (float) 1.0 / step_size[i]; | |
| siren_dct4_init (); | |
| siren_rmlt_init (); | |
| siren_initialized = 1; | |
| } | |
| int | |
| categorize_regions (int number_of_regions, int number_of_available_bits, | |
| int *absolute_region_power_index, int *power_categories, | |
| int *category_balance) | |
| { | |
| int region, delta, i, temp; | |
| int expected_number_of_code_bits; | |
| int min, max; | |
| int offset, | |
| num_rate_control_possibilities, | |
| raw_value, raw_max_idx = 0, raw_min_idx = 0; | |
| int max_rate_categories[28]; | |
| int min_rate_categories[28]; | |
| int temp_category_balances[64]; | |
| int *min_rate_ptr = NULL; | |
| int *max_rate_ptr = NULL; | |
| if (number_of_regions == 14) { | |
| num_rate_control_possibilities = 16; | |
| if (number_of_available_bits > 320) | |
| number_of_available_bits = | |
| ((number_of_available_bits - 320) * 5 / 8) + 320; | |
| } else { | |
| num_rate_control_possibilities = 32; | |
| if (number_of_regions == 28 && number_of_available_bits > 640) | |
| number_of_available_bits = | |
| ((number_of_available_bits - 640) * 5 / 8) + 640; | |
| } | |
| offset = -32; | |
| for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) { | |
| expected_number_of_code_bits = 0; | |
| for (region = 0; region < number_of_regions; region++) { | |
| i = (delta + offset - absolute_region_power_index[region]) >> 1; | |
| if (i > 7) | |
| i = 7; | |
| else if (i < 0) | |
| i = 0; | |
| power_categories[region] = i; | |
| expected_number_of_code_bits += expected_bits_table[i]; | |
| } | |
| if (expected_number_of_code_bits >= number_of_available_bits - 32) | |
| offset += delta; | |
| } | |
| expected_number_of_code_bits = 0; | |
| for (region = 0; region < number_of_regions; region++) { | |
| i = (offset - absolute_region_power_index[region]) >> 1; | |
| if (i > 7) | |
| i = 7; | |
| else if (i < 0) | |
| i = 0; | |
| max_rate_categories[region] = min_rate_categories[region] = | |
| power_categories[region] = i; | |
| expected_number_of_code_bits += expected_bits_table[i]; | |
| } | |
| min = max = expected_number_of_code_bits; | |
| min_rate_ptr = max_rate_ptr = | |
| temp_category_balances + num_rate_control_possibilities; | |
| for (i = 0; i < num_rate_control_possibilities - 1; i++) { | |
| if (min + max > number_of_available_bits * 2) { | |
| raw_value = -99; | |
| for (region = number_of_regions - 1; region >= 0; region--) { | |
| if (min_rate_categories[region] < 7) { | |
| temp = | |
| offset - absolute_region_power_index[region] - | |
| 2 * min_rate_categories[region]; | |
| if (temp > raw_value) { | |
| raw_value = temp; | |
| raw_min_idx = region; | |
| } | |
| } | |
| } | |
| *min_rate_ptr++ = raw_min_idx; | |
| min += | |
| expected_bits_table[min_rate_categories[raw_min_idx] + 1] - | |
| expected_bits_table[min_rate_categories[raw_min_idx]]; | |
| min_rate_categories[raw_min_idx]++; | |
| } else { | |
| raw_value = 99; | |
| for (region = 0; region < number_of_regions; region++) { | |
| if (max_rate_categories[region] > 0) { | |
| temp = | |
| offset - absolute_region_power_index[region] - | |
| 2 * max_rate_categories[region]; | |
| if (temp < raw_value) { | |
| raw_value = temp; | |
| raw_max_idx = region; | |
| } | |
| } | |
| } | |
| *--max_rate_ptr = raw_max_idx; | |
| max += | |
| expected_bits_table[max_rate_categories[raw_max_idx] - 1] - | |
| expected_bits_table[max_rate_categories[raw_max_idx]]; | |
| max_rate_categories[raw_max_idx]--; | |
| } | |
| } | |
| for (region = 0; region < number_of_regions; region++) | |
| power_categories[region] = max_rate_categories[region]; | |
| for (i = 0; i < num_rate_control_possibilities - 1; i++) | |
| category_balance[i] = *max_rate_ptr++; | |
| return 0; | |
| } | |
| /* | |
| Looks like the flag means what kind of encoding is used | |
| for now, it looks like : | |
| 0 : the sample rate is not encoded in the frame | |
| 1 - 2 : the sample rate is fixed in the frame | |
| 3 : sample rate is variable and there is one for each frame | |
| */ | |
| int | |
| GetSirenCodecInfo (int flag, int sample_rate, int *number_of_coefs, | |
| int *sample_rate_bits, int *rate_control_bits, | |
| int *rate_control_possibilities, int *checksum_bits, int *esf_adjustment, | |
| int *scale_factor, int *number_of_regions, int *sample_rate_code, | |
| int *bits_per_frame) | |
| { | |
| switch (flag) { | |
| case 0: | |
| *number_of_coefs = 320; | |
| *sample_rate_bits = 0; | |
| *rate_control_bits = 4; | |
| *rate_control_possibilities = 16; | |
| *checksum_bits = 0; | |
| *esf_adjustment = 7; | |
| *number_of_regions = 14; | |
| *sample_rate_code = 0; | |
| *scale_factor = 22; | |
| break; | |
| case 1: | |
| *number_of_coefs = 320; | |
| *sample_rate_bits = 2; | |
| *rate_control_bits = 4; | |
| *rate_control_possibilities = 16; | |
| *checksum_bits = 4; | |
| *esf_adjustment = -2; | |
| *number_of_regions = 14; | |
| *scale_factor = 1; | |
| if (sample_rate == 16000) | |
| *sample_rate_code = 1; | |
| else if (sample_rate == 24000) | |
| *sample_rate_code = 2; | |
| else if (sample_rate == 32000) | |
| *sample_rate_code = 3; | |
| else | |
| return 3; | |
| break; | |
| case 2: | |
| *number_of_coefs = 640; | |
| *sample_rate_bits = 2; | |
| *rate_control_bits = 5; | |
| *rate_control_possibilities = 32; | |
| *checksum_bits = 4; | |
| *esf_adjustment = 7; | |
| *number_of_regions = 28; | |
| *scale_factor = 33; | |
| if (sample_rate == 24000) | |
| *sample_rate_code = 1; | |
| else if (sample_rate == 32000) | |
| *sample_rate_code = 2; | |
| else if (sample_rate == 48000) | |
| *sample_rate_code = 3; | |
| else | |
| return 3; | |
| break; | |
| case 3: | |
| *number_of_coefs = 640; | |
| *sample_rate_bits = 6; | |
| *rate_control_bits = 5; | |
| *rate_control_possibilities = 32; | |
| *checksum_bits = 4; | |
| *esf_adjustment = 7; | |
| *scale_factor = 33; | |
| switch (sample_rate) { | |
| case 8800: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 59; | |
| break; | |
| case 9600: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 1; | |
| break; | |
| case 10400: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 13; | |
| break; | |
| case 10800: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 14; | |
| break; | |
| case 11200: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 15; | |
| break; | |
| case 11600: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 16; | |
| break; | |
| case 12000: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 2; | |
| break; | |
| case 12400: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 17; | |
| break; | |
| case 12800: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 18; | |
| break; | |
| case 13200: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 19; | |
| break; | |
| case 13600: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 20; | |
| break; | |
| case 14000: | |
| *number_of_regions = 12; | |
| *sample_rate_code = 21; | |
| break; | |
| case 14400: | |
| *number_of_regions = 16; | |
| *sample_rate_code = 3; | |
| break; | |
| case 14800: | |
| *number_of_regions = 16; | |
| *sample_rate_code = 22; | |
| break; | |
| case 15200: | |
| *number_of_regions = 16; | |
| *sample_rate_code = 23; | |
| break; | |
| case 15600: | |
| *number_of_regions = 16; | |
| *sample_rate_code = 24; | |
| break; | |
| case 16000: | |
| *number_of_regions = 16; | |
| *sample_rate_code = 25; | |
| break; | |
| case 16400: | |
| *number_of_regions = 16; | |
| *sample_rate_code = 26; | |
| break; | |
| case 16800: | |
| *number_of_regions = 18; | |
| *sample_rate_code = 4; | |
| break; | |
| case 17200: | |
| *number_of_regions = 18; | |
| *sample_rate_code = 27; | |
| break; | |
| case 17600: | |
| *number_of_regions = 18; | |
| *sample_rate_code = 28; | |
| break; | |
| case 18000: | |
| *number_of_regions = 18; | |
| *sample_rate_code = 29; | |
| break; | |
| case 18400: | |
| *number_of_regions = 18; | |
| *sample_rate_code = 30; | |
| break; | |
| case 18800: | |
| *number_of_regions = 18; | |
| *sample_rate_code = 31; | |
| break; | |
| case 19200: | |
| *number_of_regions = 20; | |
| *sample_rate_code = 5; | |
| break; | |
| case 19600: | |
| *number_of_regions = 20; | |
| *sample_rate_code = 32; | |
| break; | |
| case 20000: | |
| *number_of_regions = 20; | |
| *sample_rate_code = 33; | |
| break; | |
| case 20400: | |
| *number_of_regions = 20; | |
| *sample_rate_code = 34; | |
| break; | |
| case 20800: | |
| *number_of_regions = 20; | |
| *sample_rate_code = 35; | |
| break; | |
| case 21200: | |
| *number_of_regions = 20; | |
| *sample_rate_code = 36; | |
| break; | |
| case 21600: | |
| *number_of_regions = 22; | |
| *sample_rate_code = 6; | |
| break; | |
| case 22000: | |
| *number_of_regions = 22; | |
| *sample_rate_code = 37; | |
| break; | |
| case 22400: | |
| *number_of_regions = 22; | |
| *sample_rate_code = 38; | |
| break; | |
| case 22800: | |
| *number_of_regions = 22; | |
| *sample_rate_code = 39; | |
| break; | |
| case 23200: | |
| *number_of_regions = 22; | |
| *sample_rate_code = 40; | |
| break; | |
| case 23600: | |
| *number_of_regions = 22; | |
| *sample_rate_code = 41; | |
| break; | |
| case 24000: | |
| *number_of_regions = 24; | |
| *sample_rate_code = 7; | |
| break; | |
| case 24400: | |
| *number_of_regions = 24; | |
| *sample_rate_code = 42; | |
| break; | |
| case 24800: | |
| *number_of_regions = 24; | |
| *sample_rate_code = 43; | |
| break; | |
| case 25200: | |
| *number_of_regions = 24; | |
| *sample_rate_code = 44; | |
| break; | |
| case 25600: | |
| *number_of_regions = 24; | |
| *sample_rate_code = 45; | |
| break; | |
| case 26000: | |
| *number_of_regions = 24; | |
| *sample_rate_code = 46; | |
| break; | |
| case 26400: | |
| *number_of_regions = 26; | |
| *sample_rate_code = 8; | |
| break; | |
| case 26800: | |
| *number_of_regions = 26; | |
| *sample_rate_code = 47; | |
| break; | |
| case 27200: | |
| *number_of_regions = 26; | |
| *sample_rate_code = 48; | |
| break; | |
| case 27600: | |
| *number_of_regions = 26; | |
| *sample_rate_code = 49; | |
| break; | |
| case 28000: | |
| *number_of_regions = 26; | |
| *sample_rate_code = 50; | |
| break; | |
| case 28400: | |
| *number_of_regions = 26; | |
| *sample_rate_code = 51; | |
| break; | |
| case 28800: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 9; | |
| break; | |
| case 29200: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 52; | |
| break; | |
| case 29600: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 53; | |
| break; | |
| case 30000: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 54; | |
| break; | |
| case 30400: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 55; | |
| break; | |
| case 30800: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 56; | |
| break; | |
| case 31200: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 10; | |
| break; | |
| case 31600: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 57; | |
| break; | |
| case 32000: | |
| *number_of_regions = 28; | |
| *sample_rate_code = 58; | |
| break; | |
| default: | |
| return 3; | |
| break; | |
| } | |
| break; | |
| default: | |
| return 6; | |
| } | |
| *bits_per_frame = sample_rate / 50; | |
| return 0; | |
| } |