static int decode_packet(AVCodecContext *avctx, void *data,
                         int *got_frame_ptr, AVPacket* avpkt)
{
    WMAProDecodeCtx *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;
    *got_frame_ptr = 0;
    if (s->skip_packets > 0) {
        s->skip_packets--;
        return FFMIN(avpkt->size, avctx->block_align);
    if (s->packet_done || s->packet_loss) {
        s->packet_done = 0;
        /** sanity check for the buffer length */
        if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
            av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
                   buf_size, avctx->block_align);
            return AVERROR_INVALIDDATA;
        if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
            s->next_packet_start = buf_size - avctx->block_align;
            buf_size = avctx->block_align;
        } else {
            s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
            buf_size = FFMIN(buf_size, avctx->block_align);
        s->buf_bit_size = buf_size << 3;
        /** parse packet header */
        init_get_bits(gb, buf, s->buf_bit_size);
        if (avctx->codec_id != AV_CODEC_ID_XMA2) {
            packet_sequence_number = get_bits(gb, 4);
            skip_bits(gb, 2);
        } else {
            s->num_frames = get_bits(gb, 6);
            packet_sequence_number = 0;
        /** get number of bits that need to be added to the previous frame */
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
        if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
            skip_bits(gb, 3);
            s->skip_packets = get_bits(gb, 8);
        ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
                num_bits_prev_frame);
        /** check for packet loss */
        if (avctx->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
            av_log(avctx, AV_LOG_ERROR,
                   "Packet loss detected! seq %"PRIx8" 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);
            ff_dlog(avctx, "accumulated %x bits of frame data\n",
                    s->num_saved_bits - s->frame_offset);
            /** decode the cross packet frame if it is valid */
            if (!s->packet_loss)
                decode_frame(s, data, got_frame_ptr);
        } else if (s->num_saved_bits - s->frame_offset) {
            ff_dlog(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);
            if (!s->packet_loss)
                s->packet_done = !decode_frame(s, data, got_frame_ptr);
        } 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, data, got_frame_ptr);
        } 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);
    s->packet_offset = get_bits_count(gb) & 7;
    if (s->packet_loss)
        return AVERROR_INVALIDDATA;
    return get_bits_count(gb) >> 3;
