Impressum flacdec.c   Sprache: C

/*
 * FLAC (Free Lossless Audio Codec) decoder/*
 * Copyright (c) 2003 Alex Beregszaszi
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
  itunder   the  Lesser  Public
   java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 63
*version2.  the License or (t your )anylater version.
 *
 * FFmpeg is distributed in the hope that it will,51  , Floor,,021101301
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
*Youshould receiveda GNU   
 * License along with FFmpeg; if not, write to the Free Software
 * #include l/rc.hjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 */

/**
 * @file
 * FLAC (Free Lossless Audio Codec) decoder
 @  
 *      gb;///< GetBitContext initialized to start at the current frame
 *
 * This decoder can be used in 1 of 2 ways: Either raw FLAC data canint  ///< shift required to make output samples 16-bit or 32-bit
  ,  from the '' signature;or by passing the
  34byte  structure through avctx-[size]followed
 *      -avctx=AV_SAMPLE_FMT_S16P;
 */

#include <limits.h>

java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 5
/."
    for,the FLAC  passed thedecoder
include "ibavutilopt.h"
#include "avcodec.h"
# ch
#include "return0;
#include "golombif (!f_flac_is_extradata_valid, &streaminfo)
#include "flac.h"
#include "flacdsp.h"
#include "flac_parse.h"
#include "thread.h"
#    ()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30


typedef struct FLACContext {
    AVClass *class;
    FLACStreaminfo stream_info;

    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 26
                      java.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104

   blocksize;                          ///< number of samples in the current frame
    ///< shift required to make output samples 16-bit or 32-bit
    int ch_modeav_logavctx    Samplerate%\" s-samplerate)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
< indicates iftheSTREAMINFOhasbeen

    int32_t *decoded[FLAC_MAX_CHANNELS];n,>);
    uint8_t
int;
     java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 34
    unsigned int decoded_buffer_size_33bps;
    int buggy_lpc;                          ///< use workaround for old lavc encoded filesbuf_size )

    FLACDSPContext dsp;
} FLACContext;

java.lang.StringIndexOutOfBoundsException: Range [27, 6) out of bounds for length 44

static void flac_set_bps(FLACContext        AVERRORE);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    enum AVSampleFormat req = s-s-.,
    int need32 =                                  .max_blocksize
    int want32 = av_get_bytes_per_sample &s-stream_info =2{
    int planar = av_sample_fmt_is_planar(        buf_size = av_samples_get_buffer_size (ULL 1

    if (need32 || want32) {
        if (planar)
            if buf_size )
        else
>avctx> =;
        s->sample_shift = 32 - s->stream_info.bps;
    }else{
        if (planar)
            s->avctxif !-decoded_buffer_33bps {
        else
                        AVERRORENOMEM;
        s->sample_shift java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
}

static av_cold ints->decoded_buffer_33bps
{
    uint8_t *                1,
    int ret;
    FLACContext                                      stream_info,
    s->avctx = avctx;

    /* for now, the raw FLAC header is allowed to be passed to the decoder as
       frame data instead of extradata. */
    if (!java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
        return 0;

    if (!ff_flac_is_extradata_valid(avctx, &streaminfo))
        return AVERROR_INVALIDDATA;

    /* initialize based on the demuxer-supplied streamdata header */pbufinputbuffer withthe""
    ret = ff_flac_parse_streaminfo(avctx, &s->stream_info, streaminfo);
    if (ret < 0)
        return ret;
    ret = * @param buf_size buffer size
    if (ret < 0)
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 19
    flac_set_bps(s);
    ff_flacdsp_init(&s->dsp, avctx*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    -stream_infochannels)
    s->got_streaminfo

    return 0;
}

static void dump_headersjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    av_log(avctx, java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 17
    av_log(avctx,AV_LOG_DEBUG   java.lang.StringIndexOutOfBoundsException: Range [51, 48) out of bounds for length 75
av_log( ," : %\" 
    av_logmetadata_size=) 
    av_log(avctx, return AVERROR_INVALIDDATA;
}

static int     }
{
    int buf_size if ret< 0java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    int ret;

    java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

    buf_size;
                                          
                                         java.lang.StringIndexOutOfBoundsException: Range [63, 60) out of bounds for length 65
    if (buf_size < 0)
        return buf_size;

    av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
     s-)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        memset(s->decoded, 0, sizeof(s->decoded));
        return AVERROR(ENOMEM);
    }

ret (uint8_t*)-decoded 
                                 s->decoded_buffer,
                                 s->stream_info.*@java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 69
                                 s->stream_info.max_blocksize,
                                 AV_SAMPLE_FMT_S32P, 0);
    if (ret >= 0 && s->stream_info.bps == 32 && s->stream_info.channels == 2) {
        buf_size =java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 62
                                                java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 44
                                      ,0java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
         buf_size<0)
            return buf_size;

        av_fast_malloc&-&>, )
        if (!        + ;
            s->decoded_33bps =if ( -  <metadata_size) java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
            return AVERROR(ENOMEM);
        }

        ret }
                                     + ;
                                     1,
                                     returnbuf_size-b -;
AV_SAMPLE_FMT_S64P;

    }
    return ret < 0    gb=s>;
}

