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[21] = {
 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[21] = {
 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 #define REGION_SIZE 20
 357
 358 typedef struct SirenContext {
 359     GetBitContext gb;
 360
 361     int rate_control_possibilities;
 362     int esf_adjustment;
 363     int number_of_regions;
 364     int scale_factor;
 365     int sample_rate_bits;
 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->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 * 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 * REGION_SIZE);
 627
 628         if (category == 5 || category == 6) {
 629             i = 0;
 630             for (j = 0; j < REGION_SIZE; j++) {
 631                 if (*coefs_ptr != 0)
 632                     i++;
 633                 coefs_ptr++;
 634             }
 635
 636             if (category == 5) {
 637                 noise = decoder_standard_deviation[region] * noise_category5[i];
 638             } else
 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 * 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     ret = categorize_regions(s->number_of_regions, get_bits_left(gb),
 688                              s->absolute_region_power_index, s->power_categories,
 689                              s->category_balance);
 690     if (ret < 0)
 691         return ret;
 692
 693     for (int i = 0; i < rate_control; i++)
 694         s->power_categories[s->category_balance[i]]++;
 695
 696     ret = decode_vector(s, s->number_of_regions, get_bits_left(gb),
 697                         s->decoder_standard_deviation, s->power_categories,
 698                         s->imdct_in, s->scale_factor);
 699     if (ret < 0)
 700         return ret;
 701
 702     if (get_bits_left(gb) > 0) {
 703         do {
 704             frame_error |= !get_bits1(gb);
 705         } while (get_bits_left(gb) > 0);
 706     } else if (get_bits_left(gb) < 0 &&
 707                rate_control + 1 < s->rate_control_possibilities) {
 708         frame_error = 1;
 709     }
 710
 711     for (int i = 0; i < s->number_of_regions; i++) {
 712         if (s->absolute_region_power_index[i] > 33 ||
 713             s->absolute_region_power_index[i] < -31)
 714             frame_error = 1;
 715     }
 716
 717     if (frame_error) {
 718         memcpy(s->imdct_in, s->backup_frame, number_of_valid_coefs * sizeof(float));
 719         memset(s->backup_frame, 0, number_of_valid_coefs * sizeof(float));
 720     } else {
 721         memcpy(s->backup_frame, s->imdct_in, number_of_valid_coefs * sizeof(float));
 722     }
 723
 724     frame->nb_samples = FRAME_SIZE;
 725     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 726         return ret;
 727
 728     for (int i = 0; i < 320; i += 2)
 729         s->imdct_in[i] *= -1;
 730
 731     s->tx_fn(s->tx_ctx, s->imdct_out, s->imdct_in, sizeof(float));
 732     s->fdsp->vector_fmul_window((float *)frame->data[0],
 733                                 s->imdct_prev + (FRAME_SIZE >> 1),
 734                                 s->imdct_out, s->window,
 735                                 FRAME_SIZE >> 1);
 736     FFSWAP(float *, s->imdct_out, s->imdct_prev);
 737
 738     *got_frame = 1;
 739
 740     return avpkt->size;
 741 }
 742
 743 static av_cold void siren_flush(AVCodecContext *avctx)
 744 {
 745     SirenContext *s = avctx->priv_data;
 746
 747     memset(s->backup_frame, 0, sizeof(s->backup_frame));
 748     memset(s->imdct_prev, 0, FRAME_SIZE * sizeof(*s->imdct_prev));
 749     memset(s->imdct_out, 0, FRAME_SIZE * sizeof(*s->imdct_out));
 750 }
 751
 752 static av_cold int siren_close(AVCodecContext *avctx)
 753 {
 754     SirenContext *s = avctx->priv_data;
 755
 756     av_freep(&s->fdsp);
 757     av_tx_uninit(&s->tx_ctx);
 758
 759     return 0;
 760 }
 761
 762 const AVCodec ff_siren_decoder = {
 763     .name           = "siren",
 764     .long_name      = NULL_IF_CONFIG_SMALL("Siren"),
 765     .priv_data_size = sizeof(SirenContext),
 766     .type           = AVMEDIA_TYPE_AUDIO,
 767     .id             = AV_CODEC_ID_SIREN,
 768     .init           = siren_init,
 769     .close          = siren_close,
 770     .decode         = siren_decode,
 771     .flush          = siren_flush,
 772     .capabilities   = AV_CODEC_CAP_CHANNEL_CONF |
 773                       AV_CODEC_CAP_DR1,
 774     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
 775                       FF_CODEC_CAP_INIT_CLEANUP,
 776 };