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 #include "libavutil/mem_internal.h"
  27
  28 #include "avcodec.h"
  29 #include "get_bits.h"
  30 #include "internal.h"
  31 #include "mathops.h"
  32
  33 static const uint8_t index_table[8] = {4, 4, 3, 3, 2, 2, 1, 0};
  34 static const uint8_t vector_dimension[8] = { 2, 2, 2, 4, 4, 5, 5, 1 };
  35 static const uint8_t number_of_vectors[8] = { 10, 10, 10, 5, 5, 4, 4, 20 };
  36 static const uint8_t expected_bits_table[8] = { 52, 47, 43, 37, 29, 22, 16, 0 };
  37 static const int8_t differential_decoder_tree[27][24][2] = {
  38     {
  39         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, -12}, {-11, -10}, {-8, -9}, {-7, -6}, {-13, 12},
  40         {-5, -4}, {0, 13}, {-3, -14}, {-2, 14}, {-1, 15}, {-15, 16}, {-16, 17}, {-17, 18}, {19, 20},
  41         {21, 22}, {-18, -19}, {-20, -21}, {-22, -23}, {-32, -32}
  42     },
  43     {
  44         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {-10, -9}, {-8, -11}, {-7, -6}, {9, -5}, {10, -12}, {-4, 11},
  45         {-13, -3}, {12, -2}, {13, -14}, {-1, 14}, {15, -15}, {0, 16}, {-16, 17}, {-17, 18}, {-18, 19},
  46         {20, 21},{22, -19}, {-20, -21}, {-22, -23}, {-32, -32}
  47     },
  48     {
  49         {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {-12, 11}, {-11, -13}, {-10, -9}, {12, -14}, {-8, -7},
  50         {-15, -6}, {13, -5}, {-16, -4}, {14, -17}, {15, -3}, {16, -18}, {-2, 17}, {18, -19}, {-1, 19},
  51         {-20, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
  52     },
  53     {
  54         {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {7, -12}, {8, -9}, {9, -13}, {-14, 10}, {-8, -15}, {-16, 11},
  55         {-7, 12}, {-17, -6}, {13, 14}, {-18, 15}, {-5, -4}, {16, 17}, {-3, -2}, {-19, 18}, {-1, 19},
  56         {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
  57     },
  58     {
  59         {1, 2}, {3, 4}, {5, 6}, {-12, -11}, {-13, 7}, {8, -14}, {-10, 9}, {10, -15}, {-9, 11}, {-8, 12},
  60         {-16, 13}, {-7, -6}, {-17, 14}, {-5, -18}, {15, -4}, {16, -19}, {17, -3}, {-20, 18}, {-2, 19},
  61         {-21, 20}, {0, 21}, {22, -1}, {-22, -23}, {-32, -32}
  62     },
  63     {
  64         {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-12, -10}, {-13, -9}, {8, 9}, {-14, -8}, {10, -15}, {-7, 11},
  65         {-16, 12}, {-6, -17}, {13, 14}, {-5, 15}, {-18, 16}, {-4, 17}, {-3, -19}, {18, -2}, {-20, 19},
  66         {-1, 20}, {0, 21}, {22, -21}, {-22, -23}, {-32, -32}
  67     },
  68     {
  69         {1, 2}, {3, 4}, {5, -12}, {6, -11}, {-10, -13}, {-9, 7}, {8, -14}, {9, -8}, {-15, 10}, {-7, -16},
  70         {11, -6}, {12, -17}, {13, -5}, {-18, 14}, {15, -4}, {-19, 16}, {17, -3}, {-20, 18}, {19, 20},
  71         {21, 22}, {0, -2}, {-1, -21}, {-22, -23}, {-32, -32}
  72     },
  73     {
  74         {1, 2}, {3, 4}, {5, -12}, {6, -13}, {-11, -10}, {7, -14}, {8, -9}, {9, -15}, {-8, 10}, {-7, -16},
  75         {11, 12}, {-6, -17}, {-5, 13}, {14, 15}, {-18, -4}, {-19, 16}, {-3, 17}, {18, -2}, {-20, 19},
  76         {20, 21}, {22, 0}, {-1, -21}, {-22, -23}, {-32, -32}
  77     },
  78     {
  79         {1, 2}, {3, 4}, {5, 6}, {-11, -10}, {-12, -9}, {7, 8}, {-13, -8}, {9, -14}, {-7, 10}, {-6, -15},
  80         {11, 12}, {-5, -16}, {13, 14}, {-17, 15}, {-4, 16}, {17, -18}, {18, -3}, {-2, 19}, {-1, 0},
  81         {-19, 20}, {-20, 21}, {22, -21}, {-22, -23}, {-32, -32}
  82     },
  83     {
  84         {1, 2}, {3, 4}, {5, 6}, {-11, 7}, {-10, -12}, {-9, 8}, {-8, -13}, {9, -7}, {10, -14}, {-6, 11},
  85         {-15, 12}, {-5, 13}, {-16, -4}, {14, 15}, {-17, -3}, {-18, 16}, {17, -19}, {-2, 18}, {-20, 19},
  86         {-1, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
  87     },
  88     {
  89         {1, 2}, {3, 4}, {5, -12}, {6, -11}, {7, 8}, {-10, -13}, {-9, 9}, {-8, -14}, {10, -7}, {11, -15},
  90         {-6, 12}, {-5, 13}, {-4, -16}, {14, 15}, {-3, -17}, {16, 17}, {-18, -2}, {18, -19}, {-1, 19},
  91         {-20, 20}, {-21, 21}, {22, 0}, {-22, -23}, {-32, -32}
  92     },
  93     {
  94         {1, 2}, {3, 4}, {5, -12}, {-13, 6}, {-11, 7}, {-14, 8}, {-10, 9}, {-15, -9}, {-8, 10}, {-7, -16},
  95         {11, -6}, {12, -5}, {-17, 13}, {14, -18}, {15, -4}, {16, -19}, {17, -3}, {18, -2}, {19, -1},
  96         {-20, 20}, {21, 22}, {0, -21}, {-22, -23}, {-32, -32}
  97     },
  98     {
  99         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 100         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 101         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 102     },
 103     {
 104         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 105         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 106         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 107     },
 108     {
 109         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 110         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 111         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 112     },
 113     {
 114         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 115         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 116         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 117     },
 118     {
 119         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 120         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 121         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 122     },
 123     {
 124         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 125         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 126         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 127     },
 128     {
 129         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 130         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 131         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 132     },
 133     {
 134         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 135         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 136         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 137     },
 138     {
 139         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 140         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 141         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 142     },
 143     {
 144         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 145         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 146         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 147     },
 148     {
 149         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 150         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 151         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 152     },
 153     {
 154         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 155         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 156         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 157     },
 158     {
 159         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 160         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 161         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 162     },
 163     {
 164         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 165         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 166         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 167     },
 168     {
 169         {1, 2}, {3, 4}, {-12, 5}, {-11, -13}, {6, -14}, {-10, 7}, {8, -15}, {-9, 9}, {-16, 10}, {-8, -17},
 170         {11, 12}, {-7, -18}, {-6, 13}, {14, -5}, {15, -19}, {-4, 16}, {-20, 17}, {18, 19}, {20, 21},
 171         {22, 0}, {-1, -3}, {-2, -21}, {-22, -23}, {-32, -32}
 172     },
 173 };
 174
 175 static const uint16_t decoder_tree0[360] = {
 176     2, 1, 4, 6, 8, 10, 12, 14, 16, 18, 33, 3, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 35, 40,
 177     42, 44, 46, 5, 48, 65, 50, 52, 54, 56, 58, 60, 62, 64, 37, 66, 67, 68, 97, 70, 72, 74, 7,
 178     76, 78, 80, 82, 84, 86, 88, 99, 90, 39, 92, 94, 96, 129, 98, 9, 100, 102, 104, 106, 108,
 179     110, 112, 41, 161, 69, 114, 116, 118, 131, 120, 122, 11, 124, 126, 128, 193, 130, 132, 71,
 180     134, 43, 136, 138, 140, 163, 101, 13, 142, 144, 146, 148, 150, 152, 154, 225, 156, 158, 195,
 181     160, 162, 45, 164, 15, 166, 73, 168, 170, 133, 47, 172, 257, 174, 176, 178, 75, 103, 180, 165,
 182     182, 17, 227, 184, 105, 49, 135, 186, 289, 188, 259, 190, 192, 194, 196, 198, 291, 77, 200,
 183     202, 197, 107, 204, 19, 51, 229, 206, 167, 208, 210, 212, 214, 21, 79, 81, 109, 216, 218, 220,
 184     222, 53, 137, 224, 199, 226, 323, 321, 169, 228, 111, 230, 232, 139, 261, 234, 83, 236, 201,
 185     238, 240, 293, 242, 353, 231, 141, 244, 246, 113, 23, 355, 85, 248, 55, 115, 250, 263, 252,
 186     254, 203, 171, 256, 258, 233, 235, 143, 357, 325, 260, 295, 262, 173, 145, 177, 87, 264, 327,
 187     267, 266, 268, 175, 270, 272, 117, 297, 274, 265, 147, 179, 205, 276, 207, 237, 269, 278, 57,
 188     59, 387, 209, 280, 282, 149, 329, 385, 284, 25, 286, 239, 119, 288, 27, 290, 292, 299, 294, 359,
 189     89, 296, 298, 419, 181, 300, 331, 271, 417, 211, 361, 151, 389, 241, 302, 304, 303, 306, 308,
 190     421, 91, 310, 312, 391, 314, 121, 316, 333, 318, 275, 213, 301, 243, 183, 335, 320, 363, 322,
 191     215, 324, 393, 273, 337, 153, 326, 423, 365, 328, 367, 247, 395, 185, 123, 330, 425, 245, 155,
 192     332, 334, 305, 397, 336, 277, 217, 338, 340, 339, 427, 342, 344, 346, 307, 399, 187, 348, 309,
 193     341, 350, 369, 279, 311, 429, 249, 219, 352, 354, 356, 358, 431, 373, 401, 371, 313, 281, 433,
 194     343, 403, 251, 283
 195 };
 196
 197 static const uint16_t decoder_tree1[188] = {
 198     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,
 199     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,
 200     78, 80, 129, 41, 131, 82, 9, 71, 84, 86, 101, 88, 90, 92, 94, 96, 161, 43, 11, 73, 98, 103, 100,
 201     163, 102, 104, 106, 108, 133, 110, 105, 112, 75, 114, 45, 13, 116, 165, 118, 195, 135, 193, 120, 77,
 202     122, 47, 124, 167, 225, 126, 79, 107, 227, 128, 137, 197, 15, 130, 169, 199, 132, 109, 134, 17, 139,
 203     49, 136, 229, 138, 140, 81, 259, 142, 144, 171, 146, 141, 148, 111, 150, 201, 231, 152, 51, 257, 289,
 204     154, 19, 113, 156, 261, 158, 203, 173, 263, 143, 160, 291, 235, 83, 162, 233, 265, 164, 205, 166, 293,
 205     145, 168, 175, 177, 237, 115, 295, 170, 207, 172, 267, 174, 176, 297, 147, 178, 180, 269, 182, 271,
 206     209, 299, 239, 179, 184, 301, 241, 211, 0, 0
 207 };
 208
 209 static const uint16_t decoder_tree2[96] = {
 210     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,
 211     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,
 212     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,
 213     75, 89, 61, 86, 103, 88, 77, 90, 105, 91, 92, 107, 93, 0, 0
 214 };
 215
 216 static const uint16_t decoder_tree3[1040] = {
 217     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,
 218     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,
 219     84, 86, 131, 88, 1155, 1043, 1041, 90, 92, 5, 94, 96, 98, 100, 102, 104, 21, 106, 108, 2049, 2177, 110, 112, 114,
 220     116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 33, 144, 163, 146, 148, 150, 152, 154, 161,
 221     156, 35, 158, 1297, 160, 162, 273, 257, 164, 166, 149, 168, 1281, 170, 172, 2193, 174, 176, 178, 1299, 180, 1045,
 222     182, 184, 1173, 186, 3201, 188, 190, 192, 194, 2195, 1187, 23, 2179, 196, 7, 198, 275, 200, 2051, 202, 2065, 204,
 223     206, 1029, 1185, 208, 210, 1157, 37, 3073, 2067, 133, 212, 214, 2321, 216, 165, 218, 1059, 220, 1283, 222, 2305,
 224     224, 226, 228, 230, 259, 232, 234, 2323, 236, 1409, 1057, 1315, 238, 240, 242, 244, 246, 1425, 248, 1313, 250, 252,
 225     254, 256, 258, 260, 289, 262, 264, 1189, 266, 268, 179, 151, 270, 272, 274, 276, 278, 291, 280, 282, 9, 385, 284,
 226     286, 177, 49, 401, 1061, 288, 290, 292, 51, 294, 296, 298, 300, 302, 304, 25, 306, 2083, 39, 308, 310, 3329, 167,
 227     312, 314, 1175, 316, 318, 1203, 135, 320, 322, 324, 326, 328, 2211, 2307, 330, 1301, 332, 334, 1047, 336, 338, 2449,
 228     3217, 340, 1427, 2209, 53, 342, 2339, 3345, 344, 346, 348, 403, 181, 4097, 2197, 350, 2181, 1285, 1317, 1031, 352,
 229     354, 356, 3089, 358, 360, 4225, 277, 362, 364, 366, 368, 2069, 370, 3203, 293, 1201, 305, 372, 3219, 307, 2433, 374,
 230     376, 378, 380, 2081, 1411, 382, 384, 3075, 1443, 513, 386, 387, 388, 390, 1331, 261, 392, 394, 396, 398, 400, 1441,
 231     1075, 67, 1159, 402, 404, 406, 408, 410, 412, 414, 3347, 2325, 416, 65, 418, 420, 422, 424, 426, 2053, 193, 1073, 428,
 232     430, 432, 1537, 1329, 2337, 2213, 434, 417, 183, 41, 436, 438, 440, 442, 444, 446, 448, 450, 195, 2435, 452, 2085, 1063,
 233     1191, 454, 456, 458, 460, 419, 2071, 1553, 3091, 55, 137, 462, 464, 466, 468, 470, 472, 474, 476, 478, 2309, 4113, 480,
 234     482, 484, 486, 2451, 2465, 1205, 153, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518,
 235     520, 522, 524, 1333, 526, 1555, 2467, 2227, 3205, 3331, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 529, 309,
 236     1303, 3473, 3457, 389, 1569, 1445, 1077, 69, 2199, 1539, 4353, 550, 552, 554, 556, 558, 560, 562, 1459, 4241, 3221, 1429,
 237     2341, 279, 3475, 169, 564, 545, 3105, 323, 2353, 2097, 3235, 421, 2229, 3107, 3233, 566, 568, 570, 572, 574, 576, 578,
 238     580, 582, 584, 586, 588, 590, 592, 594, 596, 2099, 1091, 531, 2437, 4227, 405, 197, 263, 1287, 2577, 1049, 1571, 598, 600,
 239     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,
 240     1345, 1219, 3077, 1457, 2225, 2579, 515, 2561, 2469, 433, 1221, 2183, 4243, 652, 654, 656, 658, 660, 662, 664, 666, 668,
 241     670, 1217, 3333, 3093, 435, 321, 4369, 1089, 2055, 4099, 3361, 1319, 547, 1161, 1177, 672, 2355, 4115, 1413, 4257, 3349,
 242     2453, 3109, 2357, 2215, 3363, 1079, 1207, 311, 1033, 1347, 1065, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696,
 243     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,
 244     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,
 245     798, 800, 802, 804, 806, 808, 810, 812, 814, 2593, 2565, 4261, 3253, 437, 325, 3489, 2311, 4259, 1431, 2087, 2563, 295, 2343,
 246     449, 199, 265, 2201, 4371, 1193, 816, 533, 1557, 2581, 2241, 3365, 3491, 3603, 549, 2101, 1461, 1093, 2117, 3459, 3079, 4481,
 247     3095, 2327, 3461, 4129, 3249, 1447, 2471, 2231, 71, 4497, 2609, 1289, 393, 3251, 2073, 3097, 2371, 1305, 2089, 818, 820, 822,
 248     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,
 249     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,
 250     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,
 251     974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018,
 252     1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 4161, 4273, 3507, 3493, 4517, 2497, 1573, 2597, 3621, 4531, 4627, 3523,
 253     3125, 4149, 4529, 3139, 4515, 451, 4277, 2113, 4163, 4499, 3381, 4405, 1473, 4373, 2485, 3509, 565, 1589, 2613, 3585, 3123,
 254     4403, 3141, 4147, 563, 2245, 3269, 4357, 1349, 2373, 3397, 453, 1477, 2501, 2481, 579, 1601, 3477, 4103, 3265, 2243, 1587,
 255     3207, 4231, 3267, 4501, 1475, 3335, 4359, 391, 1415, 2439, 3463, 4487, 519, 1543, 2567, 3591, 4609, 4289, 4611, 2499, 4119,
 256     4385, 4145, 4401, 3223, 4247, 3379, 577, 3393, 3351, 4375, 407, 1585, 2455, 3479, 4503, 535, 1559, 2583, 3607, 3605, 4513,
 257     4485, 3111, 4135, 3121, 517, 3377, 3239, 4263, 1541, 4291, 4229, 3367, 4391, 423, 2115, 4131, 3495, 551, 1575, 2599, 3635, 3395,
 258     2103, 3127, 4151, 3589, 4101, 1603, 3255, 4279, 3601, 1335, 2359, 3383, 439, 1463, 2487, 3511, 567, 1591, 4133, 1095, 2119, 3143,
 259     2369, 1223, 2247, 3271, 327, 1351, 2375, 455, 1479, 3137, 3521, 2057, 3081, 4105, 4387, 3505, 2185, 3209, 4233, 3587, 4355, 2313,
 260     3337, 3237, 1417, 2441, 3465, 521, 1545, 3617, 3633, 561, 4625, 4121, 2611, 2483, 2595, 3225, 4249, 281, 4245, 2329, 3353, 409,
 261     1433, 2457, 3481, 537, 1561, 4483, 3619, 4389, 3113, 4275, 4117, 2217, 3241, 297, 1321, 2345, 3369, 425, 1449, 2473, 57, 1081,
 262     2105, 3129, 185, 1209, 2233, 3257, 313, 1337, 2361, 441, 1465, 73, 1097, 201, 1225, 0, 0
 263 };
 264
 265 static const uint16_t decoder_tree4[416] = {
 266     2, 4, 6, 1, 8, 10, 12, 14, 16, 18, 20, 22, 24, 3, 129, 26, 28, 9, 33, 30, 32,
 267     34, 36, 11, 161, 38, 40, 42, 41, 44, 46, 131, 43, 169, 35, 48, 137, 50, 52, 54, 56, 139,
 268     163, 171, 58, 60, 62, 64, 5, 66, 68, 70, 257, 72, 74, 76, 13, 78, 80, 289, 82, 84, 17,
 269     86, 88, 65, 90, 201, 19, 92, 94, 51, 193, 96, 98, 49, 100, 73, 102, 104, 106, 45, 108, 110,
 270     297, 112, 114, 116, 37, 203, 118, 120, 179, 122, 177, 124, 265, 126, 75, 133, 259, 291, 147, 128, 67,
 271     195, 130, 141, 173, 299, 132, 145, 134, 165, 136, 138, 140, 142, 7, 144, 146, 21, 267, 148, 53, 150,
 272     321, 152, 154, 15, 156, 81, 158, 160, 385, 162, 417, 164, 166, 168, 83, 170, 172, 329, 174, 211, 176,
 273     27, 178, 180, 182, 209, 184, 186, 188, 190, 25, 192, 331, 194, 196, 105, 57, 198, 97, 200, 202, 323,
 274     225, 59, 149, 204, 206, 233, 307, 208, 77, 181, 210, 212, 214, 216, 218, 220, 222, 47, 224, 226, 69,
 275     228, 230, 197, 232, 425, 393, 205, 275, 293, 39, 234, 236, 238, 305, 135, 155, 301, 143, 240, 242, 235,
 276     395, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 273, 269, 185, 264, 266, 268, 270, 272, 274, 276,
 277     261, 153, 278, 280, 282, 187, 337, 387, 107, 284, 427, 227, 167, 419, 286, 288, 290, 292, 294, 296, 298,
 278     300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 115,
 279     99, 85, 213, 29, 113, 23, 89, 241, 61, 449, 339, 175, 340, 342, 344, 346, 348, 350, 352, 354, 356,
 280     358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398,
 281     400, 402, 404, 406, 408, 410, 412, 414, 389, 361, 457, 465, 429, 451, 333, 109, 277, 243, 263, 295, 199,
 282     283, 151, 55, 183, 229, 357, 363, 123, 491, 397, 411, 251, 313, 441, 467, 345, 433, 461, 219, 237, 365,
 283     435, 353, 347, 405, 409, 217, 309, 437, 369, 371, 341, 117, 245, 249, 157, 285, 403, 189, 317, 93, 221,
 284     315, 401, 481, 391, 489, 121, 421, 423, 71, 483, 327, 103, 231, 443, 459, 271, 399, 355, 91, 303, 431,
 285     79, 207, 335, 111, 239, 281, 325, 279, 453, 101, 311, 87, 215, 31, 159, 63, 191
 286 };
 287
 288 static const uint16_t decoder_tree5[384] = {
 289     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,
 290     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,
 291     76, 78, 80, 681, 171, 82, 84, 555, 86, 675, 88, 651, 5, 90, 92, 1025, 94, 96, 98, 683, 13,
 292     100, 17, 102, 104, 106, 65, 108, 110, 257, 112, 114, 1153, 19, 116, 118, 120, 122, 124, 49, 126, 128,
 293     769, 289, 130, 132, 134, 73, 136, 138, 140, 142, 193, 144, 146, 148, 150, 152, 154, 517, 156, 158, 37,
 294     51, 160, 201, 162, 145, 164, 166, 168, 133, 170, 801, 45, 172, 174, 1057, 176, 178, 67, 180, 1027, 577,
 295     182, 184, 186, 188, 190, 192, 194, 196, 198, 259, 200, 202, 204, 525, 177, 265, 141, 206, 208, 210, 212,
 296     195, 297, 214, 75, 216, 1033, 203, 585, 1155, 1185, 267, 1161, 549, 218, 220, 657, 777, 147, 222, 224, 226,
 297     228, 230, 232, 234, 236, 238, 240, 587, 645, 165, 242, 244, 246, 248, 250, 771, 291, 252, 579, 1065, 1035,
 298     705, 531, 529, 659, 173, 254, 561, 653, 256, 713, 677, 557, 258, 260, 262, 264, 266, 268, 270, 272, 274,
 299     276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 707, 1059, 809, 715, 563, 179, 691, 1193,
 300     21, 779, 1067, 299, 1187, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332,
 301     334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374,
 302     376, 378, 380, 83, 69, 1281, 803, 321, 1195, 1163, 811, 1323, 689, 1321, 1099, 305, 835, 1227, 331, 843, 785,
 303     593, 1043, 1291, 1283, 1171, 275, 787, 1217, 833, 1075, 1313, 1219, 1203, 307, 819, 841, 595, 211, 723, 721, 817,
 304     1029, 329, 81, 1157, 261, 773, 1097, 1089, 1061, 1169, 1091, 1189, 293, 805, 1201, 581, 197, 709, 1289, 273, 1037,
 305     1315, 1041, 1165, 269, 781, 209, 1073, 1069, 323, 685, 1197, 301, 813, 77, 589, 205, 717, 1225, 533, 149, 661,
 306     53, 565, 181, 693, 0, 0
 307 };
 308
 309 static const uint16_t decoder_tree6[62] = {
 310     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,
 311     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,
 312     61, 47, 59, 63
 313 };
 314
 315 static const uint16_t *const decoder_tables[7] = {
 316     decoder_tree0,
 317     decoder_tree1,
 318     decoder_tree2,
 319     decoder_tree3,
 320     decoder_tree4,
 321     decoder_tree5,
 322     decoder_tree6,
 323 };
 324
 325 static const int decoder_tables_elements[7] = {
 326     FF_ARRAY_ELEMS(decoder_tree0),
 327     FF_ARRAY_ELEMS(decoder_tree1),
 328     FF_ARRAY_ELEMS(decoder_tree2),
 329     FF_ARRAY_ELEMS(decoder_tree3),
 330     FF_ARRAY_ELEMS(decoder_tree4),
 331     FF_ARRAY_ELEMS(decoder_tree5),
 332     FF_ARRAY_ELEMS(decoder_tree6),
 333 };
 334
 335 static const float mlt_quant[7][14] = {
 336     { 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 },
 337     { 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 },
 338     { 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 },
 339     { 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 },
 340     { 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 },
 341     { 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 },
 342     { 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 }
 343 };
 344
 345 static const float noise_category5[20] = {
 346     0.70711f, 0.6179f, 0.5005f, 0.3220f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f,
 347     0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f, 0.17678f
 348 };
 349
 350 static const float noise_category6[20] = {
 351     0.70711f, 0.5686f, 0.3563f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f,
 352     0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f
 353 };
 354
 355 #define FRAME_SIZE 320
 356
 357 typedef struct SirenContext {
 358     GetBitContext gb;
 359
 360     int rate_control_possibilities;
 361     int esf_adjustment;
 362     int number_of_regions;
 363     int scale_factor;
 364     int sample_rate_bits;
 365     int region_size;
 366
 367     unsigned dw1, dw2, dw3, dw4;
 368
 369     int absolute_region_power_index[32];
 370     float decoder_standard_deviation[32];
 371     int power_categories[32];
 372     int category_balance[32];
 373     float standard_deviation[64];
 374     float backup_frame[FRAME_SIZE];
 375
 376     AVFloatDSPContext *fdsp;
 377     av_tx_fn           tx_fn;
 378     AVTXContext       *tx_ctx;
 379
 380     DECLARE_ALIGNED(32, float, imdct_buf)[4][FRAME_SIZE];
 381     float          *window;
 382     float          *imdct_in;
 383     float          *imdct_out;
 384     float          *imdct_prev;
 385 } SirenContext;
 386
 387 static av_cold int siren_init(AVCodecContext *avctx)
 388 {
 389     const float scale = 1.0f / (22.f * 32768.f);
 390     SirenContext *s = avctx->priv_data;
 391     int i;
 392
 393     s->imdct_in   = s->imdct_buf[0];
 394     s->imdct_out  = s->imdct_buf[1];
 395     s->imdct_prev = s->imdct_buf[2];
 396     s->window     = s->imdct_buf[3];
 397
 398     avctx->channels       = 1;
 399     avctx->channel_layout = AV_CH_LAYOUT_MONO;
 400     avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;
 401
 402     s->rate_control_possibilities = 16;
 403     s->esf_adjustment = 7;
 404     s->number_of_regions = 14;
 405     s->scale_factor = 22;
 406     s->region_size = 20;
 407     s->dw1 = s->dw2 = s->dw3 = s->dw4 = 1;
 408
 409     for (i = 0; i < 64; i++) {
 410         float region_power = powf(10, (i - 24) * 0.3010299957);
 411
 412         s->standard_deviation[i] = sqrtf(region_power);
 413     }
 414
 415     for (i = 0; i < FRAME_SIZE; i++) {
 416         float angle = ((i + 0.5f) * M_PI_2) / 320.f;
 417         s->window[i] = sinf(angle);
 418     }
 419
 420     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 421     if (!s->fdsp)
 422         return AVERROR(ENOMEM);
 423
 424     return av_tx_init(&s->tx_ctx, &s->tx_fn, AV_TX_FLOAT_MDCT, 1, FRAME_SIZE, &scale, 0);
 425 }
 426
 427 static int decode_envelope(SirenContext *s, GetBitContext *gb,
 428                            int number_of_regions, float *decoder_standard_deviation,
 429                            int *absolute_region_power_index, int esf_adjustment)
 430 {
 431     absolute_region_power_index[0] = (int)get_bits(gb, 5) - esf_adjustment;
 432     absolute_region_power_index[0] = av_clip(absolute_region_power_index[0], -24, 39);
 433     decoder_standard_deviation[0] = s->standard_deviation[absolute_region_power_index[0] + 24];
 434
 435     for (int i = 1; i < number_of_regions; i++) {
 436         int index = 0;
 437
 438         do {
 439             index = differential_decoder_tree[i - 1][index][get_bits1(gb)];
 440         } while (index > 0);
 441
 442         absolute_region_power_index[i] = av_clip(absolute_region_power_index[i - 1] - index - 12, -24, 39);
 443         decoder_standard_deviation[i] = s->standard_deviation[absolute_region_power_index[i] + 24];
 444     }
 445
 446     return get_bits_count(gb);
 447 }
 448
 449 static int categorize_regions(int number_of_regions, int number_of_available_bits,
 450                               int *absolute_region_power_index, int *power_categories,
 451                               int *category_balance)
 452 {
 453     int region, delta, i, temp;
 454     int expected_number_of_code_bits;
 455     int min, max;
 456     int offset, num_rate_control_possibilities = 16,
 457         raw_value, raw_max_idx = 0, raw_min_idx = 0;
 458     int max_rate_categories[28];
 459     int min_rate_categories[28];
 460     int temp_category_balances[64];
 461     int *min_rate_ptr = NULL;
 462     int *max_rate_ptr = NULL;
 463
 464     offset = -32;
 465     for (delta = 32; number_of_regions > 0 && delta > 0; delta /= 2) {
 466         expected_number_of_code_bits = 0;
 467         for (region = 0; region < number_of_regions; region++) {
 468             i = (delta + offset -
 469                  absolute_region_power_index[region]) >> 1;
 470             i = av_clip_uintp2(i, 3);
 471             power_categories[region] = i;
 472             expected_number_of_code_bits += expected_bits_table[i];
 473
 474         }
 475         if (expected_number_of_code_bits >= number_of_available_bits - 32)
 476             offset += delta;
 477     }
 478
 479     expected_number_of_code_bits = 0;
 480     for (region = 0; region < number_of_regions; region++) {
 481         i = (offset - absolute_region_power_index[region]) >> 1;
 482         i = av_clip_uintp2(i, 3);
 483         max_rate_categories[region] = min_rate_categories[region] =
 484             power_categories[region] = i;
 485         expected_number_of_code_bits += expected_bits_table[i];
 486     }
 487
 488     min = max = expected_number_of_code_bits;
 489     min_rate_ptr = max_rate_ptr =
 490         temp_category_balances + num_rate_control_possibilities;
 491     for (i = 0; i < num_rate_control_possibilities - 1; i++) {
 492         if (min + max > number_of_available_bits * 2) {
 493             raw_value = -99;
 494             for (region = number_of_regions - 1; region >= 0; region--) {
 495                 if (min_rate_categories[region] < 7) {
 496                     temp =
 497                         offset - absolute_region_power_index[region] -
 498                         2 * min_rate_categories[region];
 499                     if (temp > raw_value) {
 500                         raw_value = temp;
 501                         raw_min_idx = region;
 502                     }
 503                 }
 504             }
 505             if (raw_value == -99)
 506                 return AVERROR_INVALIDDATA;
 507             *min_rate_ptr++ = raw_min_idx;
 508             min +=
 509                 expected_bits_table[min_rate_categories[raw_min_idx] + 1] -
 510                 expected_bits_table[min_rate_categories[raw_min_idx]];
 511             min_rate_categories[raw_min_idx]++;
 512         } else {
 513             raw_value = 99;
 514             for (region = 0; region < number_of_regions; region++) {
 515                 if (max_rate_categories[region] > 0) {
 516                     temp =
 517                         offset - absolute_region_power_index[region] -
 518                         2 * max_rate_categories[region];
 519                     if (temp < raw_value) {
 520                         raw_value = temp;
 521                         raw_max_idx = region;
 522                     }
 523                 }
 524             }
 525             if (raw_value == 99)
 526                 return AVERROR_INVALIDDATA;
 527
 528             *--max_rate_ptr = raw_max_idx;
 529             max += expected_bits_table[max_rate_categories[raw_max_idx] - 1] -
 530                    expected_bits_table[max_rate_categories[raw_max_idx]];
 531             max_rate_categories[raw_max_idx]--;
 532         }
 533     }
 534
 535     for (region = 0; region < number_of_regions; region++)
 536         power_categories[region] = max_rate_categories[region];
 537
 538     for (i = 0; i < num_rate_control_possibilities - 1; i++)
 539         category_balance[i] = *max_rate_ptr++;
 540
 541     return 0;
 542 }
 543
 544 static int get_dw(SirenContext *s)
 545 {
 546     int ret = s->dw1 + s->dw4;
 547
 548     if ((ret & 0x8000) != 0)
 549         ret++;
 550
 551     s->dw1 = s->dw2;
 552     s->dw2 = s->dw3;
 553     s->dw3 = s->dw4;
 554     s->dw4 = ret;
 555
 556     return ret;
 557 }
 558
 559 static int decode_vector(SirenContext *s, int number_of_regions,
 560                          int number_of_available_bits, float *decoder_standard_deviation,
 561                          int *power_categories, float *coefs, int scale_factor)
 562 {
 563     GetBitContext *gb = &s->gb;
 564     float *coefs_ptr;
 565     float decoded_value;
 566     float noise;
 567     const uint16_t *decoder_tree;
 568     int region;
 569     int category;
 570     int i, j;
 571     int index;
 572     int error = 0;
 573     int dw1;
 574     int dw2;
 575
 576     for (region = 0; region < number_of_regions; region++) {
 577         category = power_categories[region];
 578         coefs_ptr = coefs + (region * s->region_size);
 579
 580         if (category >= 0 && category < 7) {
 581             decoder_tree = decoder_tables[category];
 582
 583             for (i = 0; i < number_of_vectors[category]; i++) {
 584                 index = 0;
 585                 do {
 586                     if (get_bits_left(gb) <= 0) {
 587                         error = 1;
 588                         break;
 589                     }
 590
 591                     if (index + show_bits1(gb) >= decoder_tables_elements[category]) {
 592                         error = 1;
 593                         break;
 594                     }
 595                     index = decoder_tree[index + get_bits1(gb)];
 596                 } while ((index & 1) == 0);
 597
 598                 index >>= 1;
 599
 600                 if (error == 0 && get_bits_left(gb) >= 0) {
 601                     for (j = 0; j < vector_dimension[category]; j++) {
 602                         decoded_value = mlt_quant[category][index & ((1 << index_table[category]) - 1)];
 603                         index >>= index_table[category];
 604
 605                         if (decoded_value) {
 606                             if (!get_bits1(gb))
 607                                 decoded_value *= -decoder_standard_deviation[region];
 608                             else
 609                                 decoded_value *= decoder_standard_deviation[region];
 610                         }
 611
 612                         *coefs_ptr++ = decoded_value * scale_factor;
 613                     }
 614                 } else {
 615                     error = 1;
 616                     break;
 617                 }
 618             }
 619
 620             if (error == 1) {
 621                 for (j = region + 1; j < number_of_regions; j++)
 622                     power_categories[j] = 7;
 623                 category = 7;
 624             }
 625         }
 626
 627         coefs_ptr = coefs + (region * s->region_size);
 628
 629         if (category == 5) {
 630             i = 0;
 631             for (j = 0; j < s->region_size; j++) {
 632                 if (*coefs_ptr != 0)
 633                     i++;
 634                 coefs_ptr++;
 635             }
 636
 637             noise = decoder_standard_deviation[region] * noise_category5[i];
 638         } else if (category == 6) {
 639             i = 0;
 640             for (j = 0; j < s->region_size; j++) {
 641                 if (*coefs_ptr++ != 0)
 642                     i++;
 643             }
 644
 645             noise = decoder_standard_deviation[region] * noise_category6[i];
 646         } else if (category == 7) {
 647             noise = decoder_standard_deviation[region] * 0.70711f;
 648         } else {
 649             noise = 0;
 650         }
 651
 652         coefs_ptr = coefs + (region * s->region_size);
 653
 654         if (category == 5 || category == 6 || category == 7) {
 655             dw1 = get_dw(s);
 656             dw2 = get_dw(s);
 657
 658             for (j = 0; j < 10; j++) {
 659                 if (category == 7 || *coefs_ptr == 0)
 660                     *coefs_ptr = dw1 & 1 ? noise : -noise;
 661                 coefs_ptr++;
 662                 dw1 >>= 1;
 663
 664                 if (category == 7 || *coefs_ptr == 0)
 665                     *coefs_ptr = dw2 & 1 ? noise : -noise;
 666                 coefs_ptr++;
 667                 dw2 >>= 1;
 668             }
 669         }
 670     }
 671
 672     return error == 1 ? AVERROR_INVALIDDATA : get_bits_left(gb);
 673 }
 674
 675 static int siren_decode(AVCodecContext *avctx, void *data,
 676                         int *got_frame, AVPacket *avpkt)
 677 {
 678     SirenContext *s = avctx->priv_data;
 679     GetBitContext *gb = &s->gb;
 680     AVFrame *frame = data;
 681     int ret, number_of_valid_coefs = 20 * s->number_of_regions;
 682     int frame_error = 0, rate_control = 0;
 683
 684     if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
 685         return ret;
 686
 687     decode_envelope(s, gb, s->number_of_regions,
 688                     s->decoder_standard_deviation,
 689                     s->absolute_region_power_index, s->esf_adjustment);
 690
 691     rate_control = get_bits(gb, 4);
 692
 693     ret = categorize_regions(s->number_of_regions, get_bits_left(gb),
 694                              s->absolute_region_power_index, s->power_categories,
 695                              s->category_balance);
 696     if (ret < 0)
 697         return ret;
 698
 699     for (int i = 0; i < rate_control; i++)
 700         s->power_categories[s->category_balance[i]]++;
 701
 702     ret = decode_vector(s, s->number_of_regions, get_bits_left(gb),
 703                         s->decoder_standard_deviation, s->power_categories,
 704                         s->imdct_in, s->scale_factor);
 705     if (ret < 0)
 706         return ret;
 707
 708     if (get_bits_left(gb) > 0) {
 709         do {
 710             frame_error |= !get_bits1(gb);
 711         } while (get_bits_left(gb) > 0);
 712     } else if (get_bits_left(gb) < 0 &&
 713                rate_control + 1 < s->rate_control_possibilities) {
 714         frame_error = 1;
 715     }
 716
 717     for (int i = 0; i < s->number_of_regions; i++) {
 718         if (s->absolute_region_power_index[i] > 33 ||
 719             s->absolute_region_power_index[i] < -31)
 720             frame_error = 1;
 721     }
 722
 723     if (frame_error) {
 724         memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
 725         memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
 726     } else {
 727         memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
 728     }
 729
 730     frame->nb_samples = FRAME_SIZE;
 731     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 732         return ret;
 733
 734     for (int i = 0; i < 320; i += 2)
 735         s->imdct_in[i] *= -1;
 736
 737     s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
 738     s->fdsp->vector_fmul_window((float *)frame->data[0],
 739                                 s->imdct_prev + (FRAME_SIZE >> 1),
 740                                 s->imdct_out, s->window,
 741                                 FRAME_SIZE >> 1);
 742     FFSWAP(float *, s->imdct_out, s->imdct_prev);
 743
 744     *got_frame = 1;
 745
 746     return avpkt->size;
 747 }
 748
 749 static av_cold void siren_flush(AVCodecContext *avctx)
 750 {
 751     SirenContext *s = avctx->priv_data;
 752
 753     memset(s->backup_frame, 0, sizeof(s->backup_frame));
 754     memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
 755     memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
 756 }
 757
 758 static av_cold int siren_close(AVCodecContext *avctx)
 759 {
 760     SirenContext *s = avctx->priv_data;
 761
 762     av_freep(&s->fdsp);
 763     av_tx_uninit(&s->tx_ctx);
 764
 765     return 0;
 766 }
 767
 768 AVCodec ff_siren_decoder = {
 769     .name           = "siren",
 770     .long_name      = NULL_IF_CONFIG_SMALL("Siren"),
 771     .priv_data_size = sizeof(SirenContext),
 772     .type           = AVMEDIA_TYPE_AUDIO,
 773     .id             = AV_CODEC_ID_SIREN,
 774     .init           = siren_init,
 775     .close          = siren_close,
 776     .decode         = siren_decode,
 777     .flush          = siren_flush,
 778     .capabilities   = AV_CODEC_CAP_CHANNEL_CONF |
 779                       AV_CODEC_CAP_DR1,
 780     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
 781                       FF_CODEC_CAP_INIT_CLEANUP,
 782 };