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     unsigned 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     absolute_region_power_index[0] = av_clip(absolute_region_power_index[0], -24, 39);
 432     decoder_standard_deviation[0] = s->standard_deviation[absolute_region_power_index[0] + 24];
 433
 434     for (int i = 1; i < number_of_regions; i++) {
 435         int index = 0;
 436
 437         do {
 438             index = differential_decoder_tree[i - 1][index][get_bits1(gb)];
 439         } while (index > 0);
 440
 441         absolute_region_power_index[i] = av_clip(absolute_region_power_index[i - 1] - index - 12, -24, 39);
 442         decoder_standard_deviation[i] = s->standard_deviation[absolute_region_power_index[i] + 24];
 443     }
 444
 445     return get_bits_count(gb);
 446 }
 447
 448 static int categorize_regions(int number_of_regions, int number_of_available_bits,
 449                               int *absolute_region_power_index, int *power_categories,
 450                               int *category_balance)
 451 {
 452     int region, delta, i, temp;
 453     int expected_number_of_code_bits;
 454     int min, max;
 455     int offset, num_rate_control_possibilities = 16,
 456         raw_value, raw_max_idx = 0, raw_min_idx = 0;
 457     int max_rate_categories[28];
 458     int min_rate_categories[28];
 459     int temp_category_balances[64];
 460     int *min_rate_ptr = NULL;
 461     int *max_rate_ptr = NULL;
 462
 463     offset = -32;
 464     for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) {
 465         expected_number_of_code_bits = 0;
 466         for (region = 0; region < number_of_regions; region++) {
 467             i = (delta + offset -
 468                  absolute_region_power_index[region]) >> 1;
 469             i = av_clip_uintp2(i, 3);
 470             power_categories[region] = i;
 471             expected_number_of_code_bits += expected_bits_table[i];
 472
 473         }
 474         if (expected_number_of_code_bits >= number_of_available_bits - 32)
 475             offset += delta;
 476     }
 477
 478     expected_number_of_code_bits = 0;
 479     for (region = 0; region < number_of_regions; region++) {
 480         i = (offset - absolute_region_power_index[region]) >> 1;
 481         i = av_clip_uintp2(i, 3);
 482         max_rate_categories[region] = min_rate_categories[region] =
 483             power_categories[region] = i;
 484         expected_number_of_code_bits += expected_bits_table[i];
 485     }
 486
 487     min = max = expected_number_of_code_bits;
 488     min_rate_ptr = max_rate_ptr =
 489         temp_category_balances + num_rate_control_possibilities;
 490     for (i = 0; i < num_rate_control_possibilities - 1; i++) {
 491         if (min + max > number_of_available_bits * 2) {
 492             raw_value = -99;
 493             for (region = number_of_regions - 1; region >= 0; region--) {
 494                 if (min_rate_categories[region] < 7) {
 495                     temp =
 496                         offset - absolute_region_power_index[region] -
 497                         2 * min_rate_categories[region];
 498                     if (temp > raw_value) {
 499                         raw_value = temp;
 500                         raw_min_idx = region;
 501                     }
 502                 }
 503             }
 504             if (raw_value == -99)
 505                 return AVERROR_INVALIDDATA;
 506             *min_rate_ptr++ = raw_min_idx;
 507             min +=
 508                 expected_bits_table[min_rate_categories[raw_min_idx] + 1] -
 509                 expected_bits_table[min_rate_categories[raw_min_idx]];
 510             min_rate_categories[raw_min_idx]++;
 511         } else {
 512             raw_value = 99;
 513             for (region = 0; region < number_of_regions; region++) {
 514                 if (max_rate_categories[region] > 0) {
 515                     temp =
 516                         offset - absolute_region_power_index[region] -
 517                         2 * max_rate_categories[region];
 518                     if (temp < raw_value) {
 519                         raw_value = temp;
 520                         raw_max_idx = region;
 521                     }
 522                 }
 523             }
 524             if (raw_value == 99)
 525                 return AVERROR_INVALIDDATA;
 526
 527             *--max_rate_ptr = raw_max_idx;
 528             max += expected_bits_table[max_rate_categories[raw_max_idx] - 1] -
 529                    expected_bits_table[max_rate_categories[raw_max_idx]];
 530             max_rate_categories[raw_max_idx]--;
 531         }
 532     }
 533
 534     for (region = 0; region < number_of_regions; region++)
 535         power_categories[region] = max_rate_categories[region];
 536
 537     for (i = 0; i < num_rate_control_possibilities - 1; i++)
 538         category_balance[i] = *max_rate_ptr++;
 539
 540     return 0;
 541 }
 542
 543 static int get_dw(SirenContext *s)
 544 {
 545     int ret = s->dw1 + s->dw4;
 546
 547     if ((ret & 0x8000) != 0)
 548         ret++;
 549
 550     s->dw1 = s->dw2;
 551     s->dw2 = s->dw3;
 552     s->dw3 = s->dw4;
 553     s->dw4 = ret;
 554
 555     return ret;
 556 }
 557
 558 static int decode_vector(SirenContext *s, int number_of_regions,
 559                          int number_of_available_bits, float *decoder_standard_deviation,
 560                          int *power_categories, float *coefs, int scale_factor)
 561 {
 562     GetBitContext *gb = &s->gb;
 563     float *coefs_ptr;
 564     float decoded_value;
 565     float noise;
 566     const uint16_t *decoder_tree;
 567     int region;
 568     int category;
 569     int i, j;
 570     int index;
 571     int error = 0;
 572     int dw1;
 573     int dw2;
 574
 575     for (region = 0; region < number_of_regions; region++) {
 576         category = power_categories[region];
 577         coefs_ptr = coefs + (region * s->region_size);
 578
 579         if (category >= 0 && category < 7) {
 580             decoder_tree = decoder_tables[category];
 581
 582             for (i = 0; i < number_of_vectors[category]; i++) {
 583                 index = 0;
 584                 do {
 585                     if (get_bits_left(gb) <= 0) {
 586                         error = 1;
 587                         break;
 588                     }
 589
 590                     if (index + show_bits1(gb) >= decoder_tables_elements[category]) {
 591                         error = 1;
 592                         break;
 593                     }
 594                     index = decoder_tree[index + get_bits1(gb)];
 595                 } while ((index & 1) == 0);
 596
 597                 index >>= 1;
 598
 599                 if (error == 0 && get_bits_left(gb) >= 0) {
 600                     for (j = 0; j < vector_dimension[category]; j++) {
 601                         decoded_value = mlt_quant[category][index & ((1 << index_table[category]) - 1)];
 602                         index >>= index_table[category];
 603
 604                         if (decoded_value) {
 605                             if (!get_bits1(gb))
 606                                 decoded_value *= -decoder_standard_deviation[region];
 607                             else
 608                                 decoded_value *= decoder_standard_deviation[region];
 609                         }
 610
 611                         *coefs_ptr++ = decoded_value * scale_factor;
 612                     }
 613                 } else {
 614                     error = 1;
 615                     break;
 616                 }
 617             }
 618
 619             if (error == 1) {
 620                 for (j = region + 1; j < number_of_regions; j++)
 621                     power_categories[j] = 7;
 622                 category = 7;
 623             }
 624         }
 625
 626         coefs_ptr = coefs + (region * s->region_size);
 627
 628         if (category == 5) {
 629             i = 0;
 630             for (j = 0; j < s->region_size; j++) {
 631                 if (*coefs_ptr != 0)
 632                     i++;
 633                 coefs_ptr++;
 634             }
 635
 636             noise = decoder_standard_deviation[region] * noise_category5[i];
 637         } else if (category == 6) {
 638             i = 0;
 639             for (j = 0; j < s->region_size; j++) {
 640                 if (*coefs_ptr++ != 0)
 641                     i++;
 642             }
 643
 644             noise = decoder_standard_deviation[region] * noise_category6[i];
 645         } else if (category == 7) {
 646             noise = decoder_standard_deviation[region] * 0.70711f;
 647         } else {
 648             noise = 0;
 649         }
 650
 651         coefs_ptr = coefs + (region * s->region_size);
 652
 653         if (category == 5 || category == 6 || category == 7) {
 654             dw1 = get_dw(s);
 655             dw2 = get_dw(s);
 656
 657             for (j = 0; j < 10; j++) {
 658                 if (category == 7 || *coefs_ptr == 0)
 659                     *coefs_ptr = dw1 & 1 ? noise : -noise;
 660                 coefs_ptr++;
 661                 dw1 >>= 1;
 662
 663                 if (category == 7 || *coefs_ptr == 0)
 664                     *coefs_ptr = dw2 & 1 ? noise : -noise;
 665                 coefs_ptr++;
 666                 dw2 >>= 1;
 667             }
 668         }
 669     }
 670
 671     return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);
 672 }
 673
 674 static int siren_decode(AVCodecContext *avctx, void *data,
 675                         int *got_frame, AVPacket *avpkt)
 676 {
 677     SirenContext *s = avctx->priv_data;
 678     GetBitContext *gb = &s->gb;
 679     AVFrame *frame = data;
 680     int ret, number_of_valid_coefs = 20 * s->number_of_regions;
 681     int frame_error = 0, rate_control = 0;
 682
 683     if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
 684         return ret;
 685
 686     decode_envelope(s, gb, s->number_of_regions,
 687                     s->decoder_standard_deviation,
 688                     s->absolute_region_power_index, s->esf_adjustment);
 689
 690     rate_control = get_bits(gb, 4);
 691
 692     ret = categorize_regions(s->number_of_regions, get_bits_left(gb),
 693                              s->absolute_region_power_index, s->power_categories,
 694                              s->category_balance);
 695     if (ret < 0)
 696         return ret;
 697
 698     for (int i = 0; i < rate_control; i++)
 699         s->power_categories[s->category_balance[i]]++;
 700
 701     ret = decode_vector(s, s->number_of_regions, get_bits_left(gb),
 702                         s->decoder_standard_deviation, s->power_categories,
 703                         s->imdct_in, s->scale_factor);
 704     if (ret < 0)
 705         return ret;
 706
 707     if (get_bits_left(gb) > 0) {
 708         do {
 709             frame_error |= !get_bits1(gb);
 710         } while (get_bits_left(gb) > 0);
 711     } else if (get_bits_left(gb) < 0 &&
 712                rate_control + 1 < s->rate_control_possibilities) {
 713         frame_error = 1;
 714     }
 715
 716     for (int i = 0; i < s->number_of_regions; i++) {
 717         if (s->absolute_region_power_index[i] > 33 ||
 718             s->absolute_region_power_index[i] < -31)
 719             frame_error = 1;
 720     }
 721
 722     if (frame_error) {
 723         memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
 724         memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
 725     } else {
 726         memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
 727     }
 728
 729     frame->nb_samples = FRAME_SIZE;
 730     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 731         return ret;
 732
 733     for (int i = 0; i < 320; i += 2)
 734         s->imdct_in[i] *= -1;
 735
 736     s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
 737     s->fdsp->vector_fmul_window((float *)frame->data[0],
 738                                 s->imdct_prev + (FRAME_SIZE >> 1),
 739                                 s->imdct_out, s->window,
 740                                 FRAME_SIZE >> 1);
 741     FFSWAP(float *, s->imdct_out, s->imdct_prev);
 742
 743     *got_frame = 1;
 744
 745     return avpkt->size;
 746 }
 747
 748 static av_cold void siren_flush(AVCodecContext *avctx)
 749 {
 750     SirenContext *s = avctx->priv_data;
 751
 752     memset(s->backup_frame, 0, sizeof(s->backup_frame));
 753     memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
 754     memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
 755 }
 756
 757 static av_cold int siren_close(AVCodecContext *avctx)
 758 {
 759     SirenContext *s = avctx->priv_data;
 760
 761     av_freep(&s->fdsp);
 762     av_tx_uninit(&s->tx_ctx);
 763
 764     return 0;
 765 }
 766
 767 AVCodec ff_siren_decoder = {
 768     .name           = "siren",
 769     .long_name      = NULL_IF_CONFIG_SMALL("Siren"),
 770     .priv_data_size = sizeof(SirenContext),
 771     .type           = AVMEDIA_TYPE_AUDIO,
 772     .id             = AV_CODEC_ID_SIREN,
 773     .init           = siren_init,
 774     .close          = siren_close,
 775     .decode         = siren_decode,
 776     .flush          = siren_flush,
 777     .capabilities   = AV_CODEC_CAP_DR1,
 778     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
 779                       FF_CODEC_CAP_INIT_CLEANUP,
 780 };