static int decode_packet(AVCodecContext *avctx,

                         void *data, int *data_size, AVPacket* avpkt)

{

    WmallDecodeCtx *s = avctx->priv_data;

    GetBitContext* gb  = &s->pgb;

    const uint8_t* buf = avpkt->data;

    int buf_size       = avpkt->size;

    int num_bits_prev_frame;

    int packet_sequence_number;



    s->samples       = data;

    s->samples_end   = (float*)((int8_t*)data + *data_size);

    *data_size = 0;



    if (s->packet_done || s->packet_loss) {

        s->packet_done = 0;



        /** sanity check for the buffer length */

        if (buf_size < avctx->block_align)

            return 0;



        s->next_packet_start = buf_size - avctx->block_align;

        buf_size = avctx->block_align;

        s->buf_bit_size = buf_size << 3;



        /** parse packet header */

        init_get_bits(gb, buf, s->buf_bit_size);

        packet_sequence_number = get_bits(gb, 4);

	int seekable_frame_in_packet = get_bits1(gb);

	int spliced_packet = get_bits1(gb);



        /** get number of bits that need to be added to the previous frame */

        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);



        /** check for packet loss */

        if (!s->packet_loss &&

            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {

            s->packet_loss = 1;

            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",

                   s->packet_sequence_number, packet_sequence_number);

        }

        s->packet_sequence_number = packet_sequence_number;



        if (num_bits_prev_frame > 0) {

            int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);

            if (num_bits_prev_frame >= remaining_packet_bits) {

                num_bits_prev_frame = remaining_packet_bits;

                s->packet_done = 1;

            }



            /** append the previous frame data to the remaining data from the

                previous packet to create a full frame */

            save_bits(s, gb, num_bits_prev_frame, 1);



            /** decode the cross packet frame if it is valid */

            if (!s->packet_loss)

		decode_frame(s);

        } else if (s->num_saved_bits - s->frame_offset) {

            dprintf(avctx, "ignoring %x previously saved bits\n",

                    s->num_saved_bits - s->frame_offset);

        }



        if (s->packet_loss) {

            /** reset number of saved bits so that the decoder

                does not start to decode incomplete frames in the

                s->len_prefix == 0 case */

            s->num_saved_bits = 0;

            s->packet_loss = 0;

        }



    } else {

        int frame_size;



        s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;

        init_get_bits(gb, avpkt->data, s->buf_bit_size);

        skip_bits(gb, s->packet_offset);



        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&

            (frame_size = show_bits(gb, s->log2_frame_size)) &&

            frame_size <= remaining_bits(s, gb)) {

            save_bits(s, gb, frame_size, 0);

            s->packet_done = !decode_frame(s);

        } else if (!s->len_prefix

                   && s->num_saved_bits > get_bits_count(&s->gb)) {

            /** when the frames do not have a length prefix, we don't know

                the compressed length of the individual frames

                however, we know what part of a new packet belongs to the

                previous frame

                therefore we save the incoming packet first, then we append

                the "previous frame" data from the next packet so that

                we get a buffer that only contains full frames */

            s->packet_done = !decode_frame(s);

        } else {

            s->packet_done = 1;

	}

    }



    if (s->packet_done && !s->packet_loss &&

        remaining_bits(s, gb) > 0) {

        /** save the rest of the data so that it can be decoded

            with the next packet */

        save_bits(s, gb, remaining_bits(s, gb), 0);

    }



    *data_size = 0; // (int8_t *)s->samples - (int8_t *)data;

    s->packet_offset = get_bits_count(gb) & 7;



    return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;

}

static int decode_packet(AVCodecContext *avctx,

                         void *data, int *data_size, AVPacket* avpkt)

