Android MediaCodecVideoDecoder: Manage lifetime of texture frames

talk/app/webrtc/java/src/org/webrtc/MediaCodecVideoDecoder.java

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package org.webrtc;
 
-import android.graphics.SurfaceTexture;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaCodecInfo.CodecCapabilities;
 import android.media.MediaCodecList;
 import android.media.MediaFormat;
-import android.opengl.GLES11Ext;
-import android.opengl.GLES20;
 import android.os.Build;
+import android.os.SystemClock;
 import android.view.Surface;
 
 import org.webrtc.Logging;
 
 import java.nio.ByteBuffer;
 import java.util.Arrays;
+import java.util.LinkedList;
 import java.util.List;
-
-import javax.microedition.khronos.egl.EGLContext;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
 
 // Java-side of peerconnection_jni.cc:MediaCodecVideoDecoder.
 // This class is an implementation detail of the Java PeerConnection API.
 // MediaCodec is thread-hostile so this class must be operated on a single
 // thread.
 public class MediaCodecVideoDecoder {
   // This class is constructed, operated, and destroyed by its C++ incarnation,
   // so the class and its methods have non-public visibility.  The API this
   // class exposes aims to mimic the webrtc::VideoDecoder API as closely as
   // possibly to minimize the amount of translation work necessary.
@@ skipping 31 matching lines @@
   private static final List<Integer> supportedColorList = Arrays.asList(
     CodecCapabilities.COLOR_FormatYUV420Planar,
     CodecCapabilities.COLOR_FormatYUV420SemiPlanar,
     CodecCapabilities.COLOR_QCOM_FormatYUV420SemiPlanar,
     COLOR_QCOM_FORMATYUV420PackedSemiPlanar32m);
   private int colorFormat;
   private int width;
   private int height;
   private int stride;
   private int sliceHeight;
+  private boolean hasDecodedFirstFrame;
+  private final Queue<Long> decodeStartTimeMs = new LinkedList<Long>();
   private boolean useSurface;
-  private int textureID = 0;
-  private SurfaceTexture surfaceTexture = null;
+
+  // The below variables are only used when the decode decodes to a Surface.
+  private TextureListener textureListener;
+  // |isWaitingForTexture| is true when waiting for the transition:
+  // MediaCodec.releaseOutputBuffer() -> onTextureFrameAvailable().
+  private boolean isWaitingForTexture;
   private Surface surface = null;
-  private EglBase eglBase;
-
-  private MediaCodecVideoDecoder() {
-  }
+  private final Queue<DecodedOutputBuffer>
+      dequeuedSurfaceOutputBuffers = new LinkedList<DecodedOutputBuffer>();
 
   // Helper struct for findVp8Decoder() below.
   private static class DecoderProperties {
     public DecoderProperties(String codecName, int colorFormat) {
       this.codecName = codecName;
       this.colorFormat = colorFormat;
     }
     public final String codecName; // OpenMax component name for VP8 codec.
     public final int colorFormat;  // Color format supported by codec.
   }
@@ skipping 73 matching lines @@
   }
 
   private void checkOnMediaCodecThread() throws IllegalStateException {
     if (mediaCodecThread.getId() != Thread.currentThread().getId()) {
       throw new IllegalStateException(
           "MediaCodecVideoDecoder previously operated on " + mediaCodecThread +
           " but is now called on " + Thread.currentThread());
     }
   }
 
