-/*\r
- * Siren Encoder/Decoder library\r
- *\r
- * @author: Youness Alaoui <kakaroto@kakaroto.homelinux.net>\r
- *\r
- * This library is free software; you can redistribute it and/or\r
- * modify it under the terms of the GNU Library General Public\r
- * License as published by the Free Software Foundation; either\r
- * version 2 of the License, or (at your option) any later version.\r
- *\r
- * This library is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
- * Library General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU Library General Public\r
- * License along with this library; if not, write to the\r
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
- * Boston, MA 02111-1307, USA.\r
- */\r
-\r
-\r
-#include "siren7.h"\r
-\r
-SirenDecoder Siren7_NewDecoder(int sample_rate) {\r
- SirenDecoder decoder = (SirenDecoder) malloc(sizeof(struct stSirenDecoder));\r
- decoder->sample_rate = sample_rate;\r
-\r
- decoder->WavHeader.riff.RiffId = ME_TO_LE32(RIFF_ID);\r
- decoder->WavHeader.riff.RiffSize = sizeof(PCMWavHeader) - 2*sizeof(int);\r
- decoder->WavHeader.riff.RiffSize = ME_TO_LE32(decoder->WavHeader.riff.RiffSize);\r
- decoder->WavHeader.WaveId = ME_TO_LE32(WAVE_ID);\r
-\r
- decoder->WavHeader.FmtId = ME_TO_LE32(FMT__ID);\r
- decoder->WavHeader.FmtSize = ME_TO_LE32(sizeof(FmtChunk));\r
-\r
- decoder->WavHeader.fmt.Format = ME_TO_LE16(0x01);\r
- decoder->WavHeader.fmt.Channels = ME_TO_LE16(1);\r
- decoder->WavHeader.fmt.SampleRate = ME_TO_LE32(16000);\r
- decoder->WavHeader.fmt.ByteRate = ME_TO_LE32(32000);\r
- decoder->WavHeader.fmt.BlockAlign = ME_TO_LE16(2);\r
- decoder->WavHeader.fmt.BitsPerSample = ME_TO_LE16(16);\r
-\r
- decoder->WavHeader.FactId = ME_TO_LE32(FACT_ID);\r
- decoder->WavHeader.FactSize = ME_TO_LE32(sizeof(int));\r
- decoder->WavHeader.Samples = ME_TO_LE32(0);\r
-\r
- decoder->WavHeader.DataId = ME_TO_LE32(DATA_ID);\r
- decoder->WavHeader.DataSize = ME_TO_LE32(0);\r
-\r
- memset(decoder->context, 0, sizeof(decoder->context));\r
- memset(decoder->backup_frame, 0, sizeof(decoder->backup_frame));\r
-\r
- decoder->dw1 = 1;\r
- decoder->dw2 = 1;\r
- decoder->dw3 = 1;\r
- decoder->dw4 = 1;\r
-\r
- siren_init();\r
- return decoder;\r
-}\r
-\r
-void Siren7_CloseDecoder(SirenDecoder decoder) {\r
- free(decoder);\r
-}\r
-\r
-int Siren7_DecodeFrame(SirenDecoder decoder, unsigned char *DataIn, unsigned char *DataOut) {\r
- int number_of_coefs,\r
- sample_rate_bits,\r
- rate_control_bits,\r
- rate_control_possibilities,\r
- checksum_bits,\r
- esf_adjustment,\r
- scale_factor,\r
- number_of_regions,\r
- sample_rate_code,\r
- bits_per_frame;\r
- int decoded_sample_rate_code;\r
-\r
- static int absolute_region_power_index[28] = {0};\r
- static float decoder_standard_deviation[28] = {0};\r
- static int power_categories[28] = {0};\r
- static int category_balance[28] = {0};\r
- int ChecksumTable[4] = {0x7F80, 0x7878, 0x6666, 0x5555};\r
- int i, j;\r
-\r
- int dwRes = 0;\r
- int envelope_bits = 0;\r
- int rate_control = 0;\r
- int number_of_available_bits;\r
- int number_of_valid_coefs;\r
- int frame_error = 0;\r
-\r
- int In[20];\r
- float coefs[320];\r
- float BufferOut[320];\r
- int sum;\r
- int checksum;\r
- int calculated_checksum;\r
- int idx;\r
- int temp1;\r
- int temp2;\r
-\r
- for (i = 0; i < 20; i++)\r
-#ifdef __BIG_ENDIAN__\r
- In[i] = ((short *) DataIn)[i];\r
-#else\r
- In[i] = ((((short *) DataIn)[i] << 8) & 0xFF00) | ((((short *) DataIn)[i] >> 8) & 0x00FF);\r
-#endif\r
-\r
- dwRes = GetSirenCodecInfo(1, decoder->sample_rate, &number_of_coefs, &sample_rate_bits, &rate_control_bits, &rate_control_possibilities, &checksum_bits, &esf_adjustment, &scale_factor, &number_of_regions, &sample_rate_code, &bits_per_frame );\r
-\r
- if (dwRes != 0)\r
- return dwRes;\r
-\r
-\r
- set_bitstream(In);\r
-\r
- decoded_sample_rate_code = 0;\r
- for (i = 0; i < sample_rate_bits; i++) {\r
- decoded_sample_rate_code <<= 1;\r
- decoded_sample_rate_code |= next_bit();\r
- }\r
-\r
-\r
- if (decoded_sample_rate_code != sample_rate_code)\r
- return 7;\r
-\r
- number_of_valid_coefs = region_size * number_of_regions;\r
- number_of_available_bits = bits_per_frame - sample_rate_bits - checksum_bits ;\r
-\r
-\r
- envelope_bits = decode_envelope(number_of_regions, decoder_standard_deviation, absolute_region_power_index, esf_adjustment);\r
-\r
- number_of_available_bits -= envelope_bits;\r
-\r
- for (i = 0; i < rate_control_bits; i++) {\r
- rate_control <<= 1;\r
- rate_control |= next_bit();\r
- }\r
-\r
- number_of_available_bits -= rate_control_bits;\r
-\r
- categorize_regions(number_of_regions, number_of_available_bits, absolute_region_power_index, power_categories, category_balance);\r
-\r
- for (i = 0; i < rate_control; i++) {\r
- power_categories[category_balance[i]]++;\r
- }\r
-\r
- number_of_available_bits = decode_vector(decoder, number_of_regions, number_of_available_bits, decoder_standard_deviation, power_categories, coefs, scale_factor);\r
-\r
-\r
- frame_error = 0;\r
- if (number_of_available_bits > 0) {\r
- for (i = 0; i < number_of_available_bits; i++) {\r
- if (next_bit() == 0)\r
- frame_error = 1;\r
- }\r
- } else if (number_of_available_bits < 0 && rate_control + 1 < rate_control_possibilities) {\r
- frame_error |= 2;\r
- }\r
-\r
- for (i = 0; i < number_of_regions; i++) {\r
- if (absolute_region_power_index[i] > 33 || absolute_region_power_index[i] < -31)\r
- frame_error |= 4;\r
- }\r
-\r
- if (checksum_bits > 0) {\r
- bits_per_frame >>= 4;\r
- checksum = In[bits_per_frame - 1] & ((1 << checksum_bits) - 1);\r
- In[bits_per_frame - 1] &= ~checksum;\r
- sum = 0;\r
- idx = 0;\r
- do {\r
- sum ^= (In[idx] & 0xFFFF) << (idx % 15);\r
- } while (++idx < bits_per_frame);\r
-\r
- sum = (sum >> 15) ^ (sum & 0x7FFF);\r
- calculated_checksum = 0;\r
- for (i = 0; i < 4; i++) {\r
- temp1 = ChecksumTable[i] & sum;\r
- for (j = 8; j > 0; j >>= 1) {\r
- temp2 = temp1 >> j;\r
- temp1 ^= temp2;\r
- }\r
- calculated_checksum <<= 1;\r
- calculated_checksum |= temp1 & 1;\r
- }\r
-\r
- if (checksum != calculated_checksum)\r
- frame_error |= 8;\r
- }\r
-\r
- if (frame_error != 0) {\r
- for (i = 0; i < number_of_valid_coefs; i++) {\r
- coefs[i] = decoder->backup_frame[i];\r
- decoder->backup_frame[i] = 0;\r
- }\r
- } else {\r
- for (i = 0; i < number_of_valid_coefs; i++)\r
- decoder->backup_frame[i] = coefs[i];\r
- }\r
-\r
-\r
- for (i = number_of_valid_coefs; i < number_of_coefs; i++)\r
- coefs[i] = 0;\r
-\r
-\r
- dwRes = siren_rmlt_decode_samples(coefs, decoder->context, 320, BufferOut);\r
-\r
-\r
- for (i = 0; i < 320; i++) {\r
- if (BufferOut[i] > 32767.0)\r
- ((short *)DataOut)[i] = (short) ME_TO_LE16((short) 32767);\r
- else if (BufferOut[i] <= -32768.0)\r
- ((short *)DataOut)[i] = (short) ME_TO_LE16((short) 32768);\r
- else\r
- ((short *)DataOut)[i] = (short) ME_TO_LE16((short) BufferOut[i]);\r
- }\r
-\r
- decoder->WavHeader.Samples = ME_FROM_LE32(decoder->WavHeader.Samples);\r
- decoder->WavHeader.Samples += 320;\r
- decoder->WavHeader.Samples = ME_TO_LE32(decoder->WavHeader.Samples);\r
- decoder->WavHeader.DataSize = ME_FROM_LE32(decoder->WavHeader.DataSize);\r
- decoder->WavHeader.DataSize += 640;\r
- decoder->WavHeader.DataSize = ME_TO_LE32(decoder->WavHeader.DataSize);\r
- decoder->WavHeader.riff.RiffSize = ME_FROM_LE32(decoder->WavHeader.riff.RiffSize);\r
- decoder->WavHeader.riff.RiffSize += 640;\r
- decoder->WavHeader.riff.RiffSize = ME_TO_LE32(decoder->WavHeader.riff.RiffSize);\r
-\r
-\r
- return 0;\r
-}\r
-\r
+/*
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include "siren7.h"
+
+SirenDecoder
+Siren7_NewDecoder (int sample_rate)
+{
+ SirenDecoder decoder = (SirenDecoder) malloc (sizeof (struct stSirenDecoder));
+ decoder->sample_rate = sample_rate;
+
+ decoder->WavHeader.riff.RiffId = ME_TO_LE32 (RIFF_ID);
+ decoder->WavHeader.riff.RiffSize = sizeof (PCMWavHeader) - 2 * sizeof (int);
+ decoder->WavHeader.riff.RiffSize =
+ ME_TO_LE32 (decoder->WavHeader.riff.RiffSize);
+ decoder->WavHeader.WaveId = ME_TO_LE32 (WAVE_ID);
+
+ decoder->WavHeader.FmtId = ME_TO_LE32 (FMT__ID);
+ decoder->WavHeader.FmtSize = ME_TO_LE32 (sizeof (FmtChunk));
+
+ decoder->WavHeader.fmt.Format = ME_TO_LE16 (0x01);
+ decoder->WavHeader.fmt.Channels = ME_TO_LE16 (1);
+ decoder->WavHeader.fmt.SampleRate = ME_TO_LE32 (16000);
+ decoder->WavHeader.fmt.ByteRate = ME_TO_LE32 (32000);
+ decoder->WavHeader.fmt.BlockAlign = ME_TO_LE16 (2);
+ decoder->WavHeader.fmt.BitsPerSample = ME_TO_LE16 (16);
+
+ decoder->WavHeader.FactId = ME_TO_LE32 (FACT_ID);
+ decoder->WavHeader.FactSize = ME_TO_LE32 (sizeof (int));
+ decoder->WavHeader.Samples = ME_TO_LE32 (0);
+
+ decoder->WavHeader.DataId = ME_TO_LE32 (DATA_ID);
+ decoder->WavHeader.DataSize = ME_TO_LE32 (0);
+
+ memset (decoder->context, 0, sizeof (decoder->context));
+ memset (decoder->backup_frame, 0, sizeof (decoder->backup_frame));
+
+ decoder->dw1 = 1;
+ decoder->dw2 = 1;
+ decoder->dw3 = 1;
+ decoder->dw4 = 1;
+
+ siren_init ();
+ return decoder;
+}
+
+void
+Siren7_CloseDecoder (SirenDecoder decoder)
+{
+ free (decoder);
+}
+
+int
+Siren7_DecodeFrame (SirenDecoder decoder, unsigned char *DataIn,
+ unsigned char *DataOut)
+{
+ int number_of_coefs,
+ sample_rate_bits,
+ rate_control_bits,
+ rate_control_possibilities,
+ checksum_bits,
+ esf_adjustment,
+ scale_factor, number_of_regions, sample_rate_code, bits_per_frame;
+ int decoded_sample_rate_code;
+
+ static int absolute_region_power_index[28] = { 0 };
+ static float decoder_standard_deviation[28] = { 0 };
+ static int power_categories[28] = { 0 };
+ static int category_balance[28] = { 0 };
+ int ChecksumTable[4] = { 0x7F80, 0x7878, 0x6666, 0x5555 };
+ int i, j;
+
+ int dwRes = 0;
+ int envelope_bits = 0;
+ int rate_control = 0;
+ int number_of_available_bits;
+ int number_of_valid_coefs;
+ int frame_error = 0;
+
+ int In[20];
+ float coefs[320];
+ float BufferOut[320];
+ int sum;
+ int checksum;
+ int calculated_checksum;
+ int idx;
+ int temp1;
+ int temp2;
+
+ for (i = 0; i < 20; i++)
+#ifdef __BIG_ENDIAN__
+ In[i] = ((short *) DataIn)[i];
+#else
+ In[i] =
+ ((((short *) DataIn)[i] << 8) & 0xFF00) | ((((short *) DataIn)[i] >> 8)
+ & 0x00FF);
+#endif
+
+ dwRes =
+ GetSirenCodecInfo (1, decoder->sample_rate, &number_of_coefs,
+ &sample_rate_bits, &rate_control_bits, &rate_control_possibilities,
+ &checksum_bits, &esf_adjustment, &scale_factor, &number_of_regions,
+ &sample_rate_code, &bits_per_frame);
+
+ if (dwRes != 0)
+ return dwRes;
+
+
+ set_bitstream (In);
+
+ decoded_sample_rate_code = 0;
+ for (i = 0; i < sample_rate_bits; i++) {
+ decoded_sample_rate_code <<= 1;
+ decoded_sample_rate_code |= next_bit ();
+ }
+
+
+ if (decoded_sample_rate_code != sample_rate_code)
+ return 7;
+
+ number_of_valid_coefs = region_size * number_of_regions;
+ number_of_available_bits = bits_per_frame - sample_rate_bits - checksum_bits;
+
+
+ envelope_bits =
+ decode_envelope (number_of_regions, decoder_standard_deviation,
+ absolute_region_power_index, esf_adjustment);
+
+ number_of_available_bits -= envelope_bits;
+
+ for (i = 0; i < rate_control_bits; i++) {
+ rate_control <<= 1;
+ rate_control |= next_bit ();
+ }
+
+ number_of_available_bits -= rate_control_bits;
+
+ categorize_regions (number_of_regions, number_of_available_bits,
+ absolute_region_power_index, power_categories, category_balance);
+
+ for (i = 0; i < rate_control; i++) {
+ power_categories[category_balance[i]]++;
+ }
+
+ number_of_available_bits =
+ decode_vector (decoder, number_of_regions, number_of_available_bits,
+ decoder_standard_deviation, power_categories, coefs, scale_factor);
+
+
+ frame_error = 0;
+ if (number_of_available_bits > 0) {
+ for (i = 0; i < number_of_available_bits; i++) {
+ if (next_bit () == 0)
+ frame_error = 1;
+ }
+ } else if (number_of_available_bits < 0
+ && rate_control + 1 < rate_control_possibilities) {
+ frame_error |= 2;
+ }
+
+ for (i = 0; i < number_of_regions; i++) {
+ if (absolute_region_power_index[i] > 33
+ || absolute_region_power_index[i] < -31)
+ frame_error |= 4;
+ }
+
+ if (checksum_bits > 0) {
+ bits_per_frame >>= 4;
+ checksum = In[bits_per_frame - 1] & ((1 << checksum_bits) - 1);
+ In[bits_per_frame - 1] &= ~checksum;
+ sum = 0;
+ idx = 0;
+ do {
+ sum ^= (In[idx] & 0xFFFF) << (idx % 15);
+ } while (++idx < bits_per_frame);
+
+ sum = (sum >> 15) ^ (sum & 0x7FFF);
+ calculated_checksum = 0;
+ for (i = 0; i < 4; i++) {
+ temp1 = ChecksumTable[i] & sum;
+ for (j = 8; j > 0; j >>= 1) {
+ temp2 = temp1 >> j;
+ temp1 ^= temp2;
+ }
+ calculated_checksum <<= 1;
+ calculated_checksum |= temp1 & 1;
+ }
+
+ if (checksum != calculated_checksum)
+ frame_error |= 8;
+ }
+
+ if (frame_error != 0) {
+ for (i = 0; i < number_of_valid_coefs; i++) {
+ coefs[i] = decoder->backup_frame[i];
+ decoder->backup_frame[i] = 0;
+ }
+ } else {
+ for (i = 0; i < number_of_valid_coefs; i++)
+ decoder->backup_frame[i] = coefs[i];
+ }
+
+
+ for (i = number_of_valid_coefs; i < number_of_coefs; i++)
+ coefs[i] = 0;
+
+
+ dwRes = siren_rmlt_decode_samples (coefs, decoder->context, 320, BufferOut);
+
+
+ for (i = 0; i < 320; i++) {
+ if (BufferOut[i] > 32767.0)
+ ((short *) DataOut)[i] = (short) ME_TO_LE16 ((short) 32767);
+ else if (BufferOut[i] <= -32768.0)
+ ((short *) DataOut)[i] = (short) ME_TO_LE16 ((short) 32768);
+ else
+ ((short *) DataOut)[i] = (short) ME_TO_LE16 ((short) BufferOut[i]);
+ }
+
+ decoder->WavHeader.Samples = ME_FROM_LE32 (decoder->WavHeader.Samples);
+ decoder->WavHeader.Samples += 320;
+ decoder->WavHeader.Samples = ME_TO_LE32 (decoder->WavHeader.Samples);
+ decoder->WavHeader.DataSize = ME_FROM_LE32 (decoder->WavHeader.DataSize);
+ decoder->WavHeader.DataSize += 640;
+ decoder->WavHeader.DataSize = ME_TO_LE32 (decoder->WavHeader.DataSize);
+ decoder->WavHeader.riff.RiffSize =
+ ME_FROM_LE32 (decoder->WavHeader.riff.RiffSize);
+ decoder->WavHeader.riff.RiffSize += 640;
+ decoder->WavHeader.riff.RiffSize =
+ ME_TO_LE32 (decoder->WavHeader.riff.RiffSize);
+
+
+ return 0;
+}