{

    WmallDecodeCtx *s = avctx->priv_data;

    GetBitContext* gb  = &s->pgb;

    const uint8_t* buf = avpkt->data;

    int buf_size       = avpkt->size;

    int num_bits_prev_frame;

    int packet_sequence_number;



    s->samples       = data;

    s->samples_end   = (float*)((int8_t*)data + *data_size);

    *data_size = 0;



    if (s->packet_done || s->packet_loss) {

        s->packet_done = 0;



        

        if (buf_size < avctx->block_align)

            return 0;



        s->next_packet_start = buf_size - avctx->block_align;

        buf_size = avctx->block_align;

        s->buf_bit_size = buf_size << 3;



        

        init_get_bits(gb, buf, s->buf_bit_size);

        packet_sequence_number = get_bits(gb, 4);

	int seekable_frame_in_packet = get_bits1(gb);

	int spliced_packet = get_bits1(gb);



        

        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);



        

        if (!s->packet_loss &&

            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {

            s->packet_loss = 1;

            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",

                   s->packet_sequence_number, packet_sequence_number);

        }

        s->packet_sequence_number = packet_sequence_number;



        if (num_bits_prev_frame > 0) {

            int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);

            if (num_bits_prev_frame >= remaining_packet_bits) {

                num_bits_prev_frame = remaining_packet_bits;

                s->packet_done = 1;

            }



            



            save_bits(s, gb, num_bits_prev_frame, 1);



            

            if (!s->packet_loss)

		decode_frame(s);

        } else if (s->num_saved_bits - s->frame_offset) {

            dprintf(avctx, "ignoring %x previously saved bits\n",

                    s->num_saved_bits - s->frame_offset);

        }



        if (s->packet_loss) {

            





            s->num_saved_bits = 0;

            s->packet_loss = 0;

        }



    } else {

        int frame_size;



        s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;

        init_get_bits(gb, avpkt->data, s->buf_bit_size);

        skip_bits(gb, s->packet_offset);



        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&

            (frame_size = show_bits(gb, s->log2_frame_size)) &&

            frame_size <= remaining_bits(s, gb)) {

            save_bits(s, gb, frame_size, 0);

            s->packet_done = !decode_frame(s);

        } else if (!s->len_prefix

                   && s->num_saved_bits > get_bits_count(&s->gb)) {

            













            s->packet_done = !decode_frame(s);

        } else {

            s->packet_done = 1;

	}

    }



    if (s->packet_done && !s->packet_loss &&

        remaining_bits(s, gb) > 0) {

        



        save_bits(s, gb, remaining_bits(s, gb), 0);

    }



    *data_size = 0; 

    s->packet_offset = get_bits_count(gb) & 7;



    return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;

}

	int seekable_frame_in_packet = get_bits1(gb); 	int spliced_packet = get_bits1(gb); 		decode_frame(s);
static int FUNC_0(AVCodecContext *VAR_0,

                         void *VAR_1, int *VAR_2, AVPacket* VAR_3)

{

    WmallDecodeCtx *s = VAR_0->priv_data;

    GetBitContext* gb  = &s->pgb;

    const uint8_t* VAR_4 = VAR_3->VAR_1;

    int VAR_5       = VAR_3->size;

    int VAR_6;

    int VAR_7;



    s->samples       = VAR_1;

    s->samples_end   = (float*)((int8_t*)VAR_1 + *VAR_2);

    *VAR_2 = 0;



    if (s->packet_done || s->packet_loss) {

        s->packet_done = 0;



        

        if (VAR_5 < VAR_0->block_align)

            return 0;



        s->next_packet_start = VAR_5 - VAR_0->block_align;

        VAR_5 = VAR_0->block_align;

        s->buf_bit_size = VAR_5 << 3;



        

        init_get_bits(gb, VAR_4, s->buf_bit_size);

        VAR_7 = get_bits(gb, 4);

	int VAR_8 = get_bits1(gb);

	int VAR_9 = get_bits1(gb);



        

        VAR_6 = get_bits(gb, s->log2_frame_size);



        

        if (!s->packet_loss &&

            ((s->VAR_7 + 1) & 0xF) != VAR_7) {

            s->packet_loss = 1;

            av_log(VAR_0, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",

                   s->VAR_7, VAR_7);

        }

        s->VAR_7 = VAR_7;



        if (VAR_6 > 0) {

            int VAR_10 = s->buf_bit_size - get_bits_count(gb);

            if (VAR_6 >= VAR_10) {

                VAR_6 = VAR_10;

                s->packet_done = 1;

            }



            



            save_bits(s, gb, VAR_6, 1);



            

            if (!s->packet_loss)

		decode_frame(s);

        } else if (s->num_saved_bits - s->frame_offset) {

            dprintf(VAR_0, "ignoring %x previously saved bits\n",

                    s->num_saved_bits - s->frame_offset);

        }



        if (s->packet_loss) {

            





            s->num_saved_bits = 0;

            s->packet_loss = 0;

        }



    } else {

        int VAR_11;



        s->buf_bit_size = (VAR_3->size - s->next_packet_start) << 3;

        init_get_bits(gb, VAR_3->VAR_1, s->buf_bit_size);

        skip_bits(gb, s->packet_offset);



        if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&

            (VAR_11 = show_bits(gb, s->log2_frame_size)) &&

            VAR_11 <= remaining_bits(s, gb)) {

            save_bits(s, gb, VAR_11, 0);

            s->packet_done = !decode_frame(s);

        } else if (!s->len_prefix

                   && s->num_saved_bits > get_bits_count(&s->gb)) {

            













            s->packet_done = !decode_frame(s);

        } else {

            s->packet_done = 1;

	}

    }



    if (s->packet_done && !s->packet_loss &&

        remaining_bits(s, gb) > 0) {

        



        save_bits(s, gb, remaining_bits(s, gb), 0);

    }



    *VAR_2 = 0; 

    s->packet_offset = get_bits_count(gb) & 7;



    return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;

}

