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

1147 lines
38KB
Raw Blame History 

  1. /*

  2.  * WavPack lossless audio decoder

  3.  * Copyright (c) 2006,2011 Konstantin Shishkov

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

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

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

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

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

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

  15.  * Lesser General Public License for more details.

  16.  *

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

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. #include "libavutil/channel_layout.h"

  23. 

  24. #define BITSTREAM_READER_LE

  25. #include "avcodec.h"

  26. #include "bytestream.h"

  27. #include "get_bits.h"

  28. #include "internal.h"

  29. #include "thread.h"

  30. #include "unary.h"

  31. #include "wavpack.h"

  32. 

  33. /**

  34.  * @file

  35.  * WavPack lossless audio decoder

  36.  */

  37. 

  38. typedef struct SavedContext {

  39.     int offset;

  40.     int size;

  41.     int bits_used;

  42.     uint32_t crc;

  43. } SavedContext;

  44. 

  45. typedef struct WavpackFrameContext {

  46.     AVCodecContext *avctx;

  47.     int frame_flags;

  48.     int stereo, stereo_in;

  49.     int joint;

  50.     uint32_t CRC;

  51.     GetBitContext gb;

  52.     int got_extra_bits;

  53.     uint32_t crc_extra_bits;

  54.     GetBitContext gb_extra_bits;

  55.     int data_size; // in bits

  56.     int samples;

  57.     int terms;

  58.     Decorr decorr[MAX_TERMS];

  59.     int zero, one, zeroes;

  60.     int extra_bits;

  61.     int and, or, shift;

  62.     int post_shift;

  63.     int hybrid, hybrid_bitrate;

  64.     int hybrid_maxclip, hybrid_minclip;

  65.     int float_flag;

  66.     int float_shift;

  67.     int float_max_exp;

  68.     WvChannel ch[2];

  69.     int pos;

  70.     SavedContext sc, extra_sc;

  71. } WavpackFrameContext;

  72. 

  73. #define WV_MAX_FRAME_DECODERS 14

  74. 

  75. typedef struct WavpackContext {

  76.     AVCodecContext *avctx;

  77. 

  78.     WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];

  79.     int fdec_num;

  80. 

  81.     int block;

  82.     int samples;

  83.     int ch_offset;

  84. } WavpackContext;

  85. 

  86. #define LEVEL_DECAY(a)  (((a) + 0x80) >> 8)

  87. 

  88. static av_always_inline int get_tail(GetBitContext *gb, int k)

  89. {

  90.     int p, e, res;

  91. 

  92.     if (k < 1)

  93.         return 0;

  94.     p   = av_log2(k);

  95.     e   = (1 << (p + 1)) - k - 1;

  96.     res = get_bitsz(gb, p);

  97.     if (res >= e)

  98.         res = (res << 1) - e + get_bits1(gb);

  99.     return res;

  100. }

  101. 

  102. static int update_error_limit(WavpackFrameContext *ctx)

  103. {

  104.     int i, br[2], sl[2];

  105. 

  106.     for (i = 0; i <= ctx->stereo_in; i++) {

  107.         if (ctx->ch[i].bitrate_acc > UINT_MAX - ctx->ch[i].bitrate_delta)

  108.             return AVERROR_INVALIDDATA;

  109.         ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;

  110.         br[i]                   = ctx->ch[i].bitrate_acc >> 16;

  111.         sl[i]                   = LEVEL_DECAY(ctx->ch[i].slow_level);

  112.     }

  113.     if (ctx->stereo_in && ctx->hybrid_bitrate) {

  114.         int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;

  115.         if (balance > br[0]) {

  116.             br[1] = br[0] << 1;

  117.             br[0] = 0;

  118.         } else if (-balance > br[0]) {

  119.             br[0] <<= 1;

  120.             br[1]   = 0;

  121.         } else {

  122.             br[1] = br[0] + balance;

  123.             br[0] = br[0] - balance;

  124.         }

  125.     }

  126.     for (i = 0; i <= ctx->stereo_in; i++) {

  127.         if (ctx->hybrid_bitrate) {

  128.             if (sl[i] - br[i] > -0x100)

  129.                 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);

  130.             else

  131.                 ctx->ch[i].error_limit = 0;

  132.         } else {

  133.             ctx->ch[i].error_limit = wp_exp2(br[i]);

  134.         }

  135.     }

  136. 

  137.     return 0;

  138. }

  139. 

  140. static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,

  141.                         int channel, int *last)

  142. {

  143.     int t, t2;

  144.     int sign, base, add, ret;

  145.     WvChannel *c = &ctx->ch[channel];

  146. 

  147.     *last = 0;

  148. 

  149.     if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&

  150.         !ctx->zero && !ctx->one) {

  151.         if (ctx->zeroes) {

  152.             ctx->zeroes--;

  153.             if (ctx->zeroes) {

  154.                 c->slow_level -= LEVEL_DECAY(c->slow_level);

  155.                 return 0;

  156.             }

  157.         } else {

  158.             t = get_unary_0_33(gb);

  159.             if (t >= 2) {

  160.                 if (t >= 32 || get_bits_left(gb) < t - 1)

  161.                     goto error;

  162.                 t = get_bits_long(gb, t - 1) | (1 << (t - 1));

  163.             } else {

  164.                 if (get_bits_left(gb) < 0)

  165.                     goto error;

  166.             }

  167.             ctx->zeroes = t;

  168.             if (ctx->zeroes) {

  169.                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));

  170.                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));

  171.                 c->slow_level -= LEVEL_DECAY(c->slow_level);

  172.                 return 0;

  173.             }

  174.         }

  175.     }

  176. 

  177.     if (ctx->zero) {

  178.         t         = 0;

  179.         ctx->zero = 0;

  180.     } else {

  181.         t = get_unary_0_33(gb);

  182.         if (get_bits_left(gb) < 0)

  183.             goto error;

  184.         if (t == 16) {

  185.             t2 = get_unary_0_33(gb);

  186.             if (t2 < 2) {

  187.                 if (get_bits_left(gb) < 0)

  188.                     goto error;

  189.                 t += t2;

  190.             } else {

  191.                 if (get_bits_left(gb) < t2 - 1)

  192.                     goto error;

  193.                 t += get_bits_long(gb, t2 - 1) | (1 << (t2 - 1));

  194.             }

  195.         }

  196. 

  197.         if (ctx->one) {

  198.             ctx->one = t & 1;

  199.             t        = (t >> 1) + 1;

  200.         } else {

  201.             ctx->one = t & 1;

  202.             t      >>= 1;

  203.         }

  204.         ctx->zero = !ctx->one;

  205.     }

  206. 

  207.     if (ctx->hybrid && !channel) {

  208.         if (update_error_limit(ctx) < 0)

  209.             goto error;

  210.     }

  211. 

  212.     if (!t) {

  213.         base = 0;

  214.         add  = GET_MED(0) - 1;

  215.         DEC_MED(0);

  216.     } else if (t == 1) {

  217.         base = GET_MED(0);

  218.         add  = GET_MED(1) - 1;

  219.         INC_MED(0);

  220.         DEC_MED(1);

  221.     } else if (t == 2) {

  222.         base = GET_MED(0) + GET_MED(1);

  223.         add  = GET_MED(2) - 1;

  224.         INC_MED(0);

  225.         INC_MED(1);

  226.         DEC_MED(2);

  227.     } else {

  228.         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);

  229.         add  = GET_MED(2) - 1;

  230.         INC_MED(0);

  231.         INC_MED(1);

  232.         INC_MED(2);

  233.     }

  234.     if (!c->error_limit) {

  235.         if (add >= 0x2000000U) {

  236.             av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);

  237.             goto error;

  238.         }

  239.         ret = base + get_tail(gb, add);

  240.         if (get_bits_left(gb) <= 0)

  241.             goto error;

  242.     } else {

  243.         int mid = (base * 2U + add + 1) >> 1;

  244.         while (add > c->error_limit) {

  245.             if (get_bits_left(gb) <= 0)

  246.                 goto error;

  247.             if (get_bits1(gb)) {

  248.                 add -= (mid - base);

  249.                 base = mid;

  250.             } else

  251.                 add = mid - base - 1;

  252.             mid = (base * 2U + add + 1) >> 1;

  253.         }

  254.         ret = mid;

  255.     }

  256.     sign = get_bits1(gb);

  257.     if (ctx->hybrid_bitrate)

  258.         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);

  259.     return sign ? ~ret : ret;

  260. 

  261. error:

  262.     ret = get_bits_left(gb);

  263.     if (ret <= 0) {

  264.         av_log(ctx->avctx, AV_LOG_ERROR, "Too few bits (%d) left\n", ret);

  265.     }

  266.     *last = 1;

  267.     return 0;

  268. }

  269. 

  270. static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,

  271.                                        unsigned S)

  272. {

  273.     unsigned bit;

  274. 

  275.     if (s->extra_bits) {

  276.         S *= 1 << s->extra_bits;

  277. 

  278.         if (s->got_extra_bits &&

  279.             get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {

  280.             S   |= get_bits_long(&s->gb_extra_bits, s->extra_bits);

  281.             *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);

  282.         }

  283.     }

  284. 

  285.     bit = (S & s->and) | s->or;

  286.     bit = ((S + bit) << s->shift) - bit;

  287. 

  288.     if (s->hybrid)

  289.         bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);

  290. 

  291.     return bit << s->post_shift;

  292. }

  293. 

  294. static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)

  295. {

  296.     union {

  297.         float    f;

  298.         uint32_t u;

  299.     } value;

  300. 

  301.     unsigned int sign;

  302.     int exp = s->float_max_exp;

  303. 

  304.     if (s->got_extra_bits) {

  305.         const int max_bits  = 1 + 23 + 8 + 1;

  306.         const int left_bits = get_bits_left(&s->gb_extra_bits);

  307. 

  308.         if (left_bits + 8 * AV_INPUT_BUFFER_PADDING_SIZE < max_bits)

  309.             return 0.0;

  310.     }

  311. 

  312.     if (S) {

  313.         S  <<= s->float_shift;

  314.         sign = S < 0;

  315.         if (sign)

  316.             S = -S;

  317.         if (S >= 0x1000000) {

  318.             if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))

  319.                 S = get_bits(&s->gb_extra_bits, 23);

  320.             else

  321.                 S = 0;

  322.             exp = 255;

  323.         } else if (exp) {

  324.             int shift = 23 - av_log2(S);

  325.             exp = s->float_max_exp;

  326.             if (exp <= shift)

  327.                 shift = --exp;

  328.             exp -= shift;

  329. 

  330.             if (shift) {

  331.                 S <<= shift;

  332.                 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||

  333.                     (s->got_extra_bits &&

  334.                      (s->float_flag & WV_FLT_SHIFT_SAME) &&

  335.                      get_bits1(&s->gb_extra_bits))) {

  336.                     S |= (1 << shift) - 1;

  337.                 } else if (s->got_extra_bits &&

  338.                            (s->float_flag & WV_FLT_SHIFT_SENT)) {

  339.                     S |= get_bits(&s->gb_extra_bits, shift);

  340.                 }

  341.             }

  342.         } else {

  343.             exp = s->float_max_exp;

  344.         }

  345.         S &= 0x7fffff;

  346.     } else {

  347.         sign = 0;

  348.         exp  = 0;

  349.         if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {

  350.             if (get_bits1(&s->gb_extra_bits)) {

  351.                 S = get_bits(&s->gb_extra_bits, 23);

  352.                 if (s->float_max_exp >= 25)

  353.                     exp = get_bits(&s->gb_extra_bits, 8);

  354.                 sign = get_bits1(&s->gb_extra_bits);

  355.             } else {

  356.                 if (s->float_flag & WV_FLT_ZERO_SIGN)

  357.                     sign = get_bits1(&s->gb_extra_bits);

  358.             }

  359.         }

  360.     }

  361. 

  362.     *crc = *crc * 27 + S * 9 + exp * 3 + sign;

  363. 

  364.     value.u = (sign << 31) | (exp << 23) | S;

  365.     return value.f;

  366. }

  367. 

  368. static void wv_reset_saved_context(WavpackFrameContext *s)

  369. {

  370.     s->pos    = 0;

  371.     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;

  372. }

  373. 

  374. static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,

  375.                                uint32_t crc_extra_bits)

  376. {

  377.     if (crc != s->CRC) {

  378.         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");

  379.         return AVERROR_INVALIDDATA;

  380.     }

  381.     if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {

  382.         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");

  383.         return AVERROR_INVALIDDATA;

  384.     }

  385. 

  386.     return 0;

  387. }

  388. 

  389. static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,

  390.                                    void *dst_l, void *dst_r, const int type)

  391. {

  392.     int i, j, count = 0;

  393.     int last, t;

  394.     int A, B, L, L2, R, R2;

  395.     int pos                 = s->pos;

  396.     uint32_t crc            = s->sc.crc;

  397.     uint32_t crc_extra_bits = s->extra_sc.crc;

  398.     int16_t *dst16_l        = dst_l;

  399.     int16_t *dst16_r        = dst_r;

  400.     int32_t *dst32_l        = dst_l;

  401.     int32_t *dst32_r        = dst_r;

  402.     float *dstfl_l          = dst_l;

  403.     float *dstfl_r          = dst_r;

  404. 

  405.     s->one = s->zero = s->zeroes = 0;

  406.     do {

  407.         L = wv_get_value(s, gb, 0, &last);

  408.         if (last)

  409.             break;

  410.         R = wv_get_value(s, gb, 1, &last);

  411.         if (last)

  412.             break;

  413.         for (i = 0; i < s->terms; i++) {

  414.             t = s->decorr[i].value;

  415.             if (t > 0) {

  416.                 if (t > 8) {

  417.                     if (t & 1) {

  418.                         A = 2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];

  419.                         B = 2U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];

  420.                     } else {

  421.                         A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;

  422.                         B = (int)(3U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;

  423.                     }

  424.                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];

  425.                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];

  426.                     j                        = 0;

  427.                 } else {

  428.                     A = s->decorr[i].samplesA[pos];

  429.                     B = s->decorr[i].samplesB[pos];

  430.                     j = (pos + t) & 7;

  431.                 }

  432.                 if (type != AV_SAMPLE_FMT_S16P) {

  433.                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);

  434.                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);

  435.                 } else {

  436.                     L2 = L + ((int)(s->decorr[i].weightA * (unsigned)A + 512) >> 10);

  437.                     R2 = R + ((int)(s->decorr[i].weightB * (unsigned)B + 512) >> 10);

  438.                 }

  439.                 if (A && L)

  440.                     s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;

  441.                 if (B && R)

  442.                     s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;

  443.                 s->decorr[i].samplesA[j] = L = L2;

  444.                 s->decorr[i].samplesB[j] = R = R2;

  445.             } else if (t == -1) {

  446.                 if (type != AV_SAMPLE_FMT_S16P)

  447.                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);

  448.                 else

  449.                     L2 = L + ((int)(s->decorr[i].weightA * (unsigned)s->decorr[i].samplesA[0] + 512) >> 10);

  450.                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);

  451.                 L = L2;

  452.                 if (type != AV_SAMPLE_FMT_S16P)

  453.                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);

  454.                 else

  455.                     R2 = R + ((int)(s->decorr[i].weightB * (unsigned)L2 + 512) >> 10);

  456.                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);

  457.                 R                        = R2;

  458.                 s->decorr[i].samplesA[0] = R;

  459.             } else {

  460.                 if (type != AV_SAMPLE_FMT_S16P)

  461.                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);

  462.                 else

  463.                     R2 = R + ((int)(s->decorr[i].weightB * (unsigned)s->decorr[i].samplesB[0] + 512) >> 10);

  464.                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);

  465.                 R = R2;

  466. 

  467.                 if (t == -3) {

  468.                     R2                       = s->decorr[i].samplesA[0];

  469.                     s->decorr[i].samplesA[0] = R;

  470.                 }

  471. 

  472.                 if (type != AV_SAMPLE_FMT_S16P)

  473.                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);

  474.                 else

  475.                     L2 = L + ((int)(s->decorr[i].weightA * (unsigned)R2 + 512) >> 10);

  476.                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);

  477.                 L                        = L2;

  478.                 s->decorr[i].samplesB[0] = L;

  479.             }

  480.         }

  481. 

  482.         if (type == AV_SAMPLE_FMT_S16P) {

  483.             if (FFABS(L) + FFABS(R) > (1<<19)) {

  484.                 av_log(s->avctx, AV_LOG_ERROR, "sample %d %d too large\n", L, R);

  485.                 return AVERROR_INVALIDDATA;

  486.             }

  487.         }

  488. 

  489.         pos = (pos + 1) & 7;

  490.         if (s->joint)

  491.             L += (unsigned)(R -= (unsigned)(L >> 1));

  492.         crc = (crc * 3 + L) * 3 + R;

  493. 

  494.         if (type == AV_SAMPLE_FMT_FLTP) {

  495.             *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);

  496.             *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);

  497.         } else if (type == AV_SAMPLE_FMT_S32P) {

  498.             *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);

  499.             *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);

  500.         } else {

  501.             *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);

  502.             *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);

  503.         }

  504.         count++;

  505.     } while (!last && count < s->samples);

  506. 

  507.     wv_reset_saved_context(s);

  508. 

  509.     if (last && count < s->samples) {

  510.         int size = av_get_bytes_per_sample(type);

  511.         memset((uint8_t*)dst_l + count*size, 0, (s->samples-count)*size);

  512.         memset((uint8_t*)dst_r + count*size, 0, (s->samples-count)*size);

  513.     }

  514. 

  515.     if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&

  516.         wv_check_crc(s, crc, crc_extra_bits))

  517.         return AVERROR_INVALIDDATA;

  518. 

  519.     return 0;

  520. }

  521. 

  522. static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,

  523.                                  void *dst, const int type)

  524. {

  525.     int i, j, count = 0;

  526.     int last, t;

  527.     int A, S, T;

  528.     int pos                  = s->pos;

  529.     uint32_t crc             = s->sc.crc;

  530.     uint32_t crc_extra_bits  = s->extra_sc.crc;

  531.     int16_t *dst16           = dst;

  532.     int32_t *dst32           = dst;

  533.     float *dstfl             = dst;

  534. 

  535.     s->one = s->zero = s->zeroes = 0;

  536.     do {

  537.         T = wv_get_value(s, gb, 0, &last);

  538.         S = 0;

  539.         if (last)

  540.             break;

  541.         for (i = 0; i < s->terms; i++) {

  542.             t = s->decorr[i].value;

  543.             if (t > 8) {

  544.                 if (t & 1)

  545.                     A =  2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];

  546.                 else

  547.                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;

  548.                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];

  549.                 j                        = 0;

  550.             } else {

  551.                 A = s->decorr[i].samplesA[pos];

  552.                 j = (pos + t) & 7;

  553.             }

  554.             if (type != AV_SAMPLE_FMT_S16P)

  555.                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);

  556.             else

  557.                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);

  558.             if (A && T)

  559.                 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;

  560.             s->decorr[i].samplesA[j] = T = S;

  561.         }

  562.         pos = (pos + 1) & 7;

  563.         crc = crc * 3 + S;

  564. 

  565.         if (type == AV_SAMPLE_FMT_FLTP) {

  566.             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);

  567.         } else if (type == AV_SAMPLE_FMT_S32P) {

  568.             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);

  569.         } else {

  570.             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);

  571.         }

  572.         count++;

  573.     } while (!last && count < s->samples);

  574. 

  575.     wv_reset_saved_context(s);

  576. 

  577.     if (last && count < s->samples) {

  578.         int size = av_get_bytes_per_sample(type);

  579.         memset((uint8_t*)dst + count*size, 0, (s->samples-count)*size);

  580.     }

  581. 

  582.     if (s->avctx->err_recognition & AV_EF_CRCCHECK) {

  583.         int ret = wv_check_crc(s, crc, crc_extra_bits);

  584.         if (ret < 0 && s->avctx->err_recognition & AV_EF_EXPLODE)

  585.             return ret;

  586.     }

  587. 

  588.     return 0;

  589. }

  590. 

  591. static av_cold int wv_alloc_frame_context(WavpackContext *c)

  592. {

  593.     if (c->fdec_num == WV_MAX_FRAME_DECODERS)

  594.         return -1;

  595. 

  596.     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));

  597.     if (!c->fdec[c->fdec_num])

  598.         return -1;

  599.     c->fdec_num++;

  600.     c->fdec[c->fdec_num - 1]->avctx = c->avctx;

  601.     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);

  602. 

  603.     return 0;

  604. }

  605. 

  606. #if HAVE_THREADS

  607. static int init_thread_copy(AVCodecContext *avctx)

  608. {

  609.     WavpackContext *s = avctx->priv_data;

  610.     s->avctx = avctx;

  611.     return 0;

  612. }

  613. #endif

  614. 

  615. static av_cold int wavpack_decode_init(AVCodecContext *avctx)

  616. {

  617.     WavpackContext *s = avctx->priv_data;

  618. 

  619.     s->avctx = avctx;

  620. 

  621.     s->fdec_num = 0;

  622. 

  623.     return 0;

  624. }

  625. 

  626. static av_cold int wavpack_decode_end(AVCodecContext *avctx)

  627. {

  628.     WavpackContext *s = avctx->priv_data;

  629.     int i;

  630. 

  631.     for (i = 0; i < s->fdec_num; i++)

  632.         av_freep(&s->fdec[i]);

  633.     s->fdec_num = 0;

  634. 

  635.     return 0;

  636. }

  637. 

  638. static int wavpack_decode_block(AVCodecContext *avctx, int block_no,

  639.                                 AVFrame *frame, const uint8_t *buf, int buf_size)

  640. {

  641.     WavpackContext *wc = avctx->priv_data;

  642.     ThreadFrame tframe = { .f = frame };

  643.     WavpackFrameContext *s;

  644.     GetByteContext gb;

  645.     void *samples_l = NULL, *samples_r = NULL;

  646.     int ret;

  647.     int got_terms   = 0, got_weights = 0, got_samples = 0,

  648.         got_entropy = 0, got_bs      = 0, got_float   = 0, got_hybrid = 0;

  649.     int i, j, id, size, ssize, weights, t;

  650.     int bpp, chan = 0, chmask = 0, orig_bpp, sample_rate = 0;

  651.     int multiblock;

  652. 

  653.     if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {

  654.         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");

  655.         return AVERROR_INVALIDDATA;

  656.     }

  657. 

  658.     s = wc->fdec[block_no];

  659.     if (!s) {

  660.         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",

  661.                block_no);

  662.         return AVERROR_INVALIDDATA;

  663.     }

  664. 

  665.     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));

  666.     memset(s->ch, 0, sizeof(s->ch));

  667.     s->extra_bits     = 0;

  668.     s->and            = s->or = s->shift = 0;

  669.     s->got_extra_bits = 0;

  670. 

  671.     bytestream2_init(&gb, buf, buf_size);

  672. 

  673.     s->samples = bytestream2_get_le32(&gb);

  674.     if (s->samples != wc->samples) {

  675.         av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "

  676.                "a sequence: %d and %d\n", wc->samples, s->samples);

  677.         return AVERROR_INVALIDDATA;

  678.     }

  679.     s->frame_flags = bytestream2_get_le32(&gb);

  680.     bpp            = av_get_bytes_per_sample(avctx->sample_fmt);

  681.     orig_bpp       = ((s->frame_flags & 0x03) + 1) << 3;

  682.     multiblock     = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK;

  683. 

  684.     s->stereo         = !(s->frame_flags & WV_MONO);

  685.     s->stereo_in      =  (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;

  686.     s->joint          =   s->frame_flags & WV_JOINT_STEREO;

  687.     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;

  688.     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;

  689.     s->post_shift     = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);

  690.     if (s->post_shift < 0 || s->post_shift > 31) {

  691.         return AVERROR_INVALIDDATA;

  692.     }

  693.     s->hybrid_maxclip =  ((1LL << (orig_bpp - 1)) - 1);

  694.     s->hybrid_minclip = ((-1UL << (orig_bpp - 1)));

  695.     s->CRC            = bytestream2_get_le32(&gb);

  696. 

  697.     // parse metadata blocks

  698.     while (bytestream2_get_bytes_left(&gb)) {

  699.         id   = bytestream2_get_byte(&gb);

  700.         size = bytestream2_get_byte(&gb);

  701.         if (id & WP_IDF_LONG) {

  702.             size |= (bytestream2_get_byte(&gb)) << 8;

  703.             size |= (bytestream2_get_byte(&gb)) << 16;

  704.         }

  705.         size <<= 1; // size is specified in words

  706.         ssize  = size;

  707.         if (id & WP_IDF_ODD)

  708.             size--;

  709.         if (size < 0) {

  710.             av_log(avctx, AV_LOG_ERROR,

  711.                    "Got incorrect block %02X with size %i\n", id, size);

  712.             break;

  713.         }

  714.         if (bytestream2_get_bytes_left(&gb) < ssize) {

  715.             av_log(avctx, AV_LOG_ERROR,

  716.                    "Block size %i is out of bounds\n", size);

  717.             break;

  718.         }

  719.         switch (id & WP_IDF_MASK) {

  720.         case WP_ID_DECTERMS:

  721.             if (size > MAX_TERMS) {

  722.                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");

  723.                 s->terms = 0;

  724.                 bytestream2_skip(&gb, ssize);

  725.                 continue;

  726.             }

  727.             s->terms = size;

  728.             for (i = 0; i < s->terms; i++) {

  729.                 uint8_t val = bytestream2_get_byte(&gb);

  730.                 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;

  731.                 s->decorr[s->terms - i - 1].delta =  val >> 5;

  732.             }

  733.             got_terms = 1;

  734.             break;

  735.         case WP_ID_DECWEIGHTS:

  736.             if (!got_terms) {

  737.                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");

  738.                 continue;

  739.             }

  740.             weights = size >> s->stereo_in;

  741.             if (weights > MAX_TERMS || weights > s->terms) {

  742.                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");

  743.                 bytestream2_skip(&gb, ssize);

  744.                 continue;

  745.             }

  746.             for (i = 0; i < weights; i++) {

  747.                 t = (int8_t)bytestream2_get_byte(&gb);

  748.                 s->decorr[s->terms - i - 1].weightA = t * (1 << 3);

  749.                 if (s->decorr[s->terms - i - 1].weightA > 0)

  750.                     s->decorr[s->terms - i - 1].weightA +=

  751.                         (s->decorr[s->terms - i - 1].weightA + 64) >> 7;

  752.                 if (s->stereo_in) {

  753.                     t = (int8_t)bytestream2_get_byte(&gb);

  754.                     s->decorr[s->terms - i - 1].weightB = t * (1 << 3);

  755.                     if (s->decorr[s->terms - i - 1].weightB > 0)

  756.                         s->decorr[s->terms - i - 1].weightB +=

  757.                             (s->decorr[s->terms - i - 1].weightB + 64) >> 7;

  758.                 }

  759.             }

  760.             got_weights = 1;

  761.             break;

  762.         case WP_ID_DECSAMPLES:

  763.             if (!got_terms) {

  764.                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");

  765.                 continue;

  766.             }

  767.             t = 0;

  768.             for (i = s->terms - 1; (i >= 0) && (t < size); i--) {

  769.                 if (s->decorr[i].value > 8) {

  770.                     s->decorr[i].samplesA[0] =

  771.                         wp_exp2(bytestream2_get_le16(&gb));

  772.                     s->decorr[i].samplesA[1] =

  773.                         wp_exp2(bytestream2_get_le16(&gb));

  774. 

  775.                     if (s->stereo_in) {

  776.                         s->decorr[i].samplesB[0] =

  777.                             wp_exp2(bytestream2_get_le16(&gb));

  778.                         s->decorr[i].samplesB[1] =

  779.                             wp_exp2(bytestream2_get_le16(&gb));

  780.                         t                       += 4;

  781.                     }

  782.                     t += 4;

  783.                 } else if (s->decorr[i].value < 0) {

  784.                     s->decorr[i].samplesA[0] =

  785.                         wp_exp2(bytestream2_get_le16(&gb));

  786.                     s->decorr[i].samplesB[0] =

  787.                         wp_exp2(bytestream2_get_le16(&gb));

  788.                     t                       += 4;

  789.                 } else {

  790.                     for (j = 0; j < s->decorr[i].value; j++) {

  791.                         s->decorr[i].samplesA[j] =

  792.                             wp_exp2(bytestream2_get_le16(&gb));

  793.                         if (s->stereo_in) {

  794.                             s->decorr[i].samplesB[j] =

  795.                                 wp_exp2(bytestream2_get_le16(&gb));

  796.                         }

  797.                     }

  798.                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);

  799.                 }

  800.             }

  801.             got_samples = 1;

  802.             break;

  803.         case WP_ID_ENTROPY:

  804.             if (size != 6 * (s->stereo_in + 1)) {

  805.                 av_log(avctx, AV_LOG_ERROR,

  806.                        "Entropy vars size should be %i, got %i.\n",

  807.                        6 * (s->stereo_in + 1), size);

  808.                 bytestream2_skip(&gb, ssize);

  809.                 continue;

  810.             }

  811.             for (j = 0; j <= s->stereo_in; j++)

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

  813.                     s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));

  814.                 }

  815.             got_entropy = 1;

  816.             break;

  817.         case WP_ID_HYBRID:

  818.             if (s->hybrid_bitrate) {

  819.                 for (i = 0; i <= s->stereo_in; i++) {

  820.                     s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));

  821.                     size               -= 2;

  822.                 }

  823.             }

  824.             for (i = 0; i < (s->stereo_in + 1); i++) {

  825.                 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;

  826.                 size                -= 2;

  827.             }

  828.             if (size > 0) {

  829.                 for (i = 0; i < (s->stereo_in + 1); i++) {

  830.                     s->ch[i].bitrate_delta =

  831.                         wp_exp2((int16_t)bytestream2_get_le16(&gb));

  832.                 }

  833.             } else {

  834.                 for (i = 0; i < (s->stereo_in + 1); i++)

  835.                     s->ch[i].bitrate_delta = 0;

  836.             }

  837.             got_hybrid = 1;

  838.             break;

  839.         case WP_ID_INT32INFO: {

  840.             uint8_t val[4];

  841.             if (size != 4) {

  842.                 av_log(avctx, AV_LOG_ERROR,

  843.                        "Invalid INT32INFO, size = %i\n",

  844.                        size);

  845.                 bytestream2_skip(&gb, ssize - 4);

  846.                 continue;

  847.             }

  848.             bytestream2_get_buffer(&gb, val, 4);

  849.             if (val[0] > 31) {

  850.                 av_log(avctx, AV_LOG_ERROR,

  851.                        "Invalid INT32INFO, extra_bits = %d (> 32)\n", val[0]);

  852.                 continue;

  853.             } else if (val[0]) {

  854.                 s->extra_bits = val[0];

  855.             } else if (val[1]) {

  856.                 s->shift = val[1];

  857.             } else if (val[2]) {

  858.                 s->and   = s->or = 1;

  859.                 s->shift = val[2];

  860.             } else if (val[3]) {

  861.                 s->and   = 1;

  862.                 s->shift = val[3];

  863.             }

  864.             if (s->shift > 31) {

  865.                 av_log(avctx, AV_LOG_ERROR,

  866.                        "Invalid INT32INFO, shift = %d (> 31)\n", s->shift);

  867.                 s->and = s->or = s->shift = 0;

  868.                 continue;

  869.             }

  870.             /* original WavPack decoder forces 32-bit lossy sound to be treated

  871.              * as 24-bit one in order to have proper clipping */

  872.             if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {

  873.                 s->post_shift      += 8;

  874.                 s->shift           -= 8;

  875.                 s->hybrid_maxclip >>= 8;

  876.                 s->hybrid_minclip >>= 8;

  877.             }

  878.             break;

  879.         }

  880.         case WP_ID_FLOATINFO:

  881.             if (size != 4) {

  882.                 av_log(avctx, AV_LOG_ERROR,

  883.                        "Invalid FLOATINFO, size = %i\n", size);

  884.                 bytestream2_skip(&gb, ssize);

  885.                 continue;

  886.             }

  887.             s->float_flag    = bytestream2_get_byte(&gb);

  888.             s->float_shift   = bytestream2_get_byte(&gb);

  889.             s->float_max_exp = bytestream2_get_byte(&gb);

  890.             got_float        = 1;

  891.             bytestream2_skip(&gb, 1);

  892.             break;

  893.         case WP_ID_DATA:

  894.             s->sc.offset = bytestream2_tell(&gb);

  895.             s->sc.size   = size * 8;

  896.             if ((ret = init_get_bits8(&s->gb, gb.buffer, size)) < 0)

  897.                 return ret;

  898.             s->data_size = size * 8;

  899.             bytestream2_skip(&gb, size);

  900.             got_bs       = 1;

  901.             break;

  902.         case WP_ID_EXTRABITS:

  903.             if (size <= 4) {

  904.                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",

  905.                        size);

  906.                 bytestream2_skip(&gb, size);

  907.                 continue;

  908.             }

  909.             s->extra_sc.offset = bytestream2_tell(&gb);

  910.             s->extra_sc.size   = size * 8;

  911.             if ((ret = init_get_bits8(&s->gb_extra_bits, gb.buffer, size)) < 0)

  912.                 return ret;

  913.             s->crc_extra_bits  = get_bits_long(&s->gb_extra_bits, 32);

  914.             bytestream2_skip(&gb, size);

  915.             s->got_extra_bits  = 1;

  916.             break;

  917.         case WP_ID_CHANINFO:

  918.             if (size <= 1) {

  919.                 av_log(avctx, AV_LOG_ERROR,

  920.                        "Insufficient channel information\n");

  921.                 return AVERROR_INVALIDDATA;

  922.             }

  923.             chan = bytestream2_get_byte(&gb);

  924.             switch (size - 2) {

  925.             case 0:

  926.                 chmask = bytestream2_get_byte(&gb);

  927.                 break;

  928.             case 1:

  929.                 chmask = bytestream2_get_le16(&gb);

  930.                 break;

  931.             case 2:

  932.                 chmask = bytestream2_get_le24(&gb);

  933.                 break;

  934.             case 3:

  935.                 chmask = bytestream2_get_le32(&gb);

  936.                 break;

  937.             case 5:

  938.                 size = bytestream2_get_byte(&gb);

  939.                 if (avctx->channels != size)

  940.                     av_log(avctx, AV_LOG_WARNING, "%i channels signalled"

  941.                            " instead of %i.\n", size, avctx->channels);

  942.                 chan  |= (bytestream2_get_byte(&gb) & 0xF) << 8;

  943.                 chmask = bytestream2_get_le16(&gb);

  944.                 break;

  945.             default:

  946.                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",

  947.                        size);

  948.                 chan   = avctx->channels;

  949.                 chmask = avctx->channel_layout;

  950.             }

  951.             break;

  952.         case WP_ID_SAMPLE_RATE:

  953.             if (size != 3) {

  954.                 av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n");

  955.                 return AVERROR_INVALIDDATA;

  956.             }

  957.             sample_rate = bytestream2_get_le24(&gb);

  958.             break;

  959.         default:

  960.             bytestream2_skip(&gb, size);

  961.         }

  962.         if (id & WP_IDF_ODD)

  963.             bytestream2_skip(&gb, 1);

  964.     }

  965. 

  966.     if (!got_terms) {

  967.         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");

  968.         return AVERROR_INVALIDDATA;

  969.     }

  970.     if (!got_weights) {

  971.         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");

  972.         return AVERROR_INVALIDDATA;

  973.     }

  974.     if (!got_samples) {

  975.         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");

  976.         return AVERROR_INVALIDDATA;

  977.     }

  978.     if (!got_entropy) {

  979.         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");

  980.         return AVERROR_INVALIDDATA;

  981.     }

  982.     if (s->hybrid && !got_hybrid) {

  983.         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");

  984.         return AVERROR_INVALIDDATA;

  985.     }

  986.     if (!got_bs) {

  987.         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");

  988.         return AVERROR_INVALIDDATA;

  989.     }

  990.     if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {

  991.         av_log(avctx, AV_LOG_ERROR, "Float information not found\n");

  992.         return AVERROR_INVALIDDATA;

  993.     }

  994.     if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {

  995.         const int size   = get_bits_left(&s->gb_extra_bits);

  996.         const int wanted = s->samples * s->extra_bits << s->stereo_in;

  997.         if (size < wanted) {

  998.             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");

  999.             s->got_extra_bits = 0;

  1000.         }

  1001.     }

  1002. 

  1003.     if (!wc->ch_offset) {

  1004.         int sr = (s->frame_flags >> 23) & 0xf;

  1005.         if (sr == 0xf) {

  1006.             if (!sample_rate) {

  1007.                 av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n");

  1008.                 return AVERROR_INVALIDDATA;

  1009.             }

  1010.             avctx->sample_rate = sample_rate;

  1011.         } else

  1012.             avctx->sample_rate = wv_rates[sr];

  1013. 

  1014.         if (multiblock) {

  1015.             if (chan)

  1016.                 avctx->channels = chan;

  1017.             if (chmask)

  1018.                 avctx->channel_layout = chmask;

  1019.         } else {

  1020.             avctx->channels       = s->stereo ? 2 : 1;

  1021.             avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO :

  1022.                                                 AV_CH_LAYOUT_MONO;

  1023.         }

  1024. 

  1025.         /* get output buffer */

  1026.         frame->nb_samples = s->samples + 1;

  1027.         if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)

  1028.             return ret;

  1029.         frame->nb_samples = s->samples;

  1030.     }

  1031. 

  1032.     if (wc->ch_offset + s->stereo >= avctx->channels) {

  1033.         av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");

  1034.         return ((avctx->err_recognition & AV_EF_EXPLODE) || !wc->ch_offset) ? AVERROR_INVALIDDATA : 0;

  1035.     }

  1036. 

  1037.     samples_l = frame->extended_data[wc->ch_offset];

  1038.     if (s->stereo)

  1039.         samples_r = frame->extended_data[wc->ch_offset + 1];

  1040. 

  1041.     wc->ch_offset += 1 + s->stereo;

  1042. 

  1043.     if (s->stereo_in) {

  1044.         ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);

  1045.         if (ret < 0)

  1046.             return ret;

  1047.     } else {

  1048.         ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);

  1049.         if (ret < 0)

  1050.             return ret;

  1051. 

  1052.         if (s->stereo)

  1053.             memcpy(samples_r, samples_l, bpp * s->samples);

  1054.     }

  1055. 

  1056.     return 0;

  1057. }

  1058. 

  1059. static void wavpack_decode_flush(AVCodecContext *avctx)

  1060. {

  1061.     WavpackContext *s = avctx->priv_data;

  1062.     int i;

  1063. 

  1064.     for (i = 0; i < s->fdec_num; i++)

  1065.         wv_reset_saved_context(s->fdec[i]);

  1066. }

  1067. 

  1068. static int wavpack_decode_frame(AVCodecContext *avctx, void *data,

  1069.                                 int *got_frame_ptr, AVPacket *avpkt)

  1070. {

  1071.     WavpackContext *s  = avctx->priv_data;

  1072.     const uint8_t *buf = avpkt->data;

  1073.     int buf_size       = avpkt->size;

  1074.     AVFrame *frame     = data;

  1075.     int frame_size, ret, frame_flags;

  1076. 

  1077.     if (avpkt->size <= WV_HEADER_SIZE)

  1078.         return AVERROR_INVALIDDATA;

  1079. 

  1080.     s->block     = 0;

  1081.     s->ch_offset = 0;

  1082. 

  1083.     /* determine number of samples */

  1084.     s->samples  = AV_RL32(buf + 20);

  1085.     frame_flags = AV_RL32(buf + 24);

  1086.     if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {

  1087.         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",

  1088.                s->samples);

  1089.         return AVERROR_INVALIDDATA;

  1090.     }

  1091. 

  1092.     if (frame_flags & 0x80) {

  1093.         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

  1094.     } else if ((frame_flags & 0x03) <= 1) {

  1095.         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

  1096.     } else {

  1097.         avctx->sample_fmt          = AV_SAMPLE_FMT_S32P;

  1098.         avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;

  1099.     }

  1100. 

  1101.     while (buf_size > 0) {

  1102.         if (buf_size <= WV_HEADER_SIZE)

  1103.             break;

  1104.         frame_size = AV_RL32(buf + 4) - 12;

  1105.         buf       += 20;

  1106.         buf_size  -= 20;

  1107.         if (frame_size <= 0 || frame_size > buf_size) {

  1108.             av_log(avctx, AV_LOG_ERROR,

  1109.                    "Block %d has invalid size (size %d vs. %d bytes left)\n",

  1110.                    s->block, frame_size, buf_size);

  1111.             wavpack_decode_flush(avctx);

  1112.             return AVERROR_INVALIDDATA;

  1113.         }

  1114.         if ((ret = wavpack_decode_block(avctx, s->block,

  1115.                                         frame, buf, frame_size)) < 0) {

  1116.             wavpack_decode_flush(avctx);

  1117.             return ret;

  1118.         }

  1119.         s->block++;

  1120.         buf      += frame_size;

  1121.         buf_size -= frame_size;

  1122.     }

  1123. 

  1124.     if (s->ch_offset != avctx->channels) {

  1125.         av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n");

  1126.         return AVERROR_INVALIDDATA;

  1127.     }

  1128. 

  1129.     *got_frame_ptr = 1;

  1130. 

  1131.     return avpkt->size;

  1132. }

  1133. 

  1134. AVCodec ff_wavpack_decoder = {

  1135.     .name           = "wavpack",

  1136.     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),

  1137.     .type           = AVMEDIA_TYPE_AUDIO,

  1138.     .id             = AV_CODEC_ID_WAVPACK,

  1139.     .priv_data_size = sizeof(WavpackContext),

  1140.     .init           = wavpack_decode_init,

  1141.     .close          = wavpack_decode_end,

  1142.     .decode         = wavpack_decode_frame,

  1143.     .flush          = wavpack_decode_flush,

  1144.     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

  1145.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

  1146. };