MediaCodecPlayer implementation (stage 4 - preroll)

media/base/android/java/src/org/chromium/media/MediaCodecBridge.java

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.media;
 
 import android.annotation.TargetApi;
 import android.media.AudioFormat;
 import android.media.AudioManager;
 import android.media.AudioTrack;
@@ skipping 56 matching lines @@
     private static final String KEY_CROP_LEFT = "crop-left";
     private static final String KEY_CROP_RIGHT = "crop-right";
     private static final String KEY_CROP_BOTTOM = "crop-bottom";
     private static final String KEY_CROP_TOP = "crop-top";
 
     private ByteBuffer[] mInputBuffers;
     private ByteBuffer[] mOutputBuffers;
 
     private MediaCodec mMediaCodec;
     private AudioTrack mAudioTrack;
+    private ArrayList<byte[]> mPendingAudioBuffers;
     private boolean mFlushed;
     private long mLastPresentationTimeUs;
     private String mMime;
     private boolean mAdaptivePlaybackSupported;
 
     private static class DequeueInputResult {
         private final int mStatus;
         private final int mIndex;
 
         private DequeueInputResult(int status, int index) {
@@ skipping 208 matching lines @@
             }
         }
 
         return null;
     }
 
     private MediaCodecBridge(
             MediaCodec mediaCodec, String mime, boolean adaptivePlaybackSupported) {
         assert mediaCodec != null;
         mMediaCodec = mediaCodec;
+        mPendingAudioBuffers = new ArrayList<byte[]>();
         mMime = mime;
         mLastPresentationTimeUs = 0;
         mFlushed = true;
         mAdaptivePlaybackSupported = adaptivePlaybackSupported;
     }
 
     @CalledByNative
     private static MediaCodecBridge create(String mime, boolean isSecure, int direction) {
         // Creation of ".secure" codecs sometimes crash instead of throwing exceptions
         // on pre-JBMR2 devices.
@@ skipping 43 matching lines @@
             mMediaCodec.release();
         } catch (IllegalStateException e) {
             // The MediaCodec is stuck in a wrong state, possibly due to losing
             // the surface.
             Log.e(TAG, "Cannot release media codec", e);
         }
         mMediaCodec = null;
         if (mAudioTrack != null) {
             mAudioTrack.release();
         }
+        mPendingAudioBuffers.clear();
     }
 
     @SuppressWarnings("deprecation")
     @CalledByNative
     private boolean start() {
         try {
             mMediaCodec.start();
             if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
                 mInputBuffers = mMediaCodec.getInputBuffers();
                 mOutputBuffers = mMediaCodec.getOutputBuffers();
@@ skipping 28 matching lines @@
     }
 
     @CalledByNative
     private int flush() {
         try {
             mFlushed = true;
             if (mAudioTrack != null) {
                 // Need to call pause() here, or otherwise flush() is a no-op.
                 mAudioTrack.pause();
                 mAudioTrack.flush();
+                mPendingAudioBuffers.clear();
             }
             mMediaCodec.flush();
         } catch (IllegalStateException e) {
             Log.e(TAG, "Failed to flush MediaCodec", e);
             return MEDIA_CODEC_ERROR;
         }
         return MEDIA_CODEC_OK;
     }
 
     @CalledByNative
@@ skipping 292 matching lines @@
     }
 
     /**
      *  Play the audio buffer that is passed in.
      *
      *  @param buf Audio buffer to be rendered.
      *  @return The number of frames that have already been consumed by the
      *  hardware. This number resets to 0 after each flush call.
      */
     @CalledByNative
-    private long playOutputBuffer(byte[] buf) {
+    private long playOutputBuffer(byte[] buf, boolean postpone) {
+        if (postpone) {
+            Log.v(TAG, "Saving pending buffer");
+            mPendingAudioBuffers.add(buf);
+            return 0;
+        }
+
         if (mAudioTrack == null) {
             return 0;
         }
 
         if (AudioTrack.PLAYSTATE_PLAYING != mAudioTrack.getPlayState()) {
             mAudioTrack.play();
         }
-        int size = mAudioTrack.write(buf, 0, buf.length);
+
+        int size = 0;
+        for (byte[] pbuf : mPendingAudioBuffers) {
+            Log.v(TAG, "Writing pending buffer");
+            size = mAudioTrack.write(pbuf, 0, pbuf.length);
+            if (pbuf.length != size) {
+                Log.i(TAG, "Failed to send all data to audio output, expected size: " + pbuf.length
+                                + ", actual size: " + size);
+            }
+        }
+
+        mPendingAudioBuffers.clear();
+
+        size = mAudioTrack.write(buf, 0, buf.length);
         if (buf.length != size) {
             Log.i(TAG, "Failed to send all data to audio output, expected size: "
                     + buf.length + ", actual size: " + size);
         }
         // TODO(qinmin): Returning the head position allows us to estimate
         // the current presentation time in native code. However, it is
         // better to use AudioTrack.getCurrentTimestamp() to get the last
         // known time when a frame is played. However, we will need to
         // convert the java nano time to C++ timestamp.
         // If the stream runs too long, getPlaybackHeadPosition() could
@@ skipping 28 matching lines @@
                 return AudioFormat.CHANNEL_OUT_QUAD;
             case 6:
                 return AudioFormat.CHANNEL_OUT_5POINT1;
             case 8:
                 return AudioFormat.CHANNEL_OUT_7POINT1;
             default:
                 return AudioFormat.CHANNEL_OUT_DEFAULT;
         }
     }
 }