git.sesse.net Git - ffmpeg/blob - libavcodec/siren.c

   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 };