Add m-esr52 at 52.6.0

1 files changed, 772 insertions, 0 deletions

diff --git a/dom/media/platforms/gonk/GonkVideoDecoderManager.cpp b/dom/media/platforms/gonk/GonkVideoDecoderManager.cpp
new file mode 100644
index 000000000..0c7b3b6af
--- /dev/null
+++ b/dom/media/platforms/gonk/GonkVideoDecoderManager.cpp
@@ -0,0 +1,772 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "MediaCodecProxy.h"
+#include <OMX_IVCommon.h>
+#include <gui/Surface.h>
+#include <ICrypto.h>
+#include "GonkVideoDecoderManager.h"
+#include "GrallocImages.h"
+#include "MediaDecoderReader.h"
+#include "ImageContainer.h"
+#include "VideoUtils.h"
+#include "nsThreadUtils.h"
+#include "Layers.h"
+#include "mozilla/Logging.h"
+#include <stagefright/MediaBuffer.h>
+#include <stagefright/MetaData.h>
+#include <stagefright/MediaErrors.h>
+#include <stagefright/foundation/AString.h>
+#include "GonkNativeWindow.h"
+#include "mozilla/layers/GrallocTextureClient.h"
+#include "mozilla/layers/ImageBridgeChild.h"
+#include "mozilla/layers/TextureClient.h"
+#include "mozilla/layers/TextureClientRecycleAllocator.h"
+#include <cutils/properties.h>
+
+#define CODECCONFIG_TIMEOUT_US 10000LL
+#define READ_OUTPUT_BUFFER_TIMEOUT_US  0LL
+
+#include <android/log.h>
+#define GVDM_LOG(...) __android_log_print(ANDROID_LOG_DEBUG, "GonkVideoDecoderManager", __VA_ARGS__)
+
+#define LOG(...) MOZ_LOG(sPDMLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+using namespace mozilla::layers;
+using namespace android;
+typedef android::MediaCodecProxy MediaCodecProxy;
+
+namespace mozilla {
+
+class GonkTextureClientAllocationHelper : public layers::ITextureClientAllocationHelper
+{
+public:
+  GonkTextureClientAllocationHelper(uint32_t aGrallocFormat,
+                                    gfx::IntSize aSize)
+    : ITextureClientAllocationHelper(gfx::SurfaceFormat::UNKNOWN,
+                                     aSize,
+                                     BackendSelector::Content,
+                                     TextureFlags::DEALLOCATE_CLIENT,
+                                     ALLOC_DISALLOW_BUFFERTEXTURECLIENT)
+    , mGrallocFormat(aGrallocFormat)
+  {}
+
+  already_AddRefed<TextureClient> Allocate(KnowsCompositor* aAllocator) override
+  {
+    uint32_t usage = android::GraphicBuffer::USAGE_SW_READ_OFTEN |
+                     android::GraphicBuffer::USAGE_SW_WRITE_OFTEN |
+                     android::GraphicBuffer::USAGE_HW_TEXTURE;
+
+    GrallocTextureData* texData = GrallocTextureData::Create(mSize, mGrallocFormat,
+                                                             gfx::BackendType::NONE,
+                                                             usage, aAllocator->GetTextureForwarder());
+    if (!texData) {
+      return nullptr;
+    }
+    sp<GraphicBuffer> graphicBuffer = texData->GetGraphicBuffer();
+    if (!graphicBuffer.get()) {
+      return nullptr;
+    }
+    RefPtr<TextureClient> textureClient =
+      TextureClient::CreateWithData(texData, TextureFlags::DEALLOCATE_CLIENT, aAllocator->GetTextureForwarder());
+    return textureClient.forget();
+  }
+
+  bool IsCompatible(TextureClient* aTextureClient) override
+  {
+    if (!aTextureClient) {
+      return false;
+    }
+    sp<GraphicBuffer> graphicBuffer =
+      static_cast<GrallocTextureData*>(aTextureClient->GetInternalData())->GetGraphicBuffer();
+    if (!graphicBuffer.get() ||
+        static_cast<uint32_t>(graphicBuffer->getPixelFormat()) != mGrallocFormat ||
+        aTextureClient->GetSize() != mSize) {
+      return false;
+    }
+    return true;
+  }
+
+private:
+  uint32_t mGrallocFormat;
+};
+
+GonkVideoDecoderManager::GonkVideoDecoderManager(
+  mozilla::layers::ImageContainer* aImageContainer,
+  const VideoInfo& aConfig)
+  : mConfig(aConfig)
+  , mImageContainer(aImageContainer)
+  , mColorConverterBufferSize(0)
+  , mPendingReleaseItemsLock("GonkVideoDecoderManager::mPendingReleaseItemsLock")
+  , mNeedsCopyBuffer(false)
+{
+  MOZ_COUNT_CTOR(GonkVideoDecoderManager);
+}
+
+GonkVideoDecoderManager::~GonkVideoDecoderManager()
+{
+  MOZ_COUNT_DTOR(GonkVideoDecoderManager);
+}
+
+nsresult
+GonkVideoDecoderManager::Shutdown()
+{
+  mVideoCodecRequest.DisconnectIfExists();
+  return GonkDecoderManager::Shutdown();
+}
+
+RefPtr<MediaDataDecoder::InitPromise>
+GonkVideoDecoderManager::Init()
+{
+  mNeedsCopyBuffer = false;
+
+  uint32_t maxWidth, maxHeight;
+  char propValue[PROPERTY_VALUE_MAX];
+  property_get("ro.moz.omx.hw.max_width", propValue, "-1");
+  maxWidth = -1 == atoi(propValue) ? MAX_VIDEO_WIDTH : atoi(propValue);
+  property_get("ro.moz.omx.hw.max_height", propValue, "-1");
+  maxHeight = -1 == atoi(propValue) ? MAX_VIDEO_HEIGHT : atoi(propValue) ;
+
+  if (uint32_t(mConfig.mImage.width * mConfig.mImage.height) > maxWidth * maxHeight) {
+    GVDM_LOG("Video resolution exceeds hw codec capability");
+    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
+  }
+
+  // Validate the container-reported frame and pictureRect sizes. This ensures
+  // that our video frame creation code doesn't overflow.
+  if (!IsValidVideoRegion(mConfig.mImage, mConfig.ImageRect(), mConfig.mDisplay)) {
+    GVDM_LOG("It is not a valid region");
+    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
+  }
+
+  mReaderTaskQueue = AbstractThread::GetCurrent()->AsTaskQueue();
+  MOZ_ASSERT(mReaderTaskQueue);
+
+  if (mDecodeLooper.get() != nullptr) {
+    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
+  }
+
+  if (!InitLoopers(MediaData::VIDEO_DATA)) {
+    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
+  }
+
+  RefPtr<InitPromise> p = mInitPromise.Ensure(__func__);
+  android::sp<GonkVideoDecoderManager> self = this;
+  mDecoder = MediaCodecProxy::CreateByType(mDecodeLooper,
+                                           mConfig.mMimeType.get(),
+                                           false);
+
+  uint32_t capability = MediaCodecProxy::kEmptyCapability;
+  if (mDecoder->getCapability(&capability) == OK && (capability &
+      MediaCodecProxy::kCanExposeGraphicBuffer)) {
+#if ANDROID_VERSION >= 21
+    sp<IGonkGraphicBufferConsumer> consumer;
+    GonkBufferQueue::createBufferQueue(&mGraphicBufferProducer, &consumer);
+    mNativeWindow = new GonkNativeWindow(consumer);
+#else
+    mNativeWindow = new GonkNativeWindow();
+#endif
+  }
+
+  mVideoCodecRequest.Begin(mDecoder->AsyncAllocateVideoMediaCodec()
+    ->Then(mReaderTaskQueue, __func__,
+      [self] (bool) -> void {
+        self->mVideoCodecRequest.Complete();
+        self->codecReserved();
+      }, [self] (bool) -> void {
+        self->mVideoCodecRequest.Complete();
+        self->codecCanceled();
+      }));
+
+  return p;
+}
+
+nsresult
+GonkVideoDecoderManager::CreateVideoData(MediaBuffer* aBuffer,
+                                         int64_t aStreamOffset,
+                                         VideoData **v)
+{
+  *v = nullptr;
+  RefPtr<VideoData> data;
+  int64_t timeUs;
+  int32_t keyFrame;
+
+  if (aBuffer == nullptr) {
+    GVDM_LOG("Video Buffer is not valid!");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  AutoReleaseMediaBuffer autoRelease(aBuffer, mDecoder.get());
+
+  if (!aBuffer->meta_data()->findInt64(kKeyTime, &timeUs)) {
+    GVDM_LOG("Decoder did not return frame time");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  if (mLastTime > timeUs) {
+    GVDM_LOG("Output decoded sample time is revert. time=%lld", timeUs);
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  mLastTime = timeUs;
+
+  if (aBuffer->range_length() == 0) {
+    // Some decoders may return spurious empty buffers that we just want to ignore
+    // quoted from Android's AwesomePlayer.cpp
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (!aBuffer->meta_data()->findInt32(kKeyIsSyncFrame, &keyFrame)) {
+    keyFrame = 0;
+  }
+
+  gfx::IntRect picture =
+    mConfig.ScaledImageRect(mFrameInfo.mWidth, mFrameInfo.mHeight);
+  if (aBuffer->graphicBuffer().get()) {
+    data = CreateVideoDataFromGraphicBuffer(aBuffer, picture);
+    if (data && !mNeedsCopyBuffer) {
+      // RecycleCallback() will be responsible for release the buffer.
+      autoRelease.forget();
+    }
+    mNeedsCopyBuffer = false;
+  } else {
+    data = CreateVideoDataFromDataBuffer(aBuffer, picture);
+  }
+
+  if (!data) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  // Fill necessary info.
+  data->mOffset = aStreamOffset;
+  data->mTime = timeUs;
+  data->mKeyframe = keyFrame;
+
+  data.forget(v);
+  return NS_OK;
+}
+
+// Copy pixels from one planar YUV to another.
+static void
+CopyYUV(PlanarYCbCrData& aSource, PlanarYCbCrData& aDestination)
+{
+  // Fill Y plane.
+  uint8_t* srcY = aSource.mYChannel;
+  gfx::IntSize ySize = aSource.mYSize;
+  uint8_t* destY = aDestination.mYChannel;
+  // Y plane.
+  for (int i = 0; i < ySize.height; i++) {
+    memcpy(destY, srcY, ySize.width);
+    srcY += aSource.mYStride;
+    destY += aDestination.mYStride;
+  }
+
+  // Fill UV plane.
+  // Line start
+  uint8_t* srcU = aSource.mCbChannel;
+  uint8_t* srcV = aSource.mCrChannel;
+  uint8_t* destU = aDestination.mCbChannel;
+  uint8_t* destV = aDestination.mCrChannel;
+
+  gfx::IntSize uvSize = aSource.mCbCrSize;
+  for (int i = 0; i < uvSize.height; i++) {
+    uint8_t* su = srcU;
+    uint8_t* sv = srcV;
+    uint8_t* du = destU;
+    uint8_t* dv =destV;
+    for (int j = 0; j < uvSize.width; j++) {
+      *du++ = *su++;
+      *dv++ = *sv++;
+      // Move to next pixel.
+      su += aSource.mCbSkip;
+      sv += aSource.mCrSkip;
+      du += aDestination.mCbSkip;
+      dv += aDestination.mCrSkip;
+    }
+    // Move to next line.
+    srcU += aSource.mCbCrStride;
+    srcV += aSource.mCbCrStride;
+    destU += aDestination.mCbCrStride;
+    destV += aDestination.mCbCrStride;
+  }
+}
+
+inline static int
+Align(int aX, int aAlign)
+{
+  return (aX + aAlign - 1) & ~(aAlign - 1);
+}
+
+// Venus formats are doucmented in kernel/include/media/msm_media_info.h:
+// * Y_Stride : Width aligned to 128
+// * UV_Stride : Width aligned to 128
+// * Y_Scanlines: Height aligned to 32
+// * UV_Scanlines: Height/2 aligned to 16
+// * Total size = align((Y_Stride * Y_Scanlines
+// *          + UV_Stride * UV_Scanlines + 4096), 4096)
+static void
+CopyVenus(uint8_t* aSrc, uint8_t* aDest, uint32_t aWidth, uint32_t aHeight)
+{
+  size_t yStride = Align(aWidth, 128);
+  uint8_t* s = aSrc;
+  uint8_t* d = aDest;
+  for (size_t i = 0; i < aHeight; i++) {
+    memcpy(d, s, aWidth);
+    s += yStride;
+    d += yStride;
+  }
+  size_t uvStride = yStride;
+  size_t uvLines = (aHeight + 1) / 2;
+  size_t ySize = yStride * Align(aHeight, 32);
+  s = aSrc + ySize;
+  d = aDest + ySize;
+  for (size_t i = 0; i < uvLines; i++) {
+    memcpy(d, s, aWidth);
+    s += uvStride;
+    d += uvStride;
+  }
+}
+
+static void
+CopyGraphicBuffer(sp<GraphicBuffer>& aSource, sp<GraphicBuffer>& aDestination)
+{
+  void* srcPtr = nullptr;
+  aSource->lock(GraphicBuffer::USAGE_SW_READ_OFTEN, &srcPtr);
+  void* destPtr = nullptr;
+  aDestination->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN, &destPtr);
+  MOZ_ASSERT(srcPtr && destPtr);
+
+  // Build PlanarYCbCrData for source buffer.
+  PlanarYCbCrData srcData;
+  switch (aSource->getPixelFormat()) {
+    case HAL_PIXEL_FORMAT_YV12: {
+      // Android YV12 format is defined in system/core/include/system/graphics.h
+      srcData.mYChannel = static_cast<uint8_t*>(srcPtr);
+      srcData.mYSkip = 0;
+      srcData.mYSize.width = aSource->getWidth();
+      srcData.mYSize.height = aSource->getHeight();
+      srcData.mYStride = aSource->getStride();
+      // 4:2:0.
+      srcData.mCbCrSize.width = srcData.mYSize.width / 2;
+      srcData.mCbCrSize.height = srcData.mYSize.height / 2;
+      srcData.mCrChannel = srcData.mYChannel + (srcData.mYStride * srcData.mYSize.height);
+      // Aligned to 16 bytes boundary.
+      srcData.mCbCrStride = Align(srcData.mYStride / 2, 16);
+      srcData.mCrSkip = 0;
+      srcData.mCbChannel = srcData.mCrChannel + (srcData.mCbCrStride * srcData.mCbCrSize.height);
+      srcData.mCbSkip = 0;
+
+      // Build PlanarYCbCrData for destination buffer.
+      PlanarYCbCrData destData;
+      destData.mYChannel = static_cast<uint8_t*>(destPtr);
+      destData.mYSkip = 0;
+      destData.mYSize.width = aDestination->getWidth();
+      destData.mYSize.height = aDestination->getHeight();
+      destData.mYStride = aDestination->getStride();
+      // 4:2:0.
+      destData.mCbCrSize.width = destData.mYSize.width / 2;
+      destData.mCbCrSize.height = destData.mYSize.height / 2;
+      destData.mCrChannel = destData.mYChannel + (destData.mYStride * destData.mYSize.height);
+      // Aligned to 16 bytes boundary.
+      destData.mCbCrStride = Align(destData.mYStride / 2, 16);
+      destData.mCrSkip = 0;
+      destData.mCbChannel = destData.mCrChannel + (destData.mCbCrStride * destData.mCbCrSize.height);
+      destData.mCbSkip = 0;
+
+      CopyYUV(srcData, destData);
+      break;
+    }
+    case GrallocImage::HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
+      CopyVenus(static_cast<uint8_t*>(srcPtr),
+                static_cast<uint8_t*>(destPtr),
+                aSource->getWidth(),
+                aSource->getHeight());
+      break;
+    default:
+      NS_ERROR("Unsupported input gralloc image type. Should never be here.");
+  }
+
+
+  aSource->unlock();
+  aDestination->unlock();
+}
+
+already_AddRefed<VideoData>
+GonkVideoDecoderManager::CreateVideoDataFromGraphicBuffer(MediaBuffer* aSource,
+                                                          gfx::IntRect& aPicture)
+{
+  sp<GraphicBuffer> srcBuffer(aSource->graphicBuffer());
+  RefPtr<TextureClient> textureClient;
+
+  if (mNeedsCopyBuffer) {
+    // Copy buffer contents for bug 1199809.
+    if (!mCopyAllocator) {
+      RefPtr<layers::ImageBridgeChild> bridge = layers::ImageBridgeChild::GetSingleton();
+      mCopyAllocator = new TextureClientRecycleAllocator(bridge);
+    }
+    if (!mCopyAllocator) {
+      GVDM_LOG("Create buffer allocator failed!");
+      return nullptr;
+    }
+
+    gfx::IntSize size(srcBuffer->getWidth(), srcBuffer->getHeight());
+    GonkTextureClientAllocationHelper helper(srcBuffer->getPixelFormat(), size);
+    textureClient = mCopyAllocator->CreateOrRecycle(helper);
+    if (!textureClient) {
+      GVDM_LOG("Copy buffer allocation failed!");
+      return nullptr;
+    }
+
+    sp<GraphicBuffer> destBuffer =
+      static_cast<GrallocTextureData*>(textureClient->GetInternalData())->GetGraphicBuffer();
+
+    CopyGraphicBuffer(srcBuffer, destBuffer);
+  } else {
+    textureClient = mNativeWindow->getTextureClientFromBuffer(srcBuffer.get());
+    textureClient->SetRecycleCallback(GonkVideoDecoderManager::RecycleCallback, this);
+    static_cast<GrallocTextureData*>(textureClient->GetInternalData())->SetMediaBuffer(aSource);
+  }
+
+  RefPtr<VideoData> data =
+    VideoData::CreateAndCopyIntoTextureClient(mConfig,
+                                              0, // Filled later by caller.
+                                              0, // Filled later by caller.
+                                              1, // No way to pass sample duration from muxer to
+                                                 // OMX codec, so we hardcode the duration here.
+                                              textureClient,
+                                              false, // Filled later by caller.
+                                              -1,
+                                              aPicture);
+  return data.forget();
+}
+
+already_AddRefed<VideoData>
+GonkVideoDecoderManager::CreateVideoDataFromDataBuffer(MediaBuffer* aSource, gfx::IntRect& aPicture)
+{
+  if (!aSource->data()) {
+    GVDM_LOG("No data in Video Buffer!");
+    return nullptr;
+  }
+  uint8_t *yuv420p_buffer = (uint8_t *)aSource->data();
+  int32_t stride = mFrameInfo.mStride;
+  int32_t slice_height = mFrameInfo.mSliceHeight;
+
+  // Converts to OMX_COLOR_FormatYUV420Planar
+  if (mFrameInfo.mColorFormat != OMX_COLOR_FormatYUV420Planar) {
+    ARect crop;
+    crop.top = 0;
+    crop.bottom = mFrameInfo.mHeight;
+    crop.left = 0;
+    crop.right = mFrameInfo.mWidth;
+    yuv420p_buffer = GetColorConverterBuffer(mFrameInfo.mWidth, mFrameInfo.mHeight);
+    if (mColorConverter.convertDecoderOutputToI420(aSource->data(),
+        mFrameInfo.mWidth, mFrameInfo.mHeight, crop, yuv420p_buffer) != OK) {
+        GVDM_LOG("Color conversion failed!");
+        return nullptr;
+    }
+      stride = mFrameInfo.mWidth;
+      slice_height = mFrameInfo.mHeight;
+  }
+
+  size_t yuv420p_y_size = stride * slice_height;
+  size_t yuv420p_u_size = ((stride + 1) / 2) * ((slice_height + 1) / 2);
+  uint8_t *yuv420p_y = yuv420p_buffer;
+  uint8_t *yuv420p_u = yuv420p_y + yuv420p_y_size;
+  uint8_t *yuv420p_v = yuv420p_u + yuv420p_u_size;
+
+  VideoData::YCbCrBuffer b;
+  b.mPlanes[0].mData = yuv420p_y;
+  b.mPlanes[0].mWidth = mFrameInfo.mWidth;
+  b.mPlanes[0].mHeight = mFrameInfo.mHeight;
+  b.mPlanes[0].mStride = stride;
+  b.mPlanes[0].mOffset = 0;
+  b.mPlanes[0].mSkip = 0;
+
+  b.mPlanes[1].mData = yuv420p_u;
+  b.mPlanes[1].mWidth = (mFrameInfo.mWidth + 1) / 2;
+  b.mPlanes[1].mHeight = (mFrameInfo.mHeight + 1) / 2;
+  b.mPlanes[1].mStride = (stride + 1) / 2;
+  b.mPlanes[1].mOffset = 0;
+  b.mPlanes[1].mSkip = 0;
+
+  b.mPlanes[2].mData = yuv420p_v;
+  b.mPlanes[2].mWidth =(mFrameInfo.mWidth + 1) / 2;
+  b.mPlanes[2].mHeight = (mFrameInfo.mHeight + 1) / 2;
+  b.mPlanes[2].mStride = (stride + 1) / 2;
+  b.mPlanes[2].mOffset = 0;
+  b.mPlanes[2].mSkip = 0;
+
+  RefPtr<VideoData> data =
+    VideoData::CreateAndCopyData(mConfig,
+                                 mImageContainer,
+                                 0, // Filled later by caller.
+                                 0, // Filled later by caller.
+                                 1, // We don't know the duration.
+                                 b,
+                                 0, // Filled later by caller.
+                                 -1,
+                                 aPicture);
+
+  return data.forget();
+}
+
+bool
+GonkVideoDecoderManager::SetVideoFormat()
+{
+  // read video metadata from MediaCodec
+  sp<AMessage> codecFormat;
+  if (mDecoder->getOutputFormat(&codecFormat) == OK) {
+    AString mime;
+    int32_t width = 0;
+    int32_t height = 0;
+    int32_t stride = 0;
+    int32_t slice_height = 0;
+    int32_t color_format = 0;
+    int32_t crop_left = 0;
+    int32_t crop_top = 0;
+    int32_t crop_right = 0;
+    int32_t crop_bottom = 0;
+    if (!codecFormat->findString("mime", &mime) ||
+        !codecFormat->findInt32("width", &width) ||
+        !codecFormat->findInt32("height", &height) ||
+        !codecFormat->findInt32("stride", &stride) ||
+        !codecFormat->findInt32("slice-height", &slice_height) ||
+        !codecFormat->findInt32("color-format", &color_format) ||
+        !codecFormat->findRect("crop", &crop_left, &crop_top, &crop_right, &crop_bottom)) {
+      GVDM_LOG("Failed to find values");
+      return false;
+    }
+    mFrameInfo.mWidth = width;
+    mFrameInfo.mHeight = height;
+    mFrameInfo.mStride = stride;
+    mFrameInfo.mSliceHeight = slice_height;
+    mFrameInfo.mColorFormat = color_format;
+
+    nsIntSize displaySize(width, height);
+    if (!IsValidVideoRegion(mConfig.mDisplay,
+                            mConfig.ScaledImageRect(width, height),
+                            displaySize)) {
+      GVDM_LOG("It is not a valid region");
+      return false;
+    }
+    return true;
+  }
+  GVDM_LOG("Fail to get output format");
+  return false;
+}
+
+// Blocks until decoded sample is produced by the deoder.
+nsresult
+GonkVideoDecoderManager::Output(int64_t aStreamOffset,
+                                RefPtr<MediaData>& aOutData)
+{
+  aOutData = nullptr;
+  status_t err;
+  if (mDecoder == nullptr) {
+    GVDM_LOG("Decoder is not inited");
+    return NS_ERROR_UNEXPECTED;
+  }
+  MediaBuffer* outputBuffer = nullptr;
+  err = mDecoder->Output(&outputBuffer, READ_OUTPUT_BUFFER_TIMEOUT_US);
+
+  switch (err) {
+    case OK:
+    {
+      RefPtr<VideoData> data;
+      nsresult rv = CreateVideoData(outputBuffer, aStreamOffset, getter_AddRefs(data));
+      if (rv == NS_ERROR_NOT_AVAILABLE) {
+        // Decoder outputs a empty video buffer, try again
+        return NS_ERROR_NOT_AVAILABLE;
+      } else if (rv != NS_OK || data == nullptr) {
+        GVDM_LOG("Failed to create VideoData");
+        return NS_ERROR_UNEXPECTED;
+      }
+      aOutData = data;
+      return NS_OK;
+    }
+    case android::INFO_FORMAT_CHANGED:
+    {
+      // If the format changed, update our cached info.
+      GVDM_LOG("Decoder format changed");
+      if (!SetVideoFormat()) {
+        return NS_ERROR_UNEXPECTED;
+      }
+      return Output(aStreamOffset, aOutData);
+    }
+    case android::INFO_OUTPUT_BUFFERS_CHANGED:
+    {
+      if (mDecoder->UpdateOutputBuffers()) {
+        return Output(aStreamOffset, aOutData);
+      }
+      GVDM_LOG("Fails to update output buffers!");
+      return NS_ERROR_FAILURE;
+    }
+    case -EAGAIN:
+    {
+//      GVDM_LOG("Need to try again!");
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+    case android::ERROR_END_OF_STREAM:
+    {
+      GVDM_LOG("Got the EOS frame!");
+      RefPtr<VideoData> data;
+      nsresult rv = CreateVideoData(outputBuffer, aStreamOffset, getter_AddRefs(data));
+      if (rv == NS_ERROR_NOT_AVAILABLE) {
+        // For EOS, no need to do any thing.
+        return NS_ERROR_ABORT;
+      }
+      if (rv != NS_OK || data == nullptr) {
+        GVDM_LOG("Failed to create video data");
+        return NS_ERROR_UNEXPECTED;
+      }
+      aOutData = data;
+      return NS_ERROR_ABORT;
+    }
+    case -ETIMEDOUT:
+    {
+      GVDM_LOG("Timeout. can try again next time");
+      return NS_ERROR_UNEXPECTED;
+    }
+    default:
+    {
+      GVDM_LOG("Decoder failed, err=%d", err);
+      return NS_ERROR_UNEXPECTED;
+    }
+  }
+
+  return NS_OK;
+}
+
+void
+GonkVideoDecoderManager::codecReserved()
+{
+  if (mInitPromise.IsEmpty()) {
+    return;
+  }
+  GVDM_LOG("codecReserved");
+  sp<AMessage> format = new AMessage;
+  sp<Surface> surface;
+  status_t rv = OK;
+  // Fixed values
+  GVDM_LOG("Configure video mime type: %s, width:%d, height:%d", mConfig.mMimeType.get(), mConfig.mImage.width, mConfig.mImage.height);
+  format->setString("mime", mConfig.mMimeType.get());
+  format->setInt32("width", mConfig.mImage.width);
+  format->setInt32("height", mConfig.mImage.height);
+  // Set the "moz-use-undequeued-bufs" to use the undeque buffers to accelerate
+  // the video decoding.
+  format->setInt32("moz-use-undequeued-bufs", 1);
+  if (mNativeWindow != nullptr) {
+#if ANDROID_VERSION >= 21
+    surface = new Surface(mGraphicBufferProducer);
+#else
+    surface = new Surface(mNativeWindow->getBufferQueue());
+#endif
+  }
+  mDecoder->configure(format, surface, nullptr, 0);
+  mDecoder->Prepare();
+
+  if (mConfig.mMimeType.EqualsLiteral("video/mp4v-es")) {
+    rv = mDecoder->Input(mConfig.mCodecSpecificConfig->Elements(),
+                         mConfig.mCodecSpecificConfig->Length(), 0,
+                         android::MediaCodec::BUFFER_FLAG_CODECCONFIG,
+                         CODECCONFIG_TIMEOUT_US);
+  }
+
+  if (rv != OK) {
+    GVDM_LOG("Failed to configure codec!!!!");
+    mInitPromise.Reject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
+    return;
+  }
+
+  mInitPromise.Resolve(TrackType::kVideoTrack, __func__);
+}
+
+void
+GonkVideoDecoderManager::codecCanceled()
+{
+  GVDM_LOG("codecCanceled");
+  mInitPromise.RejectIfExists(NS_ERROR_DOM_MEDIA_CANCELED, __func__);
+}
+
+// Called on GonkDecoderManager::mTaskLooper thread.
+void
+GonkVideoDecoderManager::onMessageReceived(const sp<AMessage> &aMessage)
+{
+  switch (aMessage->what()) {
+    case kNotifyPostReleaseBuffer:
+    {
+      ReleaseAllPendingVideoBuffers();
+      break;
+    }
+
+    default:
+    {
+      GonkDecoderManager::onMessageReceived(aMessage);
+      break;
+    }
+  }
+}
+
+uint8_t *
+GonkVideoDecoderManager::GetColorConverterBuffer(int32_t aWidth, int32_t aHeight)
+{
+  // Allocate a temporary YUV420Planer buffer.
+  size_t yuv420p_y_size = aWidth * aHeight;
+  size_t yuv420p_u_size = ((aWidth + 1) / 2) * ((aHeight + 1) / 2);
+  size_t yuv420p_v_size = yuv420p_u_size;
+  size_t yuv420p_size = yuv420p_y_size + yuv420p_u_size + yuv420p_v_size;
+  if (mColorConverterBufferSize != yuv420p_size) {
+    mColorConverterBuffer = MakeUnique<uint8_t[]>(yuv420p_size);
+    mColorConverterBufferSize = yuv420p_size;
+  }
+  return mColorConverterBuffer.get();
+}
+
+/* static */
+void
+GonkVideoDecoderManager::RecycleCallback(TextureClient* aClient, void* aClosure)
+{
+  MOZ_ASSERT(aClient && !aClient->IsDead());
+  GonkVideoDecoderManager* videoManager = static_cast<GonkVideoDecoderManager*>(aClosure);
+  GrallocTextureData* client = static_cast<GrallocTextureData*>(aClient->GetInternalData());
+  aClient->ClearRecycleCallback();
+  FenceHandle handle = aClient->GetAndResetReleaseFenceHandle();
+  videoManager->PostReleaseVideoBuffer(client->GetMediaBuffer(), handle);
+}
+
+void GonkVideoDecoderManager::PostReleaseVideoBuffer(
+                                android::MediaBuffer *aBuffer,
+                                FenceHandle aReleaseFence)
+{
+  {
+    MutexAutoLock autoLock(mPendingReleaseItemsLock);
+    if (aBuffer) {
+      mPendingReleaseItems.AppendElement(ReleaseItem(aBuffer, aReleaseFence));
+    }
+  }
+  sp<AMessage> notify =
+            new AMessage(kNotifyPostReleaseBuffer, id());
+  notify->post();
+
+}
+
+void GonkVideoDecoderManager::ReleaseAllPendingVideoBuffers()
+{
+  nsTArray<ReleaseItem> releasingItems;
+  {
+    MutexAutoLock autoLock(mPendingReleaseItemsLock);
+    releasingItems.AppendElements(mPendingReleaseItems);
+    mPendingReleaseItems.Clear();
+  }
+
+  // Free all pending video buffers without holding mPendingReleaseItemsLock.
+  size_t size = releasingItems.Length();
+  for (size_t i = 0; i < size; i++) {
+    RefPtr<FenceHandle::FdObj> fdObj = releasingItems[i].mReleaseFence.GetAndResetFdObj();
+    sp<Fence> fence = new Fence(fdObj->GetAndResetFd());
+    fence->waitForever("GonkVideoDecoderManager");
+    mDecoder->ReleaseMediaBuffer(releasingItems[i].mBuffer);
+  }
+  releasingItems.Clear();
+}
+
+} // namespace mozilla