falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
96785 Commits
32 Branches
341MB
Tree: 464310c160
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '464310c160'
${ noResults }
FFmpeg/libavcodec/siren.c

774 lines
37KB
Raw Blame History 

  1. /*

  2.  * Siren audio decoder

  3.  * Copyright (c) 2012 Youness Alaoui <kakaroto@kakaroto.homelinux.net>

  4.  * Copyright (c) 2018 Paul B Mahol

  5.  * Copyright (c) 2019 Lynne <dev@lynne.ee>

  6.  *

  7.  * This file is part of FFmpeg.

  8.  *

  9.  * FFmpeg is free software; you can redistribute it and/or

  10.  * modify it under the terms of the GNU Lesser General Public

  11.  * License as published by the Free Software Foundation; either

  12.  * version 2.1 of the License, or (at your option) any later version.

  13.  *

  14.  * FFmpeg is distributed in the hope that it will be useful,

  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  17.  * Lesser General Public License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public

  20.  * License along with FFmpeg; if not, write to the Free Software

  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  22.  */

  23. 

  24. #include "libavutil/tx.h"

  25. #include "libavutil/float_dsp.h"

  26. 

  27. #include "avcodec.h"

  28. #include "get_bits.h"

  29. #include "internal.h"

  30. #include "mathops.h"

  31. 

  32. static const uint8_t index_table[8] = {4, 4, 3, 3, 2, 2, 1, 0};

  33. static const uint8_t vector_dimension[8] = { 2, 2, 2, 4, 4, 5, 5, 1 };

  34. static const uint8_t number_of_vectors[8] = { 10, 10, 10, 5, 5, 4, 4, 20 };

  35. static const uint8_t expected_bits_table[8] = { 52, 47, 43, 37, 29, 22, 16, 0 };

  36. static const int8_t differential_decoder_tree[27][24][2] = {

  37.     {

  38.         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, -12}, {-11, -10}, {-8, -9}, {-7, -6}, {-13, 12},

  39.         {-5, -4}, {0, 13}, {-3, -14}, {-2, 14}, {-1, 15}, {-15, 16}, {-16, 17}, {-17, 18}, {19, 20},

  40.         {21, 22}, {-18, -19}, {-20, -21}, {-22, -23}, {-32, -32}

  41.     },

  42.     {

  43.         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {-10, -9}, {-8, -11}, {-7, -6}, {9, -5}, {10, -12}, {-4, 11},

  44.         {-13, -3}, {12, -2}, {13, -14}, {-1, 14}, {15, -15}, {0, 16}, {-16, 17}, {-17, 18}, {-18, 19},

  45.         {20, 21},{22, -19}, {-20, -21}, {-22, -23}, {-32, -32}

  46.     },

  47.     {

  48.         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {-12, 11}, {-11, -13}, {-10, -9}, {12, -14}, {-8, -7},

  49.         {-15, -6}, {13, -5}, {-16, -4}, {14, -17}, {15, -3}, {16, -18}, {-2, 17}, {18, -19}, {-1, 19},

  50.         {-20, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}

  51.     },

  52.     {

  53.         {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {7, -12}, {8, -9}, {9, -13}, {-14, 10}, {-8, -15}, {-16, 11},

  54.         {-7, 12}, {-17, -6}, {13, 14}, {-18, 15}, {-5, -4}, {16, 17}, {-3, -2}, {-19, 18}, {-1, 19},

  55.         {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}

  56.     },

  57.     {

  58.         {1, 2}, {3, 4}, {5, 6}, {-12, -11}, {-13, 7}, {8, -14}, {-10, 9}, {10, -15}, {-9, 11}, {-8, 12},

  59.         {-16, 13}, {-7, -6}, {-17, 14}, {-5, -18}, {15, -4}, {16, -19}, {17, -3}, {-20, 18}, {-2, 19},

  60.         {-21, 20}, {0, 21}, {22, -1}, {-22, -23}, {-32, -32}

  61.     },

  62.     {

  63.         {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-12, -10}, {-13, -9}, {8, 9}, {-14, -8}, {10, -15}, {-7, 11},

  64.         {-16, 12}, {-6, -17}, {13, 14}, {-5, 15}, {-18, 16}, {-4, 17}, {-3, -19}, {18, -2}, {-20, 19},

  65.         {-1, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}

  66.     },

  67.     {

  68.         {1, 2}, {3, 4}, {5, -12}, {6, -11}, {-10, -13}, {-9, 7}, {8, -14}, {9, -8}, {-15, 10}, {-7, -16},

  69.         {11, -6}, {12, -17}, {13, -5}, {-18, 14}, {15, -4}, {-19, 16}, {17, -3}, {-20, 18}, {19, 20},

  70.         {21, 22}, {0, -2}, {-1, -21}, {-22, -23}, {-32, -32}

  71.     },

  72.     {

  73.         {1, 2}, {3, 4}, {5, -12}, {6, -13}, {-11, -10}, {7, -14}, {8, -9}, {9, -15}, {-8, 10}, {-7, -16},

  74.         {11, 12}, {-6, -17}, {-5, 13}, {14, 15}, {-18, -4}, {-19, 16}, {-3, 17}, {18, -2}, {-20, 19},

  75.         {20, 21}, {22, 0}, {-1, -21}, {-22, -23}, {-32, -32}

  76.     },

  77.     {

  78.         {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {-12, -9}, {7, 8}, {-13, -8}, {9, -14}, {-7, 10}, {-6, -15},

  79.         {11, 12}, {-5, -16}, {13, 14}, {-17, 15}, {-4, 16}, {17, -18}, {18, -3}, {-2, 19}, {-1, 0},

  80.         {-19, 20}, {-20, 21}, {22, -21}, {-22, -23}, {-32, -32}

  81.     },

  82.     {

  83.         {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-10, -12}, {-9, 8}, {-8, -13}, {9, -7}, {10, -14}, {-6, 11},

  84.         {-15, 12}, {-5, 13}, {-16, -4}, {14, 15}, {-17, -3}, {-18, 16}, {17, -19}, {-2, 18}, {-20, 19},

  85.         {-1, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}

  86.     },

  87.     {

  88.         {1, 2}, {3, 4}, {5, -12}, {6, -11}, {7, 8}, {-10, -13}, {-9, 9}, {-8, -14}, {10, -7}, {11, -15},

  89.         {-6, 12}, {-5, 13}, {-4, -16}, {14, 15}, {-3, -17}, {16, 17}, {-18, -2}, {18, -19}, {-1, 19},

  90.         {-20, 20}, {-21, 21}, {22, 0}, {-22, -23}, {-32, -32}

  91.     },

  92.     {

  93.         {1, 2}, {3, 4}, {5, -12}, {-13, 6}, {-11, 7}, {-14, 8}, {-10, 9}, {-15, -9}, {-8, 10}, {-7, -16},

  94.         {11, -6}, {12, -5}, {-17, 13}, {14, -18}, {15, -4}, {16, -19}, {17, -3}, {18, -2}, {19, -1},

  95.         {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}

  96.     },

  97.     {

  98.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  99.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  100.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  101.     },

  102.     {

  103.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  104.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  105.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  106.     },

  107.     {

  108.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  109.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  110.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  111.     },

  112.     {

  113.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  114.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  115.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  116.     },

  117.     {

  118.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  119.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  120.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  121.     },

  122.     {

  123.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  124.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  125.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  126.     },

  127.     {

  128.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  129.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  130.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  131.     },

  132.     {

  133.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  134.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  135.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  136.     },

  137.     {

  138.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  139.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  140.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  141.     },

  142.     {

  143.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  144.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  145.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  146.     },

  147.     {

  148.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  149.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  150.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  151.     },

  152.     {

  153.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  154.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  155.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  156.     },

  157.     {

  158.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  159.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  160.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  161.     },

  162.     {

  163.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  164.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  165.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  166.     },

  167.     {

  168.         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},

  169.         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},

  170.         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}

  171.     },

  172. };

  173. 

  174. static const uint16_t decoder_tree0[360] = {

  175.     2, 1, 4, 6, 8, 10, 12, 14, 16, 18, 33, 3, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 35, 40,

  176.     42, 44, 46, 5, 48, 65, 50, 52, 54, 56, 58, 60, 62, 64, 37, 66, 67, 68, 97, 70, 72, 74, 7,

  177.     76, 78, 80, 82, 84, 86, 88, 99, 90, 39, 92, 94, 96, 129, 98, 9, 100, 102, 104, 106, 108,

  178.     110, 112, 41, 161, 69, 114, 116, 118, 131, 120, 122, 11, 124, 126, 128, 193, 130, 132, 71,

  179.     134, 43, 136, 138, 140, 163, 101, 13, 142, 144, 146, 148, 150, 152, 154, 225, 156, 158, 195,

  180.     160, 162, 45, 164, 15, 166, 73, 168, 170, 133, 47, 172, 257, 174, 176, 178, 75, 103, 180, 165,

  181.     182, 17, 227, 184, 105, 49, 135, 186, 289, 188, 259, 190, 192, 194, 196, 198, 291, 77, 200,

  182.     202, 197, 107, 204, 19, 51, 229, 206, 167, 208, 210, 212, 214, 21, 79, 81, 109, 216, 218, 220,

  183.     222, 53, 137, 224, 199, 226, 323, 321, 169, 228, 111, 230, 232, 139, 261, 234, 83, 236, 201,

  184.     238, 240, 293, 242, 353, 231, 141, 244, 246, 113, 23, 355, 85, 248, 55, 115, 250, 263, 252,

  185.     254, 203, 171, 256, 258, 233, 235, 143, 357, 325, 260, 295, 262, 173, 145, 177, 87, 264, 327,

  186.     267, 266, 268, 175, 270, 272, 117, 297, 274, 265, 147, 179, 205, 276, 207, 237, 269, 278, 57,

  187.     59, 387, 209, 280, 282, 149, 329, 385, 284, 25, 286, 239, 119, 288, 27, 290, 292, 299, 294, 359,

  188.     89, 296, 298, 419, 181, 300, 331, 271, 417, 211, 361, 151, 389, 241, 302, 304, 303, 306, 308,

  189.     421, 91, 310, 312, 391, 314, 121, 316, 333, 318, 275, 213, 301, 243, 183, 335, 320, 363, 322,

  190.     215, 324, 393, 273, 337, 153, 326, 423, 365, 328, 367, 247, 395, 185, 123, 330, 425, 245, 155,

  191.     332, 334, 305, 397, 336, 277, 217, 338, 340, 339, 427, 342, 344, 346, 307, 399, 187, 348, 309,

  192.     341, 350, 369, 279, 311, 429, 249, 219, 352, 354, 356, 358, 431, 373, 401, 371, 313, 281, 433,

  193.     343, 403, 251, 283

  194. };

  195. 

  196. static const uint16_t decoder_tree1[188] = {

  197.     2, 1, 4, 6, 8, 10, 12, 14, 16, 3, 33, 18, 20, 22, 24, 26, 35, 28, 30, 32, 34, 36, 5, 65, 38, 40,

  198.     37, 42, 44, 46, 67, 48, 50, 52, 54, 56, 58, 60, 7, 62, 39, 97, 64, 69, 66, 99, 68, 70, 72, 74, 76,

  199.     78, 80, 129, 41, 131, 82, 9, 71, 84, 86, 101, 88, 90, 92, 94, 96, 161, 43, 11, 73, 98, 103, 100,

  200.     163, 102, 104, 106, 108, 133, 110, 105, 112, 75, 114, 45, 13, 116, 165, 118, 195, 135, 193, 120, 77,

  201.     122, 47, 124, 167, 225, 126, 79, 107, 227, 128, 137, 197, 15, 130, 169, 199, 132, 109, 134, 17, 139,

  202.     49, 136, 229, 138, 140, 81, 259, 142, 144, 171, 146, 141, 148, 111, 150, 201, 231, 152, 51, 257, 289,

  203.     154, 19, 113, 156, 261, 158, 203, 173, 263, 143, 160, 291, 235, 83, 162, 233, 265, 164, 205, 166, 293,

  204.     145, 168, 175, 177, 237, 115, 295, 170, 207, 172, 267, 174, 176, 297, 147, 178, 180, 269, 182, 271,

  205.     209, 299, 239, 179, 184, 301, 241, 211, 0, 0

  206. };

  207. 

  208. static const uint16_t decoder_tree2[96] = {

  209.     2, 1, 4, 6, 8, 10, 12, 3, 17, 14, 19, 16, 18, 20, 22, 24, 26, 5, 21, 35, 33, 28, 30, 32, 34, 36, 38, 37,

  210.     40, 23, 51, 42, 7, 49, 44, 46, 48, 50, 39, 53, 52, 54, 56, 25, 67, 9, 58, 60, 65, 55, 41, 62, 64, 69, 66,

  211.     11, 27, 68, 57, 83, 70, 71, 81, 43, 72, 74, 13, 76, 85, 29, 73, 78, 99, 59, 87, 101, 80, 97, 45, 82, 84,

  212.     75, 89, 61, 86, 103, 88, 77, 90, 105, 91, 92, 107, 93, 0, 0

  213. };

  214. 

  215. static const uint16_t decoder_tree3[1040] = {

  216.     2, 4, 6, 8, 10, 1, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 3, 36, 1025, 38, 40, 42, 44, 46, 48, 50,

  217.     129, 17, 52, 54, 1153, 19, 56, 58, 60, 62, 64, 66, 68, 145, 70, 72, 74, 76, 78, 1169, 1027, 147, 80, 82, 1171,

  218.     84, 86, 131, 88, 1155, 1043, 1041, 90, 92, 5, 94, 96, 98, 100, 102, 104, 21, 106, 108, 2049, 2177, 110, 112, 114,

  219.     116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 33, 144, 163, 146, 148, 150, 152, 154, 161,

  220.     156, 35, 158, 1297, 160, 162, 273, 257, 164, 166, 149, 168, 1281, 170, 172, 2193, 174, 176, 178, 1299, 180, 1045,

  221.     182, 184, 1173, 186, 3201, 188, 190, 192, 194, 2195, 1187, 23, 2179, 196, 7, 198, 275, 200, 2051, 202, 2065, 204,

  222.     206, 1029, 1185, 208, 210, 1157, 37, 3073, 2067, 133, 212, 214, 2321, 216, 165, 218, 1059, 220, 1283, 222, 2305,

  223.     224, 226, 228, 230, 259, 232, 234, 2323, 236, 1409, 1057, 1315, 238, 240, 242, 244, 246, 1425, 248, 1313, 250, 252,

  224.     254, 256, 258, 260, 289, 262, 264, 1189, 266, 268, 179, 151, 270, 272, 274, 276, 278, 291, 280, 282, 9, 385, 284,

  225.     286, 177, 49, 401, 1061, 288, 290, 292, 51, 294, 296, 298, 300, 302, 304, 25, 306, 2083, 39, 308, 310, 3329, 167,

  226.     312, 314, 1175, 316, 318, 1203, 135, 320, 322, 324, 326, 328, 2211, 2307, 330, 1301, 332, 334, 1047, 336, 338, 2449,

  227.     3217, 340, 1427, 2209, 53, 342, 2339, 3345, 344, 346, 348, 403, 181, 4097, 2197, 350, 2181, 1285, 1317, 1031, 352,

  228.     354, 356, 3089, 358, 360, 4225, 277, 362, 364, 366, 368, 2069, 370, 3203, 293, 1201, 305, 372, 3219, 307, 2433, 374,

  229.     376, 378, 380, 2081, 1411, 382, 384, 3075, 1443, 513, 386, 387, 388, 390, 1331, 261, 392, 394, 396, 398, 400, 1441,

  230.     1075, 67, 1159, 402, 404, 406, 408, 410, 412, 414, 3347, 2325, 416, 65, 418, 420, 422, 424, 426, 2053, 193, 1073, 428,

  231.     430, 432, 1537, 1329, 2337, 2213, 434, 417, 183, 41, 436, 438, 440, 442, 444, 446, 448, 450, 195, 2435, 452, 2085, 1063,

  232.     1191, 454, 456, 458, 460, 419, 2071, 1553, 3091, 55, 137, 462, 464, 466, 468, 470, 472, 474, 476, 478, 2309, 4113, 480,

  233.     482, 484, 486, 2451, 2465, 1205, 153, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518,

  234.     520, 522, 524, 1333, 526, 1555, 2467, 2227, 3205, 3331, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 529, 309,

  235.     1303, 3473, 3457, 389, 1569, 1445, 1077, 69, 2199, 1539, 4353, 550, 552, 554, 556, 558, 560, 562, 1459, 4241, 3221, 1429,

  236.     2341, 279, 3475, 169, 564, 545, 3105, 323, 2353, 2097, 3235, 421, 2229, 3107, 3233, 566, 568, 570, 572, 574, 576, 578,

  237.     580, 582, 584, 586, 588, 590, 592, 594, 596, 2099, 1091, 531, 2437, 4227, 405, 197, 263, 1287, 2577, 1049, 1571, 598, 600,

  238.     602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650,

  239.     1345, 1219, 3077, 1457, 2225, 2579, 515, 2561, 2469, 433, 1221, 2183, 4243, 652, 654, 656, 658, 660, 662, 664, 666, 668,

  240.     670, 1217, 3333, 3093, 435, 321, 4369, 1089, 2055, 4099, 3361, 1319, 547, 1161, 1177, 672, 2355, 4115, 1413, 4257, 3349,

  241.     2453, 3109, 2357, 2215, 3363, 1079, 1207, 311, 1033, 1347, 1065, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696,

  242.     698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746,

  243.     748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796,

  244.     798, 800, 802, 804, 806, 808, 810, 812, 814, 2593, 2565, 4261, 3253, 437, 325, 3489, 2311, 4259, 1431, 2087, 2563, 295, 2343,

  245.     449, 199, 265, 2201, 4371, 1193, 816, 533, 1557, 2581, 2241, 3365, 3491, 3603, 549, 2101, 1461, 1093, 2117, 3459, 3079, 4481,

  246.     3095, 2327, 3461, 4129, 3249, 1447, 2471, 2231, 71, 4497, 2609, 1289, 393, 3251, 2073, 3097, 2371, 1305, 2089, 818, 820, 822,

  247.     824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872,

  248.     874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922,

  249.     924, 926, 928, 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, 960, 962, 964, 966, 968, 970, 972,

  250.     974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018,

  251.     1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 4161, 4273, 3507, 3493, 4517, 2497, 1573, 2597, 3621, 4531, 4627, 3523,

  252.     3125, 4149, 4529, 3139, 4515, 451, 4277, 2113, 4163, 4499, 3381, 4405, 1473, 4373, 2485, 3509, 565, 1589, 2613, 3585, 3123,

  253.     4403, 3141, 4147, 563, 2245, 3269, 4357, 1349, 2373, 3397, 453, 1477, 2501, 2481, 579, 1601, 3477, 4103, 3265, 2243, 1587,

  254.     3207, 4231, 3267, 4501, 1475, 3335, 4359, 391, 1415, 2439, 3463, 4487, 519, 1543, 2567, 3591, 4609, 4289, 4611, 2499, 4119,

  255.     4385, 4145, 4401, 3223, 4247, 3379, 577, 3393, 3351, 4375, 407, 1585, 2455, 3479, 4503, 535, 1559, 2583, 3607, 3605, 4513,

  256.     4485, 3111, 4135, 3121, 517, 3377, 3239, 4263, 1541, 4291, 4229, 3367, 4391, 423, 2115, 4131, 3495, 551, 1575, 2599, 3635, 3395,

  257.     2103, 3127, 4151, 3589, 4101, 1603, 3255, 4279, 3601, 1335, 2359, 3383, 439, 1463, 2487, 3511, 567, 1591, 4133, 1095, 2119, 3143,

  258.     2369, 1223, 2247, 3271, 327, 1351, 2375, 455, 1479, 3137, 3521, 2057, 3081, 4105, 4387, 3505, 2185, 3209, 4233, 3587, 4355, 2313,

  259.     3337, 3237, 1417, 2441, 3465, 521, 1545, 3617, 3633, 561, 4625, 4121, 2611, 2483, 2595, 3225, 4249, 281, 4245, 2329, 3353, 409,

  260.     1433, 2457, 3481, 537, 1561, 4483, 3619, 4389, 3113, 4275, 4117, 2217, 3241, 297, 1321, 2345, 3369, 425, 1449, 2473, 57, 1081,

  261.     2105, 3129, 185, 1209, 2233, 3257, 313, 1337, 2361, 441, 1465, 73, 1097, 201, 1225, 0, 0

  262. };

  263. 

  264. static const uint16_t decoder_tree4[416] = {

  265.     2, 4, 6, 1, 8, 10, 12, 14, 16, 18, 20, 22, 24, 3, 129, 26, 28, 9, 33, 30, 32,

  266.     34, 36, 11, 161, 38, 40, 42, 41, 44, 46, 131, 43, 169, 35, 48, 137, 50, 52, 54, 56, 139,

  267.     163, 171, 58, 60, 62, 64, 5, 66, 68, 70, 257, 72, 74, 76, 13, 78, 80, 289, 82, 84, 17,

  268.     86, 88, 65, 90, 201, 19, 92, 94, 51, 193, 96, 98, 49, 100, 73, 102, 104, 106, 45, 108, 110,

  269.     297, 112, 114, 116, 37, 203, 118, 120, 179, 122, 177, 124, 265, 126, 75, 133, 259, 291, 147, 128, 67,

  270.     195, 130, 141, 173, 299, 132, 145, 134, 165, 136, 138, 140, 142, 7, 144, 146, 21, 267, 148, 53, 150,

  271.     321, 152, 154, 15, 156, 81, 158, 160, 385, 162, 417, 164, 166, 168, 83, 170, 172, 329, 174, 211, 176,

  272.     27, 178, 180, 182, 209, 184, 186, 188, 190, 25, 192, 331, 194, 196, 105, 57, 198, 97, 200, 202, 323,

  273.     225, 59, 149, 204, 206, 233, 307, 208, 77, 181, 210, 212, 214, 216, 218, 220, 222, 47, 224, 226, 69,

  274.     228, 230, 197, 232, 425, 393, 205, 275, 293, 39, 234, 236, 238, 305, 135, 155, 301, 143, 240, 242, 235,

  275.     395, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 273, 269, 185, 264, 266, 268, 270, 272, 274, 276,

  276.     261, 153, 278, 280, 282, 187, 337, 387, 107, 284, 427, 227, 167, 419, 286, 288, 290, 292, 294, 296, 298,

  277.     300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 115,

  278.     99, 85, 213, 29, 113, 23, 89, 241, 61, 449, 339, 175, 340, 342, 344, 346, 348, 350, 352, 354, 356,

  279.     358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398,

  280.     400, 402, 404, 406, 408, 410, 412, 414, 389, 361, 457, 465, 429, 451, 333, 109, 277, 243, 263, 295, 199,

  281.     283, 151, 55, 183, 229, 357, 363, 123, 491, 397, 411, 251, 313, 441, 467, 345, 433, 461, 219, 237, 365,

  282.     435, 353, 347, 405, 409, 217, 309, 437, 369, 371, 341, 117, 245, 249, 157, 285, 403, 189, 317, 93, 221,

  283.     315, 401, 481, 391, 489, 121, 421, 423, 71, 483, 327, 103, 231, 443, 459, 271, 399, 355, 91, 303, 431,

  284.     79, 207, 335, 111, 239, 281, 325, 279, 453, 101, 311, 87, 215, 31, 159, 63, 191

  285. };

  286. 

  287. static const uint16_t decoder_tree5[384] = {

  288.     2, 4, 1, 6, 8, 10, 12, 14, 16, 18, 20, 22, 3, 513, 24, 26, 28, 9, 129, 33, 30, 32, 34, 36, 38, 40, 11, 42, 641, 44, 46, 41,

  289.     161, 48, 515, 50, 52, 131, 54, 35, 545, 137, 56, 58, 60, 521, 62, 43, 673, 64, 169, 66, 68, 523, 70, 163, 643, 139, 553, 72, 649, 74, 547,

  290.     76, 78, 80, 681, 171, 82, 84, 555, 86, 675, 88, 651, 5, 90, 92, 1025, 94, 96, 98, 683, 13,

  291.     100, 17, 102, 104, 106, 65, 108, 110, 257, 112, 114, 1153, 19, 116, 118, 120, 122, 124, 49, 126, 128,

  292.     769, 289, 130, 132, 134, 73, 136, 138, 140, 142, 193, 144, 146, 148, 150, 152, 154, 517, 156, 158, 37,

  293.     51, 160, 201, 162, 145, 164, 166, 168, 133, 170, 801, 45, 172, 174, 1057, 176, 178, 67, 180, 1027, 577,

  294.     182, 184, 186, 188, 190, 192, 194, 196, 198, 259, 200, 202, 204, 525, 177, 265, 141, 206, 208, 210, 212,

  295.     195, 297, 214, 75, 216, 1033, 203, 585, 1155, 1185, 267, 1161, 549, 218, 220, 657, 777, 147, 222, 224, 226,

  296.     228, 230, 232, 234, 236, 238, 240, 587, 645, 165, 242, 244, 246, 248, 250, 771, 291, 252, 579, 1065, 1035,

  297.     705, 531, 529, 659, 173, 254, 561, 653, 256, 713, 677, 557, 258, 260, 262, 264, 266, 268, 270, 272, 274,

  298.     276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 707, 1059, 809, 715, 563, 179, 691, 1193,

  299.     21, 779, 1067, 299, 1187, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332,

  300.     334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374,

  301.     376, 378, 380, 83, 69, 1281, 803, 321, 1195, 1163, 811, 1323, 689, 1321, 1099, 305, 835, 1227, 331, 843, 785,

  302.     593, 1043, 1291, 1283, 1171, 275, 787, 1217, 833, 1075, 1313, 1219, 1203, 307, 819, 841, 595, 211, 723, 721, 817,

  303.     1029, 329, 81, 1157, 261, 773, 1097, 1089, 1061, 1169, 1091, 1189, 293, 805, 1201, 581, 197, 709, 1289, 273, 1037,

  304.     1315, 1041, 1165, 269, 781, 209, 1073, 1069, 323, 685, 1197, 301, 813, 77, 589, 205, 717, 1225, 533, 149, 661,

  305.     53, 565, 181, 693, 0, 0

  306. };

  307. 

  308. static const uint16_t decoder_tree6[62] = {

  309.     2, 1, 4, 6, 8, 10, 12, 14, 16, 3, 33, 5, 17, 9, 18, 20, 22, 24, 26, 28, 30, 32, 34, 7, 49, 13, 25, 36, 38, 11,

  310.     21, 41, 35, 37, 19, 40, 42, 44, 46, 48, 50, 15, 52, 57, 29, 27, 23, 53, 54, 51, 39, 45, 43, 56, 58, 31, 55, 60,

  311.     61, 47, 59, 63

  312. };

  313. 

  314. static const uint16_t *const decoder_tables[7] = {

  315.     decoder_tree0,

  316.     decoder_tree1,

  317.     decoder_tree2,

  318.     decoder_tree3,

  319.     decoder_tree4,

  320.     decoder_tree5,

  321.     decoder_tree6,

  322. };

  323. 

  324. static const int decoder_tables_elements[7] = {

  325.     FF_ARRAY_ELEMS(decoder_tree0),

  326.     FF_ARRAY_ELEMS(decoder_tree1),

  327.     FF_ARRAY_ELEMS(decoder_tree2),

  328.     FF_ARRAY_ELEMS(decoder_tree3),

  329.     FF_ARRAY_ELEMS(decoder_tree4),

  330.     FF_ARRAY_ELEMS(decoder_tree5),

  331.     FF_ARRAY_ELEMS(decoder_tree6),

  332. };

  333. 

  334. static const float mlt_quant[7][14] = {

  335.     { 0.0f, 0.392f, 0.761f, 1.120f, 1.477f, 1.832f, 2.183f, 2.541f, 2.893f, 3.245f, 3.598f, 3.942f, 4.288f, 4.724f },

  336.     { 0.0f, 0.544f, 1.060f, 1.563f, 2.068f, 2.571f, 3.072f, 3.562f, 4.070f, 4.620f, 0.0f, 0.0f, 0.0f, 0.0f },

  337.     { 0.0f, 0.746f, 1.464f, 2.180f, 2.882f, 3.584f, 4.316f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },

  338.     { 0.0f, 1.006f, 2.000f, 2.993f, 3.985f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },

  339.     { 0.0f, 1.321f, 2.703f, 3.983f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },

  340.     { 0.0f, 1.657f, 3.491f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f },

  341.     { 0.0f, 1.964f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }

  342. };

  343. 

  344. static const float noise_category5[20] = {

  345.     0.70711f, 0.6179f, 0.5005f, 0.3220f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f,

  346.     0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f

  347. };

  348. 

  349. static const float noise_category6[20] = {

  350.     0.70711f, 0.5686f, 0.3563f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f,

  351.     0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f

  352. };

  353. 

  354. #define FRAME_SIZE 320

  355. 

  356. typedef struct SirenContext {

  357.     GetBitContext gb;

  358. 

  359.     int rate_control_possibilities;

  360.     int esf_adjustment;

  361.     int number_of_regions;

  362.     int scale_factor;

  363.     int sample_rate_bits;

  364.     int region_size;

  365. 

  366.     int dw1, dw2, dw3, dw4;

  367. 

  368.     int absolute_region_power_index[32];

  369.     float decoder_standard_deviation[32];

  370.     int power_categories[32];

  371.     int category_balance[32];

  372.     float standard_deviation[64];

  373.     float backup_frame[FRAME_SIZE];

  374. 

  375.     AVFloatDSPContext *fdsp;

  376.     av_tx_fn           tx_fn;

  377.     AVTXContext       *tx_ctx;

  378. 

  379.     DECLARE_ALIGNED(32, float, imdct_buf)[4][FRAME_SIZE];

  380.     float          *window;

  381.     float          *imdct_in;

  382.     float          *imdct_out;

  383.     float          *imdct_prev;

  384. } SirenContext;

  385. 

  386. static av_cold int siren_init(AVCodecContext *avctx)

  387. {

  388.     const float scale = 1.0f / (22.f * 32768.f);

  389.     SirenContext *s = avctx->priv_data;

  390.     int i;

  391. 

  392.     s->imdct_in   = s->imdct_buf[0];

  393.     s->imdct_out  = s->imdct_buf[1];

  394.     s->imdct_prev = s->imdct_buf[2];

  395.     s->window     = s->imdct_buf[3];

  396. 

  397.     avctx->channels       = 1;

  398.     avctx->channel_layout = AV_CH_LAYOUT_MONO;

  399.     avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;

  400. 

  401.     s->rate_control_possibilities = 16;

  402.     s->esf_adjustment = 7;

  403.     s->number_of_regions = 14;

  404.     s->scale_factor = 22;

  405.     s->region_size = 20;

  406.     s->dw1 = s->dw2 = s->dw3 = s->dw4 = 1;

  407. 

  408.     for (i = 0; i < 64; i++) {

  409.         float region_power = powf(10, (i - 24) * 0.3010299957);

  410. 

  411.         s->standard_deviation[i] = sqrtf(region_power);

  412.     }

  413. 

  414.     for (i = 0; i < FRAME_SIZE; i++) {

  415.         float angle = ((i + 0.5f) * M_PI_2) / 320.f;

  416.         s->window[i] = sinf(angle);

  417.     }

  418. 

  419.     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);

  420.     if (!s->fdsp)

  421.         return AVERROR(ENOMEM);

  422. 

  423.     return av_tx_init(&s->tx_ctx, &s->tx_fn, AV_TX_FLOAT_MDCT, 1, FRAME_SIZE, &scale, 0);

  424. }

  425. 

  426. static int decode_envelope(SirenContext *s, GetBitContext *gb,

  427.                            int number_of_regions, float *decoder_standard_deviation,

  428.                            int *absolute_region_power_index, int esf_adjustment)

  429. {

  430.     absolute_region_power_index[0] = (int)get_bits(gb, 5) - esf_adjustment;

  431.     decoder_standard_deviation[0] = s->standard_deviation[absolute_region_power_index[0] + 24];

  432. 

  433.     for (int i = 1; i < number_of_regions; i++) {

  434.         int index = 0;

  435. 

  436.         do {

  437.             index = differential_decoder_tree[i - 1][index][get_bits1(gb)];

  438.         } while (index > 0);

  439. 

  440.         absolute_region_power_index[i] = absolute_region_power_index[i - 1] - index - 12;

  441.         decoder_standard_deviation[i] = s->standard_deviation[absolute_region_power_index[i] + 24];

  442.     }

  443. 

  444.     return get_bits_count(gb);

  445. }

  446. 

  447. static int categorize_regions(int number_of_regions, int number_of_available_bits,

  448.                               int *absolute_region_power_index, int *power_categories,

  449.                               int *category_balance)

  450. {

  451.     int region, delta, i, temp;

  452.     int expected_number_of_code_bits;

  453.     int min, max;

  454.     int offset, num_rate_control_possibilities = 16,

  455.         raw_value, raw_max_idx = 0, raw_min_idx = 0;

  456.     int max_rate_categories[28];

  457.     int min_rate_categories[28];

  458.     int temp_category_balances[64];

  459.     int *min_rate_ptr = NULL;

  460.     int *max_rate_ptr = NULL;

  461. 

  462.     offset = -32;

  463.     for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) {

  464.         expected_number_of_code_bits = 0;

  465.         for (region = 0; region < number_of_regions; region++) {

  466.             i = (delta + offset -

  467.                  absolute_region_power_index[region]) >> 1;

  468.             i = av_clip_uintp2(i, 3);

  469.             power_categories[region] = i;

  470.             expected_number_of_code_bits += expected_bits_table[i];

  471. 

  472.         }

  473.         if (expected_number_of_code_bits >= number_of_available_bits - 32)

  474.             offset += delta;

  475.     }

  476. 

  477.     expected_number_of_code_bits = 0;

  478.     for (region = 0; region < number_of_regions; region++) {

  479.         i = (offset - absolute_region_power_index[region]) >> 1;

  480.         i = av_clip_uintp2(i, 3);

  481.         max_rate_categories[region] = min_rate_categories[region] =

  482.             power_categories[region] = i;

  483.         expected_number_of_code_bits += expected_bits_table[i];

  484.     }

  485. 

  486.     min = max = expected_number_of_code_bits;

  487.     min_rate_ptr = max_rate_ptr =

  488.         temp_category_balances + num_rate_control_possibilities;

  489.     for (i = 0; i < num_rate_control_possibilities - 1; i++) {

  490.         if (min + max > number_of_available_bits * 2) {

  491.             raw_value = -99;

  492.             for (region = number_of_regions - 1; region >= 0; region--) {

  493.                 if (min_rate_categories[region] < 7) {

  494.                     temp =

  495.                         offset - absolute_region_power_index[region] -

  496.                         2 * min_rate_categories[region];

  497.                     if (temp > raw_value) {

  498.                         raw_value = temp;

  499.                         raw_min_idx = region;

  500.                     }

  501.                 }

  502.             }

  503.             *min_rate_ptr++ = raw_min_idx;

  504.             min +=

  505.                 expected_bits_table[min_rate_categories[raw_min_idx] + 1] -

  506.                 expected_bits_table[min_rate_categories[raw_min_idx]];

  507.             min_rate_categories[raw_min_idx]++;

  508.         } else {

  509.             raw_value = 99;

  510.             for (region = 0; region < number_of_regions; region++) {

  511.                 if (max_rate_categories[region] > 0) {

  512.                     temp =

  513.                         offset - absolute_region_power_index[region] -

  514.                         2 * max_rate_categories[region];

  515.                     if (temp < raw_value) {

  516.                         raw_value = temp;

  517.                         raw_max_idx = region;

  518.                     }

  519.                 }

  520.             }

  521. 

  522.             *--max_rate_ptr = raw_max_idx;

  523.             max += expected_bits_table[max_rate_categories[raw_max_idx] - 1] -

  524.                    expected_bits_table[max_rate_categories[raw_max_idx]];

  525.             max_rate_categories[raw_max_idx]--;

  526.         }

  527.     }

  528. 

  529.     for (region = 0; region < number_of_regions; region++)

  530.         power_categories[region] = max_rate_categories[region];

  531. 

  532.     for (i = 0; i < num_rate_control_possibilities - 1; i++)

  533.         category_balance[i] = *max_rate_ptr++;

  534. 

  535.     return 0;

  536. }

  537. 

  538. static int get_dw(SirenContext *s)

  539. {

  540.     int ret = s->dw1 + s->dw4;

  541. 

  542.     if ((ret & 0x8000) != 0)

  543.         ret++;

  544. 

  545.     s->dw1 = s->dw2;

  546.     s->dw2 = s->dw3;

  547.     s->dw3 = s->dw4;

  548.     s->dw4 = ret;

  549. 

  550.     return ret;

  551. }

  552. 

  553. static int decode_vector(SirenContext *s, int number_of_regions,

  554.                          int number_of_available_bits, float *decoder_standard_deviation,

  555.                          int *power_categories, float *coefs, int scale_factor)

  556. {

  557.     GetBitContext *gb = &s->gb;

  558.     float *coefs_ptr;

  559.     float decoded_value;

  560.     float noise;

  561.     const uint16_t *decoder_tree;

  562.     int region;

  563.     int category;

  564.     int i, j;

  565.     int index;

  566.     int error = 0;

  567.     int dw1;

  568.     int dw2;

  569. 

  570.     for (region = 0; region < number_of_regions; region++) {

  571.         category = power_categories[region];

  572.         coefs_ptr = coefs + (region * s->region_size);

  573. 

  574.         if (category >= 0 && category < 7) {

  575.             decoder_tree = decoder_tables[category];

  576. 

  577.             for (i = 0; i < number_of_vectors[category]; i++) {

  578.                 index = 0;

  579.                 do {

  580.                     if (get_bits_left(gb) <= 0) {

  581.                         error = 1;

  582.                         break;

  583.                     }

  584. 

  585.                     if (index + show_bits1(gb) >= decoder_tables_elements[category]) {

  586.                         error = 1;

  587.                         break;

  588.                     }

  589.                     index = decoder_tree[index + get_bits1(gb)];

  590.                 } while ((index & 1) == 0);

  591. 

  592.                 index >>= 1;

  593. 

  594.                 if (error == 0 && get_bits_left(gb) >= 0) {

  595.                     for (j = 0; j < vector_dimension[category]; j++) {

  596.                         decoded_value = mlt_quant[category][index & ((1 << index_table[category]) - 1)];

  597.                         index >>= index_table[category];

  598. 

  599.                         if (decoded_value) {

  600.                             if (!get_bits1(gb))

  601.                                 decoded_value *= -decoder_standard_deviation[region];

  602.                             else

  603.                                 decoded_value *= decoder_standard_deviation[region];

  604.                         }

  605. 

  606.                         *coefs_ptr++ = decoded_value * scale_factor;

  607.                     }

  608.                 } else {

  609.                     error = 1;

  610.                     break;

  611.                 }

  612.             }

  613. 

  614.             if (error == 1) {

  615.                 for (j = region + 1; j < number_of_regions; j++)

  616.                     power_categories[j] = 7;

  617.                 category = 7;

  618.             }

  619.         }

  620. 

  621.         coefs_ptr = coefs + (region * s->region_size);

  622. 

  623.         if (category == 5) {

  624.             i = 0;

  625.             for (j = 0; j < s->region_size; j++) {

  626.                 if (*coefs_ptr != 0)

  627.                     i++;

  628.                 coefs_ptr++;

  629.             }

  630. 

  631.             noise = decoder_standard_deviation[region] * noise_category5[i];

  632.         } else if (category == 6) {

  633.             i = 0;

  634.             for (j = 0; j < s->region_size; j++) {

  635.                 if (*coefs_ptr++ != 0)

  636.                     i++;

  637.             }

  638. 

  639.             noise = decoder_standard_deviation[region] * noise_category6[i];

  640.         } else if (category == 7) {

  641.             noise = decoder_standard_deviation[region] * 0.70711f;

  642.         } else {

  643.             noise = 0;

  644.         }

  645. 

  646.         coefs_ptr = coefs + (region * s->region_size);

  647. 

  648.         if (category == 5 || category == 6 || category == 7) {

  649.             dw1 = get_dw(s);

  650.             dw2 = get_dw(s);

  651. 

  652.             for (j = 0; j < 10; j++) {

  653.                 if (category == 7 || *coefs_ptr == 0)

  654.                     *coefs_ptr = dw1 & 1 ? noise : -noise;

  655.                 coefs_ptr++;

  656.                 dw1 >>= 1;

  657. 

  658.                 if (category == 7 || *coefs_ptr == 0)

  659.                     *coefs_ptr = dw2 & 1 ? noise : -noise;

  660.                 coefs_ptr++;

  661.                 dw2 >>= 1;

  662.             }

  663.         }

  664.     }

  665. 

  666.     return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);

  667. }

  668. 

  669. static int siren_decode(AVCodecContext *avctx, void *data,

  670.                         int *got_frame, AVPacket *avpkt)

  671. {

  672.     SirenContext *s = avctx->priv_data;

  673.     GetBitContext *gb = &s->gb;

  674.     AVFrame *frame = data;

  675.     int ret, number_of_valid_coefs = 20 * s->number_of_regions;

  676.     int frame_error = 0, rate_control = 0;

  677. 

  678.     if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)

  679.         return ret;

  680. 

  681.     decode_envelope(s, gb, s->number_of_regions,

  682.                     s->decoder_standard_deviation,

  683.                     s->absolute_region_power_index, s->esf_adjustment);

  684. 

  685.     rate_control = get_bits(gb, 4);

  686. 

  687.     categorize_regions(s->number_of_regions, get_bits_left(gb),

  688.                        s->absolute_region_power_index, s->power_categories,

  689.                        s->category_balance);

  690. 

  691.     for (int i = 0; i < rate_control; i++)

  692.         s->power_categories[s->category_balance[i]]++;

  693. 

  694.     ret = decode_vector(s, s->number_of_regions, get_bits_left(gb),

  695.                         s->decoder_standard_deviation, s->power_categories,

  696.                         s->imdct_in, s->scale_factor);

  697.     if (ret < 0)

  698.         return ret;

  699. 

  700.     if (get_bits_left(gb) > 0) {

  701.         do {

  702.             frame_error |= !get_bits1(gb);

  703.         } while (get_bits_left(gb) > 0);

  704.     } else if (get_bits_left(gb) < 0 &&

  705.                rate_control + 1 < s->rate_control_possibilities) {

  706.         frame_error = 1;

  707.     }

  708. 

  709.     for (int i = 0; i < s->number_of_regions; i++) {

  710.         if (s->absolute_region_power_index[i] > 33 ||

  711.             s->absolute_region_power_index[i] < -31)

  712.             frame_error = 1;

  713.     }

  714. 

  715.     if (frame_error) {

  716.         memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));

  717.         memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));

  718.     } else {

  719.         memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));

  720.     }

  721. 

  722.     frame->nb_samples = FRAME_SIZE;

  723.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

  724.         return ret;

  725. 

  726.     for (int i = 0; i < 320; i += 2)

  727.         s->imdct_in[i] *= -1;

  728. 

  729.     s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));

  730.     s->fdsp->vector_fmul_window((float *)frame->data[0],

  731.                                 s->imdct_prev + (FRAME_SIZE >> 1),

  732.                                 s->imdct_out, s->window,

  733.                                 FRAME_SIZE >> 1);

  734.     FFSWAP(float *, s->imdct_out, s->imdct_prev);

  735. 

  736.     *got_frame = 1;

  737. 

  738.     return avpkt->size;

  739. }

  740. 

  741. static av_cold void siren_flush(AVCodecContext *avctx)

  742. {

  743.     SirenContext *s = avctx->priv_data;

  744. 

  745.     memset(s->backup_frame, 0, sizeof(s->backup_frame));

  746.     memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));

  747.     memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));

  748. }

  749. 

  750. static av_cold int siren_close(AVCodecContext *avctx)

  751. {

  752.     SirenContext *s = avctx->priv_data;

  753. 

  754.     av_freep(&s->fdsp);

  755.     av_tx_uninit(&s->tx_ctx);

  756. 

  757.     return 0;

  758. }

  759. 

  760. AVCodec ff_siren_decoder = {

  761.     .name           = "siren",

  762.     .long_name      = NULL_IF_CONFIG_SMALL("Siren"),

  763.     .priv_data_size = sizeof(SirenContext),

  764.     .type           = AVMEDIA_TYPE_AUDIO,

  765.     .id             = AV_CODEC_ID_SIREN,

  766.     .init           = siren_init,

  767.     .close          = siren_close,

  768.     .decode         = siren_decode,

  769.     .flush          = siren_flush,

  770.     .capabilities   = AV_CODEC_CAP_DR1,

  771.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |

  772.                       FF_CODEC_CAP_INIT_CLEANUP,

  773. };