static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2, AVPacket* VAR_3)
{ WmallDecodeCtx *s = VAR_0->priv_data; GetBitContext* gb  = &s->pgb; const uint8_t* VAR_4 = VAR_3->VAR_1; int VAR_5       = VAR_3->size; int VAR_6; int VAR_7; s->samples       = VAR_1; s->samples_end   = (float*)((int8_t*)VAR_1 + *VAR_2); *VAR_2 = 0; if (s->packet_done || s->packet_loss) { s->packet_done = 0; if (VAR_5 < VAR_0->block_align)
return 0; s->next_packet_start = VAR_5 - VAR_0->block_align; VAR_5 = VAR_0->block_align; s->buf_bit_size = VAR_5 << 3; init_get_bits(gb, VAR_4, s->buf_bit_size); VAR_7 = get_bits(gb, 4); int VAR_8 = get_bits1(gb); int VAR_9 = get_bits1(gb); VAR_6 = get_bits(gb, s->log2_frame_size); if (!s->packet_loss &&
((s->VAR_7 + 1) & 0xF) != VAR_7) { s->packet_loss = 1; av_log(VAR_0, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
s->VAR_7, VAR_7); } s->VAR_7 = VAR_7; if (VAR_6 > 0) { int VAR_10 = s->buf_bit_size - get_bits_count(gb); if (VAR_6 >= VAR_10) { VAR_6 = VAR_10; s->packet_done = 1; } save_bits(s, gb, VAR_6, 1); if (!s->packet_loss)
decode_frame(s); } else if (s->num_saved_bits - s->frame_offset) { dprintf(VAR_0, "ignoring %x previously saved bits\n",
s->num_saved_bits - s->frame_offset); } if (s->packet_loss) { s->num_saved_bits = 0; s->packet_loss = 0; } } else { int VAR_11; s->buf_bit_size = (VAR_3->size - s->next_packet_start) << 3; init_get_bits(gb, VAR_3->VAR_1, s->buf_bit_size); skip_bits(gb, s->packet_offset); if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
(VAR_11 = show_bits(gb, s->log2_frame_size)) &&
VAR_11 <= remaining_bits(s, gb)) { save_bits(s, gb, VAR_11, 0); s->packet_done = !decode_frame(s); } else if (!s->len_prefix && s->num_saved_bits > get_bits_count(&s->gb)) { s->packet_done = !decode_frame(s); } else { s->packet_done = 1; } } if (s->packet_done && !s->packet_loss &&
remaining_bits(s, gb) > 0) { save_bits(s, gb, remaining_bits(s, gb), 0); } *VAR_2 = 0; s->packet_offset = get_bits_count(gb) & 7; return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3; }