/*
 * Decompiled with CFR 0.152.
 */
package de.maxhenkel.voicechat.concentus;

import de.maxhenkel.voicechat.concentus.BoxedValueByte;
import de.maxhenkel.voicechat.concentus.BoxedValueInt;
import de.maxhenkel.voicechat.concentus.ChannelLayout;
import de.maxhenkel.voicechat.concentus.Inlines;
import de.maxhenkel.voicechat.concentus.OpusBandwidth;
import de.maxhenkel.voicechat.concentus.OpusDecoder;
import de.maxhenkel.voicechat.concentus.OpusError;
import de.maxhenkel.voicechat.concentus.OpusException;
import de.maxhenkel.voicechat.concentus.OpusMultistream;
import de.maxhenkel.voicechat.concentus.OpusPacketInfo;

public class OpusMSDecoder {
    ChannelLayout layout = new ChannelLayout();
    OpusDecoder[] decoders = null;

    private OpusMSDecoder(int nb_streams, int nb_coupled_streams) {
        this.decoders = new OpusDecoder[nb_streams];
        for (int c = 0; c < nb_streams; ++c) {
            this.decoders[c] = new OpusDecoder();
        }
    }

    int opus_multistream_decoder_init(int Fs, int channels, int streams, int coupled_streams, short[] mapping) {
        int ret;
        int i;
        int decoder_ptr = 0;
        if (channels > 255 || channels < 1 || coupled_streams > streams || streams < 1 || coupled_streams < 0 || streams > 255 - coupled_streams) {
            throw new IllegalArgumentException("Invalid channel or coupled stream count");
        }
        this.layout.nb_channels = channels;
        this.layout.nb_streams = streams;
        this.layout.nb_coupled_streams = coupled_streams;
        for (i = 0; i < this.layout.nb_channels; ++i) {
            this.layout.mapping[i] = mapping[i];
        }
        if (OpusMultistream.validate_layout(this.layout) == 0) {
            throw new IllegalArgumentException("Invalid surround channel layout");
        }
        for (i = 0; i < this.layout.nb_coupled_streams; ++i) {
            ret = this.decoders[decoder_ptr].opus_decoder_init(Fs, 2);
            if (ret != OpusError.OPUS_OK) {
                return ret;
            }
            ++decoder_ptr;
        }
        while (i < this.layout.nb_streams) {
            ret = this.decoders[decoder_ptr].opus_decoder_init(Fs, 1);
            if (ret != OpusError.OPUS_OK) {
                return ret;
            }
            ++decoder_ptr;
            ++i;
        }
        return OpusError.OPUS_OK;
    }

    public static OpusMSDecoder create(int Fs, int channels, int streams, int coupled_streams, short[] mapping) throws OpusException {
        if (channels > 255 || channels < 1 || coupled_streams > streams || streams < 1 || coupled_streams < 0 || streams > 255 - coupled_streams) {
            throw new IllegalArgumentException("Invalid channel / stream configuration");
        }
        OpusMSDecoder st = new OpusMSDecoder(streams, coupled_streams);
        int ret = st.opus_multistream_decoder_init(Fs, channels, streams, coupled_streams, mapping);
        if (ret != OpusError.OPUS_OK) {
            if (ret == OpusError.OPUS_BAD_ARG) {
                throw new IllegalArgumentException("Bad argument while creating MS decoder");
            }
            throw new OpusException("Could not create MS decoder", ret);
        }
        return st;
    }

    static int opus_multistream_packet_validate(byte[] data, int data_ptr, int len, int nb_streams, int Fs) {
        BoxedValueByte toc = new BoxedValueByte(0);
        short[] size = new short[48];
        int samples = 0;
        BoxedValueInt packet_offset = new BoxedValueInt(0);
        BoxedValueInt dummy = new BoxedValueInt(0);
        for (int s = 0; s < nb_streams; ++s) {
            if (len <= 0) {
                return OpusError.OPUS_INVALID_PACKET;
            }
            int count = OpusPacketInfo.opus_packet_parse_impl(data, data_ptr, len, s != nb_streams - 1 ? 1 : 0, toc, null, 0, size, 0, dummy, packet_offset);
            if (count < 0) {
                return count;
            }
            int tmp_samples = OpusPacketInfo.getNumSamples(data, data_ptr, packet_offset.Val, Fs);
            if (s != 0 && samples != tmp_samples) {
                return OpusError.OPUS_INVALID_PACKET;
            }
            samples = tmp_samples;
            data_ptr += packet_offset.Val;
            len -= packet_offset.Val;
        }
        return samples;
    }

