gst/siren/common.c

   1 /*
   2  * Siren Encoder/Decoder library
   3  *
   4  *   @author: Youness Alaoui <kakaroto@kakaroto.homelinux.net>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include "siren7.h"
  23
  24 int region_size;
  25 float region_size_inverse;
  26
  27 float standard_deviation[64];
  28 float deviation_inverse[64];
  29 float region_power_table_boundary[63];
  30
  31 int expected_bits_table[8] = {52, 47, 43, 37, 29, 22, 16, 0};
  32 int vector_dimension[8] = {2, 2, 2, 4, 4, 5, 5, 1};
  33 int number_of_vectors[8] = {10, 10, 10, 5, 5, 4, 4, 20};
  34 float dead_zone[8] = {0.3f, 0.33f, 0.36f, 0.39f, 0.42f, 0.45f, 0.5f, 0.5f};
  35
  36 int max_bin[8] = {
  37   13,
  38   9,
  39   6,
  40   4,
  41   3,
  42   2,
  43   1,
  44   1};
  45
  46 float step_size[8] = {
  47   0.3536f,
  48   0.5f,
  49   0.70709997f,
  50   1.0f,
  51   1.4141999f,
  52   2.0f,
  53   2.8283999f,
  54   2.8283999f};
  55
  56 float step_size_inverse[8];
  57
  58 static int siren_initialized = 0;
  59
  60 /*
  61   STEPSIZE = 2.0 * log(sqrt(2));
  62 */
  63 #define STEPSIZE 0.3010299957
  64
  65 void siren_init() {
  66   int i;
  67   float region_power;
  68
  69   if (siren_initialized == 1)
  70     return;
  71
  72   region_size = 20;
  73   region_size_inverse = 1.0f/region_size;
  74
  75   for (i = 0; i < 64; i++) {
  76     region_power = (float) pow(10, (i-24) * STEPSIZE);
  77     standard_deviation[i] = (float) sqrt(region_power);
  78     deviation_inverse[i] = (float) 1.0 / standard_deviation[i];
  79   }
  80
  81   for (i = 0; i < 63; i++)
  82     region_power_table_boundary[i] = (float) pow(10, (i-24 + 0.5) * STEPSIZE);
  83
  84   for (i = 0; i < 8; i++)
  85     step_size_inverse[i] = (float) 1.0 / step_size[i];
  86
  87   siren_dct4_init();
  88   siren_rmlt_init();
  89
  90   siren_initialized = 1;
  91 }
  92
  93
  94 int categorize_regions(int number_of_regions, int number_of_available_bits, int *absolute_region_power_index, int *power_categories, int *category_balance) {
  95   int region, delta, i, temp;
  96   int expected_number_of_code_bits;
  97   int min, max;
  98   int offset,
  99       num_rate_control_possibilities,
 100       raw_value,
 101       raw_max_idx = 0,
 102       raw_min_idx = 0;
 103   int max_rate_categories[28];
 104   int min_rate_categories[28];
 105   int temp_category_balances[64];
 106   int *min_rate_ptr = NULL;
 107   int *max_rate_ptr = NULL;
 108
 109   if (number_of_regions == 14) {
 110     num_rate_control_possibilities = 16;
 111     if ( number_of_available_bits > 320)
 112       number_of_available_bits = ((number_of_available_bits - 320) * 5/8) + 320;
 113   } else {
 114     num_rate_control_possibilities = 32;
 115     if (number_of_regions  == 28 && number_of_available_bits > 640)
 116       number_of_available_bits = ((number_of_available_bits - 640) * 5/8) + 640;
 117   }
 118
 119   offset = -32;
 120   for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) {
 121     expected_number_of_code_bits = 0;
 122     for (region = 0; region < number_of_regions; region++) {
 123       i = (delta + offset - absolute_region_power_index[region]) >> 1;
 124       if (i > 7)
 125         i = 7;
 126       else if (i < 0)
 127         i = 0;
 128
 129       power_categories[region] = i;
 130       expected_number_of_code_bits += expected_bits_table[i];
 131
 132     }
 133     if (expected_number_of_code_bits >= number_of_available_bits-32)
 134       offset += delta;
 135   }
 136
 137   expected_number_of_code_bits = 0;
 138   for (region = 0; region  < number_of_regions; region++) {
 139     i = (offset - absolute_region_power_index[region]) >> 1;
 140     if (i > 7)
 141       i = 7;
 142     else if (i < 0)
 143       i = 0;
 144     max_rate_categories[region] = min_rate_categories[region] = power_categories[region] = i;
 145     expected_number_of_code_bits += expected_bits_table[i];
 146   }
 147
 148
 149   min = max = expected_number_of_code_bits;
 150   min_rate_ptr = max_rate_ptr = temp_category_balances + num_rate_control_possibilities;
 151   for (i = 0; i < num_rate_control_possibilities -1; i++) {
 152     if (min + max > number_of_available_bits * 2) {
 153       raw_value = -99;
 154       for (region = number_of_regions-1; region >= 0; region--) {
 155         if (min_rate_categories[region] < 7) {
 156           temp = offset - absolute_region_power_index[region] - 2*min_rate_categories[region];
 157           if (temp > raw_value) {
 158             raw_value = temp;
 159             raw_min_idx = region;
 160           }
 161         }
 162       }
 163       *min_rate_ptr++ = raw_min_idx;
 164       min += expected_bits_table[min_rate_categories[raw_min_idx] + 1] - expected_bits_table[min_rate_categories[raw_min_idx]];
 165       min_rate_categories[raw_min_idx]++;
 166     } else {
 167       raw_value = 99;
 168       for (region = 0; region < number_of_regions; region++) {
 169         if (max_rate_categories[region] > 0 ) {
 170           temp = offset - absolute_region_power_index[region] - 2*max_rate_categories[region];
 171           if (temp < raw_value) {
 172             raw_value = temp;
 173             raw_max_idx = region;
 174           }
 175         }
 176       }
 177
 178       *--max_rate_ptr = raw_max_idx;
 179       max += expected_bits_table[max_rate_categories[raw_max_idx] - 1] - expected_bits_table[max_rate_categories[raw_max_idx]];
 180       max_rate_categories[raw_max_idx]--;
 181     }
 182   }
 183
 184   for (region = 0; region < number_of_regions; region++)
 185     power_categories[region] = max_rate_categories[region];
 186
 187   for (i = 0; i < num_rate_control_possibilities-1; i++)
 188     category_balance[i] = *max_rate_ptr++;
 189
 190
 191   return 0;
 192 }
 193
 194
 195
 196 /*
 197   Looks like the flag means what kind of encoding is used
 198   for now, it looks like :
 199   0 : the sample rate is not encoded in the frame
 200   1 - 2 : the sample rate is fixed in the frame
 201   3 : sample rate is variable and there is one for each frame
 202 */
 203
 204 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 ) {
 205   switch (flag) {
 206     case 0:
 207       *number_of_coefs = 320;
 208       *sample_rate_bits = 0;
 209       *rate_control_bits = 4;
 210       *rate_control_possibilities = 16;
 211       *checksum_bits = 0;
 212       *esf_adjustment = 7;
 213       *number_of_regions = 14;
 214       *sample_rate_code = 0;
 215       *scale_factor = 22;
 216       break;
 217     case 1:
 218       *number_of_coefs = 320;
 219       *sample_rate_bits = 2;
 220       *rate_control_bits = 4;
 221       *rate_control_possibilities = 16;
 222       *checksum_bits = 4;
 223       *esf_adjustment = -2;
 224       *number_of_regions = 14;
 225       *scale_factor = 1;
 226       if (sample_rate == 16000)
 227         *sample_rate_code = 1;
 228       else if (sample_rate == 24000)
 229         *sample_rate_code = 2;
 230       else if (sample_rate == 32000)
 231         *sample_rate_code = 3;
 232       else
 233         return 3;
 234       break;
 235     case 2:
 236       *number_of_coefs = 640;
 237       *sample_rate_bits = 2;
 238       *rate_control_bits = 5;
 239       *rate_control_possibilities = 32;
 240       *checksum_bits = 4;
 241       *esf_adjustment = 7;
 242       *number_of_regions = 28;
 243       *scale_factor = 33;
 244
 245       if (sample_rate == 24000)
 246         *sample_rate_code = 1;
 247       else if (sample_rate == 24000)
 248         *sample_rate_code = 2;
 249       else if (sample_rate == 48000)
 250         *sample_rate_code = 3;
 251       else
 252         return 3;
 253
 254       break;
 255     case 3:
 256       *number_of_coefs = 640;
 257       *sample_rate_bits = 6;
 258       *rate_control_bits = 5;
 259       *rate_control_possibilities = 32;
 260       *checksum_bits = 4;
 261       *esf_adjustment = 7;
 262       *scale_factor = 33;
 263
 264       switch (sample_rate) {
 265         case 8800:
 266           *number_of_regions = 12;
 267           *sample_rate_code = 59;
 268           break;
 269         case 9600:
 270           *number_of_regions = 12;
 271           *sample_rate_code = 1;
 272           break;
 273         case 10400:
 274           *number_of_regions = 12;
 275           *sample_rate_code = 13;
 276           break;
 277         case 10800:
 278           *number_of_regions = 12;
 279           *sample_rate_code = 14;
 280           break;
 281         case 11200:
 282           *number_of_regions = 12;
 283           *sample_rate_code = 15;
 284           break;
 285         case 11600:
 286           *number_of_regions = 12;
 287           *sample_rate_code = 16;
 288           break;
 289         case 12000:
 290           *number_of_regions = 12;
 291           *sample_rate_code = 2;
 292           break;
 293         case 12400:
 294           *number_of_regions = 12;
 295           *sample_rate_code = 17;
 296           break;
 297         case 12800:
 298           *number_of_regions = 12;
 299           *sample_rate_code = 18;
 300           break;
 301         case 13200:
 302           *number_of_regions = 12;
 303           *sample_rate_code = 19;
 304           break;
 305         case 13600:
 306           *number_of_regions = 12;
 307           *sample_rate_code = 20;
 308           break;
 309         case 14000:
 310           *number_of_regions = 12;
 311           *sample_rate_code = 21;
 312           break;
 313         case 14400:
 314           *number_of_regions = 16;
 315           *sample_rate_code = 3;
 316           break;
 317         case 14800:
 318           *number_of_regions = 16;
 319           *sample_rate_code = 22;
 320           break;
 321         case 15200:
 322           *number_of_regions = 16;
 323           *sample_rate_code = 23;
 324           break;
 325         case 15600:
 326           *number_of_regions = 16;
 327           *sample_rate_code = 24;
 328           break;
 329         case 16000:
 330           *number_of_regions = 16;
 331           *sample_rate_code = 25;
 332           break;
 333         case 16400:
 334           *number_of_regions = 16;
 335           *sample_rate_code = 26;
 336           break;
 337         case 16800:
 338           *number_of_regions = 18;
 339           *sample_rate_code = 4;
 340           break;
 341         case 17200:
 342           *number_of_regions = 18;
 343           *sample_rate_code = 27;
 344           break;
 345         case 17600:
 346           *number_of_regions = 18;
 347           *sample_rate_code = 28;
 348           break;
 349         case 18000:
 350           *number_of_regions = 18;
 351           *sample_rate_code = 29;
 352           break;
 353         case 18400:
 354           *number_of_regions = 18;
 355           *sample_rate_code = 30;
 356           break;
 357         case 18800:
 358           *number_of_regions = 18;
 359           *sample_rate_code = 31;
 360           break;
 361         case 19200:
 362           *number_of_regions = 20;
 363           *sample_rate_code = 5;
 364           break;
 365         case 19600:
 366           *number_of_regions = 20;
 367           *sample_rate_code = 32;
 368           break;
 369         case 20000:
 370           *number_of_regions = 20;
 371           *sample_rate_code = 33;
 372           break;
 373         case 20400:
 374           *number_of_regions = 20;
 375           *sample_rate_code = 34;
 376           break;
 377         case 20800:
 378           *number_of_regions = 20;
 379           *sample_rate_code = 35;
 380           break;
 381         case 21200:
 382           *number_of_regions = 20;
 383           *sample_rate_code = 36;
 384           break;
 385         case 21600:
 386           *number_of_regions = 22;
 387           *sample_rate_code = 6;
 388           break;
 389         case 22000:
 390           *number_of_regions = 22;
 391           *sample_rate_code = 37;
 392           break;
 393         case 22400:
 394           *number_of_regions = 22;
 395           *sample_rate_code = 38;
 396           break;
 397         case 22800:
 398           *number_of_regions = 22;
 399           *sample_rate_code = 39;
 400           break;
 401         case 23200:
 402           *number_of_regions = 22;
 403           *sample_rate_code = 40;
 404           break;
 405         case 23600:
 406           *number_of_regions = 22;
 407           *sample_rate_code = 41;
 408           break;
 409         case 24000:
 410           *number_of_regions = 24;
 411           *sample_rate_code = 7;
 412           break;
 413         case 24400:
 414           *number_of_regions = 24;
 415           *sample_rate_code = 42;
 416           break;
 417         case 24800:
 418           *number_of_regions = 24;
 419           *sample_rate_code = 43;
 420           break;
 421         case 25200:
 422           *number_of_regions = 24;
 423           *sample_rate_code = 44;
 424           break;
 425         case 25600:
 426           *number_of_regions = 24;
 427           *sample_rate_code = 45;
 428           break;
 429         case 26000:
 430           *number_of_regions = 24;
 431           *sample_rate_code = 46;
 432           break;
 433         case 26400:
 434           *number_of_regions = 26;
 435           *sample_rate_code = 8;
 436           break;
 437         case 26800:
 438           *number_of_regions = 26;
 439           *sample_rate_code = 47;
 440           break;
 441         case 27200:
 442           *number_of_regions = 26;
 443           *sample_rate_code = 48;
 444           break;
 445         case 27600:
 446           *number_of_regions = 26;
 447           *sample_rate_code = 49;
 448           break;
 449         case 28000:
 450           *number_of_regions = 26;
 451           *sample_rate_code = 50;
 452           break;
 453         case 28400:
 454           *number_of_regions = 26;
 455           *sample_rate_code = 51;
 456           break;
 457         case 28800:
 458           *number_of_regions = 28;
 459           *sample_rate_code = 9;
 460           break;
 461         case 29200:
 462           *number_of_regions = 28;
 463           *sample_rate_code = 52;
 464           break;
 465         case 29600:
 466           *number_of_regions = 28;
 467           *sample_rate_code = 53;
 468           break;
 469         case 30000:
 470           *number_of_regions = 28;
 471           *sample_rate_code = 54;
 472           break;
 473         case 30400:
 474           *number_of_regions = 28;
 475           *sample_rate_code = 55;
 476           break;
 477         case 30800:
 478           *number_of_regions = 28;
 479           *sample_rate_code = 56;
 480           break;
 481         case 31200:
 482           *number_of_regions = 28;
 483           *sample_rate_code = 10;
 484           break;
 485         case 31600:
 486           *number_of_regions = 28;
 487           *sample_rate_code = 57;
 488           break;
 489         case 32000:
 490           *number_of_regions = 28;
 491           *sample_rate_code = 58;
 492           break;
 493         default:
 494           return 3;
 495           break;
 496       }
 497       break;
 498     default:
 499       return 6;
 500   }
 501
 502   *bits_per_frame  = sample_rate / 50;
 503   return 0;
 504 }
 505