-  // Pass null in |sharedContext| to configure the codec for ByteBuffer output.
-  private boolean initDecode(VideoCodecType type, int width, int height, EGLContext sharedContext) {
+  // Pass null in |surfaceTextureHelper| to configure the codec for ByteBuffer output.
+  private boolean initDecode(
+      VideoCodecType type, int width, int height, SurfaceTextureHelper surfaceTextureHelper) {
     if (mediaCodecThread != null) {
       throw new RuntimeException("Forgot to release()?");
     }
-    useSurface = (sharedContext != null);
+    useSurface = (surfaceTextureHelper != null);
     String mime = null;
     String[] supportedCodecPrefixes = null;
     if (type == VideoCodecType.VIDEO_CODEC_VP8) {
       mime = VP8_MIME_TYPE;
       supportedCodecPrefixes = supportedVp8HwCodecPrefixes;
     } else if (type == VideoCodecType.VIDEO_CODEC_H264) {
       mime = H264_MIME_TYPE;
       supportedCodecPrefixes = supportedH264HwCodecPrefixes;
     } else {
       throw new RuntimeException("Non supported codec " + type);
     }
     DecoderProperties properties = findDecoder(mime, supportedCodecPrefixes);
     if (properties == null) {
       throw new RuntimeException("Cannot find HW decoder for " + type);
     }
     Logging.d(TAG, "Java initDecode: " + type + " : "+ width + " x " + height +
         ". Color: 0x" + Integer.toHexString(properties.colorFormat) +
         ". Use Surface: " + useSurface);
-    if (sharedContext != null) {
-      Logging.d(TAG, "Decoder shared EGL Context: " + sharedContext);
-    }
     runningInstance = this; // Decoder is now running and can be queried for stack traces.
     mediaCodecThread = Thread.currentThread();
     try {
       this.width = width;
       this.height = height;
       stride = width;
       sliceHeight = height;
 
       if (useSurface) {
-        // Create shared EGL context.
-        eglBase = new EglBase(sharedContext, EglBase.ConfigType.PIXEL_BUFFER);
-        eglBase.createDummyPbufferSurface();
-        eglBase.makeCurrent();
-
-        // Create output surface
-        textureID = GlUtil.generateTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES);
-        Logging.d(TAG, "Video decoder TextureID = " + textureID);
-        surfaceTexture = new SurfaceTexture(textureID);
-        surface = new Surface(surfaceTexture);
+        textureListener = new TextureListener(surfaceTextureHelper);
+        surface = new Surface(surfaceTextureHelper.getSurfaceTexture());
       }
 
       MediaFormat format = MediaFormat.createVideoFormat(mime, width, height);
       if (!useSurface) {
         format.setInteger(MediaFormat.KEY_COLOR_FORMAT, properties.colorFormat);
       }
       Logging.d(TAG, "  Format: " + format);
       mediaCodec =
           MediaCodecVideoEncoder.createByCodecName(properties.codecName);
       if (mediaCodec == null) {
@@ skipping 18 matching lines @@
     Logging.d(TAG, "Java releaseDecoder");
     checkOnMediaCodecThread();
     try {
       mediaCodec.stop();
       mediaCodec.release();
     } catch (IllegalStateException e) {
       Logging.e(TAG, "release failed", e);
     }
     mediaCodec = null;
     mediaCodecThread = null;
+    decodeStartTimeMs.clear();
+    hasDecodedFirstFrame = false;
     runningInstance = null;
+    dequeuedSurfaceOutputBuffers.clear();
+    isWaitingForTexture = false;
     if (useSurface) {
       surface.release();
       surface = null;
-      Logging.d(TAG, "Delete video decoder TextureID " + textureID);
-      GLES20.glDeleteTextures(1, new int[] {textureID}, 0);
-      textureID = 0;
-      eglBase.release();
-      eglBase = null;
+      textureListener.release();
     }
     Logging.d(TAG, "Java releaseDecoder done");
   }
 
   // Dequeue an input buffer and return its index, -1 if no input buffer is
   // available, or -2 if the codec is no longer operative.
   private int dequeueInputBuffer() {
     checkOnMediaCodecThread();
     try {
       return mediaCodec.dequeueInputBuffer(DEQUEUE_INPUT_TIMEOUT);
     } catch (IllegalStateException e) {
       Logging.e(TAG, "dequeueIntputBuffer failed", e);
       return -2;
     }
   }
 
   private boolean queueInputBuffer(
       int inputBufferIndex, int size, long timestampUs) {
     checkOnMediaCodecThread();
     try {
       inputBuffers[inputBufferIndex].position(0);
       inputBuffers[inputBufferIndex].limit(size);
+      decodeStartTimeMs.add(SystemClock.elapsedRealtime());
+

[magjed_webrtc, 2015/10/30 12:28:10]

I don't think we need this empty line.

[perkj_webrtc, 2015/11/06 14:31:12]

Done.

       mediaCodec.queueInputBuffer(inputBufferIndex, 0, size, timestampUs, 0);
       return true;
     }
     catch (IllegalStateException e) {
       Logging.e(TAG, "decode failed", e);
       return false;
     }
   }
 
-  // Helper structs for dequeueOutputBuffer() below.
-  private static class DecodedByteBuffer {
-    public DecodedByteBuffer(int index, int offset, int size, long presentationTimestampUs) {
+  // Helper struct for dequeueOutputBuffer() below.
+  private static class DecodedOutputBuffer {
+    public DecodedOutputBuffer(int index, int offset, int size, long presentationTimestampUs,
+        long decodeTime) {
       this.index = index;
       this.offset = offset;
       this.size = size;
       this.presentationTimestampUs = presentationTimestampUs;
+      this.decodeTimeMs = decodeTime;
     }
 
     private final int index;
     private final int offset;
     private final int size;
     private final long presentationTimestampUs;
-  }
-
+    private final long decodeTimeMs;

[AlexG, 2015/10/30 21:06:10]

I would call it decodeLatency - it can be bigger than actual decode time.

[perkj_webrtc, 2015/11/06 14:31:12]

Do you feel strong about it ? I can change here, but 
it is called decode_time in 
webrtc/modules/video_coding/main/source/timing.cc where this eventually end up. 
Also the statistics call this decode time.
webrtc/video/receive_statistics_proxy.cc

+  }
+
+  // Helper struct for dequeueTextureBuffer() below.
   private static class DecodedTextureBuffer {
     private final int textureID;
+    private final float[] transformMatrix;
     private final long presentationTimestampUs;
-
-    public DecodedTextureBuffer(int textureID, long presentationTimestampUs) {
+    private final long decodeTimeMs;
+
+    public DecodedTextureBuffer(int textureID, float[] transformMatrix,
+        long presentationTimestampUs, long decodeTimeMs) {
       this.textureID = textureID;
+      this.transformMatrix = transformMatrix;
       this.presentationTimestampUs = presentationTimestampUs;
-    }
-  }
-
-  // Returns null if no decoded buffer is available, and otherwise either a DecodedByteBuffer or
-  // DecodedTexturebuffer depending on |useSurface| configuration.
+      this.decodeTimeMs = decodeTimeMs;
+    }
+  }
+
+  // Poll based texture listener.
+  private static class TextureListener
+      implements SurfaceTextureHelper.OnTextureFrameAvailableListener {
+    public static class TextureInfo {
+      private final int textureID;
+      private final float[] transformMatrix;
+
+      TextureInfo(int textureId, float[] transformMatrix) {
+        this.textureID = textureId;
+        this.transformMatrix = transformMatrix;
+      }
+    }
+    private final SurfaceTextureHelper surfaceTextureHelper;
+    private TextureInfo textureInfo;
+    // |newFrameLock| is used to synchronize arrival of new frames with wait()/notifyAll().
+    private final Object newFrameLock = new Object();
+
+    public TextureListener(SurfaceTextureHelper surfaceTextureHelper) {
+      this.surfaceTextureHelper = surfaceTextureHelper;
+      surfaceTextureHelper.setListener(this);
+    }
+
+    // Callback from |surfaceTextureHelper|. May be called on an arbitrary thread.
+    @Override
+    public void onTextureFrameAvailable(
+        int oesTextureId, float[] transformMatrix, long timestampNs) {
+      synchronized (newFrameLock) {
+        if (textureInfo != null) {
+          Logging.e(TAG,
+              "Unexpected onTextureFrameAvailable() called while already holding a texture.");
+          throw new IllegalStateException("Already holding a texture.");
+        }
+        // |timestampNs| is always zero on some Android versions.
+        textureInfo = new TextureInfo(oesTextureId, transformMatrix);
+        newFrameLock.notifyAll();
+      }
+    }
+
+    // Dequeues and returns a TextureInfo if available, or null otherwise.
+    public TextureInfo dequeueTextureInfo(int timeoutMs) {
+      synchronized (newFrameLock) {
+        if (textureInfo == null && timeoutMs > 0) {
+          try {
+            newFrameLock.wait(timeoutMs);
+          } catch(InterruptedException e) {
+            // Restore the interrupted status by reinterrupting the thread.
+            Thread.currentThread().interrupt();
+          }
+        }
+        TextureInfo returnedInfo = textureInfo;
+        textureInfo = null;
+        return returnedInfo;
+      }
+    }
+
+    public void release() {
+      // SurfaceTextureHelper.disconnect() will block until any onTextureFrameAvailable() in
+      // progress is done. Therefore, the call to disconnect() must be outside any synchronized
+      // statement that is also used in the onTextureFrameAvailable() above to avoid deadlocks.
+      surfaceTextureHelper.disconnect();
+      synchronized (newFrameLock) {
+        if (textureInfo != null) {
+          surfaceTextureHelper.returnTextureFrame();
+          textureInfo = null;
+        }
+      }
+    }
+  }
+
+  // Returns null if no decoded buffer is available, and otherwise a DecodedByteBuffer.
   // Throws IllegalStateException if call is made on the wrong thread, if color format changes to an
   // unsupported format, or if |mediaCodec| is not in the Executing state. Throws CodecException
   // upon codec error.
-  private Object dequeueOutputBuffer(int dequeueTimeoutUs)
-      throws IllegalStateException, MediaCodec.CodecException {

[magjed_webrtc, 2015/10/30 12:28:10]

Put 'throws IllegalStateException, MediaCodec.CodecException' back.

+  private DecodedOutputBuffer dequeueOutputBuffer(int dequeueTimeoutMs) {
     checkOnMediaCodecThread();
+    if (decodeStartTimeMs.isEmpty()) {
+      return null;
+    }
     // Drain the decoder until receiving a decoded buffer or hitting
     // MediaCodec.INFO_TRY_AGAIN_LATER.
     final MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
     while (true) {
-      final int result = mediaCodec.dequeueOutputBuffer(info, dequeueTimeoutUs);
+      final int result = mediaCodec.dequeueOutputBuffer(
+          info, TimeUnit.MILLISECONDS.toMicros(dequeueTimeoutMs));
       switch (result) {
-        case MediaCodec.INFO_TRY_AGAIN_LATER:
-          return null;
-        case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
-          outputBuffers = mediaCodec.getOutputBuffers();
-          Logging.d(TAG, "Decoder output buffers changed: " + outputBuffers.length);
-          break;
-        case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
-          MediaFormat format = mediaCodec.getOutputFormat();
-          Logging.d(TAG, "Decoder format changed: " + format.toString());
-          width = format.getInteger(MediaFormat.KEY_WIDTH);
-          height = format.getInteger(MediaFormat.KEY_HEIGHT);
-          if (!useSurface && format.containsKey(MediaFormat.KEY_COLOR_FORMAT)) {
-            colorFormat = format.getInteger(MediaFormat.KEY_COLOR_FORMAT);
-            Logging.d(TAG, "Color: 0x" + Integer.toHexString(colorFormat));
-            if (!supportedColorList.contains(colorFormat)) {
-              throw new IllegalStateException("Non supported color format: " + colorFormat);
-            }
+      case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:

[magjed_webrtc, 2015/10/30 12:28:10]

Revert switch case indentation change - it was correct before.

[perkj_webrtc, 2015/11/06 14:31:12]

Done.

+        outputBuffers = mediaCodec.getOutputBuffers();
+        Logging.d(TAG, "Decoder output buffers changed: " + outputBuffers.length);
+        if (hasDecodedFirstFrame) {

[AlexG, 2015/10/30 21:06:10]

May be just ignore it? I think it will be ok if we can swallow up some codec
misbehavior without reporting error.

[perkj_webrtc, 2015/11/06 14:31:12]

Well, what does that mean for the output buffers we are currently using in
dequeuedSurfaceOutputBuffers? I guess we then also must support dropping them
all.

+          throw new RuntimeException("Unexpected output buffer change event.");
+        }
+        break;
+      case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
+        MediaFormat format = mediaCodec.getOutputFormat();
+        Logging.d(TAG, "Decoder format changed: " + format.toString());
+        int new_width = format.getInteger(MediaFormat.KEY_WIDTH);
+        int new_height = format.getInteger(MediaFormat.KEY_HEIGHT);
+        if (hasDecodedFirstFrame && (new_width != width || new_height != height)) {

[AlexG, 2015/10/30 21:06:10]

Should we throw an exception here? Why we don't allow on-fly resolution change?

[perkj_webrtc, 2015/11/06 14:31:12]

We reset the decoder from c++
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/libjin...

So this is here to make sure that behavior is not changed without modifying the
code in Java. If the width and height changes, we need to read the width and
height into each output frame now that we might render the output buffer to the
Surface at a later time in dequeTextureFrame.

I must admit that I have no idea why this class previously did not support on
the fly size change, I hoped you knew? :-) But I assume that if size change, so
would the outputBuffers which would be a problem for all items in
dequeuedOutputBuffers.

+          throw new RuntimeException("Unexpected size change. Configured " + width + "*" +
+              height + ". New " + new_width + "*" + new_height);
+        }
+        width = format.getInteger(MediaFormat.KEY_WIDTH);
+        height = format.getInteger(MediaFormat.KEY_HEIGHT);
+
+        if (!useSurface && format.containsKey(MediaFormat.KEY_COLOR_FORMAT)) {
+          colorFormat = format.getInteger(MediaFormat.KEY_COLOR_FORMAT);
+          Logging.d(TAG, "Color: 0x" + Integer.toHexString(colorFormat));
+          if (!supportedColorList.contains(colorFormat)) {
+            throw new IllegalStateException("Non supported color format: " + colorFormat);
           }
-          if (format.containsKey("stride")) {
-            stride = format.getInteger("stride");
-          }
-          if (format.containsKey("slice-height")) {
-            sliceHeight = format.getInteger("slice-height");
-          }
-          Logging.d(TAG, "Frame stride and slice height: " + stride + " x " + sliceHeight);
-          stride = Math.max(width, stride);
-          sliceHeight = Math.max(height, sliceHeight);
-          break;
-        default:
-          // Output buffer decoded.
-          if (useSurface) {
-            mediaCodec.releaseOutputBuffer(result, true /* render */);
-            // TODO(magjed): Wait for SurfaceTexture.onFrameAvailable() before returning a texture
-            // frame.
-            return new DecodedTextureBuffer(textureID, info.presentationTimeUs);
-          } else {
-            return new DecodedByteBuffer(result, info.offset, info.size, info.presentationTimeUs);
-          }
-      }
-    }
+        }
+        if (format.containsKey("stride")) {
+          stride = format.getInteger("stride");
+        }
+        if (format.containsKey("slice-height")) {
+          sliceHeight = format.getInteger("slice-height");
+        }
+        Logging.d(TAG, "Frame stride and slice height: " + stride + " x " + sliceHeight);
+        stride = Math.max(width, stride);
+        sliceHeight = Math.max(height, sliceHeight);
+        break;
+      case MediaCodec.INFO_TRY_AGAIN_LATER:
+        return null;
+      default:
+        hasDecodedFirstFrame = true;
+        return new DecodedOutputBuffer(result, info.offset, info.size, info.presentationTimeUs,
+            SystemClock.elapsedRealtime() - decodeStartTimeMs.poll());

[magjed_webrtc, 2015/10/30 12:28:10]

Use remove() instead of poll() because you are not polling. It's an exceptional
circumstance if |decodeStartTimeMs is empty here and throwing a
NoSuchElementException is more appropriate than misleading poll() call followed
by null pointer exception crash.

[perkj_webrtc, 2015/11/06 14:31:12]

Done.

+      }
+    }
+  }
+
+  // Returns null if no decoded buffer is available, and otherwise a DecodedTextureBuffer.
+  // Throws IllegalStateException if call is made on the wrong thread, if color format changes to an
+  // unsupported format, or if |mediaCodec| is not in the Executing state. Throws CodecException
+  // upon codec error.
+  private DecodedTextureBuffer dequeueTextureBuffer(int dequeueTimeoutMs) {
+    checkOnMediaCodecThread();
+    if (!useSurface) {
+      throw new IllegalStateException("dequeueTexture() called for byte buffer decoding.");
+    }
+
+    DecodedOutputBuffer outputBuffer = dequeueOutputBuffer(dequeueTimeoutMs);
+    if (outputBuffer != null) {
+      dequeuedSurfaceOutputBuffers.add(outputBuffer);
+    }
+
+    if (dequeuedSurfaceOutputBuffers.isEmpty())

[AlexG, 2015/10/30 21:06:10]

nit: add brackets

[perkj_webrtc, 2015/11/06 14:31:12]

Done.

+      return null;
+
+    // Get the first frame in the queue.
+    DecodedOutputBuffer firstBuffer = dequeuedSurfaceOutputBuffers.peek();

[AlexG, 2015/10/30 21:06:10]

I think you may add a condition to call releaseOutputBuffer(render = false) if
dequeuedSurfaceOutputBuffers size is more than 2 or 3.

[perkj_webrtc, 2015/11/06 14:31:12]

done

+
+    if (!isWaitingForTexture) {
+      // releaseOutputBuffer renders to the decoder output surface.
+      mediaCodec.releaseOutputBuffer(firstBuffer.index, true /* render */);

[magjed_webrtc, 2015/10/30 12:28:10]

I would prefer to remove |firstBuffer| and write it like this instead:
if (!isWaitingForTexture) {
  // releaseOutputBuffer renders to the decoder output surface.
  mediaCodec.releaseOutputBuffer(
      dequeuedSurfaceOutputBuffers.peek().index, true /* render */);
  isWaitingForTexture = true;
}
and below:
...
  final DecodedOutputBuffer outputBuffer =
      dequeuedSurfaceOutputBuffers.remove();
  return new DecodedTextureBuffer(info.textureID, info.transformMatrix,
      outputBuffer.presentationTimestampUs, outputBuffer.decodeTimeMs);
}

If you feel strongly about reducing decode time caused by polling latency, you
can duplicate the first 5 lines or put the two if-statements in a for-loop with
2 runs.

[perkj_webrtc, 2015/11/06 14:31:12]

ok, I am leaning towards reducing the poll intervall in a follow up cl.

+      isWaitingForTexture = true;
+    }
+
+    // We are waiting for a frame to be rendered to the decoder surface.
+    // Check if it is ready now by waiting max |dequeueTimeoutMs|. There can only be one frame
+    // rendered at the time.

[magjed_webrtc, 2015/10/30 12:28:10]

s/rendered at the time/rendererd at a time/g

[perkj_webrtc, 2015/11/06 14:31:12]

Done.

[magjed_webrtc, 2015/11/09 16:30:52]

No?

+    TextureListener.TextureInfo info = textureListener.dequeueTextureInfo(dequeueTimeoutMs);
+    if (info != null) {
+      isWaitingForTexture = false;
+      dequeuedSurfaceOutputBuffers.remove();
+      return new DecodedTextureBuffer(info.textureID, info.transformMatrix,
+          firstBuffer.presentationTimestampUs, firstBuffer.decodeTimeMs);
+    }
+    return null;
   }
 
   // Release a dequeued output byte buffer back to the codec for re-use. Should only be called for
   // non-surface decoding.
   // Throws IllegalStateException if the call is made on the wrong thread, if codec is configured
   // for surface decoding, or if |mediaCodec| is not in the Executing state. Throws
   // MediaCodec.CodecException upon codec error.
-  private void returnDecodedByteBuffer(int index)
+  private void returnDecodedOutputBuffer(int index)
       throws IllegalStateException, MediaCodec.CodecException {
     checkOnMediaCodecThread();
     if (useSurface) {
-      throw new IllegalStateException("returnDecodedByteBuffer() called for surface decoding.");
+      throw new IllegalStateException("returnDecodedOutputBuffer() called for surface decoding.");
     }
     mediaCodec.releaseOutputBuffer(index, false /* render */);
   }
 }