    int opus_multistream_decode_native(byte[] data, int data_ptr, int len, short[] pcm, int pcm_ptr, int frame_size, int decode_fec, int soft_clip) {
        boolean do_plc = false;
        int Fs = this.getSampleRate();
        frame_size = Inlines.IMIN(frame_size, Fs / 25 * 3);
        short[] buf = new short[2 * frame_size];
        int decoder_ptr = 0;
        if (len == 0) {
            do_plc = true;
        }
        if (len < 0) {
            return OpusError.OPUS_BAD_ARG;
        }
        if (!do_plc && len < 2 * this.layout.nb_streams - 1) {
            return OpusError.OPUS_INVALID_PACKET;
        }
        if (!do_plc) {
            int ret = OpusMSDecoder.opus_multistream_packet_validate(data, data_ptr, len, this.layout.nb_streams, Fs);
            if (ret < 0) {
                return ret;
            }
            if (ret > frame_size) {
                return OpusError.OPUS_BUFFER_TOO_SMALL;
            }
        }
        for (int s = 0; s < this.layout.nb_streams; ++s) {
            int chan;
            int prev;
            OpusDecoder dec = this.decoders[decoder_ptr++];
            if (!do_plc && len <= 0) {
                return OpusError.OPUS_INTERNAL_ERROR;
            }
            BoxedValueInt packet_offset = new BoxedValueInt(0);
            int ret = dec.opus_decode_native(data, data_ptr, len, buf, 0, frame_size, decode_fec, s != this.layout.nb_streams - 1 ? 1 : 0, packet_offset, soft_clip);
            data_ptr += packet_offset.Val;
            len -= packet_offset.Val;
            if (ret <= 0) {
                return ret;
            }
            frame_size = ret;
            if (s < this.layout.nb_coupled_streams) {
                prev = -1;
                while ((chan = OpusMultistream.get_left_channel(this.layout, s, prev)) != -1) {
                    OpusMSDecoder.opus_copy_channel_out_short(pcm, pcm_ptr, this.layout.nb_channels, chan, buf, 0, 2, frame_size);
                    prev = chan;
                }
                prev = -1;
                while ((chan = OpusMultistream.get_right_channel(this.layout, s, prev)) != -1) {
                    OpusMSDecoder.opus_copy_channel_out_short(pcm, pcm_ptr, this.layout.nb_channels, chan, buf, 1, 2, frame_size);
                    prev = chan;
                }
                continue;
            }
            prev = -1;
            while ((chan = OpusMultistream.get_mono_channel(this.layout, s, prev)) != -1) {
                OpusMSDecoder.opus_copy_channel_out_short(pcm, pcm_ptr, this.layout.nb_channels, chan, buf, 0, 1, frame_size);
                prev = chan;
            }
        }
        for (int c = 0; c < this.layout.nb_channels; ++c) {
            if (this.layout.mapping[c] != 255) continue;
            OpusMSDecoder.opus_copy_channel_out_short(pcm, pcm_ptr, this.layout.nb_channels, c, null, 0, 0, frame_size);
        }
        return frame_size;
    }

    static void opus_copy_channel_out_short(short[] dst, int dst_ptr, int dst_stride, int dst_channel, short[] src, int src_ptr, int src_stride, int frame_size) {
        if (src != null) {
            for (int i = 0; i < frame_size; ++i) {
                dst[i * dst_stride + dst_channel + dst_ptr] = src[i * src_stride + src_ptr];
            }
        } else {
            for (int i = 0; i < frame_size; ++i) {
                dst[i * dst_stride + dst_channel + dst_ptr] = 0;
            }
        }
    }

    public int decodeMultistream(byte[] data, int data_offset, int len, short[] out_pcm, int out_pcm_offset, int frame_size, int decode_fec) {
        return this.opus_multistream_decode_native(data, data_offset, len, out_pcm, out_pcm_offset, frame_size, decode_fec, 0);
    }

    public OpusBandwidth getBandwidth() {
        if (this.decoders == null || this.decoders.length == 0) {
            throw new IllegalStateException("Decoder not initialized");
        }
        return this.decoders[0].getBandwidth();
    }

    public int getSampleRate() {
        if (this.decoders == null || this.decoders.length == 0) {
            throw new IllegalStateException("Decoder not initialized");
        }
        return this.decoders[0].getSampleRate();
    }

    public int getGain() {
        if (this.decoders == null || this.decoders.length == 0) {
            throw new IllegalStateException("Decoder not initialized");
        }
        return this.decoders[0].getGain();
    }

    public void setGain(int value) {
        for (int s = 0; s < this.layout.nb_streams; ++s) {
            this.decoders[s].setGain(value);
        }
    }

    public int getLastPacketDuration() {
        if (this.decoders == null || this.decoders.length == 0) {
            return OpusError.OPUS_INVALID_STATE;
        }
        return this.decoders[0].getLastPacketDuration();
    }

    public int getFinalRange() {
        int value = 0;
        for (int s = 0; s < this.layout.nb_streams; ++s) {
            value ^= this.decoders[s].getFinalRange();
        }
        return value;
    }

    public void ResetState() {
        for (int s = 0; s < this.layout.nb_streams; ++s) {
            this.decoders[s].resetState();
        }
    }

    public OpusDecoder GetMultistreamDecoderState(int streamId) {
        return this.decoders[streamId];
    }
}