Add m-esr52 at 52.6.0

1 files changed, 1104 insertions, 0 deletions

diff --git a/media/omx-plugin/OmxPlugin.cpp b/media/omx-plugin/OmxPlugin.cpp
new file mode 100644
index 000000000..4b6641c46
--- /dev/null
+++ b/media/omx-plugin/OmxPlugin.cpp
@@ -0,0 +1,1104 @@
+/* -*- 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 <stagefright/ColorConverter.h>
+#include <stagefright/DataSource.h>
+#include <stagefright/MediaExtractor.h>
+#include <stagefright/MetaData.h>
+#include <stagefright/OMXCodec.h>
+#include <media/stagefright/MediaErrors.h>
+#ifdef MOZ_WIDGET_GONK
+#include <OMX.h>
+#else
+#include <stagefright/OMXClient.h>
+#endif
+#include <algorithm>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Types.h"
+#include "MPAPI.h"
+
+#include "android/log.h"
+
+#define MAX_DECODER_NAME_LEN 256
+#define AVC_MIME_TYPE "video/avc"
+
+#define DEFAULT_STAGEFRIGHT_FLAGS OMXCodec::kClientNeedsFramebuffer
+
+#undef LOG
+#define LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "OmxPlugin" , ## args)
+
+#include <I420ColorConverter.h>
+
+using namespace MPAPI;
+
+#if !defined(MOZ_STAGEFRIGHT_OFF_T)
+#define MOZ_STAGEFRIGHT_OFF_T off64_t
+#endif
+
+using namespace android;
+
+namespace OmxPlugin {
+
+const int OMX_QCOM_COLOR_FormatYVU420PackedSemiPlanar32m4ka = 0x7FA30C01;
+const int OMX_QCOM_COLOR_FormatYVU420SemiPlanar = 0x7FA30C00;
+const int OMX_TI_COLOR_FormatYUV420PackedSemiPlanar = 0x7F000100;
+
+class OmxDecoder {
+  PluginHost *mPluginHost;
+  Decoder *mDecoder;
+  sp<MediaSource> mVideoTrack;
+  sp<MediaSource> mVideoSource;
+  sp<MediaSource> mAudioTrack;
+  sp<MediaSource> mAudioSource;
+  int32_t mVideoWidth;
+  int32_t mVideoHeight;
+  int32_t mVideoColorFormat;
+  int32_t mVideoStride;
+  int32_t mVideoSliceHeight;
+  int32_t mVideoCropLeft;
+  int32_t mVideoCropTop;
+  int32_t mVideoCropRight;
+  int32_t mVideoCropBottom;
+  int32_t mVideoRotation;
+  int32_t mAudioChannels;
+  int32_t mAudioSampleRate;
+  int64_t mDurationUs;
+  MediaBuffer *mVideoBuffer;
+  VideoFrame mVideoFrame;
+  MediaBuffer *mAudioBuffer;
+  AudioFrame mAudioFrame;
+  ColorConverter *mColorConverter;
+
+  // 'true' if a read from the audio stream was done while reading the metadata
+  bool mAudioMetadataRead;
+
+  void ReleaseVideoBuffer();
+  void ReleaseAudioBuffer();
+
+  void ToVideoFrame_YUV420Planar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame);
+  void ToVideoFrame_CbYCrY(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame);
+  void ToVideoFrame_YUV420SemiPlanar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame);
+  void ToVideoFrame_YVU420SemiPlanar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame);
+  void ToVideoFrame_YUV420PackedSemiPlanar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame);
+  void ToVideoFrame_YVU420PackedSemiPlanar32m4ka(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame);
+  bool ToVideoFrame_RGB565(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback);
+  bool ToVideoFrame_ColorConverter(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback);
+  bool ToVideoFrame_I420ColorConverter(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback);
+  bool ToVideoFrame(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback);
+  bool ToAudioFrame(AudioFrame *aFrame, int64_t aTimeUs, void *aData, size_t aDataOffset, size_t aSize,
+                    int32_t aAudioChannels, int32_t aAudioSampleRate);
+public:
+  OmxDecoder(PluginHost *aPluginHost, Decoder *aDecoder);
+  ~OmxDecoder();
+
+  bool Init();
+  bool SetVideoFormat();
+  bool SetAudioFormat();
+
+  void GetDuration(int64_t *durationUs) {
+    *durationUs = mDurationUs;
+  }
+
+  void GetVideoParameters(int32_t *width, int32_t *height) {
+    *width = mVideoWidth;
+    *height = mVideoHeight;
+  }
+
+  void GetAudioParameters(int32_t *numChannels, int32_t *sampleRate) {
+    *numChannels = mAudioChannels;
+    *sampleRate = mAudioSampleRate;
+  }
+
+  bool HasVideo() {
+    return mVideoSource != nullptr;
+  }
+
+  bool HasAudio() {
+    return mAudioSource != nullptr;
+  }
+
+  bool ReadVideo(VideoFrame *aFrame, int64_t aSeekTimeUs, BufferCallback *aBufferCallback);
+  bool ReadAudio(AudioFrame *aFrame, int64_t aSeekTimeUs);
+};
+
+#if !defined(MOZ_WIDGET_GONK)
+static class OmxClientInstance {
+public:
+  OmxClientInstance()
+    : mClient(new OMXClient())
+    , mStatus(mClient->connect())
+  {
+  }
+
+  status_t IsValid()
+  {
+    return mStatus == OK;
+  }
+
+  OMXClient *get()
+  {
+    return mClient;
+  }
+
+  ~OmxClientInstance()
+  {
+    if (mStatus == OK) {
+      mClient->disconnect();
+    }
+    delete mClient;
+  }
+
+private:
+  OMXClient *mClient;
+  status_t mStatus;
+} sClientInstance;
+#endif
+
+OmxDecoder::OmxDecoder(PluginHost *aPluginHost, Decoder *aDecoder) :
+  mPluginHost(aPluginHost),
+  mDecoder(aDecoder),
+  mVideoWidth(0),
+  mVideoHeight(0),
+  mVideoColorFormat(0),
+  mVideoStride(0),
+  mVideoSliceHeight(0),
+  mVideoCropLeft(0),
+  mVideoCropTop(0),
+  mVideoCropRight(0),
+  mVideoCropBottom(0),
+  mVideoRotation(0),
+  mAudioChannels(-1),
+  mAudioSampleRate(-1),
+  mDurationUs(-1),
+  mVideoBuffer(nullptr),
+  mAudioBuffer(nullptr),
+  mColorConverter(nullptr),
+  mAudioMetadataRead(false)
+{
+}
+
+OmxDecoder::~OmxDecoder()
+{
+  ReleaseVideoBuffer();
+  ReleaseAudioBuffer();
+
+  if (mVideoSource.get()) {
+    mVideoSource->stop();
+  }
+
+  if (mAudioSource.get()) {
+    mAudioSource->stop();
+  }
+
+  if (mColorConverter) {
+    delete mColorConverter;
+  }
+}
+
+class AutoStopMediaSource {
+  sp<MediaSource> mMediaSource;
+public:
+  AutoStopMediaSource(sp<MediaSource> aMediaSource) : mMediaSource(aMediaSource) {
+  }
+
+  ~AutoStopMediaSource() {
+    mMediaSource->stop();
+  }
+};
+
+#ifdef MOZ_WIDGET_GONK
+static sp<IOMX> sOMX = nullptr;
+static sp<IOMX> GetOMX() {
+  if(sOMX.get() == nullptr) {
+    sOMX = reinterpret_cast<IOMX*>(new OMX);
+  }
+  return sOMX;
+}
+#endif
+
+static uint32_t
+GetDefaultStagefrightFlags(PluginHost *aPluginHost)
+{
+  uint32_t flags = DEFAULT_STAGEFRIGHT_FLAGS;
+
+  char hardware[256] = "";
+  aPluginHost->GetSystemInfoString("hardware", hardware, sizeof(hardware));
+
+  if (!strcmp("qcom", hardware) ||
+      !strncmp("mt", hardware, 2)) {
+    // Qualcomm's OMXCodec implementation interprets this flag to mean that we
+    // only want a thumbnail and therefore only need one frame. After the first
+    // frame it returns EOS.
+    // Some MediaTek chipsets have also been found to do the same.
+    // All other OMXCodec implementations seen so far interpret this flag
+    // sanely; some do not return full framebuffers unless this flag is passed.
+    flags &= ~OMXCodec::kClientNeedsFramebuffer;
+  }
+
+  LOG("Hardware %s; using default flags %#x\n", hardware, flags);
+
+  return flags;
+}
+
+static uint32_t GetVideoCreationFlags(PluginHost* aPluginHost)
+{
+#ifdef MOZ_WIDGET_GONK
+  // Flag value of zero means return a hardware or software decoder
+  // depending on what the device supports.
+  return 0;
+#else
+  // Check whether the user has set a pref to override our default OMXCodec
+  // CreationFlags flags. This is useful for A/B testing hardware and software
+  // decoders for performance and bugs. The interesting flag values are:
+  //  0 = Let Stagefright choose hardware or software decoding (default)
+  //  8 = Force software decoding
+  // 16 = Force hardware decoding
+  int32_t flags = 0;
+  aPluginHost->GetIntPref("media.stagefright.omxcodec.flags", &flags);
+  if (flags != 0) {
+    LOG("media.stagefright.omxcodec.flags=%d", flags);
+    if ((flags & OMXCodec::kHardwareCodecsOnly) != 0) {
+      LOG("FORCE HARDWARE DECODING");
+    } else if ((flags & OMXCodec::kSoftwareCodecsOnly) != 0) {
+      LOG("FORCE SOFTWARE DECODING");
+    }
+  }
+
+  flags |= GetDefaultStagefrightFlags(aPluginHost);
+
+  return static_cast<uint32_t>(flags);
+#endif
+}
+
+enum ColorFormatSupport {
+  ColorFormatNotSupported = 0,
+  ColorFormatSupportOK,
+  ColorFormatSupportPreferred,
+};
+
+static ColorFormatSupport
+IsColorFormatSupported(OMX_COLOR_FORMATTYPE aColorFormat)
+{
+  switch (static_cast<int>(aColorFormat)) {
+    case OMX_COLOR_FormatCbYCrY:
+    case OMX_COLOR_FormatYUV420Planar:
+    case OMX_COLOR_FormatYUV420SemiPlanar:
+    case OMX_QCOM_COLOR_FormatYVU420PackedSemiPlanar32m4ka:
+    case OMX_QCOM_COLOR_FormatYVU420SemiPlanar:
+    case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar:
+      LOG("Colour format %#x supported natively.", aColorFormat);
+      // Prefer natively supported colour formats over formats that need another
+      // slow software conversion.
+      return ColorFormatSupportPreferred;
+    default:
+      break;
+  }
+
+  // These formats are okay if we can't find a better one; Android provides a
+  // software conversion to a sane colour format.
+  if (ColorConverter(aColorFormat, OMX_COLOR_Format16bitRGB565).isValid()) {
+    LOG("Colour format %#x supported by Android ColorConverter.", aColorFormat);
+    return ColorFormatSupportOK;
+  }
+
+  I420ColorConverter yuvConverter;
+
+  if (yuvConverter.isLoaded() &&
+      yuvConverter.getDecoderOutputFormat() == aColorFormat) {
+    LOG("Colour format %#x supported by Android I420ColorConverter.", aColorFormat);
+    return ColorFormatSupportOK;
+  }
+
+  return ColorFormatNotSupported;
+}
+
+#if defined(MOZ_ANDROID_KK)
+/**
+ * Look for a decoder that supports a colour format that we support.
+ */
+static bool
+FindPreferredDecoderAndColorFormat(const sp<IOMX>& aOmx,
+                                   char *aDecoderName,
+                                   size_t aDecoderLen,
+                                   OMX_COLOR_FORMATTYPE *aColorFormat)
+{
+  Vector<CodecCapabilities> codecs;
+
+  // Get all AVC decoder/colour format pairs that this device supports.
+  QueryCodecs(aOmx, AVC_MIME_TYPE, true /* queryDecoders */, &codecs);
+
+  // We assume that faster (hardware accelerated) decoders come first in the
+  // list, so we choose the first decoder with a colour format we can use.
+  for (uint32_t i = 0; i < codecs.size(); i++) {
+    const CodecCapabilities &caps = codecs[i];
+    const Vector<OMX_U32> &colors = caps.mColorFormats;
+
+    bool found = false;
+    for (uint32_t j = 0; j < colors.size(); j++) {
+      OMX_COLOR_FORMATTYPE color = (OMX_COLOR_FORMATTYPE)colors[j];
+
+      LOG("Decoder %s can output colour format %#x.\n",
+          caps.mComponentName.string(), color);
+
+      ColorFormatSupport supported = IsColorFormatSupported(color);
+
+      if (supported) {
+        strncpy(aDecoderName, caps.mComponentName.string(), aDecoderLen);
+        *aColorFormat = color;
+        found = true;
+      }
+
+      if (supported == ColorFormatSupportPreferred) {
+        // The colour format is natively supported -- that's as good as we're
+        // going to get.
+        break;
+      }
+    }
+
+    if (found) {
+      return true;
+    }
+  }
+
+  return false;
+}
+#endif
+
+static sp<MediaSource> CreateVideoSource(PluginHost* aPluginHost,
+                                         const sp<IOMX>& aOmx,
+                                         const sp<MediaSource>& aVideoTrack)
+{
+  uint32_t flags = GetVideoCreationFlags(aPluginHost);
+
+  char decoderName[MAX_DECODER_NAME_LEN] = "";
+  sp<MetaData> videoFormat = aVideoTrack->getFormat();
+
+#if defined(MOZ_ANDROID_KK)
+  OMX_COLOR_FORMATTYPE colorFormat = (OMX_COLOR_FORMATTYPE)0;
+  if (FindPreferredDecoderAndColorFormat(aOmx,
+                                         decoderName, sizeof(decoderName),
+                                         &colorFormat)) {
+    // We found a colour format that we can handle. Tell OMXCodec to use it in
+    // case it isn't the default.
+    videoFormat->setInt32(kKeyColorFormat, colorFormat);
+
+    LOG("Found compatible decoder %s with colour format %#x.\n",
+        decoderName, colorFormat);
+  }
+#endif
+
+  if (flags == DEFAULT_STAGEFRIGHT_FLAGS) {
+    // Let Stagefright choose hardware or software decoder.
+    sp<MediaSource> videoSource = OMXCodec::Create(aOmx, videoFormat,
+                                                   false, aVideoTrack,
+                                                   decoderName[0] ? decoderName : nullptr,
+                                                   flags);
+    if (videoSource == nullptr)
+      return nullptr;
+
+    // Now that OMXCodec has parsed the video's AVCDecoderConfigurationRecord,
+    // check whether we know how to decode this video.
+    int32_t videoColorFormat;
+    if (videoSource->getFormat()->findInt32(kKeyColorFormat, &videoColorFormat)) {
+
+      if (IsColorFormatSupported((OMX_COLOR_FORMATTYPE)videoColorFormat)) {
+        return videoSource;
+      }
+
+      // We need to implement a ToVideoFrame_*() color conversion
+      // function for this video color format.
+      LOG("Unknown video color format: %#x", videoColorFormat);
+    } else {
+      LOG("Video color format not found");
+    }
+
+    // Throw away the videoSource and try again with new flags.
+    LOG("Falling back to software decoder");
+    videoSource.clear();
+    flags = DEFAULT_STAGEFRIGHT_FLAGS | OMXCodec::kSoftwareCodecsOnly;
+  }
+
+  MOZ_ASSERT(flags != DEFAULT_STAGEFRIGHT_FLAGS);
+  return OMXCodec::Create(aOmx, aVideoTrack->getFormat(), false, aVideoTrack,
+                          nullptr, flags);
+}
+
+bool OmxDecoder::Init()
+{
+#if defined(MOZ_WIDGET_ANDROID)
+  // OMXClient::connect() always returns OK and aborts fatally if
+  // it can't connect. We may need to implement the connect functionality
+  // ourselves if this proves to be an issue.
+  if (!sClientInstance.IsValid()) {
+    LOG("OMXClient failed to connect");
+    return false;
+  }
+#endif
+
+  //register sniffers, if they are not registered in this process.
+  DataSource::RegisterDefaultSniffers();
+
+  sp<DataSource> dataSource =
+    DataSource::CreateFromURI(static_cast<char*>(mDecoder->mResource));
+  if (!dataSource.get() || dataSource->initCheck()) {
+    return false;
+  }
+
+  sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource);
+  if (extractor == nullptr) {
+    return false;
+  }
+
+  ssize_t audioTrackIndex = -1;
+  ssize_t videoTrackIndex = -1;
+  const char *audioMime = nullptr;
+  const char *videoMime = nullptr;
+
+  for (size_t i = 0; i < extractor->countTracks(); ++i) {
+    sp<MetaData> meta = extractor->getTrackMetaData(i);
+
+    const char *mime;
+    if (!meta->findCString(kKeyMIMEType, &mime)) {
+      continue;
+    }
+
+    if (videoTrackIndex == -1 && !strncasecmp(mime, "video/", 6)) {
+      videoTrackIndex = i;
+      videoMime = mime;
+    } else if (audioTrackIndex == -1 && !strncasecmp(mime, "audio/", 6)) {
+      audioTrackIndex = i;
+      audioMime = mime;
+    }
+  }
+
+  if (videoTrackIndex == -1 && audioTrackIndex == -1) {
+    return false;
+  }
+
+  int64_t totalDurationUs = 0;
+
+#ifdef MOZ_WIDGET_GONK
+  sp<IOMX> omx = GetOMX();
+#else
+  sp<IOMX> omx = sClientInstance.get()->interface();
+#endif
+
+  sp<MediaSource> videoTrack;
+  sp<MediaSource> videoSource;
+  if (videoTrackIndex != -1 && (videoTrack = extractor->getTrack(videoTrackIndex)) != nullptr) {
+    videoSource = CreateVideoSource(mPluginHost, omx, videoTrack);
+    if (videoSource == nullptr) {
+      LOG("OMXCodec failed to initialize video decoder for \"%s\"", videoMime);
+      return false;
+    }
+    status_t status = videoSource->start();
+    if (status != OK) {
+      LOG("videoSource->start() failed with status %#x", status);
+      return false;
+    }
+    int64_t durationUs;
+    if (videoTrack->getFormat()->findInt64(kKeyDuration, &durationUs)) {
+      if (durationUs < 0)
+        LOG("video duration %lld should be nonnegative", durationUs);
+      if (durationUs > totalDurationUs)
+        totalDurationUs = durationUs;
+    }
+  }
+
+  sp<MediaSource> audioTrack;
+  sp<MediaSource> audioSource;
+  if (audioTrackIndex != -1 && (audioTrack = extractor->getTrack(audioTrackIndex)) != nullptr)
+  {
+    if (!strcasecmp(audioMime, "audio/raw")) {
+      audioSource = audioTrack;
+    } else {
+      audioSource = OMXCodec::Create(omx,
+                                     audioTrack->getFormat(),
+                                     false, // decoder
+                                     audioTrack);
+    }
+
+    if (audioSource == nullptr) {
+      LOG("OMXCodec failed to initialize audio decoder for \"%s\"", audioMime);
+      return false;
+    }
+
+    status_t status = audioSource->start();
+    if (status != OK) {
+      LOG("audioSource->start() failed with status %#x", status);
+      return false;
+    }
+
+    int64_t durationUs;
+    if (audioTrack->getFormat()->findInt64(kKeyDuration, &durationUs)) {
+      if (durationUs < 0)
+        LOG("audio duration %lld should be nonnegative", durationUs);
+      if (durationUs > totalDurationUs)
+        totalDurationUs = durationUs;
+    }
+  }
+
+  // set decoder state
+  mVideoTrack = videoTrack;
+  mVideoSource = videoSource;
+  mAudioTrack = audioTrack;
+  mAudioSource = audioSource;
+  mDurationUs = totalDurationUs;
+
+  if (mVideoSource.get() && !SetVideoFormat())
+    return false;
+
+  // To reliably get the channel and sample rate data we need to read from the
+  // audio source until we get a INFO_FORMAT_CHANGE status
+  if (mAudioSource.get()) {
+    if (mAudioSource->read(&mAudioBuffer) != INFO_FORMAT_CHANGED) {
+      sp<MetaData> meta = mAudioSource->getFormat();
+      if (!meta->findInt32(kKeyChannelCount, &mAudioChannels) ||
+          !meta->findInt32(kKeySampleRate, &mAudioSampleRate)) {
+        return false;
+      }
+      mAudioMetadataRead = true;
+
+      if (mAudioChannels < 0) {
+        LOG("audio channel count %d must be nonnegative", mAudioChannels);
+        return false;
+      }
+
+      if (mAudioSampleRate < 0) {
+        LOG("audio sample rate %d must be nonnegative", mAudioSampleRate);
+        return false;
+      }
+    }
+    else if (!SetAudioFormat()) {
+        return false;
+    }
+  }
+  return true;
+}
+
+bool OmxDecoder::SetVideoFormat() {
+  sp<MetaData> format = mVideoSource->getFormat();
+
+  // Stagefright's kKeyWidth and kKeyHeight are what MPAPI calls stride and
+  // slice height. Stagefright only seems to use its kKeyStride and
+  // kKeySliceHeight to initialize camera video formats.
+
+#if defined(DEBUG)
+  int32_t unexpected;
+  if (format->findInt32(kKeyStride, &unexpected))
+    LOG("Expected kKeyWidth, but found kKeyStride %d", unexpected);
+  if (format->findInt32(kKeySliceHeight, &unexpected))
+    LOG("Expected kKeyHeight, but found kKeySliceHeight %d", unexpected);
+#endif // DEBUG
+
+  const char *componentName;
+
+  if (!format->findInt32(kKeyWidth, &mVideoStride) ||
+      !format->findInt32(kKeyHeight, &mVideoSliceHeight) ||
+      !format->findCString(kKeyDecoderComponent, &componentName) ||
+      !format->findInt32(kKeyColorFormat, &mVideoColorFormat) ) {
+    return false;
+  }
+
+  if (mVideoStride <= 0) {
+    LOG("stride %d must be positive", mVideoStride);
+    return false;
+  }
+
+  if (mVideoSliceHeight <= 0) {
+    LOG("slice height %d must be positive", mVideoSliceHeight);
+    return false;
+  }
+
+  // Gingerbread does not support the kKeyCropRect key
+  if (!format->findRect(kKeyCropRect, &mVideoCropLeft, &mVideoCropTop,
+                                      &mVideoCropRight, &mVideoCropBottom)) {
+    mVideoCropLeft = 0;
+    mVideoCropTop = 0;
+    mVideoCropRight = mVideoStride - 1;
+    mVideoCropBottom = mVideoSliceHeight - 1;
+    LOG("crop rect not available, assuming no cropping");
+  }
+
+  if (mVideoCropLeft < 0 || mVideoCropLeft >= mVideoCropRight || mVideoCropRight >= mVideoStride ||
+      mVideoCropTop < 0 || mVideoCropTop >= mVideoCropBottom || mVideoCropBottom >= mVideoSliceHeight) {
+    LOG("invalid crop rect %d,%d-%d,%d", mVideoCropLeft, mVideoCropTop, mVideoCropRight, mVideoCropBottom);
+    return false;
+  }
+
+  mVideoWidth = mVideoCropRight - mVideoCropLeft + 1;
+  mVideoHeight = mVideoCropBottom - mVideoCropTop + 1;
+  MOZ_ASSERT(mVideoWidth > 0 && mVideoWidth <= mVideoStride);
+  MOZ_ASSERT(mVideoHeight > 0 && mVideoHeight <= mVideoSliceHeight);
+
+  if (!format->findInt32(kKeyRotation, &mVideoRotation)) {
+    mVideoRotation = 0;
+    LOG("rotation not available, assuming 0");
+  }
+
+  if (mVideoRotation != 0 && mVideoRotation != 90 &&
+      mVideoRotation != 180 && mVideoRotation != 270) {
+    LOG("invalid rotation %d, assuming 0", mVideoRotation);
+  }
+
+  LOG("width: %d height: %d component: %s format: %#x stride: %d sliceHeight: %d rotation: %d crop: %d,%d-%d,%d",
+      mVideoWidth, mVideoHeight, componentName, mVideoColorFormat,
+      mVideoStride, mVideoSliceHeight, mVideoRotation,
+      mVideoCropLeft, mVideoCropTop, mVideoCropRight, mVideoCropBottom);
+
+  return true;
+}
+
+bool OmxDecoder::SetAudioFormat() {
+  // If the format changed, update our cached info.
+  if (!mAudioSource->getFormat()->findInt32(kKeyChannelCount, &mAudioChannels) ||
+      !mAudioSource->getFormat()->findInt32(kKeySampleRate, &mAudioSampleRate)) {
+    return false;
+  }
+
+  LOG("channelCount: %d sampleRate: %d", mAudioChannels, mAudioSampleRate);
+
+  if (mAudioChannels < 0) {
+    LOG("audio channel count %d must be nonnegative", mAudioChannels);
+    return false;
+  }
+
+  if (mAudioSampleRate < 0) {
+    LOG("audio sample rate %d must be nonnegative", mAudioSampleRate);
+    return false;
+  }
+
+  return true;
+}
+
+void OmxDecoder::ReleaseVideoBuffer() {
+  if (mVideoBuffer) {
+    mVideoBuffer->release();
+    mVideoBuffer = nullptr;
+  }
+}
+
+void OmxDecoder::ReleaseAudioBuffer() {
+  if (mAudioBuffer) {
+    mAudioBuffer->release();
+    mAudioBuffer = nullptr;
+  }
+}
+
+void OmxDecoder::ToVideoFrame_YUV420Planar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame) {
+  void *y = aData;
+  void *u = static_cast<uint8_t *>(y) + mVideoStride * mVideoSliceHeight;
+  void *v = static_cast<uint8_t *>(u) + mVideoStride/2 * mVideoSliceHeight/2;
+  aFrame->Set(aTimeUs, aKeyFrame,
+              aData, aSize, mVideoStride, mVideoSliceHeight, mVideoRotation,
+              y, mVideoStride, mVideoWidth, mVideoHeight, 0, 0,
+              u, mVideoStride/2, mVideoWidth/2, mVideoHeight/2, 0, 0,
+              v, mVideoStride/2, mVideoWidth/2, mVideoHeight/2, 0, 0);
+}
+
+void OmxDecoder::ToVideoFrame_CbYCrY(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame) {
+  aFrame->Set(aTimeUs, aKeyFrame,
+              aData, aSize, mVideoStride, mVideoSliceHeight, mVideoRotation,
+              aData, mVideoStride, mVideoWidth, mVideoHeight, 1, 1,
+              aData, mVideoStride, mVideoWidth/2, mVideoHeight/2, 0, 3,
+              aData, mVideoStride, mVideoWidth/2, mVideoHeight/2, 2, 3);
+}
+
+void OmxDecoder::ToVideoFrame_YUV420SemiPlanar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame) {
+  int32_t videoStride = mVideoStride;
+  int32_t videoSliceHeight = mVideoSliceHeight;
+
+  // OMX.SEC.avcdec rounds mVideoStride and mVideoSliceHeight up to the nearest
+  // multiple of 16 but the data itself is too small to fit. What we do is check
+  // to see if the video size patches the raw width and height. If so we can
+  // use those figures instead.
+
+  if (static_cast<int>(aSize) == mVideoWidth * mVideoHeight * 3 / 2) {
+    videoStride = mVideoWidth;
+    videoSliceHeight = mVideoHeight;
+  }
+
+  void *y = aData;
+  void *uv = static_cast<uint8_t *>(y) + (videoStride * videoSliceHeight);
+  aFrame->Set(aTimeUs, aKeyFrame,
+              aData, aSize, videoStride, videoSliceHeight, mVideoRotation,
+              y, videoStride, mVideoWidth, mVideoHeight, 0, 0,
+              uv, videoStride, mVideoWidth/2, mVideoHeight/2, 0, 1,
+              uv, videoStride, mVideoWidth/2, mVideoHeight/2, 1, 1);
+}
+
+void OmxDecoder::ToVideoFrame_YVU420SemiPlanar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame) {
+  ToVideoFrame_YUV420SemiPlanar(aFrame, aTimeUs, aData, aSize, aKeyFrame);
+  aFrame->Cb.mOffset = 1;
+  aFrame->Cr.mOffset = 0;
+}
+
+void OmxDecoder::ToVideoFrame_YUV420PackedSemiPlanar(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame) {
+  void *y = aData;
+  void *uv = static_cast<uint8_t *>(y) + mVideoStride * (mVideoSliceHeight - mVideoCropTop/2);
+  aFrame->Set(aTimeUs, aKeyFrame,
+              aData, aSize, mVideoStride, mVideoSliceHeight, mVideoRotation,
+              y, mVideoStride, mVideoWidth, mVideoHeight, 0, 0,
+              uv, mVideoStride, mVideoWidth/2, mVideoHeight/2, 0, 1,
+              uv, mVideoStride, mVideoWidth/2, mVideoHeight/2, 1, 1);
+}
+
+void OmxDecoder::ToVideoFrame_YVU420PackedSemiPlanar32m4ka(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame) {
+  size_t roundedSliceHeight = (mVideoSliceHeight + 31) & ~31;
+  size_t roundedStride = (mVideoStride + 31) & ~31;
+  void *y = aData;
+  void *uv = static_cast<uint8_t *>(y) + (roundedStride * roundedSliceHeight);
+  aFrame->Set(aTimeUs, aKeyFrame,
+              aData, aSize, mVideoStride, mVideoSliceHeight, mVideoRotation,
+              y, mVideoStride, mVideoWidth, mVideoHeight, 0, 0,
+              uv, mVideoStride, mVideoWidth/2, mVideoHeight/2, 1, 1,
+              uv, mVideoStride, mVideoWidth/2, mVideoHeight/2, 0, 1);
+}
+
+bool OmxDecoder::ToVideoFrame_RGB565(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback) {
+  void *buffer = (*aBufferCallback)(mVideoWidth, mVideoHeight, MPAPI::RGB565);
+
+  if (!buffer) {
+    return false;
+  }
+
+  aFrame->mTimeUs = aTimeUs;
+
+  memcpy(buffer, aData, mVideoWidth * mVideoHeight * 2);
+
+  aFrame->mSize = mVideoWidth * mVideoHeight * 2;
+
+  return true;
+}
+
+bool OmxDecoder::ToVideoFrame_ColorConverter(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback) {
+  if (!mColorConverter) {
+    mColorConverter = new ColorConverter((OMX_COLOR_FORMATTYPE)mVideoColorFormat,
+                                         OMX_COLOR_Format16bitRGB565);
+  }
+
+  if (!mColorConverter->isValid()) {
+    return false;
+  }
+
+  aFrame->mTimeUs = aTimeUs;
+
+  void *buffer = (*aBufferCallback)(mVideoWidth, mVideoHeight, MPAPI::RGB565);
+
+  if (!buffer) {
+    return false;
+  }
+
+  aFrame->mSize = mVideoWidth * mVideoHeight * 2;
+
+  mColorConverter->convert(aData, mVideoStride, mVideoSliceHeight,
+                           mVideoCropLeft, mVideoCropTop,
+                           mVideoCropLeft + mVideoWidth - 1,
+                           mVideoCropTop + mVideoHeight - 1,
+                           buffer, mVideoWidth, mVideoHeight,
+                           0, 0, mVideoWidth - 1, mVideoHeight - 1);
+
+  return true;
+}
+
+bool OmxDecoder::ToVideoFrame_I420ColorConverter(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback)
+{
+  I420ColorConverter yuvConverter;
+
+  if (!yuvConverter.isLoaded()) {
+    return false;
+  }
+
+  if (yuvConverter.getDecoderOutputFormat() != mVideoColorFormat) {
+    return false;
+  }
+
+  void *buffer = (*aBufferCallback)(mVideoWidth, mVideoHeight, MPAPI::I420);
+
+  ARect crop = { mVideoCropLeft, mVideoCropTop, mVideoCropRight, mVideoCropBottom };
+  int result = yuvConverter.convertDecoderOutputToI420(aData,
+                                                       mVideoWidth,
+                                                       mVideoHeight,
+                                                       crop,
+                                                       buffer);
+
+  // result is 0 on success, -1 otherwise.
+  if (result == OK) {
+    aFrame->mTimeUs = aTimeUs;
+    aFrame->mSize = mVideoWidth * mVideoHeight * 3 / 2;
+  }
+
+  return result == OK;
+}
+
+bool OmxDecoder::ToVideoFrame(VideoFrame *aFrame, int64_t aTimeUs, void *aData, size_t aSize, bool aKeyFrame, BufferCallback *aBufferCallback) {
+  switch (mVideoColorFormat) {
+  case OMX_COLOR_FormatYUV420Planar: // e.g. Asus Transformer, Stagefright's software decoder
+    ToVideoFrame_YUV420Planar(aFrame, aTimeUs, aData, aSize, aKeyFrame);
+    break;
+  case OMX_COLOR_FormatCbYCrY: // e.g. Droid 1
+    ToVideoFrame_CbYCrY(aFrame, aTimeUs, aData, aSize, aKeyFrame);
+    break;
+  case OMX_COLOR_FormatYUV420SemiPlanar: // e.g. Galaxy S III
+    ToVideoFrame_YUV420SemiPlanar(aFrame, aTimeUs, aData, aSize, aKeyFrame);
+    break;
+  case OMX_QCOM_COLOR_FormatYVU420SemiPlanar: // e.g. Nexus One
+    ToVideoFrame_YVU420SemiPlanar(aFrame, aTimeUs, aData, aSize, aKeyFrame);
+    break;
+  case OMX_QCOM_COLOR_FormatYVU420PackedSemiPlanar32m4ka: // e.g. Otoro
+    ToVideoFrame_YVU420PackedSemiPlanar32m4ka(aFrame, aTimeUs, aData, aSize, aKeyFrame);
+    break;
+  case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar: // e.g. Galaxy Nexus
+    ToVideoFrame_YUV420PackedSemiPlanar(aFrame, aTimeUs, aData, aSize, aKeyFrame);
+    break;
+  case OMX_COLOR_Format16bitRGB565:
+    return ToVideoFrame_RGB565(aFrame, aTimeUs, aData, aSize, aKeyFrame, aBufferCallback);
+    break;
+  default:
+    if (!ToVideoFrame_ColorConverter(aFrame, aTimeUs, aData, aSize, aKeyFrame, aBufferCallback) &&
+        !ToVideoFrame_I420ColorConverter(aFrame, aTimeUs, aData, aSize, aKeyFrame, aBufferCallback)) {
+      LOG("Unknown video color format: %#x", mVideoColorFormat);
+      return false;
+    }
+  }
+  return true;
+}
+
+bool OmxDecoder::ToAudioFrame(AudioFrame *aFrame, int64_t aTimeUs, void *aData, size_t aDataOffset, size_t aSize, int32_t aAudioChannels, int32_t aAudioSampleRate)
+{
+  aFrame->Set(aTimeUs, reinterpret_cast<char *>(aData) + aDataOffset, aSize, aAudioChannels, aAudioSampleRate);
+  return true;
+}
+
+class ReadOptions : public MediaSource::ReadOptions
+{
+  // HTC have their own version of ReadOptions with extra fields. If we don't
+  // have this here, HTCOMXCodec will corrupt our stack.
+  uint32_t sadface[16];
+};
+
+bool OmxDecoder::ReadVideo(VideoFrame *aFrame, int64_t aSeekTimeUs,
+                           BufferCallback *aBufferCallback)
+{
+  MOZ_ASSERT(aSeekTimeUs >= -1);
+
+  if (!mVideoSource.get())
+    return false;
+
+  ReleaseVideoBuffer();
+
+  status_t err;
+
+  if (aSeekTimeUs != -1) {
+    ReadOptions options;
+    options.setSeekTo(aSeekTimeUs);
+    err = mVideoSource->read(&mVideoBuffer, &options);
+  } else {
+    err = mVideoSource->read(&mVideoBuffer);
+  }
+
+  aFrame->mSize = 0;
+
+  if (err == OK && mVideoBuffer->range_length() > 0) {
+    int64_t timeUs;
+    int32_t keyFrame;
+
+    if (!mVideoBuffer->meta_data()->findInt64(kKeyTime, &timeUs) ) {
+      LOG("no frame time");
+      return false;
+    }
+
+    if (timeUs < 0) {
+      LOG("frame time %lld must be nonnegative", timeUs);
+      return false;
+    }
+
+    if (!mVideoBuffer->meta_data()->findInt32(kKeyIsSyncFrame, &keyFrame)) {
+       keyFrame = 0;
+    }
+
+    char *data = reinterpret_cast<char *>(mVideoBuffer->data()) + mVideoBuffer->range_offset();
+    size_t length = mVideoBuffer->range_length();
+
+    if (!ToVideoFrame(aFrame, timeUs, data, length, keyFrame, aBufferCallback)) {
+      return false;
+    }
+  }
+  else if (err == INFO_FORMAT_CHANGED) {
+    // If the format changed, update our cached info.
+    LOG("mVideoSource INFO_FORMAT_CHANGED");
+    if (!SetVideoFormat())
+      return false;
+    else
+      return ReadVideo(aFrame, aSeekTimeUs, aBufferCallback);
+  }
+  else if (err == ERROR_END_OF_STREAM) {
+    LOG("mVideoSource END_OF_STREAM");
+  }
+  else if (err != OK) {
+    LOG("mVideoSource ERROR %#x", err);
+  }
+
+  return err == OK;
+}
+
+bool OmxDecoder::ReadAudio(AudioFrame *aFrame, int64_t aSeekTimeUs)
+{
+  MOZ_ASSERT(aSeekTimeUs >= -1);
+
+  status_t err;
+  if (mAudioMetadataRead && aSeekTimeUs == -1) {
+    // Use the data read into the buffer during metadata time
+    err = OK;
+  }
+  else {
+    ReleaseAudioBuffer();
+    if (aSeekTimeUs != -1) {
+      ReadOptions options;
+      options.setSeekTo(aSeekTimeUs);
+      err = mAudioSource->read(&mAudioBuffer, &options);
+    } else {
+      err = mAudioSource->read(&mAudioBuffer);
+    }
+  }
+  mAudioMetadataRead = false;
+
+  aSeekTimeUs = -1;
+
+  if (err == OK && mAudioBuffer->range_length() != 0) {
+    int64_t timeUs;
+    if (!mAudioBuffer->meta_data()->findInt64(kKeyTime, &timeUs)) {
+      LOG("no frame time");
+      return false;
+    }
+
+    if (timeUs < 0) {
+      LOG("frame time %lld must be nonnegative", timeUs);
+      return false;
+    }
+
+    return ToAudioFrame(aFrame, timeUs,
+                        mAudioBuffer->data(),
+                        mAudioBuffer->range_offset(),
+                        mAudioBuffer->range_length(),
+                        mAudioChannels, mAudioSampleRate);
+  }
+  else if (err == INFO_FORMAT_CHANGED) {
+    // If the format changed, update our cached info.
+    LOG("mAudioSource INFO_FORMAT_CHANGED");
+    if (!SetAudioFormat())
+      return false;
+    else
+      return ReadAudio(aFrame, aSeekTimeUs);
+  }
+  else if (err == ERROR_END_OF_STREAM) {
+    LOG("mAudioSource END_OF_STREAM");
+  }
+  else if (err != OK) {
+    LOG("mAudioSource ERROR %#x", err);
+  }
+
+  return err == OK;
+}
+
+static OmxDecoder *cast(Decoder *decoder) {
+  return reinterpret_cast<OmxDecoder *>(decoder->mPrivate);
+}
+
+static void GetDuration(Decoder *aDecoder, int64_t *durationUs) {
+  cast(aDecoder)->GetDuration(durationUs);
+}
+
+static void GetVideoParameters(Decoder *aDecoder, int32_t *width, int32_t *height) {
+  cast(aDecoder)->GetVideoParameters(width, height);
+}
+
+static void GetAudioParameters(Decoder *aDecoder, int32_t *numChannels, int32_t *sampleRate) {
+  cast(aDecoder)->GetAudioParameters(numChannels, sampleRate);
+}
+
+static bool HasVideo(Decoder *aDecoder) {
+  return cast(aDecoder)->HasVideo();
+}
+
+static bool HasAudio(Decoder *aDecoder) {
+  return cast(aDecoder)->HasAudio();
+}
+
+static bool ReadVideo(Decoder *aDecoder, VideoFrame *aFrame, int64_t aSeekTimeUs, BufferCallback *aBufferCallback)
+{
+  return cast(aDecoder)->ReadVideo(aFrame, aSeekTimeUs, aBufferCallback);
+}
+
+static bool ReadAudio(Decoder *aDecoder, AudioFrame *aFrame, int64_t aSeekTimeUs)
+{
+  return cast(aDecoder)->ReadAudio(aFrame, aSeekTimeUs);
+}
+
+static void DestroyDecoder(Decoder *aDecoder)
+{
+  if (aDecoder->mPrivate)
+    delete reinterpret_cast<OmxDecoder *>(aDecoder->mPrivate);
+}
+
+static bool Match(const char *aMimeChars, size_t aMimeLen, const char *aNeedle)
+{
+  return !strncmp(aMimeChars, aNeedle, aMimeLen);
+}
+
+static const char* const gCodecs[] = {
+  "avc1.42E01E",  // H.264 Constrained Baseline Profile Level 3.0
+  "avc1.42001E",  // H.264 Baseline Profile Level 3.0
+  "avc1.42001F",  // H.264 Baseline Profile Level 3.1
+  "avc1.4D401E",  // H.264 Main Profile Level 3.0
+  "avc1.4D401F",  // H.264 Main Profile Level 3.1
+  "mp4a.40.2",    // AAC-LC
+  nullptr
+};
+
+static bool CanDecode(const char *aMimeChars, size_t aMimeLen, const char* const**aCodecs)
+{
+  if (!Match(aMimeChars, aMimeLen, "video/mp4") &&
+      !Match(aMimeChars, aMimeLen, "audio/mp4") &&
+      !Match(aMimeChars, aMimeLen, "audio/mpeg") &&
+      !Match(aMimeChars, aMimeLen, "application/octet-stream")) { // file urls
+    return false;
+  }
+  *aCodecs = gCodecs;
+
+  return true;
+}
+
+static bool CreateDecoder(PluginHost *aPluginHost, Decoder *aDecoder, const char *aMimeChars, size_t aMimeLen)
+{
+  OmxDecoder *omx = new OmxDecoder(aPluginHost, aDecoder);
+  if (!omx || !omx->Init()) {
+    if (omx)
+      delete omx;
+    return false;
+  }
+
+  aDecoder->mPrivate = omx;
+  aDecoder->GetDuration = GetDuration;
+  aDecoder->GetVideoParameters = GetVideoParameters;
+  aDecoder->GetAudioParameters = GetAudioParameters;
+  aDecoder->HasVideo = HasVideo;
+  aDecoder->HasAudio = HasAudio;
+  aDecoder->ReadVideo = ReadVideo;
+  aDecoder->ReadAudio = ReadAudio;
+  aDecoder->DestroyDecoder = DestroyDecoder;
+
+  return true;
+}
+
+} // namespace OmxPlugin
+
+// Export the manifest so MPAPI can find our entry points.
+Manifest MOZ_EXPORT MPAPI_MANIFEST = {
+  OmxPlugin::CanDecode,
+  OmxPlugin::CreateDecoder
+};