1 files changed, 233 insertions, 0 deletions
diff --git a/tuner/src/com/android/tv/tuner/exoplayer/audio/MediaCodecAudioDecoder.java b/tuner/src/com/android/tv/tuner/exoplayer/audio/MediaCodecAudioDecoder.java
new file mode 100644
index 00000000..80f91ebd
--- /dev/null
+++ b/tuner/src/com/android/tv/tuner/exoplayer/audio/MediaCodecAudioDecoder.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.tv.tuner.exoplayer.audio;
+
+import android.media.MediaCodec;
+import android.util.Log;
+import com.google.android.exoplayer.CodecCounters;
+import com.google.android.exoplayer.DecoderInfo;
+import com.google.android.exoplayer.ExoPlaybackException;
+import com.google.android.exoplayer.MediaCodecSelector;
+import com.google.android.exoplayer.MediaCodecUtil;
+import com.google.android.exoplayer.MediaFormat;
+import com.google.android.exoplayer.SampleHolder;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+
+/** A decoder to use MediaCodec for decoding audio stream. */
+public class MediaCodecAudioDecoder extends AudioDecoder {
+    private static final String TAG = "MediaCodecAudioDecoder";
+
+    public static final int INDEX_INVALID = -1;
+
+    private final CodecCounters mCodecCounters;
+    private final MediaCodecSelector mSelector;
+
+    private MediaCodec mCodec;
+    private MediaCodec.BufferInfo mOutputBufferInfo;
+    private ByteBuffer mMediaCodecOutputBuffer;
+    private ArrayList<Long> mDecodeOnlyPresentationTimestamps;
+    private boolean mWaitingForFirstSyncFrame;
+    private boolean mIsNewIndex;
+    private int mInputIndex;
+    private int mOutputIndex;
+
+    /** Creates a MediaCodec based audio decoder. */
+    public MediaCodecAudioDecoder(MediaCodecSelector selector) {
+        mSelector = selector;
+        mOutputBufferInfo = new MediaCodec.BufferInfo();
+        mCodecCounters = new CodecCounters();
+        mDecodeOnlyPresentationTimestamps = new ArrayList<>();
+    }
+
+    /** Returns {@code true} if there is decoder for {@code mimeType}. */
+    public static boolean supportMimeType(MediaCodecSelector selector, String mimeType) {
+        if (selector == null) {
+            return false;
+        }
+        return getDecoderInfo(selector, mimeType) != null;
+    }
+
+    private static DecoderInfo getDecoderInfo(MediaCodecSelector selector, String mimeType) {
+        try {
+            return selector.getDecoderInfo(mimeType, false);
+        } catch (MediaCodecUtil.DecoderQueryException e) {
+            Log.e(TAG, "Select decoder error:" + e);
+            return null;
+        }
+    }
+
+    private boolean shouldInitCodec(MediaFormat format) {
+        return format != null && mCodec == null;
+    }
+
+    @Override
+    public void maybeInitDecoder(MediaFormat format) throws ExoPlaybackException {
+        if (!shouldInitCodec(format)) {
+            return;
+        }
+
+        String mimeType = format.mimeType;
+        DecoderInfo decoderInfo = getDecoderInfo(mSelector, mimeType);
+        if (decoderInfo == null) {
+            Log.i(TAG, "There is not decoder found for " + mimeType);
+            return;
+        }
+
+        String codecName = decoderInfo.name;
+        try {
+            mCodec = MediaCodec.createByCodecName(codecName);
+            mCodec.configure(format.getFrameworkMediaFormatV16(), null, null, 0);
+            mCodec.start();
+        } catch (Exception e) {
+            Log.e(TAG, "Failed when configure or start codec:" + e);
+            throw new ExoPlaybackException(e);
+        }
+        mInputIndex = INDEX_INVALID;
+        mOutputIndex = INDEX_INVALID;
+        mWaitingForFirstSyncFrame = true;
+        mCodecCounters.codecInitCount++;
+    }
+
+    @Override
+    public void resetDecoderState(String mimeType) {
+        if (mCodec == null) {
+            return;
+        }
+        mInputIndex = INDEX_INVALID;
+        mOutputIndex = INDEX_INVALID;
+        mDecodeOnlyPresentationTimestamps.clear();
+        mCodec.flush();
+        mWaitingForFirstSyncFrame = true;
+    }
+
+    @Override
+    public void release() {
+        if (mCodec != null) {
+            mDecodeOnlyPresentationTimestamps.clear();
+            mInputIndex = INDEX_INVALID;
+            mOutputIndex = INDEX_INVALID;
+            mCodecCounters.codecReleaseCount++;
+            try {
+                mCodec.stop();
+            } finally {
+                try {
+                    mCodec.release();
+                } finally {
+                    mCodec = null;
+                }
+            }
+        }
+    }
+
+    /** Returns the index of input buffer which is ready for using. */
+    public int getInputIndex() {
+        return mInputIndex;
+    }
+
+    @Override
+    public ByteBuffer getInputBuffer() {
+        if (mInputIndex < 0) {
+            mInputIndex = mCodec.dequeueInputBuffer(0);
+            if (mInputIndex < 0) {
+                return null;
+            }
+            return mCodec.getInputBuffer(mInputIndex);
+        }
+        return mCodec.getInputBuffer(mInputIndex);
+    }
+
+    @Override
+    public void decode(SampleHolder sampleHolder) {
+        if (mWaitingForFirstSyncFrame) {
+            if (!sampleHolder.isSyncFrame()) {
+                sampleHolder.clearData();
+                return;
+            }
+            mWaitingForFirstSyncFrame = false;
+        }
+        long presentationTimeUs = sampleHolder.timeUs;
+        if (sampleHolder.isDecodeOnly()) {
+            mDecodeOnlyPresentationTimestamps.add(presentationTimeUs);
+        }
+        mCodec.queueInputBuffer(mInputIndex, 0, sampleHolder.data.limit(), presentationTimeUs, 0);
+        mInputIndex = INDEX_INVALID;
+        mCodecCounters.inputBufferCount++;
+    }
+
+    private int getDecodeOnlyIndex(long presentationTimeUs) {
+        final int size = mDecodeOnlyPresentationTimestamps.size();
+        for (int i = 0; i < size; i++) {
+            if (mDecodeOnlyPresentationTimestamps.get(i).longValue() == presentationTimeUs) {
+                return i;
+            }
+        }
+        return INDEX_INVALID;
+    }
+
+    /** Returns the index of output buffer which is ready for using. */
+    public int getOutputIndex() {
+        if (mOutputIndex < 0) {
+            mOutputIndex = mCodec.dequeueOutputBuffer(mOutputBufferInfo, 0);
+            mIsNewIndex = true;
+        } else {
+            mIsNewIndex = false;
+        }
+        return mOutputIndex;
+    }
+
+    @Override
+    public android.media.MediaFormat getOutputFormat() {
+        return mCodec.getOutputFormat();
+    }
+
+    /** Returns {@code true} if the output is only for decoding but not for rendering. */
+    public boolean maybeDecodeOnlyIndex() {
+        int decodeOnlyIndex = getDecodeOnlyIndex(mOutputBufferInfo.presentationTimeUs);
+        if (decodeOnlyIndex != INDEX_INVALID) {
+            mCodec.releaseOutputBuffer(mOutputIndex, false);
+            mCodecCounters.skippedOutputBufferCount++;
+            mDecodeOnlyPresentationTimestamps.remove(decodeOnlyIndex);
+            mOutputIndex = INDEX_INVALID;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public ByteBuffer getDecodedSample() {
+        if (maybeDecodeOnlyIndex() || mOutputIndex < 0) {
+            return null;
+        }
+        if (mIsNewIndex) {
+            mMediaCodecOutputBuffer = mCodec.getOutputBuffer(mOutputIndex);
+        }
+        return mMediaCodecOutputBuffer;
+    }
+
+    @Override
+    public long getDecodedTimeUs() {
+        return mOutputBufferInfo.presentationTimeUs;
+    }
+
+    /** Releases the output buffer after rendering. */
+    public void releaseOutputBuffer() {
+        mCodecCounters.renderedOutputBufferCount++;
+        mCodec.releaseOutputBuffer(mOutputIndex, false);
+        mOutputIndex = INDEX_INVALID;
+    }
+}