static int decode_packet(AVCodecContext *avctx, void *data,
                         int *got_frame_ptr, AVPacket* avpkt)
{
    WMAProDecodeCtx *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;
    *got_frame_ptr = 0;
    if (s->skip_packets > 0) {
        s->skip_packets--;
        return FFMIN(avpkt->size, avctx->block_align);
    if (s->packet_done || s->packet_loss) {
        s->packet_done = 0;
        
        if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
            av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
                   buf_size, avctx->block_align);
            return AVERROR_INVALIDDATA;
        if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
            s->next_packet_start = buf_size - avctx->block_align;
            buf_size = avctx->block_align;
        } else {
            s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
            buf_size = FFMIN(buf_size, avctx->block_align);
        s->buf_bit_size = buf_size << 3;
        
        init_get_bits(gb, buf, s->buf_bit_size);
        if (avctx->codec_id != AV_CODEC_ID_XMA2) {
            packet_sequence_number = get_bits(gb, 4);
            skip_bits(gb, 2);
        } else {
            s->num_frames = get_bits(gb, 6);
            packet_sequence_number = 0;
        
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
        if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
            skip_bits(gb, 3);
            s->skip_packets = get_bits(gb, 8);
        ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
                num_bits_prev_frame);
        
        if (avctx->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
            av_log(avctx, AV_LOG_ERROR,
                   "Packet loss detected! seq %"PRIx8" 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);
            ff_dlog(avctx, "accumulated %x bits of frame data\n",
                    s->num_saved_bits - s->frame_offset);
            
            if (!s->packet_loss)
                decode_frame(s, data, got_frame_ptr);
        } else if (s->num_saved_bits - s->frame_offset) {
            ff_dlog(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);
            if (!s->packet_loss)
                s->packet_done = !decode_frame(s, data, got_frame_ptr);
        } else if (!s->len_prefix
                   && s->num_saved_bits > get_bits_count(&s->gb)) {
            






            s->packet_done = !decode_frame(s, data, got_frame_ptr);
        } 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);
    s->packet_offset = get_bits_count(gb) & 7;
    if (s->packet_loss)
        return AVERROR_INVALIDDATA;
    return get_bits_count(gb) >> 3;
static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,
                         int *VAR_2, AVPacket* VAR_3)
{
    WMAProDecodeCtx *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;
    *VAR_2 = 0;
    if (s->skip_packets > 0) {
        s->skip_packets--;
        return FFMIN(VAR_3->size, VAR_0->block_align);
    if (s->packet_done || s->packet_loss) {
        s->packet_done = 0;
        
        if (VAR_0->codec_id == AV_CODEC_ID_WMAPRO && VAR_5 < VAR_0->block_align) {
            av_log(VAR_0, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
                   VAR_5, VAR_0->block_align);
            return AVERROR_INVALIDDATA;
        if (VAR_0->codec_id == AV_CODEC_ID_WMAPRO) {
            s->next_packet_start = VAR_5 - VAR_0->block_align;
            VAR_5 = VAR_0->block_align;
        } else {
            s->next_packet_start = VAR_5 - FFMIN(VAR_5, VAR_0->block_align);
            VAR_5 = FFMIN(VAR_5, VAR_0->block_align);
        s->buf_bit_size = VAR_5 << 3;
        
        init_get_bits(gb, VAR_4, s->buf_bit_size);
        if (VAR_0->codec_id != AV_CODEC_ID_XMA2) {
            VAR_7 = get_bits(gb, 4);
            skip_bits(gb, 2);
        } else {
            s->num_frames = get_bits(gb, 6);
            VAR_7 = 0;
        
        VAR_6 = get_bits(gb, s->log2_frame_size);
        if (VAR_0->codec_id != AV_CODEC_ID_WMAPRO) {
            skip_bits(gb, 3);
            s->skip_packets = get_bits(gb, 8);
        ff_dlog(VAR_0, "packet[%d]: nbpf %x\n", VAR_0->frame_number,
                VAR_6);
        
        if (VAR_0->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
            ((s->VAR_7 + 1) & 0xF) != VAR_7) {
            av_log(VAR_0, AV_LOG_ERROR,
                   "Packet loss detected! seq %"PRIx8" vs %x\n",
                   s->VAR_7, VAR_7);
        s->VAR_7 = VAR_7;
        if (VAR_6 > 0) {
            int VAR_8 = s->buf_bit_size - get_bits_count(gb);
            if (VAR_6 >= VAR_8) {
                VAR_6 = VAR_8;
                s->packet_done = 1;
            

            save_bits(s, gb, VAR_6, 1);
            ff_dlog(VAR_0, "accumulated %x bits of frame VAR_1\n",
                    s->num_saved_bits - s->frame_offset);
            
            if (!s->packet_loss)
                decode_frame(s, VAR_1, VAR_2);
        } else if (s->num_saved_bits - s->frame_offset) {
            ff_dlog(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_9;
        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_9 = show_bits(gb, s->log2_frame_size)) &&
            VAR_9 <= remaining_bits(s, gb)) {
            save_bits(s, gb, VAR_9, 0);
            if (!s->packet_loss)
                s->packet_done = !decode_frame(s, VAR_1, VAR_2);
        } else if (!s->len_prefix
                   && s->num_saved_bits > get_bits_count(&s->gb)) {
            






            s->packet_done = !decode_frame(s, VAR_1, VAR_2);
        } 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);
    s->packet_offset = get_bits_count(gb) & 7;
    if (s->packet_loss)
        return AVERROR_INVALIDDATA;
    return get_bits_count(gb) >> 3;
static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,
int *VAR_2, AVPacket* VAR_3)
{ WMAProDecodeCtx *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; *VAR_2 = 0; if (s->skip_packets > 0) { s->skip_packets--; return FFMIN(VAR_3->size, VAR_0->block_align); if (s->packet_done || s->packet_loss) { s->packet_done = 0; if (VAR_0->codec_id == AV_CODEC_ID_WMAPRO && VAR_5 < VAR_0->block_align) { av_log(VAR_0, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
VAR_5, VAR_0->block_align); return AVERROR_INVALIDDATA; if (VAR_0->codec_id == AV_CODEC_ID_WMAPRO) { s->next_packet_start = VAR_5 - VAR_0->block_align; VAR_5 = VAR_0->block_align; } else { s->next_packet_start = VAR_5 - FFMIN(VAR_5, VAR_0->block_align); VAR_5 = FFMIN(VAR_5, VAR_0->block_align); s->buf_bit_size = VAR_5 << 3; init_get_bits(gb, VAR_4, s->buf_bit_size); if (VAR_0->codec_id != AV_CODEC_ID_XMA2) { VAR_7 = get_bits(gb, 4); skip_bits(gb, 2); } else { s->num_frames = get_bits(gb, 6); VAR_7 = 0; VAR_6 = get_bits(gb, s->log2_frame_size); if (VAR_0->codec_id != AV_CODEC_ID_WMAPRO) { skip_bits(gb, 3); s->skip_packets = get_bits(gb, 8); ff_dlog(VAR_0, "packet[%d]: nbpf %x\n", VAR_0->frame_number,
VAR_6); if (VAR_0->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
((s->VAR_7 + 1) & 0xF) != VAR_7) { av_log(VAR_0, AV_LOG_ERROR,
"Packet loss detected! seq %"PRIx8" vs %x\n",
s->VAR_7, VAR_7); s->VAR_7 = VAR_7; if (VAR_6 > 0) { int VAR_8 = s->buf_bit_size - get_bits_count(gb); if (VAR_6 >= VAR_8) { VAR_6 = VAR_8; s->packet_done = 1; save_bits(s, gb, VAR_6, 1); ff_dlog(VAR_0, "accumulated %x bits of frame VAR_1\n",
s->num_saved_bits - s->frame_offset); if (!s->packet_loss)
decode_frame(s, VAR_1, VAR_2); } else if (s->num_saved_bits - s->frame_offset) { ff_dlog(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_9; 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_9 = show_bits(gb, s->log2_frame_size)) &&
VAR_9 <= remaining_bits(s, gb)) { save_bits(s, gb, VAR_9, 0); if (!s->packet_loss)
s->packet_done = !decode_frame(s, VAR_1, VAR_2); } else if (!s->len_prefix && s->num_saved_bits > get_bits_count(&s->gb)) { s->packet_done = !decode_frame(s, VAR_1, VAR_2); } 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); s->packet_offset = get_bits_count(gb) & 7; if (s->packet_loss)
return AVERROR_INVALIDDATA; return get_bits_count(gb) >> 3;