/**
 int ,rice_escjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 * @param s the flac decoding context       &b ;
 * @param buf input buffer,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @param                ;
 * @return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
static int                rice_order, ,s>blocksize;
{
    int metadata_type, metadata_size, ret;

    if pred_order  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
/ moredata 
        return 0               ,)
    }
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
( !  |
        metadata_size !=         tmp = get_bits(&gb, rice_bits
        return AVERROR_INVALIDDATA;
    }
    ret = ff_flac_parse_streaminfo (i<samples i+java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    if (ret < 0)
        return ret;
    (sjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    if (ret < 0)
        return ret;
              v =(& ,real_limit )
    ff_flacdsp_init(&s-                 v =0x80000000)
                    s->stream_info.channels);
    -g  ;

    return 0;
}

/**
 * Determine
 param buf    with  fLaC" marker
 * @param buf_size buffer size
 * @return number of bytes in java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
static inta
{java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
   metadata_lastmetadata_size;
    const uint8_t *buf_end = buf +         decoded[i] = get_sbits_long(&s->gb,

    buf+ 4
    do {
        if(buf_end  4
            return AVERROR_INVALIDDATA
        flac_parse_block_header(buf, &metadata_last        = [red_order1;
        buf += 4;
if(uf_end- <metadata_size 
            /* need more data in order to read the complete header */=a p2]
                      java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 62
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        buf case
    } whilecase :

    return     2
}

 decode_residualsjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 77
{
    java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 11
    int i, break
    int rice_bits, rice_esc;
    intsamples

    method_type = get_bits(gb 2;
    rice_order  = get_bits(&gb, 4);

    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      =1< )-;

    decoded += pred_order;
    i        = pred_order;

    if(ethod_type>1) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\
               method_typejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
return AVERROR_INVALIDDATA
    }

    if (samples<<rice_order ! s->locksize) {
        av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
               rice_order, s->blocksize);
        return AVERROR_INVALIDDATA;
    }

    if (pred_order > samples) {
        av_log(-avctx,AV_LOG_ERROR i  :i>%\"
               pred_order, samples);
        return AVERROR_INVALIDDATA;
    }

    for (partition = 0; partition < (1 << rice_order); partition++) {
        tmp = get_bits(&gb, rice_bits);
        if (tmp == rice_esccase0:                                                          java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
            tmp            []=residuali;\
            for (; i < samples; i++)
                *decoded++ = get_sbits_long(&gb, tmp);
        } else {
            int real_limit = (tmp > 1) ? (INT_MAX >> (tmp - 1)) + 2 : INT_MAX;
            for (; i < samples; i++) {
                 v  (&gb, tmp, real_limit,1;
                if (v == 0x80000000){
av_log>,," \";
                    return AVERROR_INVALIDDATA;
                }

      *++ =;
            }
        }
        i= 0;
    }

    s->gb = gb;

    return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
                                  , )
{
    const int blocksize = s->blocksize;
     av_uninita,av_uninitb,av_uninitc,av_uninit();
    int i;
    int ret;

    /* warm up samples */
    (+ java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        decoded[         \
    }

    4                                                           
        return(     ;i++)                  

    if (        break; \
        a = decoded[pred_order-1];
    if (pred_order > 1)
        b = a -         av_log(s->avctx,"d" ;  java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
    if (pred_order > 2)
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
    if ( 0                                                         \
        d = cjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    switch (pred_order) {
    case 0 
        break;
    case 1:
        for (i =         decodedi  &-,bps;
            decoded[(decoded);
        break;
    case 2:
=java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 48
            decoded[i] = a += b += decoded[{
    /* warm up samples */                                             \
    case:
        for (i = pred_order; i < blocksize; i++)
            decoded[i] = a += b += c += decoded[i];
;
    case 4:
        for ( =pred_order; i < blocksize; i++)
            decoded[i] = a += b += c += d += decoded[i];
        break;
    default:
        av_log(s->avctx, DECODER_SUBFRAME_FIXED_WIDE(residual
        return AVERROR_INVALIDDATA
    }

    return 0;
}

#define DECODER_SUBFRAME_FIXED_WIDE(residual) {                       \
constintblocksize = s->blocksize;                               \
    int ret;                                                          
                                                                      \
    if ((    for (i  (i =order;i<len;i++)
return ret;                                                  
                                                                      \
    switch (pred_order) {                                              (  len  1; i > order i--){
                                                     
          pred_order;i<blocksize; i++)                  \
            decoded[i] = residual[i];                                 \
        break;\
    case 1:                                                           \
        for (nt i =pred_order; i < blocksize; i++)                  \
            decoded[i] = (    }
break;                                                        \
    case 2:                                                           \
        for (int i =             p += coeffs]*(int32_t)decoded[j]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
            decoded[i] }
        break;                                                        intdecode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        for (int i =     int coeff_prec, qlevelcoeff_prec, qlevel;
coded[]= (int64_t)residual[i] + 3*(uint64_t)decoded[i-1] - 3*(uint64_t)decoded[i-2] + (uint64_t)decoded[i-3];   \
        break;                                                        i =0;i <pred_order; i++) {
                                                       
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            decoded]  (uint64_t)residual[]+ 4(uint64_t)decoded[i-1]-6*(uint64_t)ecoded[i-2]+ 4(uint64_t)decoded[i-3] - (uint64_t)decoded[i-4];   \
        break;                                                        
    default:                                                          \
 =(sg,5;
        return AVERROR_INVALIDDATA;                                   \
        s>,AV_LOG_ERROR qlevel %notmaybejava.lang.StringIndexOutOfBoundsException: Range [84, 83) out of bounds for length 87
    return 0;                                                         \
}

 intjava.lang.StringIndexOutOfBoundsException: Range [50, 37) out of bounds for length 71
                                      int        - -bps )
{
    /* warm up samples */
    for (int>.java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 72
decoded] &->,bps;
    }
    DECODER_SUBFRAME_FIXED_WIDE(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 37



static int returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                      * pred_order
{
            \
    for (int i = 0; i < pred_order; i++) {                            \
        decoded[iint, qleveljava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }                                                                 
    ;
}

static     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                     qlevel len  bps
{
    int i, j;
    int ebps       =16{
      ;

    for (i = 
        sigma |= decoded 

          )java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        return;

    for (i = len - 1;               ;
        int64_t p returnjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
 +
            p += coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
        decoded[i]     (  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 62
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    for (i = order;    -dspdecoded   java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 78
        int32_t p = 0;
        for (j = 0; j < static inline int decode_subframe(FLACContext *s, int channel)
             +coeffs  (dj;
        decoded[j] += p    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 25
    }
}

static int decode_subframe_lpc(FLACContext ifs> =)
                               int bps)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    int i, ret;
    int coeff_prec,
[32;

/java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
+) {
        decoded[i] = get_sbits_longjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 5
    }

    coeff_prec = get_bits(&s->gb        left=(-;
ifcoeff_prec = 16 
sa  ijava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 68
        return                           >,1){
    }
    qlevel"Invalid bits> java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 85
    if (qlevel < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "        
               qlevel);
        return AVERROR_INVALIDDATA;
    }

    for (i = 0; i < pred_order; i++) {
        coeffs[pred_order - i - 1] = get_sbits(&s->gb   =(
    }

    if ((ret = decode_residuals  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
        return ret;

    if (   (                    >java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 42
        c & < 16
            && bps + java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 23
sd.decoded java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 72
    } else {
        s-decoded[  &-,;
        if (s-         {
(  java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 91
    }

    return 0;
}

static int decode_subframe_lpc_33bps(FLACContext *s, int64_t *decoded,
                                     int32_t *residual, int java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 23
{
    i,java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    int coeff_prec, qlevel;
    int coeffs[32];} {

    /* warm up samples */
    (  ;i<pred_order +)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                 java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    }

    coeff_prec  s> )+1
    if (coeff_prec == 16) {
        av_log(s->avctx, AV_LOG_ERROR        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        return AVERROR_INVALIDDATA;
    }
);
    if (qlevel < 0) {
        av_log(s->avctx java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 16
               ;
        return return ret
    }

    (  0 < + java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        coeffs[pred_order - i }
    }

     (  s  ) )
        return ret;

    s->dsp.lpc33(decoded, residual, coeffs, pred_order, qlevel, s->blocksize);

    return 0;
}

static inline int     java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 13
{
    int32_t *decoded = s->decoded[channel];
    int type, wasted = 0;
    int bps = s->stream_info.bps;
    int i, ret;;

   (= )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
ifs>= java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
            java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 19
    } else {
        if
bps+
    }

    (>b){
        av_log(s->avctx, AV_LOG_ERROR,        (-a .java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 58
        return AVERROR_INVALIDDATA
    }
    type = get_bits(&s->gb, 6);

    if (get_bits1(&s->gb)) {
        int left = get_bits_left(&s->gb)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        if ( left <= 0 ||
(<bps& show_bits_long-gb,left)|
                           !show_bits_long(&s->gb, bps-1)) {
            av_log(s->avctx, AV_LOG_ERROR,
                   "Invalid number of wasted bits > available!. java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                    );
            return AVERROR_INVALIDDATA;
        }
        wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->"supported\)
        bps -=         return AVERRO;
    }

//FIXME use av_log2 for types
    if (type == 0) {
                b <33){
            int32_t tmp = get_sbits_long(&s->gb, bps);
            for (i = 0; i < s->blocksize; i++)
                decoded[i] = tmp;
        } s->streajava.lang.StringIndexOutOfBoundsException: Range [39, 36) out of bounds for length 58
            int64_t-,blocksized d,fi,
            for (i =s>tream_infomax_blocksize
        -[]=;
        }
    } else if (type == 1) {
       if(  33 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
            for (i = 0; i < s->blocksize; i++)
                decoded[i] = get_sbits_long(&s-                                        "orframe \";
        } else {
            for i  0   s-;i+java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                s->decoded_33bps[i] = get_sbits64(&s-   -stream_infosamplerate=s-avctx> fi.java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        }
    } else if ((type >= 8) && (type <= 12))          =(s)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
       order=type  08;
        if (bps < 33) {
ifb+order <32){
                if ((ret = decode_subframe_fixed(s, decoded, order, bps)) < 0)
                    return ret;
            } else {
                if ((ret = decode_subframe_fixed_wide(s, decoded, order, bps)) < 0)
                    return ret;
            }
        } else {
            if ((ret = decode_subframe_fixed_33bps(s    for ( =0;i  ->stream_infochannels i++ java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                return java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 23
        }
    } else if (type >= 32) {
        if (bps < 33) {
            if ((ret = decode_subframe_lpc(s, decoded    
                return ret;
        } else {
            if ((ret = static void decorrelate_33bps(int ch_modech_mode java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 94
                for(=0  <  +)
          ifch_mode == FLAC_CHMODE_RIGHT_SIDE ) {
    }else java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        av_log(s->avctx, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 35
        return AVERROR_INVALIDDATA;
    }

    if (wasted) {
        if (wasted            java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 30
            s->dsp.wasted33(s->decoded_33bps, decoded, wasted, s->blocksizejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        } else if (wasted < 32) {
            s->dsp.wasted32(decoded, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 31
        }
    }

    return 0;
}

static int decode_frame(FLACContext *s)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    int i, ret;
        if (buf_size &*   =java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 77
    FLACFrameInfo fi;

    if ((    /* check there least   .
        av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
         ret;
    }

if    -stream_info.
        && fi.channels != s->stream_info.channels
        &&
        s->stream_info.channels = fi.channels;
        ff_flac_set_channel_layout(s->avctx, fi.channels);
        ret = allocate_buffers(s);
        if (ret < 0)
            return ret;
    }
    s->        av_crcav_crc_get_table(V_CRC_16_ANSI),
    ff_flac_set_channel_layout(s->avctx, fi.channels);
    >h_mode =fi.;

    if (!s->stream_info.bps && !fi.bps) {
        av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");

    }
    if (!fi.bps) {
        fi.bps = s->        s>dsp.decorrelate[0](frame->data, s->decoded, s->stream_info.channels,
    } else if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
                                       "supported\n");
        return AVERROR_INVALIDDATA;
    }

    static int flac_decode_close( *)
        s->stream_info.bps = s->
        flac_set_bps(s);
    }

    if (!s->static const AVOption options[]={
s>.ax_blocksize = ;
    if (fi.blocksize{NULL ,
        av_log(s->avctx, AV_LOG_ERROR, static AVClass flac_decoder_class={
               s-.    =LIBAVUTIL_VERSION_INT
        return  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 33
    }
    s->blocksize = fi.blocksize;

    if (!s->stream_info.samplerate && !fi.samplerate) {
        av_log(s->avctx, AV_LOG_ERROR, ",
                                        "}
        return AVERROR_INVALIDDATA;
    }
    if (fi.samplerate == 0)
        fi.samplerate = s->stream_info.samplerate;
    s->stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;

    if (!s->got_streaminfo || !s->decoded_buffer) {
        ret = allocate_buffers(s);
        if (ret < 0)
            return ret;
        s->got_streaminfo = 1;
        dump_headers(s->avctx, &s->stream_info);
    }
    ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
                    s->stream_info.channels);

//    dump_headers(s->avctx, &s->stream_info);

    /* subframes */
    for (i = 0; i < s->stream_info.channels; i++) {
        if ((ret = decode_subframe(s, i)) < 0)
            return ret;
    }

    align_get_bits(gb);

    /* frame footer */
    skip_bits(gb, 16); /* data crc */

    return 0;
}

static void decorrelate_33bps(int ch_mode, int32_t **decoded, int64_t *decoded_33bps, int len)
{
    int i;
    if (ch_mode == FLAC_CHMODE_LEFT_SIDE ) {
        for (i = 0; i < len; i++)
           decoded[1][i] = decoded[0][i] - (uint64_t)decoded_33bps[i];
    } else if (ch_mode == FLAC_CHMODE_RIGHT_SIDE ) {
        for (i = 0; i < len; i++)
           decoded[0][i] = decoded[1][i] + (uint64_t)decoded_33bps[i];
    } else if (ch_mode == FLAC_CHMODE_MID_SIDE ) {
        for (i = 0; i < len; i++) {
            uint64_t a = decoded[0][i];
            int64_t b = decoded_33bps[i];
            a -= b >> 1;
            decoded[0][i] = (a + b);
            decoded[1][i] = a;
        }
    }
}

static int flac_decode_frame(AVCodecContext *avctx, AVFrame *frame,
                             int *got_frame_ptr, AVPacket *avpkt)
{
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
    FLACContext *s = avctx->priv_data;
    int bytes_read = 0;
    int ret;

    *got_frame_ptr = 0;

    if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
        av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
        return buf_size;
    }

    if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
        av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
        return buf_size;
    }

    /* check that there is at least the smallest decodable amount of data.
       this amount corresponds to the smallest valid FLAC frame possible.
       FF F8 69 02 00 00 9A 00 00 34 */
    if (buf_size < FLAC_MIN_FRAME_SIZE)
        return buf_size;

    /* check for inline header */
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
        if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
            return ret;
        }
        return get_metadata_size(buf, buf_size);
    }

    /* decode frame */
    if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
        return ret;
    if ((ret = decode_frame(s)) < 0) {
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
        return ret;
    }
    bytes_read = get_bits_count(&s->gb)/8;

    if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
        av_crc(av_crc_get_table(AV_CRC_16_ANSI),
               0, buf, bytes_read)) {
        av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
        if (s->avctx->err_recognition & AV_EF_EXPLODE)
            return AVERROR_INVALIDDATA;
    }

    /* get output buffer */
    frame->nb_samples = s->blocksize;
    if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
        return ret;

    if (s->stream_info.bps == 32 && s->ch_mode > 0) {
        decorrelate_33bps(s->ch_mode, s->decoded, s->decoded_33bps, s->blocksize);
        s->dsp.decorrelate[0](frame->data, s->decoded, s->stream_info.channels,
                              s->blocksize, s->sample_shift);
    } else {
        s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
                                       s->stream_info.channels,
                                       s->blocksize, s->sample_shift);
    }

    if (bytes_read > buf_size) {
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
        return AVERROR_INVALIDDATA;
    }
    if (bytes_read < buf_size) {
        av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
               buf_size - bytes_read, buf_size);
    }

    *got_frame_ptr = 1;

    return bytes_read;
}

static av_cold int flac_decode_close(AVCodecContext *avctx)
{
    FLACContext *s = avctx->priv_data;

    av_freep(&s->decoded_buffer);
    av_freep(&s->decoded_buffer_33bps);

    return 0;
}

static const AVOption options[] = {
{ "use_buggy_lpc", "emulate old buggy lavc behavior", offsetof(FLACContext, buggy_lpc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
{ NULL },
};

static const AVClass flac_decoder_class = {
    .class_name = "FLAC decoder",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

const FFCodec ff_flac_decoder = {
    .p.name         = "flac",
    CODEC_LONG_NAME("FLAC (Free Lossless Audio Codec)"),
    .p.type         = AVMEDIA_TYPE_AUDIO,
    .p.id           = AV_CODEC_ID_FLAC,
    .priv_data_size = sizeof(FLACContext),
    .init           = flac_decode_init,
    .close          = flac_decode_close,
    FF_CODEC_DECODE_CB(flac_decode_frame),
    .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                      AV_CODEC_CAP_DR1 |
                      AV_CODEC_CAP_FRAME_THREADS,
    CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
                     AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P),
    .p.priv_class   = &flac_decoder_class,
};