package com.tencent.decoder;

import android.annotation.TargetApi;
import android.media.AudioManager;
import android.media.AudioTrack;
import android.media.MediaCodec;
import android.media.MediaCodecList;
import android.media.MediaCrypto;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.util.Log;
import android.view.Surface;
import java.io.IOException;
import java.nio.ByteBuffer;

/* JADX INFO: loaded from: classes.dex */
public class AudioDecoder {
    private static final int TIMEOUTUS = 100;
    private AudioManager mAudioMgr;
    private AudioTrack mAudioTrack;
    private MediaCodec.BufferInfo mBufInfo;
    private MediaCodec mCodec;
    private ByteBuffer mCsd;
    private byte[] mCsdData;
    private Thread mDecoderThread;
    private eosCbinterface mEosCb;
    private MediaExtractor mExtractor;
    private MediaFormat mFormat;
    private ByteBuffer[] mInputBuf;
    private ByteBuffer[] mOutputBuf;
    private int mTrackBufSz;
    private final String TAG = "AUDIODEC";
    private boolean mEos = false;
    private boolean mThreadStart = false;
    private int mSampleRate = 0;
    private int mChannel = 0;

    public class b implements Runnable {
        private b() {
        }

        @Override // java.lang.Runnable
        public void run() {
            int iDequeueOutputBuffer;
            String str;
            AudioDecoder audioDecoder = AudioDecoder.this;
            audioDecoder.mInputBuf = audioDecoder.mCodec.getInputBuffers();
            AudioDecoder audioDecoder2 = AudioDecoder.this;
            audioDecoder2.mOutputBuf = audioDecoder2.mCodec.getOutputBuffers();
            AudioDecoder.this.mBufInfo = new MediaCodec.BufferInfo();
            AudioDecoder.this.mAudioTrack.play();
            while (true) {
                if (AudioDecoder.this.mEos || !AudioDecoder.this.mThreadStart || Thread.interrupted()) {
                    break;
                }
                int iDequeueInputBuffer = AudioDecoder.this.mCodec.dequeueInputBuffer(100L);
                if (iDequeueInputBuffer >= 0) {
                    int sampleData = AudioDecoder.this.mExtractor.readSampleData(AudioDecoder.this.mInputBuf[iDequeueInputBuffer], 0);
                    MediaCodec mediaCodec = AudioDecoder.this.mCodec;
                    if (sampleData < 0) {
                        mediaCodec.queueInputBuffer(iDequeueInputBuffer, 0, 0, 0L, 4);
                        AudioDecoder.this.mEos = true;
                    } else {
                        mediaCodec.queueInputBuffer(iDequeueInputBuffer, 0, sampleData, AudioDecoder.this.mExtractor.getSampleTime(), 0);
                        AudioDecoder.this.mExtractor.advance();
                    }
                }
                try {
                    iDequeueOutputBuffer = AudioDecoder.this.mCodec.dequeueOutputBuffer(AudioDecoder.this.mBufInfo, 100L);
                } catch (Exception unused) {
                    Log.e("AUDIODEC", "OutputBuffer dequeueOutputBuffer exception");
                    iDequeueOutputBuffer = 0;
                }
                if (iDequeueOutputBuffer != -3) {
                    if (iDequeueOutputBuffer == -2) {
                        AudioDecoder audioDecoder3 = AudioDecoder.this;
                        audioDecoder3.mFormat = audioDecoder3.mCodec.getOutputFormat();
                        AudioDecoder.this.mAudioTrack.setPlaybackRate(AudioDecoder.this.mFormat.getInteger("sample-rate"));
                        str = "New format : " + AudioDecoder.this.mFormat;
                    } else if (iDequeueOutputBuffer != -1) {
                        ByteBuffer byteBuffer = AudioDecoder.this.mOutputBuf[iDequeueOutputBuffer];
                        byte[] bArr = new byte[AudioDecoder.this.mBufInfo.size];
                        byteBuffer.get(bArr);
                        byteBuffer.clear();
                        AudioDecoder.this.mAudioTrack.write(bArr, 0, AudioDecoder.this.mBufInfo.size);
                        AudioDecoder.this.mCodec.releaseOutputBuffer(iDequeueOutputBuffer, false);
                    } else {
                        str = "DequeueOutputBuffer timed out!";
                    }
                    Log.d("AUDIODEC", str);
                } else {
                    Log.d("AUDIODEC", "INFO_OUTPUT_BUFFERS_CHANGED");
                    AudioDecoder audioDecoder4 = AudioDecoder.this;
                    audioDecoder4.mOutputBuf = audioDecoder4.mCodec.getOutputBuffers();
                }
                if ((AudioDecoder.this.mBufInfo.flags & 4) != 0) {
                    Log.d("AUDIODEC", "OutputBuffer BUFFER_FLAG_END_OF_STREAM");
                    AudioDecoder.this.mEos = true;
                    break;
                }
            }
            if (AudioDecoder.this.mEos) {
                AudioDecoder.this.mEosCb.sendEosMsg(AudioDecoder.this.mEos);
            }
        }
    }

