Add texture support to HardwareVideoDecoder.

webrtc/sdk/android/src/java/org/webrtc/I420BufferImpl.java

 /*
  *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.webrtc;
 
 import java.nio.ByteBuffer;
 import org.webrtc.VideoFrame.I420Buffer;
 
 /** Implementation of an I420 VideoFrame buffer. */
 class I420BufferImpl implements VideoFrame.I420Buffer {
+  private final ByteBuffer buffer;
   private final int width;
   private final int height;
-  private final int strideUV;
-  private final ByteBuffer y;
-  private final ByteBuffer u;
-  private final ByteBuffer v;
+  private final int chromaHeight;
+  private final int yPos;
+  private final int strideY;
+  private final int uPos;
+  private final int strideU;
+  private final int vPos;
+  private final int strideV;
+  private final ReleaseCallback releaseCallback;
 
-  I420BufferImpl(int width, int height) {
+  private int refCount;
+
+  /** Allocates an I420Buffer backed by existing data. */
+  I420BufferImpl(ByteBuffer buffer, int width, int height, int yPos, int strideY, int uPos,

[sakal, 2017/07/17 13:44:56]

I would prefer to just have a constructor that is passed in a buffer and the
parameters and a static method I420BufferImpl.allocate that allocates a buffer.
We could also add a method getBuffer to this class and just use
I420BufferImpl.allocate in OesTextureBuffer.toI420. 

[mellem, 2017/07/17 21:57:15]

Changed the second constructor to an allocate() method.  We can't use it in
OesTextureBuffer.toI420 regardless of whether the entire backing buffer is
accessible.  The YuvConverter uses a different stride and starts the v data in a
different position.  It also needs a bit of extra space to prevent Java
byte-buffer slices from overrunning the buffer when accessing the v channel.

+      int strideU, int vPos, int strideV, ReleaseCallback releaseCallback) {
+    this.buffer = buffer;
     this.width = width;
     this.height = height;
-    this.strideUV = (width + 1) / 2;
-    int halfHeight = (height + 1) / 2;
-    this.y = ByteBuffer.allocateDirect(width * height);
-    this.u = ByteBuffer.allocateDirect(strideUV * halfHeight);
-    this.v = ByteBuffer.allocateDirect(strideUV * halfHeight);
+    this.chromaHeight = half(height);
+    this.yPos = yPos;
+    this.strideY = strideY;
+    this.uPos = uPos;
+    this.strideU = strideU;
+    this.vPos = vPos;
+    this.strideV = strideV;
+    this.releaseCallback = releaseCallback;
+
+    this.refCount = 1;
+  }
+
+  /** Allocates an empty I420Buffer suitable for an image of the given width and height. */
+  I420BufferImpl(int width, int height) {
+    this(ByteBuffer.allocateDirect(size(width, height)), width, height, 0 /* yPos */,
+        width /* strideY */, width * height /* uPos */, half(width) /* strideU */,
+        width * height + half(width) * half(height) /* vPos */, half(width) /* strideV */,
+        null /* releaseCallback */);
   }
 
   @Override
   public int getWidth() {
     return width;
   }
 
   @Override
   public int getHeight() {
     return height;
   }
 
   @Override
   public ByteBuffer getDataY() {
-    return y;
+    ByteBuffer data = buffer.slice();
+    data.position(yPos);
+    data.limit(yPos + getStrideY() * height);
+    return data;
   }
 
   @Override
   public ByteBuffer getDataU() {
-    return u;
+    ByteBuffer data = buffer.slice();
+    data.position(uPos);
+    data.limit(uPos + strideU * chromaHeight);
+    return data;
   }
 
   @Override
   public ByteBuffer getDataV() {
-    return v;
+    ByteBuffer data = buffer.slice();
+    data.position(vPos);
+    data.limit(vPos + strideV * chromaHeight);
+    return data;
   }
 
   @Override
   public int getStrideY() {
-    return width;
+    return strideY;
   }
 
   @Override
   public int getStrideU() {
-    return strideUV;
+    return strideU;
   }
 
   @Override
   public int getStrideV() {
-    return strideUV;
+    return strideV;
   }
 
   @Override
   public I420Buffer toI420() {
     return this;
   }
 
   @Override
-  public void retain() {}
+  public void retain() {
+    ++refCount;
+  }
 
   @Override
-  public void release() {}
+  public void release() {
+    if (--refCount == 0 && releaseCallback != null) {
+      releaseCallback.onRelease();
+    }
+  }
+
+  // Callback called when the frame is no longer referenced.
+  interface ReleaseCallback {
+    // Called when the frame is no longer referenced.
+    void onRelease();
+  }
+
+  private static int half(int num) {
+    return (num + 1) / 2;
+  }
+
+  private static int size(int width, int height) {
+    return width * height + half(width) * half(height) * 2;
+  }
 }