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

1511 lines
55KB
Raw Blame History 

  1. /*

  2.  * copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>

  3.  *

  4.  * This library is free software; you can redistribute it and/or

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

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

  7.  * version 2 of the License, or (at your option) any later version.

  8.  *

  9.  * This library is distributed in the hope that it will be useful,

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

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

  12.  * Lesser General Public License for more details.

  13.  *

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

  15.  * License along with this library; if not, write to the Free Software

  16.  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

  17.  */

  18. 

  19. /**

  20.  * @file vorbis_enc.c

  21.  * Native Vorbis encoder.

  22.  * @author Oded Shimon <ods15@ods15.dyndns.org>

  23.  */

  24. 

  25. #include "avcodec.h"

  26. #include "dsputil.h"

  27. #include "vorbis.h"

  28. 

  29. #undef NDEBUG

  30. #include <assert.h>

  31. 

  32. typedef struct {

  33.     int nentries;

  34.     uint8_t * lens;

  35.     uint32_t * codewords;

  36.     int ndimentions;

  37.     float min;

  38.     float delta;

  39.     int seq_p;

  40.     int lookup;

  41.     int * quantlist;

  42.     float * dimentions;

  43. } codebook_t;

  44. 

  45. typedef struct {

  46.     int dim;

  47.     int subclass;

  48.     int masterbook;

  49.     int * books;

  50. } floor_class_t;

  51. 

  52. typedef struct {

  53.     int partitions;

  54.     int * partition_to_class;

  55.     int nclasses;

  56.     floor_class_t * classes;

  57.     int multiplier;

  58.     int rangebits;

  59.     int values;

  60.     floor1_entry_t * list;

  61. } floor_t;

  62. 

  63. typedef struct {

  64.     int type;

  65.     int begin;

  66.     int end;

  67.     int partition_size;

  68.     int classifications;

  69.     int classbook;

  70.     int8_t (*books)[8];

  71.     float (*maxes)[2];

  72. } residue_t;

  73. 

  74. typedef struct {

  75.     int submaps;

  76.     int * mux;

  77.     int * floor;

  78.     int * residue;

  79.     int coupling_steps;

  80.     int * magnitude;

  81.     int * angle;

  82. } mapping_t;

  83. 

  84. typedef struct {

  85.     int blockflag;

  86.     int mapping;

  87. } vorbis_mode_t;

  88. 

  89. typedef struct {

  90.     int channels;

  91.     int sample_rate;

  92.     int blocksize[2]; // in (1<<n) format

  93.     MDCTContext mdct[2];

  94.     const float * win[2];

  95.     int have_saved;

  96.     float * saved;

  97.     float * samples;

  98.     float * floor; // also used for tmp values for mdct

  99.     float * coeffs; // also used for residue after floor

  100.     float quality;

  101. 

  102.     int ncodebooks;

  103.     codebook_t * codebooks;

  104. 

  105.     int nfloors;

  106.     floor_t * floors;

  107. 

  108.     int nresidues;

  109.     residue_t * residues;

  110. 

  111.     int nmappings;

  112.     mapping_t * mappings;

  113. 

  114.     int nmodes;

  115.     vorbis_mode_t * modes;

  116. } venc_context_t;

  117. 

  118. typedef struct {

  119.     int total;

  120.     int total_pos;

  121.     int pos;

  122.     uint8_t * buf_ptr;

  123. } PutBitContext;

  124. 

  125. static const uint8_t codebook0[] = {

  126.    2, 10,  8, 14,  7, 12, 11, 14,  1,  5,  3,  7,  4,  9,  7,

  127.   13,

  128. };

  129. 

  130. static const uint8_t codebook1[] = {

  131.    1,  4,  2,  6,  3,  7,  5,  7,

  132. };

  133. 

  134. static const uint8_t codebook2[] = {

  135.    1,  5,  7, 21,  5,  8,  9, 21, 10,  9, 12, 20, 20, 16, 20,

  136.   20,  4,  8,  9, 20,  6,  8,  9, 20, 11, 11, 13, 20, 20, 15,

  137.   17, 20,  9, 11, 14, 20,  8, 10, 15, 20, 11, 13, 15, 20, 20,

  138.   20, 20, 20, 20, 20, 20, 20, 13, 20, 20, 20, 18, 18, 20, 20,

  139.   20, 20, 20, 20,  3,  6,  8, 20,  6,  7,  9, 20, 10,  9, 12,

  140.   20, 20, 20, 20, 20,  5,  7,  9, 20,  6,  6,  9, 20, 10,  9,

  141.   12, 20, 20, 20, 20, 20,  8, 10, 13, 20,  8,  9, 12, 20, 11,

  142.   10, 12, 20, 20, 20, 20, 20, 18, 20, 20, 20, 15, 17, 18, 20,

  143.   18, 17, 18, 20, 20, 20, 20, 20,  7, 10, 12, 20,  8,  9, 11,

  144.   20, 14, 13, 14, 20, 20, 20, 20, 20,  6,  9, 12, 20,  7,  8,

  145.   11, 20, 12, 11, 13, 20, 20, 20, 20, 20,  9, 11, 15, 20,  8,

  146.   10, 14, 20, 12, 11, 14, 20, 20, 20, 20, 20, 20, 20, 20, 20,

  147.   20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 11, 16, 18,

  148.   20, 15, 15, 17, 20, 20, 17, 20, 20, 20, 20, 20, 20,  9, 14,

  149.   16, 20, 12, 12, 15, 20, 17, 15, 18, 20, 20, 20, 20, 20, 16,

  150.   19, 18, 20, 15, 16, 20, 20, 17, 17, 20, 20, 20, 20, 20, 20,

  151.   20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,

  152.   20,

  153. };

  154. 

  155. static const uint8_t codebook3[] = {

  156.    2,  3,  7, 13,  4,  4,  7, 15,  8,  6,  9, 17, 21, 16, 15,

  157.   21,  2,  5,  7, 11,  5,  5,  7, 14,  9,  7, 10, 16, 17, 15,

  158.   16, 21,  4,  7, 10, 17,  7,  7,  9, 15, 11,  9, 11, 16, 21,

  159.   18, 15, 21, 18, 21, 21, 21, 15, 17, 17, 19, 21, 19, 18, 20,

  160.   21, 21, 21, 20,

  161. };

  162. 

  163. static const uint8_t codebook4[] = {

  164.    5,  5,  5,  5,  6,  5,  6,  5,  6,  5,  6,  5,  6,  5,  6,

  165.    5,  6,  5,  6,  5,  6,  5,  6,  5,  7,  5,  7,  5,  7,  5,

  166.    7,  5,  8,  6,  8,  6,  8,  6,  9,  6,  9,  6, 10,  6, 10,

  167.    6, 11,  6, 11,  7, 11,  7, 12,  7, 12,  7, 12,  7, 12,  7,

  168.   12,  7, 12,  7, 12,  7, 12,  8, 13,  8, 12,  8, 12,  8, 13,

  169.    8, 13,  9, 13,  9, 13,  9, 13,  9, 12, 10, 12, 10, 13, 10,

  170.   14, 11, 14, 12, 14, 13, 14, 13, 14, 14, 15, 16, 15, 15, 15,

  171.   14, 15, 17, 21, 22, 22, 21, 22, 22, 22, 22, 22, 22, 21, 21,

  172.   21, 21, 21, 21, 21, 21, 21, 21,

  173. };

  174. 

  175. static const uint8_t codebook5[] = {

  176.    2,  5,  5,  4,  5,  4,  5,  4,  5,  4,  6,  5,  6,  5,  6,

  177.    5,  6,  5,  7,  5,  7,  6,  8,  6,  8,  6,  8,  6,  9,  6,

  178.    9,  6,

  179. };

  180. 

  181. static const uint8_t codebook6[] = {

  182.    8,  5,  8,  4,  9,  4,  9,  4,  9,  4,  9,  4,  9,  4,  9,

  183.    4,  9,  4,  9,  4,  9,  4,  8,  4,  8,  4,  9,  5,  9,  5,

  184.    9,  5,  9,  5,  9,  6, 10,  6, 10,  7, 10,  8, 11,  9, 11,

  185.   11, 12, 13, 12, 14, 13, 15, 13, 15, 14, 16, 14, 17, 15, 17,

  186.   15, 15, 16, 16, 15, 16, 16, 16, 15, 18, 16, 15, 17, 17, 19,

  187.   19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,

  188.   19, 19, 19, 19, 19, 19,

  189. };

  190. 

  191. static const uint8_t codebook7[] = {

  192.    1,  5,  5,  5,  5,  5,  5,  5,  6,  5,  6,  5,  6,  5,  6,

  193.    5,  6,  6,  7,  7,  7,  7,  8,  7,  8,  8,  9,  8, 10,  9,

  194.   10,  9,

  195. };

  196. 

  197. static const uint8_t codebook8[] = {

  198.    4,  3,  4,  3,  4,  4,  5,  4,  5,  4,  5,  5,  6,  5,  6,

  199.    5,  7,  5,  7,  6,  7,  6,  8,  7,  8,  7,  8,  7,  9,  8,

  200.    9,  9,  9,  9, 10, 10, 10, 11,  9, 12,  9, 12,  9, 15, 10,

  201.   14,  9, 13, 10, 13, 10, 12, 10, 12, 10, 13, 10, 12, 11, 13,

  202.   11, 14, 12, 13, 13, 14, 14, 13, 14, 15, 14, 16, 13, 13, 14,

  203.   16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

  204.   16, 16, 16, 16, 15, 15,

  205. };

  206. 

  207. static const uint8_t codebook9[] = {

  208.    4,  5,  4,  5,  3,  5,  3,  5,  3,  5,  4,  4,  4,  4,  5,

  209.    5,  5,

  210. };

  211. 

  212. static const uint8_t codebook10[] = {

  213.    3,  3,  4,  3,  4,  4,  4,  4,  5,  5,  5,  5,  5,  6,  5,

  214.    7,  5,  8,  6,  8,  6,  9,  7, 10,  7, 10,  8, 10,  8, 11,

  215.    9, 11,

  216. };

  217. 

  218. static const uint8_t codebook11[] = {

  219.    3,  7,  3,  8,  3, 10,  3,  8,  3,  9,  3,  8,  4,  9,  4,

  220.    9,  5,  9,  6, 10,  6,  9,  7, 11,  7, 12,  9, 13, 10, 13,

  221.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  222.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  223.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  224.   12, 12, 12,

  225. };

  226. 

  227. static const uint8_t codebook12[] = {

  228.    4,  5,  4,  5,  4,  5,  4,  5,  3,  5,  3,  5,  3,  5,  4,

  229.    5,  4,

  230. };

  231. 

  232. static const uint8_t codebook13[] = {

  233.    4,  2,  4,  2,  5,  3,  5,  4,  6,  6,  6,  7,  7,  8,  7,

  234.    8,  7,  8,  7,  9,  8,  9,  8,  9,  8, 10,  8, 11,  9, 12,

  235.    9, 12,

  236. };

  237. 

  238. static const uint8_t codebook14[] = {

  239.    2,  5,  2,  6,  3,  6,  4,  7,  4,  7,  5,  9,  5, 11,  6,

  240.   11,  6, 11,  7, 11,  6, 11,  6, 11,  9, 11,  8, 11, 11, 11,

  241.   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,

  242.   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,

  243.   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 10, 10, 10,

  244.   10, 10, 10,

  245. };

  246. 

  247. static const uint8_t codebook15[] = {

  248.    5,  6, 11, 11, 11, 11, 10, 10, 12, 11,  5,  2, 11,  5,  6,

  249.    6,  7,  9, 11, 13, 13, 10,  7, 11,  6,  7,  8,  9, 10, 12,

  250.   11,  5, 11,  6,  8,  7,  9, 11, 14, 15, 11,  6,  6,  8,  4,

  251.    5,  7,  8, 10, 13, 10,  5,  7,  7,  5,  5,  6,  8, 10, 11,

  252.   10,  7,  7,  8,  6,  5,  5,  7,  9,  9, 11,  8,  8, 11,  8,

  253.    7,  6,  6,  7,  9, 12, 11, 10, 13,  9,  9,  7,  7,  7,  9,

  254.   11, 13, 12, 15, 12, 11,  9,  8,  8,  8,

  255. };

  256. 

  257. static const uint8_t codebook16[] = {

  258.    2,  4,  4,  0,  0,  0,  0,  0,  0,  5,  6,  6,  0,  0,  0,

  259.    0,  0,  0,  5,  6,  6,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  260.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  261.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  262.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  263.    0,  0,  0,  0,  0,  0,  5,  7,  7,  0,  0,  0,  0,  0,  0,

  264.    7,  8,  8,  0,  0,  0,  0,  0,  0,  6,  7,  8,  0,  0,  0,

  265.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  266.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  267.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  268.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  7,  7,

  269.    0,  0,  0,  0,  0,  0,  6,  8,  7,  0,  0,  0,  0,  0,  0,

  270.    7,  8,  8,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  271.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  272.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  273.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  274.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  275.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  276.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  277.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  278.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  279.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  280.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  281.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  282.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  283.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  284.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  285.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  286.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  287.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  288.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  289.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  290.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  291.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  292.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  293.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  294.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  295.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  296.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  297.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  298.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  299.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  300.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  301.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  302.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  303.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  304.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  305.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  306.    0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  7,  7,  0,  0,  0,

  307.    0,  0,  0,  7,  8,  8,  0,  0,  0,  0,  0,  0,  7,  8,  8,

  308.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  309.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  310.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  311.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  312.    7,  8,  8,  0,  0,  0,  0,  0,  0,  8,  8,  9,  0,  0,  0,

  313.    0,  0,  0,  8,  9,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  314.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  315.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  316.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  317.    0,  0,  0,  0,  0,  0,  6,  8,  8,  0,  0,  0,  0,  0,  0,

  318.    7,  9,  8,  0,  0,  0,  0,  0,  0,  8,  9,  9,  0,  0,  0,

  319.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  320.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  321.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  322.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  323.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  324.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  325.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  326.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  327.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  328.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  329.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  330.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  331.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  332.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  333.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  334.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  335.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  336.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  337.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  338.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  339.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  340.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  341.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  342.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  343.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  344.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  345.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  346.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  347.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  348.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  349.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  350.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  351.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  352.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  353.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  354.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  355.    0,  0,  0,  5,  7,  7,  0,  0,  0,  0,  0,  0,  7,  8,  8,

  356.    0,  0,  0,  0,  0,  0,  7,  8,  8,  0,  0,  0,  0,  0,  0,

  357.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  358.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  359.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  360.    0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  8,  8,  0,  0,  0,

  361.    0,  0,  0,  8,  9,  9,  0,  0,  0,  0,  0,  0,  7,  8,  9,

  362.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  363.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  364.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  365.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  366.    6,  8,  8,  0,  0,  0,  0,  0,  0,  8,  9,  9,  0,  0,  0,

  367.    0,  0,  0,  8,  9,  8,

  368. };

  369. 

  370. static const uint8_t codebook17[] = {

  371.    2,  5,  5,  0,  0,  0,  5,  5,  0,  0,  0,  5,  5,  0,  0,

  372.    0,  7,  8,  0,  0,  0,  0,  0,  0,  0,  5,  6,  6,  0,  0,

  373.    0,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0, 10, 10,  0,  0,

  374.    0,  0,  0,  0,  0,  5,  6,  6,  0,  0,  0,  7,  7,  0,  0,

  375.    0,  7,  7,  0,  0,  0, 10, 10,  0,  0,  0,  0,  0,  0,  0,

  376.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  377.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  378.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  379.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  380.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  381.    5,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0,  7,  7,  0,  0,

  382.    0,  9,  9,  0,  0,  0,  0,  0,  0,  0,  5,  7,  7,  0,  0,

  383.    0,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0,  9,  9,  0,  0,

  384.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  385.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  386.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  387.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  388.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  389.    0,  0,  0,  0,  0,  5,  7,  7,  0,  0,  0,  7,  7,  0,  0,

  390.    0,  7,  7,  0,  0,  0,  9,  9,  0,  0,  0,  0,  0,  0,  0,

  391.    5,  7,  7,  0,  0,  0,  7,  7,  0,  0,  0,  7,  7,  0,  0,

  392.    0,  9,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  393.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  394.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  395.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  396.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  397.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8, 10, 10,  0,  0,

  398.    0,  9,  9,  0,  0,  0,  9,  9,  0,  0,  0, 10, 10,  0,  0,

  399.    0,  0,  0,  0,  0,  8, 10, 10,  0,  0,  0,  9,  9,  0,  0,

  400.    0,  9,  9,  0,  0,  0, 10, 10,

  401. };

  402. 

  403. static const uint8_t codebook18[] = {

  404.    2,  4,  3,  6,  6,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  405.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  4,  4,  4,  6,  6,

  406.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  407.    0,  0,  0,  0,  0,  4,  4,  4,  6,  6,  0,  0,  0,  0,  0,

  408.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  409.    6,  6,  6,  9,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  410.    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  6,  6,  7,  9,  9,

  411. };

  412. 

  413. static const uint8_t codebook19[] = {

  414.    2,  3,  3,  6,  6,  0,  0,  0,  0,  0,  4,  4,  6,  6,  0,

  415.    0,  0,  0,  0,  4,  4,  6,  6,  0,  0,  0,  0,  0,  5,  5,

  416.    6,  6,  0,  0,  0,  0,  0,  0,  0,  6,  6,  0,  0,  0,  0,

  417.    0,  0,  0,  7,  8,  0,  0,  0,  0,  0,  0,  0,  7,  7,  0,

  418.    0,  0,  0,  0,  0,  0,  9,  9,

  419. };

  420. 

  421. static const uint8_t codebook20[] = {

  422.    1,  3,  4,  6,  6,  7,  7,  9,  9,  0,  5,  5,  7,  7,  7,

  423.    8,  9,  9,  0,  5,  5,  7,  7,  8,  8,  9,  9,  0,  7,  7,

  424.    8,  8,  8,  8, 10, 10,  0,  0,  0,  8,  8,  8,  8, 10, 10,

  425.    0,  0,  0,  9,  9,  9,  9, 10, 10,  0,  0,  0,  9,  9,  9,

  426.    9, 10, 10,  0,  0,  0, 10, 10, 10, 10, 11, 11,  0,  0,  0,

  427.    0,  0, 10, 10, 11, 11,

  428. };

  429. 

  430. static const uint8_t codebook21[] = {

  431.    2,  3,  3,  6,  6,  7,  7,  8,  8,  8,  8,  9,  9, 10, 10,

  432.   11, 10,  0,  5,  5,  7,  7,  8,  8,  9,  9,  9,  9, 10, 10,

  433.   10, 10, 11, 11,  0,  5,  5,  7,  7,  8,  8,  9,  9,  9,  9,

  434.   10, 10, 10, 10, 11, 11,  0,  6,  6,  7,  7,  8,  8,  9,  9,

  435.    9,  9, 10, 10, 11, 11, 11, 11,  0,  0,  0,  7,  7,  8,  8,

  436.    9,  9,  9,  9, 10, 10, 11, 11, 11, 12,  0,  0,  0,  8,  8,

  437.    8,  8,  9,  9,  9,  9, 10, 10, 11, 11, 12, 12,  0,  0,  0,

  438.    8,  8,  8,  8,  9,  9,  9,  9, 10, 10, 11, 11, 12, 12,  0,

  439.    0,  0,  9,  9,  9,  9, 10, 10, 10, 10, 11, 10, 11, 11, 12,

  440.   12,  0,  0,  0,  0,  0,  9,  9, 10, 10, 10, 10, 11, 11, 11,

  441.   11, 12, 12,  0,  0,  0,  0,  0,  9,  8,  9,  9, 10, 10, 11,

  442.   11, 12, 12, 12, 12,  0,  0,  0,  0,  0,  8,  8,  9,  9, 10,

  443.   10, 11, 11, 12, 11, 12, 12,  0,  0,  0,  0,  0,  9, 10, 10,

  444.   10, 11, 11, 11, 11, 12, 12, 13, 13,  0,  0,  0,  0,  0,  0,

  445.    0, 10, 10, 10, 10, 11, 11, 12, 12, 13, 13,  0,  0,  0,  0,

  446.    0,  0,  0, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13,  0,  0,

  447.    0,  0,  0,  0,  0, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13,

  448.    0,  0,  0,  0,  0,  0,  0, 11, 11, 12, 12, 12, 12, 13, 13,

  449.   13, 13,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 12, 12, 12,

  450.   13, 13, 13, 13,

  451. };

  452. 

  453. static const uint8_t codebook22[] = {

  454.    1,  4,  4,  7,  6,  6,  7,  6,  6,  4,  7,  7, 10,  9,  9,

  455.   11,  9,  9,  4,  7,  7, 10,  9,  9, 11,  9,  9,  7, 10, 10,

  456.   11, 11, 10, 12, 11, 11,  6,  9,  9, 11, 10, 10, 11, 10, 10,

  457.    6,  9,  9, 11, 10, 10, 11, 10, 10,  7, 11, 11, 11, 11, 11,

  458.   12, 11, 11,  6,  9,  9, 11, 10, 10, 11, 10, 10,  6,  9,  9,

  459.   11, 10, 10, 11, 10, 10,

  460. };

  461. 

  462. static const uint8_t codebook23[] = {

  463.    2,  4,  4,  6,  6,  7,  7,  7,  7,  8,  8, 10,  5,  5,  6,

  464.    6,  7,  7,  8,  8,  8,  8, 10,  5,  5,  6,  6,  7,  7,  8,

  465.    8,  8,  8, 10,  6,  6,  7,  7,  8,  8,  8,  8,  8,  8, 10,

  466.   10, 10,  7,  7,  8,  7,  8,  8,  8,  8, 10, 10, 10,  8,  8,

  467.    8,  8,  8,  8,  8,  8, 10, 10, 10,  7,  8,  8,  8,  8,  8,

  468.    8,  8, 10, 10, 10,  8,  8,  8,  8,  8,  8,  8,  8, 10, 10,

  469.   10, 10, 10,  8,  8,  8,  8,  8,  8, 10, 10, 10, 10, 10,  9,

  470.    9,  8,  8,  9,  8, 10, 10, 10, 10, 10,  8,  8,  8,  8,  8,

  471.    8,

  472. };

  473. 

  474. static const uint8_t codebook24[] = {

  475.    1,  4,  4,  6,  6,  7,  7,  8,  8,  9,  9, 10, 10,  6,  5,

  476.    5,  7,  7,  8,  8,  8,  8,  9,  9, 10, 10,  7,  5,  5,  7,

  477.    7,  8,  8,  8,  8,  9,  9, 11, 10,  0,  8,  8,  8,  8,  9,

  478.    9,  9,  9, 10, 10, 11, 11,  0,  8,  8,  8,  8,  9,  9,  9,

  479.    9, 10, 10, 11, 11,  0, 12, 12,  9,  9, 10, 10, 10, 10, 11,

  480.   11, 11, 12,  0, 13, 13,  9,  9, 10, 10, 10, 10, 11, 11, 12,

  481.   12,  0,  0,  0, 10, 10, 10, 10, 11, 11, 12, 12, 12, 12,  0,

  482.    0,  0, 10, 10, 10, 10, 11, 11, 12, 12, 12, 12,  0,  0,  0,

  483.   14, 14, 11, 11, 11, 11, 12, 12, 13, 13,  0,  0,  0, 14, 14,

  484.   11, 11, 11, 11, 12, 12, 13, 13,  0,  0,  0,  0,  0, 12, 12,

  485.   12, 12, 13, 13, 14, 13,  0,  0,  0,  0,  0, 13, 13, 12, 12,

  486.   13, 12, 14, 13,

  487. };

  488. 

  489. static const uint8_t codebook25[] = {

  490.    2,  4,  4,  5,  5,  6,  5,  5,  5,  5,  6,  4,  5,  5,  5,

  491.    6,  5,  5,  5,  5,  6,  6,  6,  5,  5,

  492. };

  493. 

  494. static const uint8_t codebook26[] = {

  495.    1,  4,  4, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,  4,  9,

  496.    8, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,  2,  9,  7, 12,

  497.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  498.   12, 12, 12, 12, 12, 12, 12, 12, 12, 11, 12, 12, 12, 12, 12,

  499.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  500.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  501.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  502.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  503.   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

  504.   12, 12, 12, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,

  505.   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,

  506.   11, 11, 11, 11,

  507. };

  508. 

  509. static const uint8_t codebook27[] = {

  510.    1,  4,  4,  6,  6,  7,  7,  8,  7,  9,  9, 10, 10, 10, 10,

  511.    6,  5,  5,  7,  7,  8,  8, 10,  8, 11, 10, 12, 12, 13, 13,

  512.    6,  5,  5,  7,  7,  8,  8, 10,  9, 11, 11, 12, 12, 13, 12,

  513.   18,  8,  8,  8,  8,  9,  9, 10,  9, 11, 10, 12, 12, 13, 13,

  514.   18,  8,  8,  8,  8,  9,  9, 10, 10, 11, 11, 13, 12, 14, 13,

  515.   18, 11, 11,  9,  9, 10, 10, 11, 11, 11, 12, 13, 12, 13, 14,

  516.   18, 11, 11,  9,  8, 11, 10, 11, 11, 11, 11, 12, 12, 14, 13,

  517.   18, 18, 18, 10, 11, 10, 11, 12, 12, 12, 12, 13, 12, 14, 13,

  518.   18, 18, 18, 10, 11, 11,  9, 12, 11, 12, 12, 12, 13, 13, 13,

  519.   18, 18, 17, 14, 14, 11, 11, 12, 12, 13, 12, 14, 12, 14, 13,

  520.   18, 18, 18, 14, 14, 11, 10, 12,  9, 12, 13, 13, 13, 13, 13,

  521.   18, 18, 17, 16, 18, 13, 13, 12, 12, 13, 11, 14, 12, 14, 14,

  522.   17, 18, 18, 17, 18, 13, 12, 13, 10, 12, 11, 14, 14, 14, 14,

  523.   17, 18, 18, 18, 18, 15, 16, 12, 12, 13, 10, 14, 12, 14, 15,

  524.   18, 18, 18, 16, 17, 16, 14, 12, 11, 13, 10, 13, 13, 14, 15,

  525. };

  526. 

  527. static const uint8_t codebook28[] = {

  528.    2,  5,  5,  6,  6,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,

  529.    8,  8, 10,  6,  6,  7,  7,  8,  7,  8,  8,  8,  8,  8,  9,

  530.    9,  9,  9,  9, 10,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,

  531.    9,  9,  9,  9,  9,  9, 10,  7,  7,  7,  7,  8,  8,  8,  8,

  532.    9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10,  7,  7,  8,  8,

  533.    8,  9,  9,  9,  9,  9,  9,  9,  9,  9, 11, 11, 11,  8,  8,

  534.    8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10,

  535.    8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10,

  536.   10, 10,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10,

  537.    9, 10, 10, 10, 11, 11,  9,  9,  9,  9,  9,  9,  9,  9,  9,

  538.    9,  9,  9, 11, 10, 11, 11, 11,  9,  9,  9,  9,  9,  9, 10,

  539.   10,  9,  9, 10,  9, 11, 10, 11, 11, 11,  9,  9,  9,  9,  9,

  540.    9,  9,  9, 10, 10, 10,  9, 11, 11, 11, 11, 11,  9,  9,  9,

  541.    9, 10, 10,  9,  9,  9,  9, 10,  9, 11, 11, 11, 11, 11, 11,

  542.   11,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 11, 11, 11, 11,

  543.   11, 11, 11, 10,  9, 10, 10,  9, 10,  9,  9, 10,  9, 11, 10,

  544.   10, 11, 11, 11, 11,  9, 10,  9,  9,  9,  9, 10, 10, 10, 10,

  545.   11, 11, 11, 11, 11, 11, 10, 10, 10,  9,  9, 10,  9, 10,  9,

  546.   10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11,  9,  9,  9,  9,

  547.    9, 10, 10, 10,

  548. };

  549. 

  550. static const struct {

  551.     int dim;

  552.     int len;

  553.     int real_len;

  554.     const uint8_t * clens;

  555.     int lookup;

  556.     float min;

  557.     float delta;

  558.     const uint8_t * quant;

  559. } cvectors[] = {

  560.     { 2,   16,   16, codebook0,  0 },

  561.     { 2,    8,    8, codebook1,  0 },

  562.     { 2,  256,  256, codebook2,  0 },

  563.     { 2,   64,   64, codebook3,  0 },

  564.     { 2,  128,  128, codebook4,  0 },

  565.     { 2,   32,   32, codebook5,  0 },

  566.     { 2,   96,   96, codebook6,  0 },

  567.     { 2,   32,   32, codebook7,  0 },

  568.     { 2,   96,   96, codebook8,  0 },

  569.     { 2,   17,   17, codebook9,  0 },

  570.     { 2,   32,   32, codebook10, 0 },

  571.     { 2,   78,   78, codebook11, 0 },

  572.     { 2,   17,   17, codebook12, 0 },

  573.     { 2,   32,   32, codebook13, 0 },

  574.     { 2,   78,   78, codebook14, 0 },

  575.     { 2,  100,  100, codebook15, 0 },

  576.     { 8, 1641, 6561, codebook16, 1,    -1.0,   1.0, (const uint8_t[]){ 1, 0, 2, } },

  577.     { 4,  443,  625, codebook17, 1,    -2.0,   1.0, (const uint8_t[]){ 2, 1, 3, 0, 4, } },

  578.     { 4,  105,  625, codebook18, 1,    -2.0,   1.0, (const uint8_t[]){ 2, 1, 3, 0, 4, } },

  579.     { 2,   68,   81, codebook19, 1,    -4.0,   1.0, (const uint8_t[]){ 4, 3, 5, 2, 6, 1, 7, 0, 8, } },

  580.     { 2,   81,   81, codebook20, 1,    -4.0,   1.0, (const uint8_t[]){ 4, 3, 5, 2, 6, 1, 7, 0, 8, } },

  581.     { 2,  289,  289, codebook21, 1,    -8.0,   1.0, (const uint8_t[]){ 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, 0, 16, } },

  582.     { 4,   81,   81, codebook22, 1,   -11.0,  11.0, (const uint8_t[]){ 1, 0, 2, } },

  583.     { 2,  121,  121, codebook23, 1,    -5.0,   1.0, (const uint8_t[]){ 5, 4, 6, 3, 7, 2, 8, 1, 9, 0, 10, } },

  584.     { 2,  169,  169, codebook24, 1,   -30.0,   5.0, (const uint8_t[]){ 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12, } },

  585.     { 2,   25,   25, codebook25, 1,    -2.0,   1.0, (const uint8_t[]){ 2, 1, 3, 0, 4, } },

  586.     { 2,  169,  169, codebook26, 1, -1530.0, 255.0, (const uint8_t[]){ 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12, } },

  587.     { 2,  225,  225, codebook27, 1,  -119.0,  17.0, (const uint8_t[]){ 7, 6, 8, 5, 9, 4, 10, 3, 11, 2, 12, 1, 13, 0, 14, } },

  588.     { 2,  289,  289, codebook28, 1,    -8.0,   1.0, (const uint8_t[]){ 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, 0, 16, } },

  589. };

  590. 

  591. static inline void init_put_bits(PutBitContext * pb, uint8_t * buf, int buffer_len) {

  592.     pb->total = buffer_len * 8;

  593.     pb->total_pos = 0;

  594.     pb->pos = 0;

  595.     pb->buf_ptr = buf;

  596. }

  597. 

  598. static void put_bits(PutBitContext * pb, int bits, uint64_t val) {

  599.     if ((pb->total_pos += bits) >= pb->total) return;

  600.     if (!bits) return;

  601.     if (pb->pos) {

  602.         if (pb->pos > bits) {

  603.             *pb->buf_ptr |= val << (8 - pb->pos);

  604.             pb->pos -= bits;

  605.             bits = 0;

  606.         } else {

  607.             *pb->buf_ptr++ |= (val << (8 - pb->pos)) & 0xFF;

  608.             val >>= pb->pos;

  609.             bits -= pb->pos;

  610.             pb->pos = 0;

  611.         }

  612.     }

  613.     for (; bits >= 8; bits -= 8) {

  614.         *pb->buf_ptr++ = val & 0xFF;

  615.         val >>= 8;

  616.     }

  617.     if (bits) {

  618.         *pb->buf_ptr = val;

  619.         pb->pos = 8 - bits;

  620.     }

  621. }

  622. 

  623. static inline void flush_put_bits(PutBitContext * pb) {

  624. }

  625. 

  626. static inline int put_bits_count(PutBitContext * pb) {

  627.     return pb->total_pos;

  628. }

  629. 

  630. static inline void put_codeword(PutBitContext * pb, codebook_t * cb, int entry) {

  631.     assert(entry >= 0);

  632.     assert(entry < cb->nentries);

  633.     assert(cb->lens[entry]);

  634.     put_bits(pb, cb->lens[entry], cb->codewords[entry]);

  635. }

  636. 

  637. static int cb_lookup_vals(int lookup, int dimentions, int entries) {

  638.     if (lookup == 1) return ff_vorbis_nth_root(entries, dimentions);

  639.     else if (lookup == 2) return dimentions * entries;

  640.     return 0;

  641. }

  642. 

  643. static void ready_codebook(codebook_t * cb) {

  644.     int i;

  645. 

  646.     ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries);

  647. 

  648.     if (!cb->lookup) cb->dimentions = NULL;

  649.     else {

  650.         int vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries);

  651.         cb->dimentions = av_malloc(sizeof(float) * cb->nentries * cb->ndimentions);

  652.         for (i = 0; i < cb->nentries; i++) {

  653.             float last = 0;

  654.             int j;

  655.             int div = 1;

  656.             for (j = 0; j < cb->ndimentions; j++) {

  657.                 int off;

  658.                 if (cb->lookup == 1) off = (i / div) % vals; // lookup type 1

  659.                 else off = i * cb->ndimentions + j; // lookup type 2

  660. 

  661.                 cb->dimentions[i * cb->ndimentions + j] = last + cb->min + cb->quantlist[off] * cb->delta;

  662.                 if (cb->seq_p) last = cb->dimentions[i * cb->ndimentions + j];

  663.                 div *= vals;

  664.             }

  665.         }

  666.     }

  667. 

  668. }

  669. 

  670. static void ready_residue(residue_t * rc, venc_context_t * venc) {

  671.     int i;

  672.     assert(rc->type == 2);

  673.     rc->maxes = av_mallocz(sizeof(float[2]) * rc->classifications);

  674.     for (i = 0; i < rc->classifications; i++) {

  675.         int j;

  676.         codebook_t * cb;

  677.         for (j = 0; j < 8; j++) if (rc->books[i][j] != -1) break;

  678.         if (j == 8) continue; // zero

  679.         cb = &venc->codebooks[rc->books[i][j]];

  680.         assert(cb->ndimentions >= 2);

  681.         assert(cb->lookup);

  682. 

  683.         for (j = 0; j < cb->nentries; j++) {

  684.             float a;

  685.             if (!cb->lens[j]) continue;

  686.             a = fabs(cb->dimentions[j * cb->ndimentions]);

  687.             if (a > rc->maxes[i][0]) rc->maxes[i][0] = a;

  688.             a = fabs(cb->dimentions[j * cb->ndimentions + 1]);

  689.             if (a > rc->maxes[i][1]) rc->maxes[i][1] = a;

  690.         }

  691.     }

  692.     // small bias

  693.     for (i = 0; i < rc->classifications; i++) {

  694.         rc->maxes[i][0] += 0.8;

  695.         rc->maxes[i][1] += 0.8;

  696.     }

  697. }

  698. 

  699. static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccontext) {

  700.     floor_t * fc;

  701.     residue_t * rc;

  702.     mapping_t * mc;

  703.     int i, book;

  704. 

  705.     venc->channels = avccontext->channels;

  706.     venc->sample_rate = avccontext->sample_rate;

  707.     venc->blocksize[0] = venc->blocksize[1] = 11;

  708. 

  709.     venc->ncodebooks = sizeof(cvectors)/sizeof(cvectors[0]);

  710.     venc->codebooks = av_malloc(sizeof(codebook_t) * venc->ncodebooks);

  711. 

  712.     // codebook 0..14 - floor1 book, values 0..255

  713.     // codebook 15 residue masterbook

  714.     // codebook 16..29 residue

  715.     for (book = 0; book < venc->ncodebooks; book++) {

  716.         codebook_t * cb = &venc->codebooks[book];

  717.         int vals;

  718.         cb->ndimentions = cvectors[book].dim;

  719.         cb->nentries = cvectors[book].real_len;

  720.         cb->min = cvectors[book].min;

  721.         cb->delta = cvectors[book].delta;

  722.         cb->lookup = cvectors[book].lookup;

  723.         cb->seq_p = 0;

  724. 

  725.         cb->lens = av_malloc(sizeof(uint8_t) * cb->nentries);

  726.         cb->codewords = av_malloc(sizeof(uint32_t) * cb->nentries);

  727.         memcpy(cb->lens, cvectors[book].clens, cvectors[book].len);

  728.         memset(cb->lens + cvectors[book].len, 0, cb->nentries - cvectors[book].len);

  729. 

  730.         if (cb->lookup) {

  731.             vals = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries);

  732.             cb->quantlist = av_malloc(sizeof(int) * vals);

  733.             for (i = 0; i < vals; i++) cb->quantlist[i] = cvectors[book].quant[i];

  734.         } else {

  735.             cb->quantlist = NULL;

  736.         }

  737.         ready_codebook(cb);

  738.     }

  739. 

  740.     venc->nfloors = 1;

  741.     venc->floors = av_malloc(sizeof(floor_t) * venc->nfloors);

  742. 

  743.     // just 1 floor

  744.     fc = &venc->floors[0];

  745.     fc->partitions = 8;

  746.     fc->partition_to_class = av_malloc(sizeof(int) * fc->partitions);

  747.     fc->nclasses = 0;

  748.     for (i = 0; i < fc->partitions; i++) {

  749.         int a[] = {0,1,2,2,3,3,4,4};

  750.         fc->partition_to_class[i] = a[i];

  751.         fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]);

  752.     }

  753.     fc->nclasses++;

  754.     fc->classes = av_malloc(sizeof(floor_class_t) * fc->nclasses);

  755.     for (i = 0; i < fc->nclasses; i++) {

  756.         floor_class_t * c = &fc->classes[i];

  757.         int j, books;

  758.         int dim[] = {3,4,3,4,3};

  759.         int subclass[] = {0,1,1,2,2};

  760.         int masterbook[] = {0/*none*/,0,1,2,3};

  761.         int * nbooks[] = {

  762.             (int[]){ 4 },

  763.             (int[]){ 5, 6 },

  764.             (int[]){ 7, 8 },

  765.             (int[]){ -1, 9, 10, 11 },

  766.             (int[]){ -1, 12, 13, 14 },

  767.         };

  768.         c->dim = dim[i];

  769.         c->subclass = subclass[i];

  770.         c->masterbook = masterbook[i];

  771.         books = (1 << c->subclass);

  772.         c->books = av_malloc(sizeof(int) * books);

  773.         for (j = 0; j < books; j++) c->books[j] = nbooks[i][j];

  774.     }

  775.     fc->multiplier = 2;

  776.     fc->rangebits = venc->blocksize[0] - 1;

  777. 

  778.     fc->values = 2;

  779.     for (i = 0; i < fc->partitions; i++)

  780.         fc->values += fc->classes[fc->partition_to_class[i]].dim;

  781. 

  782.     fc->list = av_malloc(sizeof(floor1_entry_t) * fc->values);

  783.     fc->list[0].x = 0;

  784.     fc->list[1].x = 1 << fc->rangebits;

  785.     for (i = 2; i < fc->values; i++) {

  786.         static const int a[] = {

  787.              93, 23,372,  6, 46,186,750, 14, 33, 65,

  788.             130,260,556,  3, 10, 18, 28, 39, 55, 79,

  789.             111,158,220,312,464,650,850

  790.         };

  791.         fc->list[i].x = a[i - 2];

  792.     }

  793.     ff_vorbis_ready_floor1_list(fc->list, fc->values);

  794. 

  795.     venc->nresidues = 1;

  796.     venc->residues = av_malloc(sizeof(residue_t) * venc->nresidues);

  797. 

  798.     // single residue

  799.     rc = &venc->residues[0];

  800.     rc->type = 2;

  801.     rc->begin = 0;

  802.     rc->end = 1600;

  803.     rc->partition_size = 32;

  804.     rc->classifications = 10;

  805.     rc->classbook = 15;

  806.     rc->books = av_malloc(sizeof(*rc->books) * rc->classifications);

  807.     {

  808.         static const int8_t a[10][8] = {

  809.             { -1, -1, -1, -1, -1, -1, -1, -1, },

  810.             { -1, -1, 16, -1, -1, -1, -1, -1, },

  811.             { -1, -1, 17, -1, -1, -1, -1, -1, },

  812.             { -1, -1, 18, -1, -1, -1, -1, -1, },

  813.             { -1, -1, 19, -1, -1, -1, -1, -1, },

  814.             { -1, -1, 20, -1, -1, -1, -1, -1, },

  815.             { -1, -1, 21, -1, -1, -1, -1, -1, },

  816.             { 22, 23, -1, -1, -1, -1, -1, -1, },

  817.             { 24, 25, -1, -1, -1, -1, -1, -1, },

  818.             { 26, 27, 28, -1, -1, -1, -1, -1, },

  819.         };

  820.         memcpy(rc->books, a, sizeof a);

  821.     }

  822.     ready_residue(rc, venc);

  823. 

  824.     venc->nmappings = 1;

  825.     venc->mappings = av_malloc(sizeof(mapping_t) * venc->nmappings);

  826. 

  827.     // single mapping

  828.     mc = &venc->mappings[0];

  829.     mc->submaps = 1;

  830.     mc->mux = av_malloc(sizeof(int) * venc->channels);

  831.     for (i = 0; i < venc->channels; i++) mc->mux[i] = 0;

  832.     mc->floor = av_malloc(sizeof(int) * mc->submaps);

  833.     mc->residue = av_malloc(sizeof(int) * mc->submaps);

  834.     for (i = 0; i < mc->submaps; i++) {

  835.         mc->floor[i] = 0;

  836.         mc->residue[i] = 0;

  837.     }

  838.     mc->coupling_steps = venc->channels == 2 ? 1 : 0;

  839.     mc->magnitude = av_malloc(sizeof(int) * mc->coupling_steps);

  840.     mc->angle = av_malloc(sizeof(int) * mc->coupling_steps);

  841.     if (mc->coupling_steps) {

  842.         mc->magnitude[0] = 0;

  843.         mc->angle[0] = 1;

  844.     }

  845. 

  846.     venc->nmodes = 1;

  847.     venc->modes = av_malloc(sizeof(vorbis_mode_t) * venc->nmodes);

  848. 

  849.     // single mode

  850.     venc->modes[0].blockflag = 0;

  851.     venc->modes[0].mapping = 0;

  852. 

  853.     venc->have_saved = 0;

  854.     venc->saved = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]) / 2);

  855.     venc->samples = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]));

  856.     venc->floor = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]) / 2);

  857.     venc->coeffs = av_malloc(sizeof(float) * venc->channels * (1 << venc->blocksize[1]) / 2);

  858. 

  859.     venc->win[0] = ff_vorbis_vwin[venc->blocksize[0] - 6];

  860.     venc->win[1] = ff_vorbis_vwin[venc->blocksize[1] - 6];

  861. 

  862.     ff_mdct_init(&venc->mdct[0], venc->blocksize[0], 0);

  863.     ff_mdct_init(&venc->mdct[1], venc->blocksize[1], 0);

  864. }

  865. 

  866. static void put_float(PutBitContext * pb, float f) {

  867.     int exp, mant;

  868.     uint32_t res = 0;

  869.     mant = (int)ldexp(frexp(f, &exp), 20);

  870.     exp += 788 - 20;

  871.     if (mant < 0) { res |= (1 << 31); mant = -mant; }

  872.     res |= mant | (exp << 21);

  873.     put_bits(pb, 32, res);

  874. }

  875. 

  876. static void put_codebook_header(PutBitContext * pb, codebook_t * cb) {

  877.     int i;

  878.     int ordered = 0;

  879. 

  880.     put_bits(pb, 24, 0x564342); //magic

  881.     put_bits(pb, 16, cb->ndimentions);

  882.     put_bits(pb, 24, cb->nentries);

  883. 

  884.     for (i = 1; i < cb->nentries; i++) if (cb->lens[i] < cb->lens[i-1]) break;

  885.     if (i == cb->nentries) ordered = 1;

  886. 

  887.     put_bits(pb, 1, ordered);

  888.     if (ordered) {

  889.         int len = cb->lens[0];

  890.         put_bits(pb, 5, len - 1);

  891.         i = 0;

  892.         while (i < cb->nentries) {

  893.             int j;

  894.             for (j = 0; j+i < cb->nentries; j++) if (cb->lens[j+i] != len) break;

  895.             put_bits(pb, ilog(cb->nentries - i), j);

  896.             i += j;

  897.             len++;

  898.         }

  899.     } else {

  900.         int sparse = 0;

  901.         for (i = 0; i < cb->nentries; i++) if (!cb->lens[i]) break;

  902.         if (i != cb->nentries) sparse = 1;

  903.         put_bits(pb, 1, sparse);

  904. 

  905.         for (i = 0; i < cb->nentries; i++) {

  906.             if (sparse) put_bits(pb, 1, !!cb->lens[i]);

  907.             if (cb->lens[i]) put_bits(pb, 5, cb->lens[i] - 1);

  908.         }

  909.     }

  910. 

  911.     put_bits(pb, 4, cb->lookup);

  912.     if (cb->lookup) {

  913.         int tmp = cb_lookup_vals(cb->lookup, cb->ndimentions, cb->nentries);

  914.         int bits = ilog(cb->quantlist[0]);

  915. 

  916.         for (i = 1; i < tmp; i++) bits = FFMAX(bits, ilog(cb->quantlist[i]));

  917. 

  918.         put_float(pb, cb->min);

  919.         put_float(pb, cb->delta);

  920. 

  921.         put_bits(pb, 4, bits - 1);

  922.         put_bits(pb, 1, cb->seq_p);

  923. 

  924.         for (i = 0; i < tmp; i++) put_bits(pb, bits, cb->quantlist[i]);

  925.     }

  926. }

  927. 

  928. static void put_floor_header(PutBitContext * pb, floor_t * fc) {

  929.     int i;

  930. 

  931.     put_bits(pb, 16, 1); // type, only floor1 is supported

  932. 

  933.     put_bits(pb, 5, fc->partitions);

  934. 

  935.     for (i = 0; i < fc->partitions; i++) put_bits(pb, 4, fc->partition_to_class[i]);

  936. 

  937.     for (i = 0; i < fc->nclasses; i++) {

  938.         int j, books;

  939. 

  940.         put_bits(pb, 3, fc->classes[i].dim - 1);

  941.         put_bits(pb, 2, fc->classes[i].subclass);

  942. 

  943.         if (fc->classes[i].subclass) put_bits(pb, 8, fc->classes[i].masterbook);

  944. 

  945.         books = (1 << fc->classes[i].subclass);

  946. 

  947.         for (j = 0; j < books; j++) put_bits(pb, 8, fc->classes[i].books[j] + 1);

  948.     }

  949. 

  950.     put_bits(pb, 2, fc->multiplier - 1);

  951.     put_bits(pb, 4, fc->rangebits);

  952. 

  953.     for (i = 2; i < fc->values; i++) put_bits(pb, fc->rangebits, fc->list[i].x);

  954. }

  955. 

  956. static void put_residue_header(PutBitContext * pb, residue_t * rc) {

  957.     int i;

  958. 

  959.     put_bits(pb, 16, rc->type);

  960. 

  961.     put_bits(pb, 24, rc->begin);

  962.     put_bits(pb, 24, rc->end);

  963.     put_bits(pb, 24, rc->partition_size - 1);

  964.     put_bits(pb, 6, rc->classifications - 1);

  965.     put_bits(pb, 8, rc->classbook);

  966. 

  967.     for (i = 0; i < rc->classifications; i++) {

  968.         int j, tmp = 0;

  969.         for (j = 0; j < 8; j++) tmp |= (rc->books[i][j] != -1) << j;

  970. 

  971.         put_bits(pb, 3, tmp & 7);

  972.         put_bits(pb, 1, tmp > 7);

  973. 

  974.         if (tmp > 7) put_bits(pb, 5, tmp >> 3);

  975.     }

  976. 

  977.     for (i = 0; i < rc->classifications; i++) {

  978.         int j;

  979.         for (j = 0; j < 8; j++)

  980.             if (rc->books[i][j] != -1)

  981.                 put_bits(pb, 8, rc->books[i][j]);

  982.     }

  983. }

  984. 

  985. static int put_main_header(venc_context_t * venc, uint8_t ** out) {

  986.     int i;

  987.     PutBitContext pb;

  988.     uint8_t buffer[50000] = {0}, * p = buffer;

  989.     int buffer_len = sizeof buffer;

  990.     int len, hlens[3];

  991. 

  992.     // identification header

  993.     init_put_bits(&pb, p, buffer_len);

  994.     put_bits(&pb, 8, 1); //magic

  995.     for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]);

  996.     put_bits(&pb, 32, 0); // version

  997.     put_bits(&pb, 8, venc->channels);

  998.     put_bits(&pb, 32, venc->sample_rate);

  999.     put_bits(&pb, 32, 0); // bitrate

  1000.     put_bits(&pb, 32, 0); // bitrate

  1001.     put_bits(&pb, 32, 0); // bitrate

  1002.     put_bits(&pb, 4, venc->blocksize[0]);

  1003.     put_bits(&pb, 4, venc->blocksize[1]);

  1004.     put_bits(&pb, 1, 1); // framing

  1005. 

  1006.     flush_put_bits(&pb);

  1007.     hlens[0] = (put_bits_count(&pb) + 7) / 8;

  1008.     buffer_len -= hlens[0];

  1009.     p += hlens[0];

  1010. 

  1011.     // comment header

  1012.     init_put_bits(&pb, p, buffer_len);

  1013.     put_bits(&pb, 8, 3); //magic

  1014.     for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]);

  1015.     put_bits(&pb, 32, 0); // vendor length TODO

  1016.     put_bits(&pb, 32, 0); // amount of comments

  1017.     put_bits(&pb, 1, 1); // framing

  1018. 

  1019.     flush_put_bits(&pb);

  1020.     hlens[1] = (put_bits_count(&pb) + 7) / 8;

  1021.     buffer_len -= hlens[1];

  1022.     p += hlens[1];

  1023. 

  1024.     // setup header

  1025.     init_put_bits(&pb, p, buffer_len);

  1026.     put_bits(&pb, 8, 5); //magic

  1027.     for (i = 0; "vorbis"[i]; i++) put_bits(&pb, 8, "vorbis"[i]);

  1028. 

  1029.     // codebooks

  1030.     put_bits(&pb, 8, venc->ncodebooks - 1);

  1031.     for (i = 0; i < venc->ncodebooks; i++) put_codebook_header(&pb, &venc->codebooks[i]);

  1032. 

  1033.     // time domain, reserved, zero

  1034.     put_bits(&pb, 6, 0);

  1035.     put_bits(&pb, 16, 0);

  1036. 

  1037.     // floors

  1038.     put_bits(&pb, 6, venc->nfloors - 1);

  1039.     for (i = 0; i < venc->nfloors; i++) put_floor_header(&pb, &venc->floors[i]);

  1040. 

  1041.     // residues

  1042.     put_bits(&pb, 6, venc->nresidues - 1);

  1043.     for (i = 0; i < venc->nresidues; i++) put_residue_header(&pb, &venc->residues[i]);

  1044. 

  1045.     // mappings

  1046.     put_bits(&pb, 6, venc->nmappings - 1);

  1047.     for (i = 0; i < venc->nmappings; i++) {

  1048.         mapping_t * mc = &venc->mappings[i];

  1049.         int j;

  1050.         put_bits(&pb, 16, 0); // mapping type

  1051. 

  1052.         put_bits(&pb, 1, mc->submaps > 1);

  1053.         if (mc->submaps > 1) put_bits(&pb, 4, mc->submaps - 1);

  1054. 

  1055.         put_bits(&pb, 1, !!mc->coupling_steps);

  1056.         if (mc->coupling_steps) {

  1057.             put_bits(&pb, 8, mc->coupling_steps - 1);

  1058.             for (j = 0; j < mc->coupling_steps; j++) {

  1059.                 put_bits(&pb, ilog(venc->channels - 1), mc->magnitude[j]);

  1060.                 put_bits(&pb, ilog(venc->channels - 1), mc->angle[j]);

  1061.             }

  1062.         }

  1063. 

  1064.         put_bits(&pb, 2, 0); // reserved

  1065. 

  1066.         if (mc->submaps > 1) for (j = 0; j < venc->channels; j++) put_bits(&pb, 4, mc->mux[j]);

  1067. 

  1068.         for (j = 0; j < mc->submaps; j++) {

  1069.             put_bits(&pb, 8, 0); // reserved time configuration

  1070.             put_bits(&pb, 8, mc->floor[j]);

  1071.             put_bits(&pb, 8, mc->residue[j]);

  1072.         }

  1073.     }

  1074. 

  1075.     // modes

  1076.     put_bits(&pb, 6, venc->nmodes - 1);

  1077.     for (i = 0; i < venc->nmodes; i++) {

  1078.         put_bits(&pb, 1, venc->modes[i].blockflag);

  1079.         put_bits(&pb, 16, 0); // reserved window type

  1080.         put_bits(&pb, 16, 0); // reserved transform type

  1081.         put_bits(&pb, 8, venc->modes[i].mapping);

  1082.     }

  1083. 

  1084.     put_bits(&pb, 1, 1); // framing

  1085. 

  1086.     flush_put_bits(&pb);

  1087.     hlens[2] = (put_bits_count(&pb) + 7) / 8;

  1088. 

  1089.     len = hlens[0] + hlens[1] + hlens[2];

  1090.     p = *out = av_mallocz(64 + len + len/255);

  1091. 

  1092.     *p++ = 2;

  1093.     p += av_xiphlacing(p, hlens[0]);

  1094.     p += av_xiphlacing(p, hlens[1]);

  1095.     buffer_len = 0;

  1096.     for (i = 0; i < 3; i++) {

  1097.         memcpy(p, buffer + buffer_len, hlens[i]);

  1098.         p += hlens[i];

  1099.         buffer_len += hlens[i];

  1100.     }

  1101. 

  1102.     return p - *out;

  1103. }

  1104. 

  1105. static float get_floor_average(floor_t * fc, float * coeffs, int i) {

  1106.     int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x;

  1107.     int end   = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x;

  1108.     int j;

  1109.     float average = 0;

  1110. 

  1111.     for (j = begin; j < end; j++) average += fabs(coeffs[j]);

  1112.     return average / (end - begin);

  1113. }

  1114. 

  1115. static void floor_fit(venc_context_t * venc, floor_t * fc, float * coeffs, int * posts, int samples) {

  1116.     int range = 255 / fc->multiplier + 1;

  1117.     int i;

  1118.     float tot_average = 0.;

  1119.     float averages[fc->values];

  1120.     for (i = 0; i < fc->values; i++) tot_average += averages[i] = get_floor_average(fc, coeffs, i);

  1121.     tot_average /= fc->values;

  1122.     tot_average /= venc->quality;

  1123. 

  1124.     for (i = 0; i < fc->values; i++) {

  1125.         int position = fc->list[fc->list[i].sort].x;

  1126.         float average = averages[i];

  1127.         int j;

  1128. 

  1129.         average /= pow(average, 0.5) / tot_average * pow(0.8, position/200.); // MAGIC!

  1130.         for (j = 0; j < range - 1; j++) if (ff_vorbis_floor1_inverse_db_table[j * fc->multiplier] > average) break;

  1131.         posts[fc->list[i].sort] = j;

  1132.     }

  1133. }

  1134. 

  1135. static int render_point(int x0, int y0, int x1, int y1, int x) {

  1136.     return y0 +  (x - x0) * (y1 - y0) / (x1 - x0);

  1137. }

  1138. 

  1139. static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb, int * posts, float * floor, int samples) {

  1140.     int range = 255 / fc->multiplier + 1;

  1141.     int coded[fc->values]; // first 2 values are unused

  1142.     int i, counter;

  1143.     int lx, ly;

  1144. 

  1145.     put_bits(pb, 1, 1); // non zero

  1146.     put_bits(pb, ilog(range - 1), posts[0]);

  1147.     put_bits(pb, ilog(range - 1), posts[1]);

  1148.     coded[0] = coded[1] = 1;

  1149. 

  1150.     for (i = 2; i < fc->values; i++) {

  1151.         int predicted = render_point(fc->list[fc->list[i].low].x,

  1152.                                      posts[fc->list[i].low],

  1153.                                      fc->list[fc->list[i].high].x,

  1154.                                      posts[fc->list[i].high],

  1155.                                      fc->list[i].x);

  1156.         int highroom = range - predicted;

  1157.         int lowroom = predicted;

  1158.         int room = FFMIN(highroom, lowroom);

  1159.         if (predicted == posts[i]) {

  1160.             coded[i] = 0; // must be used later as flag!

  1161.             continue;

  1162.         } else {

  1163.             if (!coded[fc->list[i].low]) coded[fc->list[i].low] = -1;

  1164.             if (!coded[fc->list[i].high]) coded[fc->list[i].high] = -1;

  1165.         }

  1166.         if (posts[i] > predicted) {

  1167.             if (posts[i] - predicted > room) coded[i] = posts[i] - predicted + lowroom;

  1168.             else coded[i] = (posts[i] - predicted) << 1;

  1169.         } else {

  1170.             if (predicted - posts[i] > room) coded[i] = predicted - posts[i] + highroom - 1;

  1171.             else coded[i] = ((predicted - posts[i]) << 1) - 1;

  1172.         }

  1173.     }

  1174. 

  1175.     counter = 2;

  1176.     for (i = 0; i < fc->partitions; i++) {

  1177.         floor_class_t * c = &fc->classes[fc->partition_to_class[i]];

  1178.         int k, cval = 0, csub = 1<<c->subclass;

  1179.         if (c->subclass) {

  1180.             codebook_t * book = &venc->codebooks[c->masterbook];

  1181.             int cshift = 0;

  1182.             for (k = 0; k < c->dim; k++) {

  1183.                 int l;

  1184.                 for (l = 0; l < csub; l++) {

  1185.                     int maxval = 1;

  1186.                     if (c->books[l] != -1) maxval = venc->codebooks[c->books[l]].nentries;

  1187.                     // coded could be -1, but this still works, cause thats 0

  1188.                     if (coded[counter + k] < maxval) break;

  1189.                 }

  1190.                 assert(l != csub);

  1191.                 cval |= l << cshift;

  1192.                 cshift += c->subclass;

  1193.             }

  1194.             put_codeword(pb, book, cval);

  1195.         }

  1196.         for (k = 0; k < c->dim; k++) {

  1197.             int book = c->books[cval & (csub-1)];

  1198.             int entry = coded[counter++];

  1199.             cval >>= c->subclass;

  1200.             if (book == -1) continue;

  1201.             if (entry == -1) entry = 0;

  1202.             put_codeword(pb, &venc->codebooks[book], entry);

  1203.         }

  1204.     }

  1205. 

  1206.     lx = 0;

  1207.     ly = posts[0] * fc->multiplier; // sorted 0 is still 0

  1208.     for (i = 1; i < fc->values; i++) {

  1209.         int pos = fc->list[i].sort;

  1210.         if (coded[pos]) {

  1211.             render_line(lx, ly, fc->list[pos].x, posts[pos] * fc->multiplier, floor, samples);

  1212.             lx = fc->list[pos].x;

  1213.             ly = posts[pos] * fc->multiplier;

  1214.         }

  1215.         if (lx >= samples) break;

  1216.     }

  1217.     if (lx < samples) render_line(lx, ly, samples, ly, floor, samples);

  1218. }

  1219. 

  1220. static float * put_vector(codebook_t * book, PutBitContext * pb, float * num) {

  1221.     int i;

  1222.     int entry = -1;

  1223.     float distance = 0;

  1224.     assert(book->dimentions);

  1225.     for (i = 0; i < book->nentries; i++) {

  1226.         float d = 0.;

  1227.         int j;

  1228.         if (!book->lens[i]) continue;

  1229.         for (j = 0; j < book->ndimentions; j++) {

  1230.             float a = (book->dimentions[i * book->ndimentions + j] - num[j]);

  1231.             d += a*a;

  1232.         }

  1233.         if (entry == -1 || distance > d) {

  1234.             entry = i;

  1235.             distance = d;

  1236.         }

  1237.     }

  1238.     put_codeword(pb, book, entry);

  1239.     return &book->dimentions[entry * book->ndimentions];

  1240. }

  1241. 

  1242. static void residue_encode(venc_context_t * venc, residue_t * rc, PutBitContext * pb, float * coeffs, int samples, int real_ch) {

  1243.     int pass, i, j, p, k;

  1244.     int psize = rc->partition_size;

  1245.     int partitions = (rc->end - rc->begin) / psize;

  1246.     int channels = (rc->type == 2) ? 1 : real_ch;

  1247.     int classes[channels][partitions];

  1248.     int classwords = venc->codebooks[rc->classbook].ndimentions;

  1249. 

  1250.     assert(rc->type == 2);

  1251.     assert(real_ch == 2);

  1252.     for (p = 0; p < partitions; p++) {

  1253.         float max1 = 0., max2 = 0.;

  1254.         int s = rc->begin + p * psize;

  1255.         for (k = s; k < s + psize; k += 2) {

  1256.             max1 = FFMAX(max1, fabs(coeffs[          k / real_ch]));

  1257.             max2 = FFMAX(max2, fabs(coeffs[samples + k / real_ch]));

  1258.         }

  1259. 

  1260.         for (i = 0; i < rc->classifications - 1; i++) {

  1261.             if (max1 < rc->maxes[i][0] && max2 < rc->maxes[i][1]) break;

  1262.         }

  1263.         classes[0][p] = i;

  1264.     }

  1265. 

  1266.     for (pass = 0; pass < 8; pass++) {

  1267.         p = 0;

  1268.         while (p < partitions) {

  1269.             if (pass == 0) for (j = 0; j < channels; j++) {

  1270.                 codebook_t * book = &venc->codebooks[rc->classbook];

  1271.                 int entry = 0;

  1272.                 for (i = 0; i < classwords; i++) {

  1273.                     entry *= rc->classifications;

  1274.                     entry += classes[j][p + i];

  1275.                 }

  1276.                 put_codeword(pb, book, entry);

  1277.             }

  1278.             for (i = 0; i < classwords && p < partitions; i++, p++) {

  1279.                 for (j = 0; j < channels; j++) {

  1280.                     int nbook = rc->books[classes[j][p]][pass];

  1281.                     codebook_t * book = &venc->codebooks[nbook];

  1282.                     float * buf = coeffs + samples*j + rc->begin + p*psize;

  1283.                     if (nbook == -1) continue;

  1284. 

  1285.                     assert(rc->type == 0 || rc->type == 2);

  1286.                     assert(!(psize % book->ndimentions));

  1287. 

  1288.                     if (rc->type == 0) {

  1289.                         for (k = 0; k < psize; k += book->ndimentions) {

  1290.                             float * a = put_vector(book, pb, &buf[k]);

  1291.                             int l;

  1292.                             for (l = 0; l < book->ndimentions; l++) buf[k + l] -= a[l];

  1293.                         }

  1294.                     } else {

  1295.                         for (k = 0; k < psize; k += book->ndimentions) {

  1296.                             int dim = book->ndimentions, s = rc->begin + p * psize + k, l;

  1297.                             float vec[dim], * a = vec;

  1298.                             for (l = s; l < s + dim; l++)

  1299.                                 *a++ = coeffs[(l % real_ch) * samples + l / real_ch];

  1300.                             a = put_vector(book, pb, vec);

  1301.                             for (l = s; l < s + dim; l++)

  1302.                                 coeffs[(l % real_ch) * samples + l / real_ch] -= *a++;

  1303.                         }

  1304.                     }

  1305.                 }

  1306.             }

  1307.         }

  1308.     }

  1309. }

  1310. 

  1311. static int window(venc_context_t * venc, signed short * audio, int samples) {

  1312.     int i, j, channel;

  1313.     const float * win = venc->win[0];

  1314.     int window_len = 1 << (venc->blocksize[0] - 1);

  1315.     float n = (float)(1 << venc->blocksize[0]) / 4.;

  1316.     // FIXME use dsp

  1317. 

  1318.     if (!venc->have_saved && !samples) return 0;

  1319. 

  1320.     if (venc->have_saved) {

  1321.         for (channel = 0; channel < venc->channels; channel++) {

  1322.             memcpy(venc->samples + channel*window_len*2, venc->saved + channel*window_len, sizeof(float)*window_len);

  1323.         }

  1324.     } else {

  1325.         for (channel = 0; channel < venc->channels; channel++) {

  1326.             memset(venc->samples + channel*window_len*2, 0, sizeof(float)*window_len);

  1327.         }

  1328.     }

  1329. 

  1330.     if (samples) {

  1331.         for (channel = 0; channel < venc->channels; channel++) {

  1332.             float * offset = venc->samples + channel*window_len*2 + window_len;

  1333.             j = channel;

  1334.             for (i = 0; i < samples; i++, j += venc->channels)

  1335.                 offset[i] = audio[j] / 32768. / n * win[window_len - i - 1];

  1336.         }

  1337.     } else {

  1338.         for (channel = 0; channel < venc->channels; channel++) {

  1339.             memset(venc->samples + channel*window_len*2 + window_len, 0, sizeof(float)*window_len);

  1340.         }

  1341.     }

  1342. 

  1343.     for (channel = 0; channel < venc->channels; channel++) {

  1344.         ff_mdct_calc(&venc->mdct[0], venc->coeffs + channel*window_len, venc->samples + channel*window_len*2, venc->floor/*tmp*/);

  1345.     }

  1346. 

  1347.     if (samples) {

  1348.         for (channel = 0; channel < venc->channels; channel++) {

  1349.             float * offset = venc->saved + channel*window_len;

  1350.             j = channel;

  1351.             for (i = 0; i < samples; i++, j += venc->channels)

  1352.                 offset[i] = audio[j] / 32768. / n * win[i];

  1353.         }

  1354.         venc->have_saved = 1;

  1355.     } else {

  1356.         venc->have_saved = 0;

  1357.     }

  1358.     return 1;

  1359. }

  1360. 

  1361. static int vorbis_encode_init(AVCodecContext * avccontext)

  1362. {

  1363.     venc_context_t * venc = avccontext->priv_data;

  1364. 

  1365.     if (avccontext->channels != 2) return -1;

  1366. 

  1367.     create_vorbis_context(venc, avccontext);

  1368. 

  1369.     if (avccontext->flags & CODEC_FLAG_QSCALE) venc->quality = avccontext->global_quality / (float)FF_QP2LAMBDA / 100.;

  1370.     else venc->quality = 0.17;

  1371. 

  1372.     avccontext->extradata_size = put_main_header(venc, (uint8_t**)&avccontext->extradata);

  1373. 

  1374.     avccontext->frame_size = 1 << (venc->blocksize[0] - 1);

  1375. 

  1376.     avccontext->coded_frame = avcodec_alloc_frame();

  1377.     avccontext->coded_frame->key_frame = 1;

  1378. 

  1379.     return 0;

  1380. }

  1381. 

  1382. static int vorbis_encode_frame(AVCodecContext * avccontext, unsigned char * packets, int buf_size, void *data)

  1383. {

  1384.     venc_context_t * venc = avccontext->priv_data;

  1385.     signed short * audio = data;

  1386.     int samples = data ? avccontext->frame_size : 0;

  1387.     vorbis_mode_t * mode;

  1388.     mapping_t * mapping;

  1389.     PutBitContext pb;

  1390.     int i;

  1391. 

  1392.     if (!window(venc, audio, samples)) return 0;

  1393.     samples = 1 << (venc->blocksize[0] - 1);

  1394. 

  1395.     init_put_bits(&pb, packets, buf_size);

  1396. 

  1397.     put_bits(&pb, 1, 0); // magic bit

  1398. 

  1399.     put_bits(&pb, ilog(venc->nmodes - 1), 0); // 0 bits, the mode

  1400. 

  1401.     mode = &venc->modes[0];

  1402.     mapping = &venc->mappings[mode->mapping];

  1403.     if (mode->blockflag) {

  1404.         put_bits(&pb, 1, 0);

  1405.         put_bits(&pb, 1, 0);

  1406.     }

  1407. 

  1408.     for (i = 0; i < venc->channels; i++) {

  1409.         floor_t * fc = &venc->floors[mapping->floor[mapping->mux[i]]];

  1410.         int posts[fc->values];

  1411.         floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples);

  1412.         floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples);

  1413.     }

  1414. 

  1415.     for (i = 0; i < venc->channels; i++) {

  1416.         int j;

  1417.         for (j = 0; j < samples; j++) {

  1418.             venc->coeffs[i * samples + j] /= venc->floor[i * samples + j];

  1419.         }

  1420.     }

  1421. 

  1422.     for (i = 0; i < mapping->coupling_steps; i++) {

  1423.         float * mag = venc->coeffs + mapping->magnitude[i] * samples;

  1424.         float * ang = venc->coeffs + mapping->angle[i] * samples;

  1425.         int j;

  1426.         for (j = 0; j < samples; j++) {

  1427.             float m = mag[j];

  1428.             float a = ang[j];

  1429.             if (m > 0) {

  1430.                 ang[j] = m - a;

  1431.                 if (a > m) mag[j] = a;

  1432.                 else mag[j] = m;

  1433.             } else {

  1434.                 ang[j] = a - m;

  1435.                 if (a > m) mag[j] = m;

  1436.                 else mag[j] = a;

  1437.             }

  1438.         }

  1439.     }

  1440. 

  1441.     residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]], &pb, venc->coeffs, samples, venc->channels);

  1442. 

  1443.     flush_put_bits(&pb);

  1444.     return (put_bits_count(&pb) + 7) / 8;

  1445. }

  1446. 

  1447. 

  1448. static int vorbis_encode_close(AVCodecContext * avccontext)

  1449. {

  1450.     venc_context_t * venc = avccontext->priv_data;

  1451.     int i;

  1452. 

  1453.     if (venc->codebooks) for (i = 0; i < venc->ncodebooks; i++) {

  1454.         av_freep(&venc->codebooks[i].lens);

  1455.         av_freep(&venc->codebooks[i].codewords);

  1456.         av_freep(&venc->codebooks[i].quantlist);

  1457.         av_freep(&venc->codebooks[i].dimentions);

  1458.     }

  1459.     av_freep(&venc->codebooks);

  1460. 

  1461.     if (venc->floors) for (i = 0; i < venc->nfloors; i++) {

  1462.         int j;

  1463.         av_freep(&venc->floors[i].classes);

  1464.         if (venc->floors[i].classes)

  1465.             for (j = 0; j < venc->floors[i].nclasses; j++)

  1466.                 av_freep(&venc->floors[i].classes[j].books);

  1467.         av_freep(&venc->floors[i].partition_to_class);

  1468.         av_freep(&venc->floors[i].list);

  1469.     }

  1470.     av_freep(&venc->floors);

  1471. 

  1472.     if (venc->residues) for (i = 0; i < venc->nresidues; i++) {

  1473.         av_freep(&venc->residues[i].books);

  1474.         av_freep(&venc->residues[i].maxes);

  1475.     }

  1476.     av_freep(&venc->residues);

  1477. 

  1478.     if (venc->mappings) for (i = 0; i < venc->nmappings; i++) {

  1479.         av_freep(&venc->mappings[i].mux);

  1480.         av_freep(&venc->mappings[i].floor);

  1481.         av_freep(&venc->mappings[i].residue);

  1482.     }

  1483.     av_freep(&venc->mappings);

  1484. 

  1485.     av_freep(&venc->modes);

  1486. 

  1487.     av_freep(&venc->saved);

  1488.     av_freep(&venc->samples);

  1489.     av_freep(&venc->floor);

  1490.     av_freep(&venc->coeffs);

  1491. 

  1492.     ff_mdct_end(&venc->mdct[0]);

  1493.     ff_mdct_end(&venc->mdct[1]);

  1494. 

  1495.     av_freep(&avccontext->coded_frame);

  1496.     av_freep(&avccontext->extradata);

  1497. 

  1498.     return 0 ;

  1499. }

  1500. 

  1501. AVCodec vorbis_encoder = {

  1502.     "vorbis",

  1503.     CODEC_TYPE_AUDIO,

  1504.     CODEC_ID_VORBIS,

  1505.     sizeof(venc_context_t),

  1506.     vorbis_encode_init,

  1507.     vorbis_encode_frame,

  1508.     vorbis_encode_close,

  1509.     .capabilities= CODEC_CAP_DELAY,

  1510. };