    public interface eosCbinterface {
        void sendEosMsg(boolean z2);
    }

    public AudioDecoder(eosCbinterface eoscbinterface) {
        this.mEosCb = eoscbinterface;
    }

    private void releaseAudioDecoder() {
        this.mCodec.stop();
        this.mCodec.release();
        this.mCodec = null;
        this.mExtractor.release();
        this.mExtractor = null;
        if (this.mAudioTrack.getPlayState() == 3) {
            this.mAudioTrack.stop();
        }
        this.mAudioTrack.release();
        this.mAudioTrack = null;
        this.mEos = false;
    }

    @TargetApi(21)
    public boolean initAudioDecoder(String str) throws IOException {
        String str2;
        this.mEos = false;
        MediaExtractor mediaExtractor = new MediaExtractor();
        this.mExtractor = mediaExtractor;
        mediaExtractor.setDataSource(str);
        MediaFormat trackFormat = this.mExtractor.getTrackFormat(0);
        this.mFormat = trackFormat;
        if (trackFormat == null) {
            str2 = "Format is NULL";
        } else {
            String string = trackFormat.getString("mime");
            if (string.startsWith("audio/")) {
                StringBuilder sbF = g.a.a.a.a.F("Format : ");
                sbF.append(this.mFormat);
                Log.d("AUDIODEC", sbF.toString());
                this.mExtractor.selectTrack(0);
                this.mSampleRate = this.mFormat.getInteger("sample-rate");
                this.mChannel = this.mFormat.getInteger("channel-count");
            }
            new MediaCodecList(1).findDecoderForFormat(this.mFormat);
            MediaCodec mediaCodecCreateDecoderByType = MediaCodec.createDecoderByType(string);
            this.mCodec = mediaCodecCreateDecoderByType;
            mediaCodecCreateDecoderByType.configure(this.mFormat, (Surface) null, (MediaCrypto) null, 0);
            if (this.mCodec != null) {
                this.mTrackBufSz = AudioTrack.getMinBufferSize(this.mSampleRate, 12, 2);
                StringBuilder sbF2 = g.a.a.a.a.F("AudioTrack minimum size = ");
                sbF2.append(this.mTrackBufSz);
                Log.d("AUDIODEC", sbF2.toString());
                this.mAudioTrack = new AudioTrack(0, this.mSampleRate, 12, 2, this.mTrackBufSz * 4, 1);
                return true;
            }
            str2 = "Codec is NULL";
        }
        Log.d("AUDIODEC", str2);
        return false;
    }

    public void startAudioDecoder() {
        this.mCodec.start();
        this.mThreadStart = true;
        Thread thread = new Thread(new b());
        this.mDecoderThread = thread;
        thread.start();
        Log.d("AUDIODEC", "Start audio decoder");
    }

    public void stopAudioDecoder() {
        if (this.mThreadStart) {
            this.mThreadStart = false;
            try {
                this.mDecoderThread.interrupt();
                this.mDecoderThread.join(1000L);
            } catch (InterruptedException e2) {
                e2.printStackTrace();
            }
            releaseAudioDecoder();
            Log.d("AUDIODEC", "Stop play success");
        }
    }
}