Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * WavPack lossless audio encoder
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. #define BITSTREAM_WRITER_LE
  22.  
  23. #include "libavutil/intreadwrite.h"
  24. #include "libavutil/opt.h"
  25. #include "avcodec.h"
  26. #include "internal.h"
  27. #include "put_bits.h"
  28. #include "bytestream.h"
  29. #include "wavpackenc.h"
  30. #include "wavpack.h"
  31.  
  32. #define UPDATE_WEIGHT(weight, delta, source, result) \
  33.     if ((source) && (result)) { \
  34.         int32_t s = (int32_t) ((source) ^ (result)) >> 31; \
  35.         weight = ((delta) ^ s) + ((weight) - s); \
  36.     }
  37.  
  38. #define APPLY_WEIGHT_F(weight, sample) ((((((sample) & 0xffff) * (weight)) >> 9) + \
  39.     ((((sample) & ~0xffff) >> 9) * (weight)) + 1) >> 1)
  40.  
  41. #define APPLY_WEIGHT_I(weight, sample) (((weight) * (sample) + 512) >> 10)
  42.  
  43. #define APPLY_WEIGHT(weight, sample) ((sample) != (short) (sample) ? \
  44.     APPLY_WEIGHT_F(weight, sample) : APPLY_WEIGHT_I (weight, sample))
  45.  
  46. #define CLEAR(destin) memset(&destin, 0, sizeof(destin));
  47.  
  48. #define SHIFT_LSB       13
  49. #define SHIFT_MASK      (0x1FU << SHIFT_LSB)
  50.  
  51. #define MAG_LSB         18
  52. #define MAG_MASK        (0x1FU << MAG_LSB)
  53.  
  54. #define SRATE_LSB       23
  55. #define SRATE_MASK      (0xFU << SRATE_LSB)
  56.  
  57. #define EXTRA_TRY_DELTAS     1
  58. #define EXTRA_ADJUST_DELTAS  2
  59. #define EXTRA_SORT_FIRST     4
  60. #define EXTRA_BRANCHES       8
  61. #define EXTRA_SORT_LAST     16
  62.  
  63. typedef struct WavPackExtraInfo {
  64.     struct Decorr dps[MAX_TERMS];
  65.     int nterms, log_limit, gt16bit;
  66.     uint32_t best_bits;
  67. } WavPackExtraInfo;
  68.  
  69. typedef struct WavPackWords {
  70.     int pend_data, holding_one, zeros_acc;
  71.     int holding_zero, pend_count;
  72.     WvChannel c[2];
  73. } WavPackWords;
  74.  
  75. typedef struct WavPackEncodeContext {
  76.     AVClass *class;
  77.     AVCodecContext *avctx;
  78.     PutBitContext pb;
  79.     int block_samples;
  80.     int buffer_size;
  81.     int sample_index;
  82.     int stereo, stereo_in;
  83.     int ch_offset;
  84.  
  85.     int32_t *samples[2];
  86.     int samples_size[2];
  87.  
  88.     int32_t *sampleptrs[MAX_TERMS+2][2];
  89.     int sampleptrs_size[MAX_TERMS+2][2];
  90.  
  91.     int32_t *temp_buffer[2][2];
  92.     int temp_buffer_size[2][2];
  93.  
  94.     int32_t *best_buffer[2];
  95.     int best_buffer_size[2];
  96.  
  97.     int32_t *js_left, *js_right;
  98.     int js_left_size, js_right_size;
  99.  
  100.     int32_t *orig_l, *orig_r;
  101.     int orig_l_size, orig_r_size;
  102.  
  103.     unsigned extra_flags;
  104.     int optimize_mono;
  105.     int decorr_filter;
  106.     int joint;
  107.     int num_branches;
  108.  
  109.     uint32_t flags;
  110.     uint32_t crc_x;
  111.     WavPackWords w;
  112.  
  113.     uint8_t int32_sent_bits, int32_zeros, int32_ones, int32_dups;
  114.     uint8_t float_flags, float_shift, float_max_exp, max_exp;
  115.     int32_t shifted_ones, shifted_zeros, shifted_both;
  116.     int32_t false_zeros, neg_zeros, ordata;
  117.  
  118.     int num_terms, shift, joint_stereo, false_stereo;
  119.     int num_decorrs, num_passes, best_decorr, mask_decorr;
  120.     struct Decorr decorr_passes[MAX_TERMS];
  121.     const WavPackDecorrSpec *decorr_specs;
  122.     float delta_decay;
  123. } WavPackEncodeContext;
  124.  
  125. static av_cold int wavpack_encode_init(AVCodecContext *avctx)
  126. {
  127.     WavPackEncodeContext *s = avctx->priv_data;
  128.  
  129.     s->avctx = avctx;
  130.  
  131.     if (avctx->channels > 255) {
  132.         av_log(avctx, AV_LOG_ERROR, "Invalid channel count: %d\n", avctx->channels);
  133.         return AVERROR(EINVAL);
  134.     }
  135.  
  136.     if (!avctx->frame_size) {
  137.         int block_samples;
  138.         if (!(avctx->sample_rate & 1))
  139.             block_samples = avctx->sample_rate / 2;
  140.         else
  141.             block_samples = avctx->sample_rate;
  142.  
  143.         while (block_samples * avctx->channels > WV_MAX_SAMPLES)
  144.             block_samples /= 2;
  145.  
  146.         while (block_samples * avctx->channels < 40000)
  147.             block_samples *= 2;
  148.         avctx->frame_size = block_samples;
  149.     } else if (avctx->frame_size && (avctx->frame_size < 128 ||
  150.                               avctx->frame_size > WV_MAX_SAMPLES)) {
  151.         av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n", avctx->frame_size);
  152.         return AVERROR(EINVAL);
  153.     }
  154.  
  155.     if (avctx->compression_level != FF_COMPRESSION_DEFAULT) {
  156.         if (avctx->compression_level >= 3) {
  157.             s->decorr_filter = 3;
  158.             s->num_passes = 9;
  159.             if      (avctx->compression_level >= 8) {
  160.                 s->num_branches = 4;
  161.                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_SORT_LAST|EXTRA_BRANCHES;
  162.             } else if (avctx->compression_level >= 7) {
  163.                 s->num_branches = 3;
  164.                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES;
  165.             } else if (avctx->compression_level >= 6) {
  166.                 s->num_branches = 2;
  167.                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES;
  168.             } else if (avctx->compression_level >= 5) {
  169.                 s->num_branches = 1;
  170.                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES;
  171.             } else if (avctx->compression_level >= 4) {
  172.                 s->num_branches = 1;
  173.                 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_BRANCHES;
  174.             }
  175.         } else if (avctx->compression_level == 2) {
  176.             s->decorr_filter = 2;
  177.             s->num_passes = 4;
  178.         } else if (avctx->compression_level == 1) {
  179.             s->decorr_filter = 1;
  180.             s->num_passes = 2;
  181.         } else if (avctx->compression_level < 1) {
  182.             s->decorr_filter = 0;
  183.             s->num_passes = 0;
  184.         }
  185.     }
  186.  
  187.     s->num_decorrs = decorr_filter_sizes[s->decorr_filter];
  188.     s->decorr_specs = decorr_filters[s->decorr_filter];
  189.  
  190.     s->delta_decay = 2.0;
  191.  
  192.     return 0;
  193. }
  194.  
  195. static void shift_mono(int32_t *samples, int nb_samples, int shift)
  196. {
  197.     int i;
  198.     for (i = 0; i < nb_samples; i++)
  199.         samples[i] >>= shift;
  200. }
  201.  
  202. static void shift_stereo(int32_t *left, int32_t *right,
  203.                          int nb_samples, int shift)
  204. {
  205.     int i;
  206.     for (i = 0; i < nb_samples; i++) {
  207.         left [i] >>= shift;
  208.         right[i] >>= shift;
  209.     }
  210. }
  211.  
  212. #define FLOAT_SHIFT_ONES 1
  213. #define FLOAT_SHIFT_SAME 2
  214. #define FLOAT_SHIFT_SENT 4
  215. #define FLOAT_ZEROS_SENT 8
  216. #define FLOAT_NEG_ZEROS  0x10
  217. #define FLOAT_EXCEPTIONS 0x20
  218.  
  219. #define get_mantissa(f)     ((f) & 0x7fffff)
  220. #define get_exponent(f)     (((f) >> 23) & 0xff)
  221. #define get_sign(f)         (((f) >> 31) & 0x1)
  222.  
  223. static void process_float(WavPackEncodeContext *s, int32_t *sample)
  224. {
  225.     int32_t shift_count, value, f = *sample;
  226.  
  227.     if (get_exponent(f) == 255) {
  228.         s->float_flags |= FLOAT_EXCEPTIONS;
  229.         value = 0x1000000;
  230.         shift_count = 0;
  231.     } else if (get_exponent(f)) {
  232.         shift_count = s->max_exp - get_exponent(f);
  233.         value = 0x800000 + get_mantissa(f);
  234.     } else {
  235.         shift_count = s->max_exp ? s->max_exp - 1 : 0;
  236.         value = get_mantissa(f);
  237.     }
  238.  
  239.     if (shift_count < 25)
  240.         value >>= shift_count;
  241.     else
  242.         value = 0;
  243.  
  244.     if (!value) {
  245.         if (get_exponent(f) || get_mantissa(f))
  246.             s->false_zeros++;
  247.         else if (get_sign(f))
  248.             s->neg_zeros++;
  249.     } else if (shift_count) {
  250.         int32_t mask = (1 << shift_count) - 1;
  251.  
  252.         if (!(get_mantissa(f) & mask))
  253.             s->shifted_zeros++;
  254.         else if ((get_mantissa(f) & mask) == mask)
  255.             s->shifted_ones++;
  256.         else
  257.             s->shifted_both++;
  258.     }
  259.  
  260.     s->ordata |= value;
  261.     *sample = get_sign(f) ? -value : value;
  262. }
  263.  
  264. static int scan_float(WavPackEncodeContext *s,
  265.                       int32_t *samples_l, int32_t *samples_r,
  266.                       int nb_samples)
  267. {
  268.     uint32_t crc = 0xffffffffu;
  269.     int i;
  270.  
  271.     s->shifted_ones = s->shifted_zeros = s->shifted_both = s->ordata = 0;
  272.     s->float_shift = s->float_flags = 0;
  273.     s->false_zeros = s->neg_zeros = 0;
  274.     s->max_exp = 0;
  275.  
  276.     if (s->flags & WV_MONO_DATA) {
  277.         for (i = 0; i < nb_samples; i++) {
  278.             int32_t f = samples_l[i];
  279.             crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
  280.  
  281.             if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
  282.                 s->max_exp = get_exponent(f);
  283.         }
  284.     } else {
  285.         for (i = 0; i < nb_samples; i++) {
  286.             int32_t f;
  287.  
  288.             f = samples_l[i];
  289.             crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
  290.             if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
  291.                 s->max_exp = get_exponent(f);
  292.  
  293.             f = samples_r[i];
  294.             crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f);
  295.  
  296.             if (get_exponent(f) > s->max_exp && get_exponent(f) < 255)
  297.                 s->max_exp = get_exponent(f);
  298.         }
  299.     }
  300.  
  301.     s->crc_x = crc;
  302.  
  303.     if (s->flags & WV_MONO_DATA) {
  304.         for (i = 0; i < nb_samples; i++)
  305.             process_float(s, &samples_l[i]);
  306.     } else {
  307.         for (i = 0; i < nb_samples; i++) {
  308.             process_float(s, &samples_l[i]);
  309.             process_float(s, &samples_r[i]);
  310.         }
  311.     }
  312.  
  313.     s->float_max_exp = s->max_exp;
  314.  
  315.     if (s->shifted_both)
  316.         s->float_flags |= FLOAT_SHIFT_SENT;
  317.     else if (s->shifted_ones && !s->shifted_zeros)
  318.         s->float_flags |= FLOAT_SHIFT_ONES;
  319.     else if (s->shifted_ones && s->shifted_zeros)
  320.         s->float_flags |= FLOAT_SHIFT_SAME;
  321.     else if (s->ordata && !(s->ordata & 1)) {
  322.         do {
  323.             s->float_shift++;
  324.             s->ordata >>= 1;
  325.         } while (!(s->ordata & 1));
  326.  
  327.         if (s->flags & WV_MONO_DATA)
  328.             shift_mono(samples_l, nb_samples, s->float_shift);
  329.         else
  330.             shift_stereo(samples_l, samples_r, nb_samples, s->float_shift);
  331.     }
  332.  
  333.     s->flags &= ~MAG_MASK;
  334.  
  335.     while (s->ordata) {
  336.         s->flags += 1 << MAG_LSB;
  337.         s->ordata >>= 1;
  338.     }
  339.  
  340.     if (s->false_zeros || s->neg_zeros)
  341.         s->float_flags |= FLOAT_ZEROS_SENT;
  342.  
  343.     if (s->neg_zeros)
  344.         s->float_flags |= FLOAT_NEG_ZEROS;
  345.  
  346.     return s->float_flags & (FLOAT_EXCEPTIONS | FLOAT_ZEROS_SENT |
  347.                              FLOAT_SHIFT_SENT | FLOAT_SHIFT_SAME);
  348. }
  349.  
  350. static void scan_int23(WavPackEncodeContext *s,
  351.                        int32_t *samples_l, int32_t *samples_r,
  352.                        int nb_samples)
  353. {
  354.     uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
  355.     int i, total_shift = 0;
  356.  
  357.     s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0;
  358.  
  359.     if (s->flags & WV_MONO_DATA) {
  360.         for (i = 0; i < nb_samples; i++) {
  361.             int32_t M = samples_l[i];
  362.  
  363.             magdata |= (M < 0) ? ~M : M;
  364.             xordata |= M ^ -(M & 1);
  365.             anddata &= M;
  366.             ordata  |= M;
  367.  
  368.             if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
  369.                 return;
  370.         }
  371.     } else {
  372.         for (i = 0; i < nb_samples; i++) {
  373.             int32_t L = samples_l[i];
  374.             int32_t R = samples_r[i];
  375.  
  376.             magdata |= (L < 0) ? ~L : L;
  377.             magdata |= (R < 0) ? ~R : R;
  378.             xordata |= L ^ -(L & 1);
  379.             xordata |= R ^ -(R & 1);
  380.             anddata &= L & R;
  381.             ordata  |= L | R;
  382.  
  383.             if ((ordata & 1) && !(anddata & 1) && (xordata & 2))
  384.                 return;
  385.         }
  386.     }
  387.  
  388.     s->flags &= ~MAG_MASK;
  389.  
  390.     while (magdata) {
  391.         s->flags += 1 << MAG_LSB;
  392.         magdata >>= 1;
  393.     }
  394.  
  395.     if (!(s->flags & MAG_MASK))
  396.         return;
  397.  
  398.     if (!(ordata & 1)) {
  399.         do {
  400.             s->flags -= 1 << MAG_LSB;
  401.             s->int32_zeros++;
  402.             total_shift++;
  403.             ordata >>= 1;
  404.         } while (!(ordata & 1));
  405.     } else if (anddata & 1) {
  406.         do {
  407.             s->flags -= 1 << MAG_LSB;
  408.             s->int32_ones++;
  409.             total_shift++;
  410.             anddata >>= 1;
  411.         } while (anddata & 1);
  412.     } else if (!(xordata & 2)) {
  413.         do {
  414.             s->flags -= 1 << MAG_LSB;
  415.             s->int32_dups++;
  416.             total_shift++;
  417.             xordata >>= 1;
  418.         } while (!(xordata & 2));
  419.     }
  420.  
  421.     if (total_shift) {
  422.         s->flags |= WV_INT32_DATA;
  423.  
  424.         if (s->flags & WV_MONO_DATA)
  425.             shift_mono(samples_l, nb_samples, total_shift);
  426.         else
  427.             shift_stereo(samples_l, samples_r, nb_samples, total_shift);
  428.     }
  429. }
  430.  
  431. static int scan_int32(WavPackEncodeContext *s,
  432.                       int32_t *samples_l, int32_t *samples_r,
  433.                       int nb_samples)
  434. {
  435.     uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0;
  436.     uint32_t crc = 0xffffffffu;
  437.     int i, total_shift = 0;
  438.  
  439.     s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0;
  440.  
  441.     if (s->flags & WV_MONO_DATA) {
  442.         for (i = 0; i < nb_samples; i++) {
  443.             int32_t M = samples_l[i];
  444.  
  445.             crc = crc * 9 + (M & 0xffff) * 3 + ((M >> 16) & 0xffff);
  446.             magdata |= (M < 0) ? ~M : M;
  447.             xordata |= M ^ -(M & 1);
  448.             anddata &= M;
  449.             ordata  |= M;
  450.         }
  451.     } else {
  452.         for (i = 0; i < nb_samples; i++) {
  453.             int32_t L = samples_l[i];
  454.             int32_t R = samples_r[i];
  455.  
  456.             crc = crc * 9 + (L & 0xffff) * 3 + ((L >> 16) & 0xffff);
  457.             crc = crc * 9 + (R & 0xffff) * 3 + ((R >> 16) & 0xffff);
  458.             magdata |= (L < 0) ? ~L : L;
  459.             magdata |= (R < 0) ? ~R : R;
  460.             xordata |= L ^ -(L & 1);
  461.             xordata |= R ^ -(R & 1);
  462.             anddata &= L & R;
  463.             ordata  |= L | R;
  464.         }
  465.     }
  466.  
  467.     s->crc_x = crc;
  468.     s->flags &= ~MAG_MASK;
  469.  
  470.     while (magdata) {
  471.         s->flags += 1 << MAG_LSB;
  472.         magdata >>= 1;
  473.     }
  474.  
  475.     if (!((s->flags & MAG_MASK) >> MAG_LSB)) {
  476.         s->flags &= ~WV_INT32_DATA;
  477.         return 0;
  478.     }
  479.  
  480.     if (!(ordata & 1))
  481.         do {
  482.             s->flags -= 1 << MAG_LSB;
  483.             s->int32_zeros++;
  484.             total_shift++;
  485.             ordata >>= 1;
  486.         } while (!(ordata & 1));
  487.     else if (anddata & 1)
  488.         do {
  489.             s->flags -= 1 << MAG_LSB;
  490.             s->int32_ones++;
  491.             total_shift++;
  492.             anddata >>= 1;
  493.         } while (anddata & 1);
  494.     else if (!(xordata & 2))
  495.         do {
  496.             s->flags -= 1 << MAG_LSB;
  497.             s->int32_dups++;
  498.             total_shift++;
  499.             xordata >>= 1;
  500.         } while (!(xordata & 2));
  501.  
  502.     if (((s->flags & MAG_MASK) >> MAG_LSB) > 23) {
  503.         s->int32_sent_bits = (uint8_t)(((s->flags & MAG_MASK) >> MAG_LSB) - 23);
  504.         total_shift += s->int32_sent_bits;
  505.         s->flags &= ~MAG_MASK;
  506.         s->flags += 23 << MAG_LSB;
  507.     }
  508.  
  509.     if (total_shift) {
  510.         s->flags |= WV_INT32_DATA;
  511.  
  512.         if (s->flags & WV_MONO_DATA)
  513.             shift_mono(samples_l, nb_samples, total_shift);
  514.         else
  515.             shift_stereo(samples_l, samples_r, nb_samples, total_shift);
  516.     }
  517.  
  518.     return s->int32_sent_bits;
  519. }
  520.  
  521. static int8_t store_weight(int weight)
  522. {
  523.     weight = av_clip(weight, -1024, 1024);
  524.     if (weight > 0)
  525.         weight -= (weight + 64) >> 7;
  526.  
  527.     return (weight + 4) >> 3;
  528. }
  529.  
  530. static int restore_weight(int8_t weight)
  531. {
  532.     int result;
  533.  
  534.     if ((result = (int) weight << 3) > 0)
  535.         result += (result + 64) >> 7;
  536.  
  537.     return result;
  538. }
  539.  
  540. static int log2s(int32_t value)
  541. {
  542.     return (value < 0) ? -wp_log2(-value) : wp_log2(value);
  543. }
  544.  
  545. static void decorr_mono(int32_t *in_samples, int32_t *out_samples,
  546.                         int nb_samples, struct Decorr *dpp, int dir)
  547. {
  548.     int m = 0, i;
  549.  
  550.     dpp->sumA = 0;
  551.  
  552.     if (dir < 0) {
  553.         out_samples += (nb_samples - 1);
  554.         in_samples  += (nb_samples - 1);
  555.     }
  556.  
  557.     dpp->weightA = restore_weight(store_weight(dpp->weightA));
  558.  
  559.     for (i = 0; i < MAX_TERM; i++)
  560.         dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i]));
  561.  
  562.     if (dpp->value > MAX_TERM) {
  563.         while (nb_samples--) {
  564.             int32_t left, sam_A;
  565.  
  566.             sam_A = ((3 - (dpp->value & 1)) * dpp->samplesA[0] - dpp->samplesA[1]) >> !(dpp->value & 1);
  567.  
  568.             dpp->samplesA[1] = dpp->samplesA[0];
  569.             dpp->samplesA[0] = left = in_samples[0];
  570.  
  571.             left -= APPLY_WEIGHT(dpp->weightA, sam_A);
  572.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left);
  573.             dpp->sumA += dpp->weightA;
  574.             out_samples[0] = left;
  575.             in_samples += dir;
  576.             out_samples += dir;
  577.         }
  578.     } else if (dpp->value > 0) {
  579.         while (nb_samples--) {
  580.             int k = (m + dpp->value) & (MAX_TERM - 1);
  581.             int32_t left, sam_A;
  582.  
  583.             sam_A = dpp->samplesA[m];
  584.             dpp->samplesA[k] = left = in_samples[0];
  585.             m = (m + 1) & (MAX_TERM - 1);
  586.  
  587.             left -= APPLY_WEIGHT(dpp->weightA, sam_A);
  588.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left);
  589.             dpp->sumA += dpp->weightA;
  590.             out_samples[0] = left;
  591.             in_samples += dir;
  592.             out_samples += dir;
  593.         }
  594.     }
  595.  
  596.     if (m && dpp->value > 0 && dpp->value <= MAX_TERM) {
  597.         int32_t temp_A[MAX_TERM];
  598.  
  599.         memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
  600.  
  601.         for (i = 0; i < MAX_TERM; i++) {
  602.             dpp->samplesA[i] = temp_A[m];
  603.             m = (m + 1) & (MAX_TERM - 1);
  604.         }
  605.     }
  606. }
  607.  
  608. static void reverse_mono_decorr(struct Decorr *dpp)
  609. {
  610.     if (dpp->value > MAX_TERM) {
  611.         int32_t sam_A;
  612.  
  613.         if (dpp->value & 1)
  614.             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  615.         else
  616.             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
  617.  
  618.         dpp->samplesA[1] = dpp->samplesA[0];
  619.         dpp->samplesA[0] = sam_A;
  620.  
  621.         if (dpp->value & 1)
  622.             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  623.         else
  624.             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
  625.  
  626.         dpp->samplesA[1] = sam_A;
  627.     } else if (dpp->value > 1) {
  628.         int i, j, k;
  629.  
  630.         for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) {
  631.             i &= (MAX_TERM - 1);
  632.             j &= (MAX_TERM - 1);
  633.             dpp->samplesA[i] ^= dpp->samplesA[j];
  634.             dpp->samplesA[j] ^= dpp->samplesA[i];
  635.             dpp->samplesA[i] ^= dpp->samplesA[j];
  636.         }
  637.     }
  638. }
  639.  
  640. static uint32_t log2sample(uint32_t v, int limit, uint32_t *result)
  641. {
  642.     uint32_t dbits;
  643.  
  644.     if ((v += v >> 9) < (1 << 8)) {
  645.         dbits = nbits_table[v];
  646.         *result += (dbits << 8) + wp_log2_table[(v << (9 - dbits)) & 0xff];
  647.     } else {
  648.         if (v < (1 << 16))
  649.             dbits = nbits_table[v >> 8] + 8;
  650.         else if (v < (1 << 24))
  651.             dbits = nbits_table[v >> 16] + 16;
  652.         else
  653.             dbits = nbits_table[v >> 24] + 24;
  654.  
  655.         *result += dbits = (dbits << 8) + wp_log2_table[(v >> (dbits - 9)) & 0xff];
  656.  
  657.         if (limit && dbits >= limit)
  658.             return 1;
  659.     }
  660.  
  661.     return 0;
  662. }
  663.  
  664. static uint32_t log2mono(int32_t *samples, int nb_samples, int limit)
  665. {
  666.     uint32_t result = 0;
  667.     while (nb_samples--) {
  668.         if (log2sample(abs(*samples++), limit, &result))
  669.             return UINT32_MAX;
  670.     }
  671.     return result;
  672. }
  673.  
  674. static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r,
  675.                            int nb_samples, int limit)
  676. {
  677.     uint32_t result = 0;
  678.     while (nb_samples--) {
  679.         if (log2sample(abs(*samples_l++), limit, &result) ||
  680.             log2sample(abs(*samples_r++), limit, &result))
  681.             return UINT32_MAX;
  682.     }
  683.     return result;
  684. }
  685.  
  686. static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples,
  687.                                int nb_samples, struct Decorr *dpp,
  688.                                int tindex)
  689. {
  690.     struct Decorr dp, *dppi = dpp + tindex;
  691.     int delta = dppi->delta, pre_delta, term = dppi->value;
  692.  
  693.     if (delta == 7)
  694.         pre_delta = 7;
  695.     else if (delta < 2)
  696.         pre_delta = 3;
  697.     else
  698.         pre_delta = delta + 1;
  699.  
  700.     CLEAR(dp);
  701.     dp.value = term;
  702.     dp.delta = pre_delta;
  703.     decorr_mono(samples, outsamples, FFMIN(2048, nb_samples), &dp, -1);
  704.     dp.delta = delta;
  705.  
  706.     if (tindex == 0)
  707.         reverse_mono_decorr(&dp);
  708.     else
  709.         CLEAR(dp.samplesA);
  710.  
  711.     memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA));
  712.     dppi->weightA = dp.weightA;
  713.  
  714.     if (delta == 0) {
  715.         dp.delta = 1;
  716.         decorr_mono(samples, outsamples, nb_samples, &dp, 1);
  717.         dp.delta = 0;
  718.         memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA));
  719.         dppi->weightA = dp.weightA = dp.sumA / nb_samples;
  720.     }
  721.  
  722.     decorr_mono(samples, outsamples, nb_samples, &dp, 1);
  723. }
  724.  
  725. static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info,
  726.                          int depth, int delta, uint32_t input_bits)
  727. {
  728.     int term, branches = s->num_branches - depth;
  729.     int32_t *samples, *outsamples;
  730.     uint32_t term_bits[22], bits;
  731.  
  732.     if (branches < 1 || depth + 1 == info->nterms)
  733.         branches = 1;
  734.  
  735.     CLEAR(term_bits);
  736.     samples = s->sampleptrs[depth][0];
  737.     outsamples = s->sampleptrs[depth + 1][0];
  738.  
  739.     for (term = 1; term <= 18; term++) {
  740.         if (term == 17 && branches == 1 && depth + 1 < info->nterms)
  741.             continue;
  742.  
  743.         if (term > 8 && term < 17)
  744.             continue;
  745.  
  746.         if (!s->extra_flags && (term > 4 && term < 17))
  747.             continue;
  748.  
  749.         info->dps[depth].value = term;
  750.         info->dps[depth].delta = delta;
  751.         decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth);
  752.         bits = log2mono(outsamples, s->block_samples, info->log_limit);
  753.  
  754.         if (bits < info->best_bits) {
  755.             info->best_bits = bits;
  756.             CLEAR(s->decorr_passes);
  757.             memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1));
  758.             memcpy(s->sampleptrs[info->nterms + 1][0],
  759.                    s->sampleptrs[depth + 1][0], s->block_samples * 4);
  760.         }
  761.  
  762.         term_bits[term + 3] = bits;
  763.     }
  764.  
  765.     while (depth + 1 < info->nterms && branches--) {
  766.         uint32_t local_best_bits = input_bits;
  767.         int best_term = 0, i;
  768.  
  769.         for (i = 0; i < 22; i++)
  770.             if (term_bits[i] && term_bits[i] < local_best_bits) {
  771.                 local_best_bits = term_bits[i];
  772.                 best_term = i - 3;
  773.             }
  774.  
  775.         if (!best_term)
  776.             break;
  777.  
  778.         term_bits[best_term + 3] = 0;
  779.  
  780.         info->dps[depth].value = best_term;
  781.         info->dps[depth].delta = delta;
  782.         decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth);
  783.  
  784.         recurse_mono(s, info, depth + 1, delta, local_best_bits);
  785.     }
  786. }
  787.  
  788. static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
  789. {
  790.     int reversed = 1;
  791.     uint32_t bits;
  792.  
  793.     while (reversed) {
  794.         int ri, i;
  795.  
  796.         memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes));
  797.         reversed = 0;
  798.  
  799.         for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) {
  800.  
  801.             if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value)
  802.                 break;
  803.  
  804.             if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) {
  805.                 decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0],
  806.                                    s->block_samples, info->dps, ri);
  807.                 continue;
  808.             }
  809.  
  810.             info->dps[ri  ] = s->decorr_passes[ri+1];
  811.             info->dps[ri+1] = s->decorr_passes[ri  ];
  812.  
  813.             for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++)
  814.                 decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0],
  815.                                    s->block_samples, info->dps, i);
  816.  
  817.             bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit);
  818.             if (bits < info->best_bits) {
  819.                 reversed = 1;
  820.                 info->best_bits = bits;
  821.                 CLEAR(s->decorr_passes);
  822.                 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
  823.                 memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0],
  824.                        s->block_samples * 4);
  825.             } else {
  826.                 info->dps[ri  ] = s->decorr_passes[ri];
  827.                 info->dps[ri+1] = s->decorr_passes[ri+1];
  828.                 decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0],
  829.                                    s->block_samples, info->dps, ri);
  830.             }
  831.         }
  832.     }
  833. }
  834.  
  835. static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info)
  836. {
  837.     int lower = 0, delta, d;
  838.     uint32_t bits;
  839.  
  840.     if (!s->decorr_passes[0].value)
  841.         return;
  842.     delta = s->decorr_passes[0].delta;
  843.  
  844.     for (d = delta - 1; d >= 0; d--) {
  845.         int i;
  846.  
  847.         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
  848.             info->dps[i].value = s->decorr_passes[i].value;
  849.             info->dps[i].delta = d;
  850.             decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0],
  851.                                s->block_samples, info->dps, i);
  852.         }
  853.  
  854.         bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit);
  855.         if (bits >= info->best_bits)
  856.             break;
  857.  
  858.         lower = 1;
  859.         info->best_bits = bits;
  860.         CLEAR(s->decorr_passes);
  861.         memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
  862.         memcpy(s->sampleptrs[info->nterms + 1][0],  s->sampleptrs[i][0],
  863.                s->block_samples * 4);
  864.     }
  865.  
  866.     for (d = delta + 1; !lower && d <= 7; d++) {
  867.         int i;
  868.  
  869.         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
  870.             info->dps[i].value = s->decorr_passes[i].value;
  871.             info->dps[i].delta = d;
  872.             decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0],
  873.                                s->block_samples, info->dps, i);
  874.         }
  875.  
  876.         bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit);
  877.         if (bits >= info->best_bits)
  878.             break;
  879.  
  880.         info->best_bits = bits;
  881.         CLEAR(s->decorr_passes);
  882.         memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
  883.         memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0],
  884.                s->block_samples * 4);
  885.     }
  886. }
  887.  
  888. static int allocate_buffers2(WavPackEncodeContext *s, int nterms)
  889. {
  890.     int i;
  891.  
  892.     for (i = 0; i < nterms + 2; i++) {
  893.         av_fast_padded_malloc(&s->sampleptrs[i][0], &s->sampleptrs_size[i][0],
  894.                               s->block_samples * 4);
  895.         if (!s->sampleptrs[i][0])
  896.             return AVERROR(ENOMEM);
  897.         if (!(s->flags & WV_MONO_DATA)) {
  898.             av_fast_padded_malloc(&s->sampleptrs[i][1], &s->sampleptrs_size[i][1],
  899.                                   s->block_samples * 4);
  900.             if (!s->sampleptrs[i][1])
  901.                 return AVERROR(ENOMEM);
  902.         }
  903.     }
  904.  
  905.     return 0;
  906. }
  907.  
  908. static int allocate_buffers(WavPackEncodeContext *s)
  909. {
  910.     int i;
  911.  
  912.     for (i = 0; i < 2; i++) {
  913.         av_fast_padded_malloc(&s->best_buffer[0], &s->best_buffer_size[0],
  914.                               s->block_samples * 4);
  915.         if (!s->best_buffer[0])
  916.             return AVERROR(ENOMEM);
  917.  
  918.         av_fast_padded_malloc(&s->temp_buffer[i][0], &s->temp_buffer_size[i][0],
  919.                               s->block_samples * 4);
  920.         if (!s->temp_buffer[i][0])
  921.             return AVERROR(ENOMEM);
  922.         if (!(s->flags & WV_MONO_DATA)) {
  923.             av_fast_padded_malloc(&s->best_buffer[1], &s->best_buffer_size[1],
  924.                                   s->block_samples * 4);
  925.             if (!s->best_buffer[1])
  926.                 return AVERROR(ENOMEM);
  927.  
  928.             av_fast_padded_malloc(&s->temp_buffer[i][1], &s->temp_buffer_size[i][1],
  929.                                   s->block_samples * 4);
  930.             if (!s->temp_buffer[i][1])
  931.                 return AVERROR(ENOMEM);
  932.         }
  933.     }
  934.  
  935.     return 0;
  936. }
  937.  
  938. static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples)
  939. {
  940.     WavPackExtraInfo info;
  941.     int i;
  942.  
  943.     info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
  944.     info.log_limit = FFMIN(6912, info.log_limit);
  945.  
  946.     info.nterms = s->num_terms;
  947.  
  948.     if (allocate_buffers2(s, s->num_terms))
  949.         return;
  950.  
  951.     memcpy(info.dps, s->decorr_passes, sizeof(info.dps));
  952.     memcpy(s->sampleptrs[0][0], samples, s->block_samples * 4);
  953.  
  954.     for (i = 0; i < info.nterms && info.dps[i].value; i++)
  955.         decorr_mono(s->sampleptrs[i][0], s->sampleptrs[i + 1][0],
  956.                     s->block_samples, info.dps + i, 1);
  957.  
  958.     info.best_bits = log2mono(s->sampleptrs[info.nterms][0], s->block_samples, 0) * 1;
  959.     memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4);
  960.  
  961.     if (s->extra_flags & EXTRA_BRANCHES)
  962.         recurse_mono(s, &info, 0, (int) floor(s->delta_decay + 0.5),
  963.                      log2mono(s->sampleptrs[0][0], s->block_samples, 0));
  964.  
  965.     if (s->extra_flags & EXTRA_SORT_FIRST)
  966.         sort_mono(s, &info);
  967.  
  968.     if (s->extra_flags & EXTRA_TRY_DELTAS) {
  969.         delta_mono(s, &info);
  970.  
  971.         if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value)
  972.             s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0);
  973.         else
  974.             s->delta_decay = 2.0;
  975.     }
  976.  
  977.     if (s->extra_flags & EXTRA_SORT_LAST)
  978.         sort_mono(s, &info);
  979.  
  980.     if (do_samples)
  981.         memcpy(samples, s->sampleptrs[info.nterms + 1][0], s->block_samples * 4);
  982.  
  983.     for (i = 0; i < info.nterms; i++)
  984.         if (!s->decorr_passes[i].value)
  985.             break;
  986.  
  987.     s->num_terms = i;
  988. }
  989.  
  990. static void scan_word(WavPackEncodeContext *s, WvChannel *c,
  991.                       int32_t *samples, int nb_samples, int dir)
  992. {
  993.     if (dir < 0)
  994.         samples += nb_samples - 1;
  995.  
  996.     while (nb_samples--) {
  997.         uint32_t low, value = labs(samples[0]);
  998.  
  999.         if (value < GET_MED(0)) {
  1000.             DEC_MED(0);
  1001.         } else {
  1002.             low = GET_MED(0);
  1003.             INC_MED(0);
  1004.  
  1005.             if (value - low < GET_MED(1)) {
  1006.                 DEC_MED(1);
  1007.             } else {
  1008.                 low += GET_MED(1);
  1009.                 INC_MED(1);
  1010.  
  1011.                 if (value - low < GET_MED(2)) {
  1012.                     DEC_MED(2);
  1013.                 } else {
  1014.                     INC_MED(2);
  1015.                 }
  1016.             }
  1017.         }
  1018.         samples += dir;
  1019.     }
  1020. }
  1021.  
  1022. static int wv_mono(WavPackEncodeContext *s, int32_t *samples,
  1023.                    int no_history, int do_samples)
  1024. {
  1025.     struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}};
  1026.     int nb_samples = s->block_samples;
  1027.     int buf_size = sizeof(int32_t) * nb_samples;
  1028.     uint32_t best_size = UINT32_MAX, size;
  1029.     int log_limit, pi, i, ret;
  1030.  
  1031.     for (i = 0; i < nb_samples; i++)
  1032.         if (samples[i])
  1033.             break;
  1034.  
  1035.     if (i == nb_samples) {
  1036.         CLEAR(s->decorr_passes);
  1037.         CLEAR(s->w);
  1038.         s->num_terms = 0;
  1039.         return 0;
  1040.     }
  1041.  
  1042.     log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
  1043.     log_limit = FFMIN(6912, log_limit);
  1044.  
  1045.     if ((ret = allocate_buffers(s)) < 0)
  1046.         return ret;
  1047.  
  1048.     if (no_history || s->num_passes >= 7)
  1049.         s->best_decorr = s->mask_decorr = 0;
  1050.  
  1051.     for (pi = 0; pi < s->num_passes;) {
  1052.         const WavPackDecorrSpec *wpds;
  1053.         int nterms, c, j;
  1054.  
  1055.         if (!pi) {
  1056.             c = s->best_decorr;
  1057.         } else {
  1058.             if (s->mask_decorr == 0)
  1059.                 c = 0;
  1060.             else
  1061.                 c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr;
  1062.  
  1063.             if (c == s->best_decorr) {
  1064.                 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
  1065.                 continue;
  1066.             }
  1067.         }
  1068.  
  1069.         wpds = &s->decorr_specs[c];
  1070.         nterms = decorr_filter_nterms[s->decorr_filter];
  1071.  
  1072.         while (1) {
  1073.         memcpy(s->temp_buffer[0][0], samples, buf_size);
  1074.         CLEAR(save_decorr_passes);
  1075.  
  1076.         for (j = 0; j < nterms; j++) {
  1077.             CLEAR(temp_decorr_pass);
  1078.             temp_decorr_pass.delta = wpds->delta;
  1079.             temp_decorr_pass.value = wpds->terms[j];
  1080.  
  1081.             if (temp_decorr_pass.value < 0)
  1082.                 temp_decorr_pass.value = 1;
  1083.  
  1084.             decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0],
  1085.                         FFMIN(nb_samples, 2048), &temp_decorr_pass, -1);
  1086.  
  1087.             if (j) {
  1088.                 CLEAR(temp_decorr_pass.samplesA);
  1089.             } else {
  1090.                 reverse_mono_decorr(&temp_decorr_pass);
  1091.             }
  1092.  
  1093.             memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr));
  1094.             decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0],
  1095.                         nb_samples, &temp_decorr_pass, 1);
  1096.         }
  1097.  
  1098.         size = log2mono(s->temp_buffer[j&1][0], nb_samples, log_limit);
  1099.         if (size != UINT32_MAX || !nterms)
  1100.             break;
  1101.         nterms >>= 1;
  1102.         }
  1103.  
  1104.         if (size < best_size) {
  1105.             memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size);
  1106.             memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS);
  1107.             s->num_terms = nterms;
  1108.             s->best_decorr = c;
  1109.             best_size = size;
  1110.         }
  1111.  
  1112.         if (pi++)
  1113.             s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
  1114.     }
  1115.  
  1116.     if (s->extra_flags)
  1117.         analyze_mono(s, samples, do_samples);
  1118.     else if (do_samples)
  1119.         memcpy(samples, s->best_buffer[0], buf_size);
  1120.  
  1121.     if (no_history || s->extra_flags) {
  1122.         CLEAR(s->w);
  1123.         scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1);
  1124.     }
  1125.     return 0;
  1126. }
  1127.  
  1128. static void decorr_stereo(int32_t *in_left, int32_t *in_right,
  1129.                           int32_t *out_left, int32_t *out_right,
  1130.                           int nb_samples, struct Decorr *dpp, int dir)
  1131. {
  1132.     int m = 0, i;
  1133.  
  1134.     dpp->sumA = dpp->sumB = 0;
  1135.  
  1136.     if (dir < 0) {
  1137.         out_left  += nb_samples - 1;
  1138.         out_right += nb_samples - 1;
  1139.         in_left   += nb_samples - 1;
  1140.         in_right  += nb_samples - 1;
  1141.     }
  1142.  
  1143.     dpp->weightA = restore_weight(store_weight(dpp->weightA));
  1144.     dpp->weightB = restore_weight(store_weight(dpp->weightB));
  1145.  
  1146.     for (i = 0; i < MAX_TERM; i++) {
  1147.         dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i]));
  1148.         dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i]));
  1149.     }
  1150.  
  1151.     switch (dpp->value) {
  1152.     case 2:
  1153.         while (nb_samples--) {
  1154.             int32_t sam, tmp;
  1155.  
  1156.             sam = dpp->samplesA[0];
  1157.             dpp->samplesA[0] = dpp->samplesA[1];
  1158.             out_left[0] = tmp = (dpp->samplesA[1] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
  1159.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1160.             dpp->sumA += dpp->weightA;
  1161.  
  1162.             sam = dpp->samplesB[0];
  1163.             dpp->samplesB[0] = dpp->samplesB[1];
  1164.             out_right[0] = tmp = (dpp->samplesB[1] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam);
  1165.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1166.             dpp->sumB += dpp->weightB;
  1167.  
  1168.             in_left   += dir;
  1169.             out_left  += dir;
  1170.             in_right  += dir;
  1171.             out_right += dir;
  1172.         }
  1173.         break;
  1174.     case 17:
  1175.         while (nb_samples--) {
  1176.             int32_t sam, tmp;
  1177.  
  1178.             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  1179.             dpp->samplesA[1] = dpp->samplesA[0];
  1180.             out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
  1181.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1182.             dpp->sumA += dpp->weightA;
  1183.  
  1184.             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
  1185.             dpp->samplesB[1] = dpp->samplesB[0];
  1186.             out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT (dpp->weightB, sam);
  1187.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1188.             dpp->sumB += dpp->weightB;
  1189.  
  1190.             in_left   += dir;
  1191.             out_left  += dir;
  1192.             in_right  += dir;
  1193.             out_right += dir;
  1194.         }
  1195.         break;
  1196.     case 18:
  1197.         while (nb_samples--) {
  1198.             int32_t sam, tmp;
  1199.  
  1200.             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
  1201.             dpp->samplesA[1] = dpp->samplesA[0];
  1202.             out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
  1203.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1204.             dpp->sumA += dpp->weightA;
  1205.  
  1206.             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
  1207.             dpp->samplesB[1] = dpp->samplesB[0];
  1208.             out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam);
  1209.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1210.             dpp->sumB += dpp->weightB;
  1211.  
  1212.             in_left   += dir;
  1213.             out_left  += dir;
  1214.             in_right  += dir;
  1215.             out_right += dir;
  1216.         }
  1217.         break;
  1218.     default: {
  1219.         int k = dpp->value & (MAX_TERM - 1);
  1220.  
  1221.         while (nb_samples--) {
  1222.             int32_t sam, tmp;
  1223.  
  1224.             sam = dpp->samplesA[m];
  1225.             out_left[0] = tmp = (dpp->samplesA[k] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam);
  1226.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1227.             dpp->sumA += dpp->weightA;
  1228.  
  1229.             sam = dpp->samplesB[m];
  1230.             out_right[0] = tmp = (dpp->samplesB[k] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam);
  1231.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1232.             dpp->sumB += dpp->weightB;
  1233.  
  1234.             in_left   += dir;
  1235.             out_left  += dir;
  1236.             in_right  += dir;
  1237.             out_right += dir;
  1238.             m = (m + 1) & (MAX_TERM - 1);
  1239.             k = (k + 1) & (MAX_TERM - 1);
  1240.         }
  1241.  
  1242.         if (m) {
  1243.             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
  1244.             int k;
  1245.  
  1246.             memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
  1247.             memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
  1248.  
  1249.             for (k = 0; k < MAX_TERM; k++) {
  1250.                 dpp->samplesA[k] = temp_A[m];
  1251.                 dpp->samplesB[k] = temp_B[m];
  1252.                 m = (m + 1) & (MAX_TERM - 1);
  1253.             }
  1254.         }
  1255.         break;
  1256.         }
  1257.     case -1:
  1258.         while (nb_samples--) {
  1259.             int32_t sam_A, sam_B, tmp;
  1260.  
  1261.             sam_A = dpp->samplesA[0];
  1262.             out_left[0] = tmp = (sam_B = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A);
  1263.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  1264.             dpp->sumA += dpp->weightA;
  1265.  
  1266.             out_right[0] = tmp = (dpp->samplesA[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B);
  1267.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  1268.             dpp->sumB += dpp->weightB;
  1269.  
  1270.             in_left   += dir;
  1271.             out_left  += dir;
  1272.             in_right  += dir;
  1273.             out_right += dir;
  1274.         }
  1275.         break;
  1276.     case -2:
  1277.         while (nb_samples--) {
  1278.             int32_t sam_A, sam_B, tmp;
  1279.  
  1280.             sam_B = dpp->samplesB[0];
  1281.             out_right[0] = tmp = (sam_A = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B);
  1282.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  1283.             dpp->sumB += dpp->weightB;
  1284.  
  1285.             out_left[0] = tmp = (dpp->samplesB[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A);
  1286.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  1287.             dpp->sumA += dpp->weightA;
  1288.  
  1289.             in_left   += dir;
  1290.             out_left  += dir;
  1291.             in_right  += dir;
  1292.             out_right += dir;
  1293.         }
  1294.         break;
  1295.     case -3:
  1296.         while (nb_samples--) {
  1297.             int32_t sam_A, sam_B, tmp;
  1298.  
  1299.             sam_A = dpp->samplesA[0];
  1300.             sam_B = dpp->samplesB[0];
  1301.  
  1302.             dpp->samplesA[0] = tmp = in_right[0];
  1303.             out_right[0] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B);
  1304.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  1305.             dpp->sumB += dpp->weightB;
  1306.  
  1307.             dpp->samplesB[0] = tmp = in_left[0];
  1308.             out_left[0] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A);
  1309.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  1310.             dpp->sumA += dpp->weightA;
  1311.  
  1312.             in_left   += dir;
  1313.             out_left  += dir;
  1314.             in_right  += dir;
  1315.             out_right += dir;
  1316.         }
  1317.         break;
  1318.     }
  1319. }
  1320.  
  1321. static void reverse_decorr(struct Decorr *dpp)
  1322. {
  1323.     if (dpp->value > MAX_TERM) {
  1324.         int32_t sam_A, sam_B;
  1325.  
  1326.         if (dpp->value & 1) {
  1327.             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  1328.             sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1];
  1329.         } else {
  1330.             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
  1331.             sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1;
  1332.         }
  1333.  
  1334.         dpp->samplesA[1] = dpp->samplesA[0];
  1335.         dpp->samplesB[1] = dpp->samplesB[0];
  1336.         dpp->samplesA[0] = sam_A;
  1337.         dpp->samplesB[0] = sam_B;
  1338.  
  1339.         if (dpp->value & 1) {
  1340.             sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  1341.             sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1];
  1342.         } else {
  1343.             sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
  1344.             sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1;
  1345.         }
  1346.  
  1347.         dpp->samplesA[1] = sam_A;
  1348.         dpp->samplesB[1] = sam_B;
  1349.     } else if (dpp->value > 1) {
  1350.         int i, j, k;
  1351.  
  1352.         for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) {
  1353.             i &= (MAX_TERM - 1);
  1354.             j &= (MAX_TERM - 1);
  1355.             dpp->samplesA[i] ^= dpp->samplesA[j];
  1356.             dpp->samplesA[j] ^= dpp->samplesA[i];
  1357.             dpp->samplesA[i] ^= dpp->samplesA[j];
  1358.             dpp->samplesB[i] ^= dpp->samplesB[j];
  1359.             dpp->samplesB[j] ^= dpp->samplesB[i];
  1360.             dpp->samplesB[i] ^= dpp->samplesB[j];
  1361.         }
  1362.     }
  1363. }
  1364.  
  1365. static void decorr_stereo_quick(int32_t *in_left,  int32_t *in_right,
  1366.                                 int32_t *out_left, int32_t *out_right,
  1367.                                 int nb_samples, struct Decorr *dpp)
  1368. {
  1369.     int m = 0, i;
  1370.  
  1371.     dpp->weightA = restore_weight(store_weight(dpp->weightA));
  1372.     dpp->weightB = restore_weight(store_weight(dpp->weightB));
  1373.  
  1374.     for (i = 0; i < MAX_TERM; i++) {
  1375.         dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i]));
  1376.         dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i]));
  1377.     }
  1378.  
  1379.     switch (dpp->value) {
  1380.     case 2:
  1381.         for (i = 0; i < nb_samples; i++) {
  1382.             int32_t sam, tmp;
  1383.  
  1384.             sam = dpp->samplesA[0];
  1385.             dpp->samplesA[0] = dpp->samplesA[1];
  1386.             out_left[i] = tmp = (dpp->samplesA[1] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
  1387.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1388.  
  1389.             sam = dpp->samplesB[0];
  1390.             dpp->samplesB[0] = dpp->samplesB[1];
  1391.             out_right[i] = tmp = (dpp->samplesB[1] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
  1392.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1393.         }
  1394.         break;
  1395.     case 17:
  1396.         for (i = 0; i < nb_samples; i++) {
  1397.             int32_t sam, tmp;
  1398.  
  1399.             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  1400.             dpp->samplesA[1] = dpp->samplesA[0];
  1401.             out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
  1402.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1403.  
  1404.             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
  1405.             dpp->samplesB[1] = dpp->samplesB[0];
  1406.             out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
  1407.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1408.         }
  1409.         break;
  1410.     case 18:
  1411.         for (i = 0; i < nb_samples; i++) {
  1412.             int32_t sam, tmp;
  1413.  
  1414.             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
  1415.             dpp->samplesA[1] = dpp->samplesA[0];
  1416.             out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
  1417.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1418.  
  1419.             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
  1420.             dpp->samplesB[1] = dpp->samplesB[0];
  1421.             out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
  1422.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1423.         }
  1424.         break;
  1425.     default: {
  1426.         int k = dpp->value & (MAX_TERM - 1);
  1427.  
  1428.         for (i = 0; i < nb_samples; i++) {
  1429.             int32_t sam, tmp;
  1430.  
  1431.             sam = dpp->samplesA[m];
  1432.             out_left[i] = tmp = (dpp->samplesA[k] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
  1433.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  1434.  
  1435.             sam = dpp->samplesB[m];
  1436.             out_right[i] = tmp = (dpp->samplesB[k] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
  1437.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  1438.  
  1439.             m = (m + 1) & (MAX_TERM - 1);
  1440.             k = (k + 1) & (MAX_TERM - 1);
  1441.         }
  1442.  
  1443.         if (m) {
  1444.             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
  1445.             int k;
  1446.  
  1447.             memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
  1448.             memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
  1449.  
  1450.             for (k = 0; k < MAX_TERM; k++) {
  1451.                 dpp->samplesA[k] = temp_A[m];
  1452.                 dpp->samplesB[k] = temp_B[m];
  1453.                 m = (m + 1) & (MAX_TERM - 1);
  1454.             }
  1455.         }
  1456.         break;
  1457.     }
  1458.     case -1:
  1459.         for (i = 0; i < nb_samples; i++) {
  1460.             int32_t sam_A, sam_B, tmp;
  1461.  
  1462.             sam_A = dpp->samplesA[0];
  1463.             out_left[i] = tmp = (sam_B = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
  1464.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  1465.  
  1466.             out_right[i] = tmp = (dpp->samplesA[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
  1467.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  1468.         }
  1469.         break;
  1470.     case -2:
  1471.         for (i = 0; i < nb_samples; i++) {
  1472.             int32_t sam_A, sam_B, tmp;
  1473.  
  1474.             sam_B = dpp->samplesB[0];
  1475.             out_right[i] = tmp = (sam_A = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
  1476.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  1477.  
  1478.             out_left[i] = tmp = (dpp->samplesB[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
  1479.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  1480.         }
  1481.         break;
  1482.     case -3:
  1483.         for (i = 0; i < nb_samples; i++) {
  1484.             int32_t sam_A, sam_B, tmp;
  1485.  
  1486.             sam_A = dpp->samplesA[0];
  1487.             sam_B = dpp->samplesB[0];
  1488.  
  1489.             dpp->samplesA[0] = tmp = in_right[i];
  1490.             out_right[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B);
  1491.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  1492.  
  1493.             dpp->samplesB[0] = tmp = in_left[i];
  1494.             out_left[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A);
  1495.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  1496.         }
  1497.         break;
  1498.     }
  1499. }
  1500.  
  1501. static void decorr_stereo_buffer(WavPackExtraInfo *info,
  1502.                                  int32_t *in_left,  int32_t *in_right,
  1503.                                  int32_t *out_left, int32_t *out_right,
  1504.                                  int nb_samples, int tindex)
  1505. {
  1506.     struct Decorr dp = {0}, *dppi = info->dps + tindex;
  1507.     int delta = dppi->delta, pre_delta;
  1508.     int term = dppi->value;
  1509.  
  1510.     if (delta == 7)
  1511.         pre_delta = 7;
  1512.     else if (delta < 2)
  1513.         pre_delta = 3;
  1514.     else
  1515.         pre_delta = delta + 1;
  1516.  
  1517.     dp.value = term;
  1518.     dp.delta = pre_delta;
  1519.     decorr_stereo(in_left, in_right, out_left, out_right,
  1520.                   FFMIN(2048, nb_samples), &dp, -1);
  1521.     dp.delta = delta;
  1522.  
  1523.     if (tindex == 0) {
  1524.         reverse_decorr(&dp);
  1525.     } else {
  1526.         CLEAR(dp.samplesA);
  1527.         CLEAR(dp.samplesB);
  1528.     }
  1529.  
  1530.     memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA));
  1531.     memcpy(dppi->samplesB, dp.samplesB, sizeof(dp.samplesB));
  1532.     dppi->weightA = dp.weightA;
  1533.     dppi->weightB = dp.weightB;
  1534.  
  1535.     if (delta == 0) {
  1536.         dp.delta = 1;
  1537.         decorr_stereo(in_left, in_right, out_left, out_right, nb_samples, &dp, 1);
  1538.         dp.delta = 0;
  1539.         memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA));
  1540.         memcpy(dp.samplesB, dppi->samplesB, sizeof(dp.samplesB));
  1541.         dppi->weightA = dp.weightA = dp.sumA / nb_samples;
  1542.         dppi->weightB = dp.weightB = dp.sumB / nb_samples;
  1543.     }
  1544.  
  1545.     if (info->gt16bit)
  1546.         decorr_stereo(in_left, in_right, out_left, out_right,
  1547.                            nb_samples, &dp, 1);
  1548.     else
  1549.         decorr_stereo_quick(in_left, in_right, out_left, out_right,
  1550.                             nb_samples, &dp);
  1551. }
  1552.  
  1553. static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
  1554. {
  1555.     int reversed = 1;
  1556.     uint32_t bits;
  1557.  
  1558.     while (reversed) {
  1559.         int ri, i;
  1560.  
  1561.         memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes));
  1562.         reversed = 0;
  1563.  
  1564.         for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) {
  1565.  
  1566.             if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value)
  1567.                 break;
  1568.  
  1569.             if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) {
  1570.                 decorr_stereo_buffer(info,
  1571.                                      s->sampleptrs[ri  ][0], s->sampleptrs[ri  ][1],
  1572.                                      s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1],
  1573.                                      s->block_samples, ri);
  1574.                 continue;
  1575.             }
  1576.  
  1577.             info->dps[ri  ] = s->decorr_passes[ri+1];
  1578.             info->dps[ri+1] = s->decorr_passes[ri  ];
  1579.  
  1580.             for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++)
  1581.                 decorr_stereo_buffer(info,
  1582.                                      s->sampleptrs[i  ][0], s->sampleptrs[i  ][1],
  1583.                                      s->sampleptrs[i+1][0], s->sampleptrs[i+1][1],
  1584.                                      s->block_samples, i);
  1585.  
  1586.             bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1],
  1587.                               s->block_samples, info->log_limit);
  1588.  
  1589.             if (bits < info->best_bits) {
  1590.                 reversed = 1;
  1591.                 info->best_bits = bits;
  1592.                 CLEAR(s->decorr_passes);
  1593.                 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
  1594.                 memcpy(s->sampleptrs[info->nterms + 1][0],
  1595.                        s->sampleptrs[i][0], s->block_samples * 4);
  1596.                 memcpy(s->sampleptrs[info->nterms + 1][1],
  1597.                        s->sampleptrs[i][1], s->block_samples * 4);
  1598.             } else {
  1599.                 info->dps[ri  ] = s->decorr_passes[ri  ];
  1600.                 info->dps[ri+1] = s->decorr_passes[ri+1];
  1601.                 decorr_stereo_buffer(info,
  1602.                                      s->sampleptrs[ri  ][0], s->sampleptrs[ri  ][1],
  1603.                                      s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1],
  1604.                                      s->block_samples, ri);
  1605.             }
  1606.         }
  1607.     }
  1608. }
  1609.  
  1610. static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info)
  1611. {
  1612.     int lower = 0, delta, d, i;
  1613.     uint32_t bits;
  1614.  
  1615.     if (!s->decorr_passes[0].value)
  1616.         return;
  1617.     delta = s->decorr_passes[0].delta;
  1618.  
  1619.     for (d = delta - 1; d >= 0; d--) {
  1620.         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
  1621.             info->dps[i].value = s->decorr_passes[i].value;
  1622.             info->dps[i].delta = d;
  1623.             decorr_stereo_buffer(info,
  1624.                                  s->sampleptrs[i  ][0], s->sampleptrs[i  ][1],
  1625.                                  s->sampleptrs[i+1][0], s->sampleptrs[i+1][1],
  1626.                                  s->block_samples, i);
  1627.         }
  1628.  
  1629.         bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1],
  1630.                           s->block_samples, info->log_limit);
  1631.         if (bits >= info->best_bits)
  1632.             break;
  1633.         lower = 1;
  1634.         info->best_bits = bits;
  1635.         CLEAR(s->decorr_passes);
  1636.         memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
  1637.         memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0],
  1638.                s->block_samples * 4);
  1639.         memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[i][1],
  1640.                s->block_samples * 4);
  1641.     }
  1642.  
  1643.     for (d = delta + 1; !lower && d <= 7; d++) {
  1644.         for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) {
  1645.             info->dps[i].value = s->decorr_passes[i].value;
  1646.             info->dps[i].delta = d;
  1647.             decorr_stereo_buffer(info,
  1648.                                  s->sampleptrs[i  ][0], s->sampleptrs[i  ][1],
  1649.                                  s->sampleptrs[i+1][0], s->sampleptrs[i+1][1],
  1650.                                  s->block_samples, i);
  1651.         }
  1652.  
  1653.         bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1],
  1654.                           s->block_samples, info->log_limit);
  1655.  
  1656.         if (bits < info->best_bits) {
  1657.             info->best_bits = bits;
  1658.             CLEAR(s->decorr_passes);
  1659.             memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i);
  1660.             memcpy(s->sampleptrs[info->nterms + 1][0],
  1661.                    s->sampleptrs[i][0], s->block_samples * 4);
  1662.             memcpy(s->sampleptrs[info->nterms + 1][1],
  1663.                    s->sampleptrs[i][1], s->block_samples * 4);
  1664.         }
  1665.         else
  1666.             break;
  1667.     }
  1668. }
  1669.  
  1670. static void recurse_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info,
  1671.                            int depth, int delta, uint32_t input_bits)
  1672. {
  1673.     int term, branches = s->num_branches - depth;
  1674.     int32_t *in_left, *in_right, *out_left, *out_right;
  1675.     uint32_t term_bits[22], bits;
  1676.  
  1677.     if (branches < 1 || depth + 1 == info->nterms)
  1678.         branches = 1;
  1679.  
  1680.     CLEAR(term_bits);
  1681.     in_left   = s->sampleptrs[depth    ][0];
  1682.     in_right  = s->sampleptrs[depth    ][1];
  1683.     out_left  = s->sampleptrs[depth + 1][0];
  1684.     out_right = s->sampleptrs[depth + 1][1];
  1685.  
  1686.     for (term = -3; term <= 18; term++) {
  1687.         if (!term || (term > 8 && term < 17))
  1688.             continue;
  1689.  
  1690.         if (term == 17 && branches == 1 && depth + 1 < info->nterms)
  1691.             continue;
  1692.  
  1693.         if (term == -1 || term == -2)
  1694.             if (!(s->flags & WV_CROSS_DECORR))
  1695.                 continue;
  1696.  
  1697.         if (!s->extra_flags && (term > 4 && term < 17))
  1698.             continue;
  1699.  
  1700.         info->dps[depth].value = term;
  1701.         info->dps[depth].delta = delta;
  1702.         decorr_stereo_buffer(info, in_left, in_right, out_left, out_right,
  1703.                              s->block_samples, depth);
  1704.         bits = log2stereo(out_left, out_right, s->block_samples, info->log_limit);
  1705.  
  1706.         if (bits < info->best_bits) {
  1707.             info->best_bits = bits;
  1708.             CLEAR(s->decorr_passes);
  1709.             memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1));
  1710.             memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[depth + 1][0],
  1711.                    s->block_samples * 4);
  1712.             memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[depth + 1][1],
  1713.                    s->block_samples * 4);
  1714.         }
  1715.  
  1716.         term_bits[term + 3] = bits;
  1717.     }
  1718.  
  1719.     while (depth + 1 < info->nterms && branches--) {
  1720.         uint32_t local_best_bits = input_bits;
  1721.         int best_term = 0, i;
  1722.  
  1723.         for (i = 0; i < 22; i++)
  1724.             if (term_bits[i] && term_bits[i] < local_best_bits) {
  1725.                 local_best_bits = term_bits[i];
  1726.                 best_term = i - 3;
  1727.             }
  1728.  
  1729.         if (!best_term)
  1730.             break;
  1731.  
  1732.         term_bits[best_term + 3] = 0;
  1733.  
  1734.         info->dps[depth].value = best_term;
  1735.         info->dps[depth].delta = delta;
  1736.         decorr_stereo_buffer(info, in_left, in_right, out_left, out_right,
  1737.                              s->block_samples, depth);
  1738.  
  1739.         recurse_stereo(s, info, depth + 1, delta, local_best_bits);
  1740.     }
  1741. }
  1742.  
  1743. static void analyze_stereo(WavPackEncodeContext *s,
  1744.                            int32_t *in_left, int32_t *in_right,
  1745.                            int do_samples)
  1746. {
  1747.     WavPackExtraInfo info;
  1748.     int i;
  1749.  
  1750.     info.gt16bit = ((s->flags & MAG_MASK) >> MAG_LSB) >= 16;
  1751.  
  1752.     info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
  1753.     info.log_limit = FFMIN(6912, info.log_limit);
  1754.  
  1755.     info.nterms = s->num_terms;
  1756.  
  1757.     if (allocate_buffers2(s, s->num_terms))
  1758.         return;
  1759.  
  1760.     memcpy(info.dps, s->decorr_passes, sizeof(info.dps));
  1761.     memcpy(s->sampleptrs[0][0], in_left,  s->block_samples * 4);
  1762.     memcpy(s->sampleptrs[0][1], in_right, s->block_samples * 4);
  1763.  
  1764.     for (i = 0; i < info.nterms && info.dps[i].value; i++)
  1765.         if (info.gt16bit)
  1766.             decorr_stereo(s->sampleptrs[i    ][0], s->sampleptrs[i    ][1],
  1767.                           s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1],
  1768.                           s->block_samples, info.dps + i, 1);
  1769.         else
  1770.             decorr_stereo_quick(s->sampleptrs[i    ][0], s->sampleptrs[i    ][1],
  1771.                                 s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1],
  1772.                                 s->block_samples, info.dps + i);
  1773.  
  1774.     info.best_bits = log2stereo(s->sampleptrs[info.nterms][0], s->sampleptrs[info.nterms][1],
  1775.                                 s->block_samples, 0);
  1776.  
  1777.     memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4);
  1778.     memcpy(s->sampleptrs[info.nterms + 1][1], s->sampleptrs[i][1], s->block_samples * 4);
  1779.  
  1780.     if (s->extra_flags & EXTRA_BRANCHES)
  1781.         recurse_stereo(s, &info, 0, (int) floor(s->delta_decay + 0.5),
  1782.                        log2stereo(s->sampleptrs[0][0], s->sampleptrs[0][1],
  1783.                                   s->block_samples, 0));
  1784.  
  1785.     if (s->extra_flags & EXTRA_SORT_FIRST)
  1786.         sort_stereo(s, &info);
  1787.  
  1788.     if (s->extra_flags & EXTRA_TRY_DELTAS) {
  1789.         delta_stereo(s, &info);
  1790.  
  1791.         if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value)
  1792.             s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0);
  1793.         else
  1794.             s->delta_decay = 2.0;
  1795.     }
  1796.  
  1797.     if (s->extra_flags & EXTRA_SORT_LAST)
  1798.         sort_stereo(s, &info);
  1799.  
  1800.     if (do_samples) {
  1801.         memcpy(in_left,  s->sampleptrs[info.nterms + 1][0], s->block_samples * 4);
  1802.         memcpy(in_right, s->sampleptrs[info.nterms + 1][1], s->block_samples * 4);
  1803.     }
  1804.  
  1805.     for (i = 0; i < info.nterms; i++)
  1806.         if (!s->decorr_passes[i].value)
  1807.             break;
  1808.  
  1809.     s->num_terms = i;
  1810. }
  1811.  
  1812. static int wv_stereo(WavPackEncodeContext *s,
  1813.                      int32_t *samples_l, int32_t *samples_r,
  1814.                      int no_history, int do_samples)
  1815. {
  1816.     struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}};
  1817.     int nb_samples = s->block_samples, ret;
  1818.     int buf_size = sizeof(int32_t) * nb_samples;
  1819.     int log_limit, force_js = 0, force_ts = 0, got_js = 0, pi, i;
  1820.     uint32_t best_size = UINT32_MAX, size;
  1821.  
  1822.     for (i = 0; i < nb_samples; i++)
  1823.         if (samples_l[i] || samples_r[i])
  1824.             break;
  1825.  
  1826.     if (i == nb_samples) {
  1827.         s->flags &= ~((uint32_t) WV_JOINT_STEREO);
  1828.         CLEAR(s->decorr_passes);
  1829.         CLEAR(s->w);
  1830.         s->num_terms = 0;
  1831.         return 0;
  1832.     }
  1833.  
  1834.     log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256;
  1835.     log_limit = FFMIN(6912, log_limit);
  1836.  
  1837.     if (s->joint) {
  1838.         force_js = s->joint > 0;
  1839.         force_ts = s->joint < 0;
  1840.     }
  1841.  
  1842.     if ((ret = allocate_buffers(s)) < 0)
  1843.         return ret;
  1844.  
  1845.     if (no_history || s->num_passes >= 7)
  1846.         s->best_decorr = s->mask_decorr = 0;
  1847.  
  1848.     for (pi = 0; pi < s->num_passes;) {
  1849.         const WavPackDecorrSpec *wpds;
  1850.         int nterms, c, j;
  1851.  
  1852.         if (!pi)
  1853.             c = s->best_decorr;
  1854.         else {
  1855.             if (s->mask_decorr == 0)
  1856.                 c = 0;
  1857.             else
  1858.                 c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr;
  1859.  
  1860.             if (c == s->best_decorr) {
  1861.                 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
  1862.                 continue;
  1863.             }
  1864.         }
  1865.  
  1866.         wpds = &s->decorr_specs[c];
  1867.         nterms = decorr_filter_nterms[s->decorr_filter];
  1868.  
  1869.         while (1) {
  1870.             if (force_js || (wpds->joint_stereo && !force_ts)) {
  1871.                 if (!got_js) {
  1872.                     av_fast_padded_malloc(&s->js_left,  &s->js_left_size,  buf_size);
  1873.                     av_fast_padded_malloc(&s->js_right, &s->js_right_size, buf_size);
  1874.                     memcpy(s->js_left,  samples_l, buf_size);
  1875.                     memcpy(s->js_right, samples_r, buf_size);
  1876.  
  1877.                     for (i = 0; i < nb_samples; i++)
  1878.                         s->js_right[i] += ((s->js_left[i] -= s->js_right[i]) >> 1);
  1879.                     got_js = 1;
  1880.                 }
  1881.  
  1882.                 memcpy(s->temp_buffer[0][0], s->js_left,  buf_size);
  1883.                 memcpy(s->temp_buffer[0][1], s->js_right, buf_size);
  1884.             } else {
  1885.                 memcpy(s->temp_buffer[0][0], samples_l, buf_size);
  1886.                 memcpy(s->temp_buffer[0][1], samples_r, buf_size);
  1887.             }
  1888.  
  1889.             CLEAR(save_decorr_passes);
  1890.  
  1891.             for (j = 0; j < nterms; j++) {
  1892.                 CLEAR(temp_decorr_pass);
  1893.                 temp_decorr_pass.delta = wpds->delta;
  1894.                 temp_decorr_pass.value = wpds->terms[j];
  1895.  
  1896.                 if (temp_decorr_pass.value < 0 && !(s->flags & WV_CROSS_DECORR))
  1897.                     temp_decorr_pass.value = -3;
  1898.  
  1899.                 decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1],
  1900.                               s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1],
  1901.                               FFMIN(2048, nb_samples), &temp_decorr_pass, -1);
  1902.  
  1903.                 if (j) {
  1904.                     CLEAR(temp_decorr_pass.samplesA);
  1905.                     CLEAR(temp_decorr_pass.samplesB);
  1906.                 } else {
  1907.                     reverse_decorr(&temp_decorr_pass);
  1908.                 }
  1909.  
  1910.                 memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr));
  1911.  
  1912.                 if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16)
  1913.                     decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1],
  1914.                                   s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1],
  1915.                                   nb_samples, &temp_decorr_pass, 1);
  1916.                 else
  1917.                     decorr_stereo_quick(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1],
  1918.                                         s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1],
  1919.                                         nb_samples, &temp_decorr_pass);
  1920.             }
  1921.  
  1922.             size = log2stereo(s->temp_buffer[j&1][0], s->temp_buffer[j&1][1],
  1923.                               nb_samples, log_limit);
  1924.             if (size != UINT32_MAX || !nterms)
  1925.                 break;
  1926.             nterms >>= 1;
  1927.         }
  1928.  
  1929.         if (size < best_size) {
  1930.             memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size);
  1931.             memcpy(s->best_buffer[1], s->temp_buffer[j&1][1], buf_size);
  1932.             memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS);
  1933.             s->num_terms = nterms;
  1934.             s->best_decorr = c;
  1935.             best_size = size;
  1936.         }
  1937.  
  1938.         if (pi++)
  1939.             s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1;
  1940.     }
  1941.  
  1942.     if (force_js || (s->decorr_specs[s->best_decorr].joint_stereo && !force_ts))
  1943.         s->flags |= WV_JOINT_STEREO;
  1944.     else
  1945.         s->flags &= ~((uint32_t) WV_JOINT_STEREO);
  1946.  
  1947.     if (s->extra_flags) {
  1948.         if (s->flags & WV_JOINT_STEREO) {
  1949.             analyze_stereo(s, s->js_left, s->js_right, do_samples);
  1950.  
  1951.             if (do_samples) {
  1952.                 memcpy(samples_l, s->js_left,  buf_size);
  1953.                 memcpy(samples_r, s->js_right, buf_size);
  1954.             }
  1955.         } else
  1956.             analyze_stereo(s, samples_l, samples_r, do_samples);
  1957.     } else if (do_samples) {
  1958.         memcpy(samples_l, s->best_buffer[0], buf_size);
  1959.         memcpy(samples_r, s->best_buffer[1], buf_size);
  1960.     }
  1961.  
  1962.     if (s->extra_flags || no_history ||
  1963.         s->joint_stereo != s->decorr_specs[s->best_decorr].joint_stereo) {
  1964.         s->joint_stereo = s->decorr_specs[s->best_decorr].joint_stereo;
  1965.         CLEAR(s->w);
  1966.         scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1);
  1967.         scan_word(s, &s->w.c[1], s->best_buffer[1], nb_samples, -1);
  1968.     }
  1969.     return 0;
  1970. }
  1971.  
  1972. #define count_bits(av) ( \
  1973.  (av) < (1 << 8) ? nbits_table[av] : \
  1974.   ( \
  1975.    (av) < (1 << 16) ? nbits_table[(av) >> 8] + 8 : \
  1976.    ((av) < (1 << 24) ? nbits_table[(av) >> 16] + 16 : nbits_table[(av) >> 24] + 24) \
  1977.   ) \
  1978. )
  1979.  
  1980. static void encode_flush(WavPackEncodeContext *s)
  1981. {
  1982.     WavPackWords *w = &s->w;
  1983.     PutBitContext *pb = &s->pb;
  1984.  
  1985.     if (w->zeros_acc) {
  1986.         int cbits = count_bits(w->zeros_acc);
  1987.  
  1988.         do {
  1989.             if (cbits > 31) {
  1990.                 put_bits(pb, 31, 0x7FFFFFFF);
  1991.                 cbits -= 31;
  1992.             } else {
  1993.                 put_bits(pb, cbits, (1 << cbits) - 1);
  1994.                 cbits = 0;
  1995.             }
  1996.         } while (cbits);
  1997.  
  1998.         put_bits(pb, 1, 0);
  1999.  
  2000.         while (w->zeros_acc > 1) {
  2001.             put_bits(pb, 1, w->zeros_acc & 1);
  2002.             w->zeros_acc >>= 1;
  2003.         }
  2004.  
  2005.         w->zeros_acc = 0;
  2006.     }
  2007.  
  2008.     if (w->holding_one) {
  2009.         if (w->holding_one >= 16) {
  2010.             int cbits;
  2011.  
  2012.             put_bits(pb, 16, (1 << 16) - 1);
  2013.             put_bits(pb, 1, 0);
  2014.             w->holding_one -= 16;
  2015.             cbits = count_bits(w->holding_one);
  2016.  
  2017.             do {
  2018.                 if (cbits > 31) {
  2019.                     put_bits(pb, 31, 0x7FFFFFFF);
  2020.                     cbits -= 31;
  2021.                 } else {
  2022.                     put_bits(pb, cbits, (1 << cbits) - 1);
  2023.                     cbits = 0;
  2024.                 }
  2025.             } while (cbits);
  2026.  
  2027.             put_bits(pb, 1, 0);
  2028.  
  2029.             while (w->holding_one > 1) {
  2030.                 put_bits(pb, 1, w->holding_one & 1);
  2031.                 w->holding_one >>= 1;
  2032.             }
  2033.  
  2034.             w->holding_zero = 0;
  2035.         } else {
  2036.             put_bits(pb, w->holding_one, (1 << w->holding_one) - 1);
  2037.         }
  2038.  
  2039.         w->holding_one = 0;
  2040.     }
  2041.  
  2042.     if (w->holding_zero) {
  2043.         put_bits(pb, 1, 0);
  2044.         w->holding_zero = 0;
  2045.     }
  2046.  
  2047.     if (w->pend_count) {
  2048.         put_bits(pb, w->pend_count, w->pend_data);
  2049.         w->pend_data = w->pend_count = 0;
  2050.     }
  2051. }
  2052.  
  2053. static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample)
  2054. {
  2055.     WavPackWords *w = &s->w;
  2056.     uint32_t ones_count, low, high;
  2057.     int sign = sample < 0;
  2058.  
  2059.     if (s->w.c[0].median[0] < 2 && !s->w.holding_zero && s->w.c[1].median[0] < 2) {
  2060.         if (w->zeros_acc) {
  2061.             if (sample)
  2062.                 encode_flush(s);
  2063.             else {
  2064.                 w->zeros_acc++;
  2065.                 return;
  2066.             }
  2067.         } else if (sample) {
  2068.             put_bits(&s->pb, 1, 0);
  2069.         } else {
  2070.             CLEAR(s->w.c[0].median);
  2071.             CLEAR(s->w.c[1].median);
  2072.             w->zeros_acc = 1;
  2073.             return;
  2074.         }
  2075.     }
  2076.  
  2077.     if (sign)
  2078.         sample = ~sample;
  2079.  
  2080.     if (sample < (int32_t) GET_MED(0)) {
  2081.         ones_count = low = 0;
  2082.         high = GET_MED(0) - 1;
  2083.         DEC_MED(0);
  2084.     } else {
  2085.         low = GET_MED(0);
  2086.         INC_MED(0);
  2087.  
  2088.         if (sample - low < GET_MED(1)) {
  2089.             ones_count = 1;
  2090.             high = low + GET_MED(1) - 1;
  2091.             DEC_MED(1);
  2092.         } else {
  2093.             low += GET_MED(1);
  2094.             INC_MED(1);
  2095.  
  2096.             if (sample - low < GET_MED(2)) {
  2097.                 ones_count = 2;
  2098.                 high = low + GET_MED(2) - 1;
  2099.                 DEC_MED(2);
  2100.             } else {
  2101.                 ones_count = 2 + (sample - low) / GET_MED(2);
  2102.                 low += (ones_count - 2) * GET_MED(2);
  2103.                 high = low + GET_MED(2) - 1;
  2104.                 INC_MED(2);
  2105.             }
  2106.         }
  2107.     }
  2108.  
  2109.     if (w->holding_zero) {
  2110.         if (ones_count)
  2111.             w->holding_one++;
  2112.  
  2113.         encode_flush(s);
  2114.  
  2115.         if (ones_count) {
  2116.             w->holding_zero = 1;
  2117.             ones_count--;
  2118.         } else
  2119.             w->holding_zero = 0;
  2120.     } else
  2121.         w->holding_zero = 1;
  2122.  
  2123.     w->holding_one = ones_count * 2;
  2124.  
  2125.     if (high != low) {
  2126.         uint32_t maxcode = high - low, code = sample - low;
  2127.         int bitcount = count_bits(maxcode);
  2128.         uint32_t extras = (1 << bitcount) - maxcode - 1;
  2129.  
  2130.         if (code < extras) {
  2131.             w->pend_data |= code << w->pend_count;
  2132.             w->pend_count += bitcount - 1;
  2133.         } else {
  2134.             w->pend_data |= ((code + extras) >> 1) << w->pend_count;
  2135.             w->pend_count += bitcount - 1;
  2136.             w->pend_data |= ((code + extras) & 1) << w->pend_count++;
  2137.         }
  2138.     }
  2139.  
  2140.     w->pend_data |= ((int32_t) sign << w->pend_count++);
  2141.  
  2142.     if (!w->holding_zero)
  2143.         encode_flush(s);
  2144. }
  2145.  
  2146. static void pack_int32(WavPackEncodeContext *s,
  2147.                        int32_t *samples_l, int32_t *samples_r,
  2148.                        int nb_samples)
  2149. {
  2150.     const int sent_bits = s->int32_sent_bits;
  2151.     PutBitContext *pb = &s->pb;
  2152.     int i, pre_shift;
  2153.  
  2154.     pre_shift = s->int32_zeros + s->int32_ones + s->int32_dups;
  2155.  
  2156.     if (!sent_bits)
  2157.         return;
  2158.  
  2159.     if (s->flags & WV_MONO_DATA) {
  2160.         for (i = 0; i < nb_samples; i++) {
  2161.             put_sbits(pb, sent_bits, samples_l[i] >> pre_shift);
  2162.         }
  2163.     } else {
  2164.         for (i = 0; i < nb_samples; i++) {
  2165.             put_sbits(pb, sent_bits, samples_l[i] >> pre_shift);
  2166.             put_sbits(pb, sent_bits, samples_r[i] >> pre_shift);
  2167.         }
  2168.     }
  2169. }
  2170.  
  2171. static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample)
  2172. {
  2173.     const int max_exp = s->float_max_exp;
  2174.     PutBitContext *pb = &s->pb;
  2175.     int32_t value, shift_count;
  2176.  
  2177.     if (get_exponent(*sample) == 255) {
  2178.         if (get_mantissa(*sample)) {
  2179.             put_bits(pb, 1, 1);
  2180.             put_bits(pb, 23, get_mantissa(*sample));
  2181.         } else {
  2182.             put_bits(pb, 1, 0);
  2183.         }
  2184.  
  2185.         value = 0x1000000;
  2186.         shift_count = 0;
  2187.     } else if (get_exponent(*sample)) {
  2188.         shift_count = max_exp - get_exponent(*sample);
  2189.         value = 0x800000 + get_mantissa(*sample);
  2190.     } else {
  2191.         shift_count = max_exp ? max_exp - 1 : 0;
  2192.         value = get_mantissa(*sample);
  2193.     }
  2194.  
  2195.     if (shift_count < 25)
  2196.         value >>= shift_count;
  2197.     else
  2198.         value = 0;
  2199.  
  2200.     if (!value) {
  2201.         if (s->float_flags & FLOAT_ZEROS_SENT) {
  2202.             if (get_exponent(*sample) || get_mantissa(*sample)) {
  2203.                 put_bits(pb, 1, 1);
  2204.                 put_bits(pb, 23, get_mantissa(*sample));
  2205.  
  2206.                 if (max_exp >= 25)
  2207.                     put_bits(pb, 8, get_exponent(*sample));
  2208.  
  2209.                 put_bits(pb, 1, get_sign(*sample));
  2210.             } else {
  2211.                 put_bits(pb, 1, 0);
  2212.  
  2213.                 if (s->float_flags & FLOAT_NEG_ZEROS)
  2214.                     put_bits(pb, 1, get_sign(*sample));
  2215.             }
  2216.         }
  2217.     } else if (shift_count) {
  2218.         if (s->float_flags & FLOAT_SHIFT_SENT) {
  2219.             int32_t data = get_mantissa(*sample) & ((1 << shift_count) - 1);
  2220.             put_bits(pb, shift_count, data);
  2221.         } else if (s->float_flags & FLOAT_SHIFT_SAME) {
  2222.             put_bits(pb, 1, get_mantissa(*sample) & 1);
  2223.         }
  2224.     }
  2225. }
  2226.  
  2227. static void pack_float(WavPackEncodeContext *s,
  2228.                        int32_t *samples_l, int32_t *samples_r,
  2229.                        int nb_samples)
  2230. {
  2231.     int i;
  2232.  
  2233.     if (s->flags & WV_MONO_DATA) {
  2234.         for (i = 0; i < nb_samples; i++)
  2235.             pack_float_sample(s, &samples_l[i]);
  2236.     } else {
  2237.         for (i = 0; i < nb_samples; i++) {
  2238.             pack_float_sample(s, &samples_l[i]);
  2239.             pack_float_sample(s, &samples_r[i]);
  2240.         }
  2241.     }
  2242. }
  2243.  
  2244. static void decorr_stereo_pass2(struct Decorr *dpp,
  2245.                                 int32_t *samples_l, int32_t *samples_r,
  2246.                                 int nb_samples)
  2247. {
  2248.     int i, m, k;
  2249.  
  2250.     switch (dpp->value) {
  2251.     case 17:
  2252.         for (i = 0; i < nb_samples; i++) {
  2253.             int32_t sam, tmp;
  2254.  
  2255.             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  2256.             dpp->samplesA[1] = dpp->samplesA[0];
  2257.             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam);
  2258.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  2259.  
  2260.             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
  2261.             dpp->samplesB[1] = dpp->samplesB[0];
  2262.             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam);
  2263.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  2264.         }
  2265.         break;
  2266.     case 18:
  2267.         for (i = 0; i < nb_samples; i++) {
  2268.             int32_t sam, tmp;
  2269.  
  2270.             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
  2271.             dpp->samplesA[1] = dpp->samplesA[0];
  2272.             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam);
  2273.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  2274.  
  2275.             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
  2276.             dpp->samplesB[1] = dpp->samplesB[0];
  2277.             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam);
  2278.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  2279.         }
  2280.         break;
  2281.     default:
  2282.         for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) {
  2283.             int32_t sam, tmp;
  2284.  
  2285.             sam = dpp->samplesA[m];
  2286.             samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam);
  2287.             UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp);
  2288.  
  2289.             sam = dpp->samplesB[m];
  2290.             samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam);
  2291.             UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp);
  2292.  
  2293.             m = (m + 1) & (MAX_TERM - 1);
  2294.             k = (k + 1) & (MAX_TERM - 1);
  2295.         }
  2296.         if (m) {
  2297.             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
  2298.  
  2299.             memcpy(temp_A, dpp->samplesA, sizeof (dpp->samplesA));
  2300.             memcpy(temp_B, dpp->samplesB, sizeof (dpp->samplesB));
  2301.  
  2302.             for (k = 0; k < MAX_TERM; k++) {
  2303.                 dpp->samplesA[k] = temp_A[m];
  2304.                 dpp->samplesB[k] = temp_B[m];
  2305.                 m = (m + 1) & (MAX_TERM - 1);
  2306.             }
  2307.         }
  2308.         break;
  2309.     case -1:
  2310.         for (i = 0; i < nb_samples; i++) {
  2311.             int32_t sam_A, sam_B, tmp;
  2312.  
  2313.             sam_A = dpp->samplesA[0];
  2314.             samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A);
  2315.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  2316.  
  2317.             samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B);
  2318.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  2319.         }
  2320.         break;
  2321.     case -2:
  2322.         for (i = 0; i < nb_samples; i++) {
  2323.             int32_t sam_A, sam_B, tmp;
  2324.  
  2325.             sam_B = dpp->samplesB[0];
  2326.             samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B);
  2327.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  2328.  
  2329.             samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A);
  2330.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  2331.         }
  2332.         break;
  2333.     case -3:
  2334.         for (i = 0; i < nb_samples; i++) {
  2335.             int32_t sam_A, sam_B, tmp;
  2336.  
  2337.             sam_A = dpp->samplesA[0];
  2338.             sam_B = dpp->samplesB[0];
  2339.  
  2340.             dpp->samplesA[0] = tmp = samples_r[i];
  2341.             samples_r[i] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B);
  2342.             UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp);
  2343.  
  2344.             dpp->samplesB[0] = tmp = samples_l[i];
  2345.             samples_l[i] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A);
  2346.             UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp);
  2347.         }
  2348.         break;
  2349.     }
  2350. }
  2351.  
  2352. #define update_weight_d2(weight, delta, source, result) \
  2353.     if (source && result) \
  2354.         weight -= (((source ^ result) >> 29) & 4) - 2;
  2355.  
  2356. #define update_weight_clip_d2(weight, delta, source, result) \
  2357.     if (source && result) { \
  2358.         const int32_t s = (source ^ result) >> 31; \
  2359.         if ((weight = (weight ^ s) + (2 - s)) > 1024) weight = 1024; \
  2360.         weight = (weight ^ s) - s; \
  2361.     }
  2362.  
  2363. static void decorr_stereo_pass_id2(struct Decorr *dpp,
  2364.                                    int32_t *samples_l, int32_t *samples_r,
  2365.                                    int nb_samples)
  2366. {
  2367.     int i, m, k;
  2368.  
  2369.     switch (dpp->value) {
  2370.     case 17:
  2371.         for (i = 0; i < nb_samples; i++) {
  2372.             int32_t sam, tmp;
  2373.  
  2374.             sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  2375.             dpp->samplesA[1] = dpp->samplesA[0];
  2376.             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
  2377.             update_weight_d2(dpp->weightA, dpp->delta, sam, tmp);
  2378.  
  2379.             sam = 2 * dpp->samplesB[0] - dpp->samplesB[1];
  2380.             dpp->samplesB[1] = dpp->samplesB[0];
  2381.             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
  2382.             update_weight_d2(dpp->weightB, dpp->delta, sam, tmp);
  2383.         }
  2384.         break;
  2385.     case 18:
  2386.         for (i = 0; i < nb_samples; i++) {
  2387.             int32_t sam, tmp;
  2388.  
  2389.             sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1);
  2390.             dpp->samplesA[1] = dpp->samplesA[0];
  2391.             samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
  2392.             update_weight_d2(dpp->weightA, dpp->delta, sam, tmp);
  2393.  
  2394.             sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1);
  2395.             dpp->samplesB[1] = dpp->samplesB[0];
  2396.             samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
  2397.             update_weight_d2(dpp->weightB, dpp->delta, sam, tmp);
  2398.         }
  2399.         break;
  2400.     default:
  2401.         for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) {
  2402.             int32_t sam, tmp;
  2403.  
  2404.             sam = dpp->samplesA[m];
  2405.             samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam);
  2406.             update_weight_d2(dpp->weightA, dpp->delta, sam, tmp);
  2407.  
  2408.             sam = dpp->samplesB[m];
  2409.             samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam);
  2410.             update_weight_d2(dpp->weightB, dpp->delta, sam, tmp);
  2411.  
  2412.             m = (m + 1) & (MAX_TERM - 1);
  2413.             k = (k + 1) & (MAX_TERM - 1);
  2414.         }
  2415.  
  2416.         if (m) {
  2417.             int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
  2418.  
  2419.             memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
  2420.             memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
  2421.  
  2422.             for (k = 0; k < MAX_TERM; k++) {
  2423.                 dpp->samplesA[k] = temp_A[m];
  2424.                 dpp->samplesB[k] = temp_B[m];
  2425.                 m = (m + 1) & (MAX_TERM - 1);
  2426.             }
  2427.         }
  2428.         break;
  2429.     case -1:
  2430.         for (i = 0; i < nb_samples; i++) {
  2431.             int32_t sam_A, sam_B, tmp;
  2432.  
  2433.             sam_A = dpp->samplesA[0];
  2434.             samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
  2435.             update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp);
  2436.  
  2437.             samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
  2438.             update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp);
  2439.         }
  2440.         break;
  2441.     case -2:
  2442.         for (i = 0; i < nb_samples; i++) {
  2443.             int32_t sam_A, sam_B, tmp;
  2444.  
  2445.             sam_B = dpp->samplesB[0];
  2446.             samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B);
  2447.             update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp);
  2448.  
  2449.             samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A);
  2450.             update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp);
  2451.         }
  2452.         break;
  2453.     case -3:
  2454.         for (i = 0; i < nb_samples; i++) {
  2455.             int32_t sam_A, sam_B, tmp;
  2456.  
  2457.             sam_A = dpp->samplesA[0];
  2458.             sam_B = dpp->samplesB[0];
  2459.  
  2460.             dpp->samplesA[0] = tmp = samples_r[i];
  2461.             samples_r[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B);
  2462.             update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp);
  2463.  
  2464.             dpp->samplesB[0] = tmp = samples_l[i];
  2465.             samples_l[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A);
  2466.             update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp);
  2467.         }
  2468.         break;
  2469.     }
  2470. }
  2471.  
  2472. static void put_metadata_block(PutByteContext *pb, int flags, int size)
  2473. {
  2474.     if (size & 1)
  2475.         flags |= WP_IDF_ODD;
  2476.  
  2477.     bytestream2_put_byte(pb, flags);
  2478.     bytestream2_put_byte(pb, (size + 1) >> 1);
  2479. }
  2480.  
  2481. static int wavpack_encode_block(WavPackEncodeContext *s,
  2482.                                 int32_t *samples_l, int32_t *samples_r,
  2483.                                 uint8_t *out, int out_size)
  2484. {
  2485.     int block_size, start, end, data_size, tcount, temp, m = 0;
  2486.     int i, j, ret = 0, got_extra = 0, nb_samples = s->block_samples;
  2487.     uint32_t crc = 0xffffffffu;
  2488.     struct Decorr *dpp;
  2489.     PutByteContext pb;
  2490.  
  2491.     if (s->flags & WV_MONO_DATA) {
  2492.         CLEAR(s->w);
  2493.     }
  2494.     if (!(s->flags & WV_MONO) && s->optimize_mono) {
  2495.         int32_t lor = 0, diff = 0;
  2496.  
  2497.         for (i = 0; i < nb_samples; i++) {
  2498.             lor  |= samples_l[i] | samples_r[i];
  2499.             diff |= samples_l[i] - samples_r[i];
  2500.  
  2501.             if (lor && diff)
  2502.                 break;
  2503.         }
  2504.  
  2505.         if (i == nb_samples && lor && !diff) {
  2506.             s->flags &= ~(WV_JOINT_STEREO | WV_CROSS_DECORR);
  2507.             s->flags |= WV_FALSE_STEREO;
  2508.  
  2509.             if (!s->false_stereo) {
  2510.                 s->false_stereo = 1;
  2511.                 s->num_terms = 0;
  2512.                 CLEAR(s->w);
  2513.             }
  2514.         } else if (s->false_stereo) {
  2515.             s->false_stereo = 0;
  2516.             s->num_terms = 0;
  2517.             CLEAR(s->w);
  2518.         }
  2519.     }
  2520.  
  2521.     if (s->flags & SHIFT_MASK) {
  2522.         int shift = (s->flags & SHIFT_MASK) >> SHIFT_LSB;
  2523.         int mag = (s->flags & MAG_MASK) >> MAG_LSB;
  2524.  
  2525.         if (s->flags & WV_MONO_DATA)
  2526.             shift_mono(samples_l, nb_samples, shift);
  2527.         else
  2528.             shift_stereo(samples_l, samples_r, nb_samples, shift);
  2529.  
  2530.         if ((mag -= shift) < 0)
  2531.             s->flags &= ~MAG_MASK;
  2532.         else
  2533.             s->flags -= (1 << MAG_LSB) * shift;
  2534.     }
  2535.  
  2536.     if ((s->flags & WV_FLOAT_DATA) || (s->flags & MAG_MASK) >> MAG_LSB >= 24) {
  2537.         av_fast_padded_malloc(&s->orig_l, &s->orig_l_size, sizeof(int32_t) * nb_samples);
  2538.         memcpy(s->orig_l, samples_l, sizeof(int32_t) * nb_samples);
  2539.         if (!(s->flags & WV_MONO_DATA)) {
  2540.             av_fast_padded_malloc(&s->orig_r, &s->orig_r_size, sizeof(int32_t) * nb_samples);
  2541.             memcpy(s->orig_r, samples_r, sizeof(int32_t) * nb_samples);
  2542.         }
  2543.  
  2544.         if (s->flags & WV_FLOAT_DATA)
  2545.             got_extra = scan_float(s, samples_l, samples_r, nb_samples);
  2546.         else
  2547.             got_extra = scan_int32(s, samples_l, samples_r, nb_samples);
  2548.         s->num_terms = 0;
  2549.     } else {
  2550.         scan_int23(s, samples_l, samples_r, nb_samples);
  2551.         if (s->shift != s->int32_zeros + s->int32_ones + s->int32_dups) {
  2552.             s->shift = s->int32_zeros + s->int32_ones + s->int32_dups;
  2553.             s->num_terms = 0;
  2554.         }
  2555.     }
  2556.  
  2557.     if (!s->num_passes && !s->num_terms) {
  2558.         s->num_passes = 1;
  2559.  
  2560.         if (s->flags & WV_MONO_DATA)
  2561.             ret = wv_mono(s, samples_l, 1, 0);
  2562.         else
  2563.             ret = wv_stereo(s, samples_l, samples_r, 1, 0);
  2564.  
  2565.         s->num_passes = 0;
  2566.     }
  2567.     if (s->flags & WV_MONO_DATA) {
  2568.         for (i = 0; i < nb_samples; i++)
  2569.             crc += (crc << 1) + samples_l[i];
  2570.  
  2571.         if (s->num_passes)
  2572.             ret = wv_mono(s, samples_l, !s->num_terms, 1);
  2573.     } else {
  2574.         for (i = 0; i < nb_samples; i++)
  2575.             crc += (crc << 3) + (samples_l[i] << 1) + samples_l[i] + samples_r[i];
  2576.  
  2577.         if (s->num_passes)
  2578.             ret = wv_stereo(s, samples_l, samples_r, !s->num_terms, 1);
  2579.     }
  2580.     if (ret < 0)
  2581.         return ret;
  2582.  
  2583.     if (!s->ch_offset)
  2584.         s->flags |= WV_INITIAL_BLOCK;
  2585.  
  2586.     s->ch_offset += 1 + !(s->flags & WV_MONO);
  2587.  
  2588.     if (s->ch_offset == s->avctx->channels)
  2589.         s->flags |= WV_FINAL_BLOCK;
  2590.  
  2591.     bytestream2_init_writer(&pb, out, out_size);
  2592.     bytestream2_put_le32(&pb, MKTAG('w', 'v', 'p', 'k'));
  2593.     bytestream2_put_le32(&pb, 0);
  2594.     bytestream2_put_le16(&pb, 0x410);
  2595.     bytestream2_put_le16(&pb, 0);
  2596.     bytestream2_put_le32(&pb, 0);
  2597.     bytestream2_put_le32(&pb, s->sample_index);
  2598.     bytestream2_put_le32(&pb, nb_samples);
  2599.     bytestream2_put_le32(&pb, s->flags);
  2600.     bytestream2_put_le32(&pb, crc);
  2601.  
  2602.     if (s->flags & WV_INITIAL_BLOCK &&
  2603.         s->avctx->channel_layout != AV_CH_LAYOUT_MONO &&
  2604.         s->avctx->channel_layout != AV_CH_LAYOUT_STEREO) {
  2605.         put_metadata_block(&pb, WP_ID_CHANINFO, 5);
  2606.         bytestream2_put_byte(&pb, s->avctx->channels);
  2607.         bytestream2_put_le32(&pb, s->avctx->channel_layout);
  2608.         bytestream2_put_byte(&pb, 0);
  2609.     }
  2610.  
  2611.     if ((s->flags & SRATE_MASK) == SRATE_MASK) {
  2612.         put_metadata_block(&pb, WP_ID_SAMPLE_RATE, 3);
  2613.         bytestream2_put_le24(&pb, s->avctx->sample_rate);
  2614.         bytestream2_put_byte(&pb, 0);
  2615.     }
  2616.  
  2617.     put_metadata_block(&pb, WP_ID_DECTERMS, s->num_terms);
  2618.     for (i = 0; i < s->num_terms; i++) {
  2619.         struct Decorr *dpp = &s->decorr_passes[i];
  2620.         bytestream2_put_byte(&pb, ((dpp->value + 5) & 0x1f) | ((dpp->delta << 5) & 0xe0));
  2621.     }
  2622.     if (s->num_terms & 1)
  2623.         bytestream2_put_byte(&pb, 0);
  2624.  
  2625. #define WRITE_DECWEIGHT(type) do {            \
  2626.         temp = store_weight(type);    \
  2627.         bytestream2_put_byte(&pb, temp);      \
  2628.         type = restore_weight(temp);  \
  2629.     } while (0)
  2630.  
  2631.     bytestream2_put_byte(&pb, WP_ID_DECWEIGHTS);
  2632.     bytestream2_put_byte(&pb, 0);
  2633.     start = bytestream2_tell_p(&pb);
  2634.     for (i = s->num_terms - 1; i >= 0; --i) {
  2635.         struct Decorr *dpp = &s->decorr_passes[i];
  2636.  
  2637.         if (store_weight(dpp->weightA) ||
  2638.             (!(s->flags & WV_MONO_DATA) && store_weight(dpp->weightB)))
  2639.                 break;
  2640.     }
  2641.     tcount = i + 1;
  2642.     for (i = 0; i < s->num_terms; i++) {
  2643.         struct Decorr *dpp = &s->decorr_passes[i];
  2644.         if (i < tcount) {
  2645.             WRITE_DECWEIGHT(dpp->weightA);
  2646.             if (!(s->flags & WV_MONO_DATA))
  2647.                 WRITE_DECWEIGHT(dpp->weightB);
  2648.         } else {
  2649.             dpp->weightA = dpp->weightB = 0;
  2650.         }
  2651.     }
  2652.     end = bytestream2_tell_p(&pb);
  2653.     out[start - 2] = WP_ID_DECWEIGHTS | (((end - start) & 1) ? WP_IDF_ODD: 0);
  2654.     out[start - 1] = (end - start + 1) >> 1;
  2655.     if ((end - start) & 1)
  2656.         bytestream2_put_byte(&pb, 0);
  2657.  
  2658. #define WRITE_DECSAMPLE(type) do {        \
  2659.         temp = log2s(type);               \
  2660.         type = wp_exp2(temp);             \
  2661.         bytestream2_put_le16(&pb, temp);  \
  2662.     } while (0)
  2663.  
  2664.     bytestream2_put_byte(&pb, WP_ID_DECSAMPLES);
  2665.     bytestream2_put_byte(&pb, 0);
  2666.     start = bytestream2_tell_p(&pb);
  2667.     for (i = 0; i < s->num_terms; i++) {
  2668.         struct Decorr *dpp = &s->decorr_passes[i];
  2669.         if (i == 0) {
  2670.             if (dpp->value > MAX_TERM) {
  2671.                 WRITE_DECSAMPLE(dpp->samplesA[0]);
  2672.                 WRITE_DECSAMPLE(dpp->samplesA[1]);
  2673.                 if (!(s->flags & WV_MONO_DATA)) {
  2674.                     WRITE_DECSAMPLE(dpp->samplesB[0]);
  2675.                     WRITE_DECSAMPLE(dpp->samplesB[1]);
  2676.                 }
  2677.             } else if (dpp->value < 0) {
  2678.                 WRITE_DECSAMPLE(dpp->samplesA[0]);
  2679.                 WRITE_DECSAMPLE(dpp->samplesB[0]);
  2680.             } else {
  2681.                 for (j = 0; j < dpp->value; j++) {
  2682.                     WRITE_DECSAMPLE(dpp->samplesA[j]);
  2683.                     if (!(s->flags & WV_MONO_DATA))
  2684.                         WRITE_DECSAMPLE(dpp->samplesB[j]);
  2685.                 }
  2686.             }
  2687.         } else {
  2688.             CLEAR(dpp->samplesA);
  2689.             CLEAR(dpp->samplesB);
  2690.         }
  2691.     }
  2692.     end = bytestream2_tell_p(&pb);
  2693.     out[start - 1] = (end - start) >> 1;
  2694.  
  2695. #define WRITE_CHAN_ENTROPY(chan) do {               \
  2696.         for (i = 0; i < 3; i++) {                   \
  2697.             temp = wp_log2(s->w.c[chan].median[i]); \
  2698.             bytestream2_put_le16(&pb, temp);        \
  2699.             s->w.c[chan].median[i] = wp_exp2(temp); \
  2700.         }                                           \
  2701.     } while (0)
  2702.  
  2703.     put_metadata_block(&pb, WP_ID_ENTROPY, 6 * (1 + (!(s->flags & WV_MONO_DATA))));
  2704.     WRITE_CHAN_ENTROPY(0);
  2705.     if (!(s->flags & WV_MONO_DATA))
  2706.         WRITE_CHAN_ENTROPY(1);
  2707.  
  2708.     if (s->flags & WV_FLOAT_DATA) {
  2709.         put_metadata_block(&pb, WP_ID_FLOATINFO, 4);
  2710.         bytestream2_put_byte(&pb, s->float_flags);
  2711.         bytestream2_put_byte(&pb, s->float_shift);
  2712.         bytestream2_put_byte(&pb, s->float_max_exp);
  2713.         bytestream2_put_byte(&pb, 127);
  2714.     }
  2715.  
  2716.     if (s->flags & WV_INT32_DATA) {
  2717.         put_metadata_block(&pb, WP_ID_INT32INFO, 4);
  2718.         bytestream2_put_byte(&pb, s->int32_sent_bits);
  2719.         bytestream2_put_byte(&pb, s->int32_zeros);
  2720.         bytestream2_put_byte(&pb, s->int32_ones);
  2721.         bytestream2_put_byte(&pb, s->int32_dups);
  2722.     }
  2723.  
  2724.     if (s->flags & WV_MONO_DATA && !s->num_passes) {
  2725.         for (i = 0; i < nb_samples; i++) {
  2726.             int32_t code = samples_l[i];
  2727.  
  2728.             for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++) {
  2729.                 int32_t sam;
  2730.  
  2731.                 if (dpp->value > MAX_TERM) {
  2732.                     if (dpp->value & 1)
  2733.                         sam = 2 * dpp->samplesA[0] - dpp->samplesA[1];
  2734.                     else
  2735.                         sam = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1;
  2736.  
  2737.                     dpp->samplesA[1] = dpp->samplesA[0];
  2738.                     dpp->samplesA[0] = code;
  2739.                 } else {
  2740.                     sam = dpp->samplesA[m];
  2741.                     dpp->samplesA[(m + dpp->value) & (MAX_TERM - 1)] = code;
  2742.                 }
  2743.  
  2744.                 code -= APPLY_WEIGHT(dpp->weightA, sam);
  2745.                 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, code);
  2746.             }
  2747.  
  2748.             m = (m + 1) & (MAX_TERM - 1);
  2749.             samples_l[i] = code;
  2750.         }
  2751.         if (m) {
  2752.             for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++)
  2753.                 if (dpp->value > 0 && dpp->value <= MAX_TERM) {
  2754.                 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];
  2755.                 int k;
  2756.  
  2757.                 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA));
  2758.                 memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB));
  2759.  
  2760.                 for (k = 0; k < MAX_TERM; k++) {
  2761.                     dpp->samplesA[k] = temp_A[m];
  2762.                     dpp->samplesB[k] = temp_B[m];
  2763.                     m = (m + 1) & (MAX_TERM - 1);
  2764.                 }
  2765.             }
  2766.         }
  2767.     } else if (!s->num_passes) {
  2768.         if (s->flags & WV_JOINT_STEREO) {
  2769.             for (i = 0; i < nb_samples; i++)
  2770.                 samples_r[i] += ((samples_l[i] -= samples_r[i]) >> 1);
  2771.         }
  2772.  
  2773.         for (i = 0; i < s->num_terms; i++) {
  2774.             struct Decorr *dpp = &s->decorr_passes[i];
  2775.             if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16 || dpp->delta != 2)
  2776.                 decorr_stereo_pass2(dpp, samples_l, samples_r, nb_samples);
  2777.             else
  2778.                 decorr_stereo_pass_id2(dpp, samples_l, samples_r, nb_samples);
  2779.         }
  2780.     }
  2781.  
  2782.     bytestream2_put_byte(&pb, WP_ID_DATA | WP_IDF_LONG);
  2783.     init_put_bits(&s->pb, pb.buffer + 3, bytestream2_get_bytes_left_p(&pb));
  2784.     if (s->flags & WV_MONO_DATA) {
  2785.         for (i = 0; i < nb_samples; i++)
  2786.             wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
  2787.     } else {
  2788.         for (i = 0; i < nb_samples; i++) {
  2789.             wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]);
  2790.             wavpack_encode_sample(s, &s->w.c[1], s->samples[1][i]);
  2791.         }
  2792.     }
  2793.     encode_flush(s);
  2794.     flush_put_bits(&s->pb);
  2795.     data_size = put_bits_count(&s->pb) >> 3;
  2796.     bytestream2_put_le24(&pb, (data_size + 1) >> 1);
  2797.     bytestream2_skip_p(&pb, data_size);
  2798.     if (data_size & 1)
  2799.         bytestream2_put_byte(&pb, 0);
  2800.  
  2801.     if (got_extra) {
  2802.         bytestream2_put_byte(&pb, WP_ID_EXTRABITS | WP_IDF_LONG);
  2803.         init_put_bits(&s->pb, pb.buffer + 7, bytestream2_get_bytes_left_p(&pb));
  2804.         if (s->flags & WV_FLOAT_DATA)
  2805.             pack_float(s, s->orig_l, s->orig_r, nb_samples);
  2806.         else
  2807.             pack_int32(s, s->orig_l, s->orig_r, nb_samples);
  2808.         flush_put_bits(&s->pb);
  2809.         data_size = put_bits_count(&s->pb) >> 3;
  2810.         bytestream2_put_le24(&pb, (data_size + 5) >> 1);
  2811.         bytestream2_put_le32(&pb, s->crc_x);
  2812.         bytestream2_skip_p(&pb, data_size);
  2813.         if (data_size & 1)
  2814.             bytestream2_put_byte(&pb, 0);
  2815.     }
  2816.  
  2817.     block_size = bytestream2_tell_p(&pb);
  2818.     AV_WL32(out + 4, block_size - 8);
  2819.  
  2820.     av_assert0(!bytestream2_get_eof(&pb));
  2821.  
  2822.     return block_size;
  2823. }
  2824.  
  2825. static void fill_buffer(WavPackEncodeContext *s,
  2826.                         const int8_t *src, int32_t *dst,
  2827.                         int nb_samples)
  2828. {
  2829.     int i;
  2830.  
  2831. #define COPY_SAMPLES(type, offset, shift) do {            \
  2832.         const type *sptr = (const type *)src;             \
  2833.         for (i = 0; i < nb_samples; i++)                  \
  2834.             dst[i] = (sptr[i] - offset) >> shift;         \
  2835.     } while (0)
  2836.  
  2837.     switch (s->avctx->sample_fmt) {
  2838.     case AV_SAMPLE_FMT_U8P:
  2839.         COPY_SAMPLES(int8_t, 0x80, 0);
  2840.         break;
  2841.     case AV_SAMPLE_FMT_S16P:
  2842.         COPY_SAMPLES(int16_t, 0, 0);
  2843.         break;
  2844.     case AV_SAMPLE_FMT_S32P:
  2845.         if (s->avctx->bits_per_raw_sample <= 24) {
  2846.             COPY_SAMPLES(int32_t, 0, 8);
  2847.             break;
  2848.         }
  2849.     case AV_SAMPLE_FMT_FLTP:
  2850.         memcpy(dst, src, nb_samples * 4);
  2851.     }
  2852. }
  2853.  
  2854. static void set_samplerate(WavPackEncodeContext *s)
  2855. {
  2856.     int i;
  2857.  
  2858.     for (i = 0; i < 15; i++) {
  2859.         if (wv_rates[i] == s->avctx->sample_rate)
  2860.             break;
  2861.     }
  2862.  
  2863.     s->flags = i << SRATE_LSB;
  2864. }
  2865.  
  2866. static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
  2867.                                 const AVFrame *frame, int *got_packet_ptr)
  2868. {
  2869.     WavPackEncodeContext *s = avctx->priv_data;
  2870.     int buf_size, ret;
  2871.     uint8_t *buf;
  2872.  
  2873.     s->block_samples = frame->nb_samples;
  2874.     av_fast_padded_malloc(&s->samples[0], &s->samples_size[0],
  2875.                           sizeof(int32_t) * s->block_samples);
  2876.     if (!s->samples[0])
  2877.         return AVERROR(ENOMEM);
  2878.     if (avctx->channels > 1) {
  2879.         av_fast_padded_malloc(&s->samples[1], &s->samples_size[1],
  2880.                               sizeof(int32_t) * s->block_samples);
  2881.         if (!s->samples[1])
  2882.             return AVERROR(ENOMEM);
  2883.     }
  2884.  
  2885.     buf_size = s->block_samples * avctx->channels * 8
  2886.              + 200 * avctx->channels /* for headers */;
  2887.     if ((ret = ff_alloc_packet2(avctx, avpkt, buf_size, 0)) < 0)
  2888.         return ret;
  2889.     buf = avpkt->data;
  2890.  
  2891.     for (s->ch_offset = 0; s->ch_offset < avctx->channels;) {
  2892.         set_samplerate(s);
  2893.  
  2894.         switch (s->avctx->sample_fmt) {
  2895.         case AV_SAMPLE_FMT_S16P: s->flags |= 1; break;
  2896.         case AV_SAMPLE_FMT_S32P: s->flags |= 3 - (s->avctx->bits_per_raw_sample <= 24); break;
  2897.         case AV_SAMPLE_FMT_FLTP: s->flags |= 3 | WV_FLOAT_DATA;
  2898.         }
  2899.  
  2900.         fill_buffer(s, frame->extended_data[s->ch_offset], s->samples[0], s->block_samples);
  2901.         if (avctx->channels - s->ch_offset == 1) {
  2902.             s->flags |= WV_MONO;
  2903.         } else {
  2904.             s->flags |= WV_CROSS_DECORR;
  2905.             fill_buffer(s, frame->extended_data[s->ch_offset + 1], s->samples[1], s->block_samples);
  2906.         }
  2907.  
  2908.         s->flags += (1 << MAG_LSB) * ((s->flags & 3) * 8 + 7);
  2909.  
  2910.         if ((ret = wavpack_encode_block(s, s->samples[0], s->samples[1],
  2911.                                         buf, buf_size)) < 0)
  2912.             return ret;
  2913.  
  2914.         buf      += ret;
  2915.         buf_size -= ret;
  2916.     }
  2917.     s->sample_index += frame->nb_samples;
  2918.  
  2919.     avpkt->pts      = frame->pts;
  2920.     avpkt->size     = buf - avpkt->data;
  2921.     avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
  2922.     *got_packet_ptr = 1;
  2923.     return 0;
  2924. }
  2925.  
  2926. static av_cold int wavpack_encode_close(AVCodecContext *avctx)
  2927. {
  2928.     WavPackEncodeContext *s = avctx->priv_data;
  2929.     int i;
  2930.  
  2931.     for (i = 0; i < MAX_TERMS + 2; i++) {
  2932.         av_freep(&s->sampleptrs[i][0]);
  2933.         av_freep(&s->sampleptrs[i][1]);
  2934.         s->sampleptrs_size[i][0] = s->sampleptrs_size[i][1] = 0;
  2935.     }
  2936.  
  2937.     for (i = 0; i < 2; i++) {
  2938.         av_freep(&s->samples[i]);
  2939.         s->samples_size[i] = 0;
  2940.  
  2941.         av_freep(&s->best_buffer[i]);
  2942.         s->best_buffer_size[i] = 0;
  2943.  
  2944.         av_freep(&s->temp_buffer[i][0]);
  2945.         av_freep(&s->temp_buffer[i][1]);
  2946.         s->temp_buffer_size[i][0] = s->temp_buffer_size[i][1] = 0;
  2947.     }
  2948.  
  2949.     av_freep(&s->js_left);
  2950.     av_freep(&s->js_right);
  2951.     s->js_left_size = s->js_right_size = 0;
  2952.  
  2953.     av_freep(&s->orig_l);
  2954.     av_freep(&s->orig_r);
  2955.     s->orig_l_size = s->orig_r_size = 0;
  2956.  
  2957.     return 0;
  2958. }
  2959.  
  2960. #define OFFSET(x) offsetof(WavPackEncodeContext, x)
  2961. #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
  2962. static const AVOption options[] = {
  2963.     { "joint_stereo",  "", OFFSET(joint), AV_OPT_TYPE_INT, {.i64=0},-1, 1, FLAGS, "joint" },
  2964.     { "on",   "mid/side",   0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, FLAGS, "joint"},
  2965.     { "off",  "left/right", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, "joint"},
  2966.     { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, FLAGS, "joint"},
  2967.     { "optimize_mono",        "", OFFSET(optimize_mono), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "opt_mono" },
  2968.     { "on",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "opt_mono"},
  2969.     { "off",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "opt_mono"},
  2970.     { NULL },
  2971. };
  2972.  
  2973. static const AVClass wavpack_encoder_class = {
  2974.     .class_name = "WavPack encoder",
  2975.     .item_name  = av_default_item_name,
  2976.     .option     = options,
  2977.     .version    = LIBAVUTIL_VERSION_INT,
  2978. };
  2979.  
  2980. AVCodec ff_wavpack_encoder = {
  2981.     .name           = "wavpack",
  2982.     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
  2983.     .type           = AVMEDIA_TYPE_AUDIO,
  2984.     .id             = AV_CODEC_ID_WAVPACK,
  2985.     .priv_data_size = sizeof(WavPackEncodeContext),
  2986.     .priv_class     = &wavpack_encoder_class,
  2987.     .init           = wavpack_encode_init,
  2988.     .encode2        = wavpack_encode_frame,
  2989.     .close          = wavpack_encode_close,
  2990.     .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME,
  2991.     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8P,
  2992.                                                      AV_SAMPLE_FMT_S16P,
  2993.                                                      AV_SAMPLE_FMT_S32P,
  2994.                                                      AV_SAMPLE_FMT_FLTP,
  2995.                                                      AV_SAMPLE_FMT_NONE },
  2996. };
  2997.