Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 435 insertions, 0 deletions

diff --git a/dom/media/gmp-plugin-openh264/fakeopenh264.info b/dom/media/gmp-plugin-openh264/fakeopenh264.info
new file mode 100644
index 0000000000..814a96be32
--- /dev/null
+++ b/dom/media/gmp-plugin-openh264/fakeopenh264.info
@@ -0,0 +1,4 @@
+Name: fakeopenh264
+Description: Fake GMP Plugin
+Version: 1.0
+APIs: encode-video[h264:fake], decode-video[h264:fake]
diff --git a/dom/media/gmp-plugin-openh264/gmp-fake-openh264.cpp b/dom/media/gmp-plugin-openh264/gmp-fake-openh264.cpp
new file mode 100644
index 0000000000..4c5e95643e
--- /dev/null
+++ b/dom/media/gmp-plugin-openh264/gmp-fake-openh264.cpp
@@ -0,0 +1,406 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2014, Cisco Systems
+ *     Copyright (c)  2014, Mozilla
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * 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.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "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
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS 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.
+ *
+ *
+ *************************************************************************************
+ */
+
+#include <stdint.h>
+#include <cstring>
+#include <iostream>
+#include <assert.h>
+
+#include "gmp-platform.h"
+#include "gmp-video-host.h"
+#include "gmp-video-encode.h"
+#include "gmp-video-decode.h"
+#include "gmp-video-frame-i420.h"
+#include "gmp-video-frame-encoded.h"
+
+#include "mozilla/PodOperations.h"
+
+#if defined(_MSC_VER)
+#  define PUBLIC_FUNC __declspec(dllexport)
+#else
+#  define PUBLIC_FUNC
+#endif
+
+#define BIG_FRAME 10000
+
+#define GL_CRIT 0
+#define GL_ERROR 1
+#define GL_INFO 2
+#define GL_DEBUG 3
+
+const char* kLogStrings[] = {"Critical", "Error", "Info", "Debug"};
+
+static int g_log_level = GL_CRIT;
+
+#define GMPLOG(l, x)                                     \
+  do {                                                   \
+    if (l <= g_log_level) {                              \
+      const char* log_string = "unknown";                \
+      if ((l >= 0) && (l <= 3)) {                        \
+        log_string = kLogStrings[l];                     \
+      }                                                  \
+      std::cerr << log_string << ": " << x << std::endl; \
+    }                                                    \
+  } while (0)
+
+class FakeVideoEncoder;
+class FakeVideoDecoder;
+
+// Turn off padding for this structure. Having extra bytes can result in
+// bitstream parsing problems.
+#pragma pack(push, 1)
+struct EncodedFrame {
+  struct SPSNalu {
+    uint32_t size_;
+    uint8_t payload[14];
+  } sps_nalu;
+  struct PPSNalu {
+    uint32_t size_;
+    uint8_t payload[4];
+  } pps_nalu;
+  struct IDRNalu {
+    uint32_t size_;
+    uint8_t h264_compat_;
+    uint32_t magic_;
+    uint32_t width_;
+    uint32_t height_;
+    uint8_t y_;
+    uint8_t u_;
+    uint8_t v_;
+    uint32_t timestamp_;
+  } idr_nalu;
+};
+#pragma pack(pop)
+
+#define ENCODED_FRAME_MAGIC 0x004000b8
+
+template <typename T>
+class SelfDestruct {
+ public:
+  explicit SelfDestruct(T* t) : t_(t) {}
+  ~SelfDestruct() {
+    if (t_) {
+      t_->Destroy();
+    }
+  }
+
+ private:
+  T* t_;
+};
+
+class FakeVideoEncoder : public GMPVideoEncoder {
+ public:
+  explicit FakeVideoEncoder(GMPVideoHost* hostAPI) : host_(hostAPI) {}
+
+  void InitEncode(const GMPVideoCodec& codecSettings,
+                  const uint8_t* aCodecSpecific, uint32_t aCodecSpecificSize,
+                  GMPVideoEncoderCallback* callback, int32_t numberOfCores,
+                  uint32_t maxPayloadSize) override {
+    callback_ = callback;
+    frame_size_ = (maxPayloadSize > 0 && maxPayloadSize < BIG_FRAME)
+                      ? maxPayloadSize
+                      : BIG_FRAME;
+    frame_size_ -= 24 + 40;
+    // default header+extension size is 24, but let's leave extra room if
+    // we enable more extensions.
+    // XXX -- why isn't the size passed in based on the size minus extensions?
+
+    const char* env = getenv("GMP_LOGGING");
+    if (env) {
+      g_log_level = atoi(env);
+    }
+    GMPLOG(GL_INFO, "Initialized encoder");
+  }
+
+  void SendFrame(GMPVideoi420Frame* inputImage, GMPVideoFrameType frame_type,
+                 int nal_type) {
+    // Encode this in a frame that looks a little bit like H.264.
+    // Send SPS/PPS/IDR to avoid confusing people
+    // Copy the data. This really should convert this to network byte order.
+    EncodedFrame eframe;
+
+    // These values were chosen to force a SPS id of 0
+    eframe.sps_nalu = {sizeof(EncodedFrame::SPSNalu) - sizeof(uint32_t),
+                       {0x67, 0x42, 0xc0, 0xd, 0x8c, 0x8d, 0x40, 0xa0, 0xf9,
+                        0x0, 0xf0, 0x88, 0x46, 0xa0}};
+
+    // These values were chosen to force a PPS id of 0
+    eframe.pps_nalu = {sizeof(EncodedFrame::PPSNalu) - sizeof(uint32_t),
+                       {0x68, 0xce, 0x3c, 0x80}};
+
+    eframe.idr_nalu.size_ = sizeof(EncodedFrame::IDRNalu) - sizeof(uint32_t);
+    // We force IFrame here - if we send PFrames, the webrtc.org code gets
+    // tripped up attempting to find non-existent previous IFrames.
+    eframe.idr_nalu.h264_compat_ =
+        nal_type;  // 5 = IFrame/IDR slice, 1=PFrame/slice
+    eframe.idr_nalu.magic_ = ENCODED_FRAME_MAGIC;
+    eframe.idr_nalu.width_ = inputImage->Width();
+    eframe.idr_nalu.height_ = inputImage->Height();
+    eframe.idr_nalu.y_ = AveragePlane(inputImage->Buffer(kGMPYPlane),
+                                      inputImage->AllocatedSize(kGMPYPlane));
+    eframe.idr_nalu.u_ = AveragePlane(inputImage->Buffer(kGMPUPlane),
+                                      inputImage->AllocatedSize(kGMPUPlane));
+    eframe.idr_nalu.v_ = AveragePlane(inputImage->Buffer(kGMPVPlane),
+                                      inputImage->AllocatedSize(kGMPVPlane));
+
+    eframe.idr_nalu.timestamp_ = inputImage->Timestamp();
+
+    // Now return the encoded data back to the parent.
+    GMPVideoFrame* ftmp;
+    GMPErr err = host_->CreateFrame(kGMPEncodedVideoFrame, &ftmp);
+    if (err != GMPNoErr) {
+      GMPLOG(GL_ERROR, "Error creating encoded frame");
+      return;
+    }
+
+    GMPVideoEncodedFrame* f = static_cast<GMPVideoEncodedFrame*>(ftmp);
+
+    err = f->CreateEmptyFrame(sizeof(eframe));
+    if (err != GMPNoErr) {
+      GMPLOG(GL_ERROR, "Error allocating frame data");
+      f->Destroy();
+      return;
+    }
+    memcpy(f->Buffer(), &eframe, sizeof(eframe));
+    f->SetEncodedWidth(eframe.idr_nalu.width_);
+    f->SetEncodedHeight(eframe.idr_nalu.height_);
+    f->SetTimeStamp(eframe.idr_nalu.timestamp_);
+    f->SetFrameType(frame_type);
+    f->SetCompleteFrame(true);
+    f->SetBufferType(GMP_BufferLength32);
+
+    GMPLOG(GL_DEBUG, "Encoding complete. type= "
+                         << f->FrameType()
+                         << " NAL_type=" << (int)eframe.idr_nalu.h264_compat_
+                         << " length=" << f->Size()
+                         << " timestamp=" << f->TimeStamp()
+                         << " width/height=" << eframe.idr_nalu.width_ << "x"
+                         << eframe.idr_nalu.height_);
+
+    // Return the encoded frame.
+    GMPCodecSpecificInfo info;
+    mozilla::PodZero(&info);
+    info.mCodecType = kGMPVideoCodecH264;
+    info.mBufferType = GMP_BufferLength32;
+    info.mCodecSpecific.mH264.mSimulcastIdx = 0;
+    GMPLOG(GL_DEBUG, "Calling callback");
+    callback_->Encoded(f, reinterpret_cast<uint8_t*>(&info), sizeof(info));
+    GMPLOG(GL_DEBUG, "Callback called");
+  }
+
+  void Encode(GMPVideoi420Frame* inputImage, const uint8_t* aCodecSpecificInfo,
+              uint32_t aCodecSpecificInfoLength,
+              const GMPVideoFrameType* aFrameTypes,
+              uint32_t aFrameTypesLength) override {
+    GMPLOG(GL_DEBUG, __FUNCTION__ << " size=" << inputImage->Width() << "x"
+                                  << inputImage->Height());
+
+    assert(aFrameTypesLength != 0);
+    GMPVideoFrameType frame_type = aFrameTypes[0];
+
+    SelfDestruct<GMPVideoi420Frame> ifd(inputImage);
+
+    if (frame_type == kGMPKeyFrame) {
+      if (!inputImage) return;
+    }
+    if (!inputImage) {
+      GMPLOG(GL_ERROR, "no input image");
+      return;
+    }
+
+    if (frame_type == kGMPKeyFrame ||
+        frames_encoded_++ % 10 == 0) {  // periodically send iframes anyways
+      // 5 = IFrame/IDR slice
+      SendFrame(inputImage, kGMPKeyFrame, 5);
+    } else {
+      // 1 = PFrame/slice
+      SendFrame(inputImage, frame_type, 1);
+    }
+  }
+
+  void SetChannelParameters(uint32_t aPacketLoss, uint32_t aRTT) override {}
+
+  void SetRates(uint32_t aNewBitRate, uint32_t aFrameRate) override {}
+
+  void SetPeriodicKeyFrames(bool aEnable) override {}
+
+  void EncodingComplete() override { delete this; }
+
+ private:
+  uint8_t AveragePlane(uint8_t* ptr, size_t len) {
+    uint64_t val = 0;
+
+    for (size_t i = 0; i < len; ++i) {
+      val += ptr[i];
+    }
+
+    return (val / len) % 0xff;
+  }
+
+  GMPVideoHost* host_;
+  GMPVideoEncoderCallback* callback_ = nullptr;
+  uint32_t frame_size_ = BIG_FRAME;
+  uint32_t frames_encoded_ = 0;
+};
+
+class FakeVideoDecoder : public GMPVideoDecoder {
+ public:
+  explicit FakeVideoDecoder(GMPVideoHost* hostAPI)
+      : host_(hostAPI), callback_(nullptr) {}
+
+  ~FakeVideoDecoder() override = default;
+
+  void InitDecode(const GMPVideoCodec& codecSettings,
+                  const uint8_t* aCodecSpecific, uint32_t aCodecSpecificSize,
+                  GMPVideoDecoderCallback* callback,
+                  int32_t coreCount) override {
+    GMPLOG(GL_INFO, "InitDecode");
+
+    const char* env = getenv("GMP_LOGGING");
+    if (env) {
+      g_log_level = atoi(env);
+    }
+    callback_ = callback;
+  }
+
+  void Decode(GMPVideoEncodedFrame* inputFrame, bool missingFrames,
+              const uint8_t* aCodecSpecificInfo,
+              uint32_t aCodecSpecificInfoLength,
+              int64_t renderTimeMs = -1) override {
+    GMPLOG(GL_DEBUG, __FUNCTION__
+                         << "Decoding frame size=" << inputFrame->Size()
+                         << " timestamp=" << inputFrame->TimeStamp());
+
+    // Attach a self-destructor so that the input frame is destroyed on return.
+    SelfDestruct<GMPVideoEncodedFrame> ifd(inputFrame);
+
+    EncodedFrame* eframe;
+    eframe = reinterpret_cast<EncodedFrame*>(inputFrame->Buffer());
+    GMPLOG(GL_DEBUG, "magic=" << eframe->idr_nalu.magic_ << " h264_compat="
+                              << (int)eframe->idr_nalu.h264_compat_
+                              << " width=" << eframe->idr_nalu.width_
+                              << " height=" << eframe->idr_nalu.height_
+                              << " timestamp=" << inputFrame->TimeStamp()
+                              << " y/u/v=" << (int)eframe->idr_nalu.y_ << ":"
+                              << (int)eframe->idr_nalu.u_ << ":"
+                              << (int)eframe->idr_nalu.v_);
+    if (inputFrame->Size() != (sizeof(*eframe))) {
+      GMPLOG(GL_ERROR, "Couldn't decode frame. Size=" << inputFrame->Size());
+      return;
+    }
+
+    if (eframe->idr_nalu.magic_ != ENCODED_FRAME_MAGIC) {
+      GMPLOG(GL_ERROR,
+             "Couldn't decode frame. Magic=" << eframe->idr_nalu.magic_);
+      return;
+    }
+    if (eframe->idr_nalu.h264_compat_ != 5 &&
+        eframe->idr_nalu.h264_compat_ != 1) {
+      // only return video for iframes or pframes
+      GMPLOG(GL_DEBUG, "Not a video frame: NAL type "
+                           << (int)eframe->idr_nalu.h264_compat_);
+      return;
+    }
+
+    int width = eframe->idr_nalu.width_;
+    int height = eframe->idr_nalu.height_;
+    int ystride = eframe->idr_nalu.width_;
+    int uvstride = eframe->idr_nalu.width_ / 2;
+
+    GMPLOG(GL_DEBUG, "Video frame ready for display "
+                         << width << "x" << height
+                         << " timestamp=" << inputFrame->TimeStamp());
+
+    GMPVideoFrame* ftmp = nullptr;
+
+    // Translate the image.
+    GMPErr err = host_->CreateFrame(kGMPI420VideoFrame, &ftmp);
+    if (err != GMPNoErr) {
+      GMPLOG(GL_ERROR, "Couldn't allocate empty I420 frame");
+      return;
+    }
+
+    GMPVideoi420Frame* frame = static_cast<GMPVideoi420Frame*>(ftmp);
+    err = frame->CreateEmptyFrame(width, height, ystride, uvstride, uvstride);
+    if (err != GMPNoErr) {
+      GMPLOG(GL_ERROR, "Couldn't make decoded frame");
+      return;
+    }
+
+    memset(frame->Buffer(kGMPYPlane), eframe->idr_nalu.y_,
+           frame->AllocatedSize(kGMPYPlane));
+    memset(frame->Buffer(kGMPUPlane), eframe->idr_nalu.u_,
+           frame->AllocatedSize(kGMPUPlane));
+    memset(frame->Buffer(kGMPVPlane), eframe->idr_nalu.v_,
+           frame->AllocatedSize(kGMPVPlane));
+
+    GMPLOG(GL_DEBUG, "Allocated size = " << frame->AllocatedSize(kGMPYPlane));
+    frame->SetTimestamp(inputFrame->TimeStamp());
+    frame->SetDuration(inputFrame->Duration());
+    callback_->Decoded(frame);
+  }
+
+  void Reset() override {}
+
+  void Drain() override {}
+
+  void DecodingComplete() override { delete this; }
+
+  GMPVideoHost* host_;
+  GMPVideoDecoderCallback* callback_;
+};
+
+extern "C" {
+
+PUBLIC_FUNC GMPErr GMPInit(const GMPPlatformAPI* aPlatformAPI) {
+  return GMPNoErr;
+}
+
+PUBLIC_FUNC GMPErr GMPGetAPI(const char* aApiName, void* aHostAPI,
+                             void** aPluginApi) {
+  if (!strcmp(aApiName, GMP_API_VIDEO_DECODER)) {
+    *aPluginApi = new FakeVideoDecoder(static_cast<GMPVideoHost*>(aHostAPI));
+    return GMPNoErr;
+  }
+  if (!strcmp(aApiName, GMP_API_VIDEO_ENCODER)) {
+    *aPluginApi = new FakeVideoEncoder(static_cast<GMPVideoHost*>(aHostAPI));
+    return GMPNoErr;
+  }
+  return GMPGenericErr;
+}
+
+PUBLIC_FUNC void GMPShutdown(void) {}
+
+}  // extern "C"
diff --git a/dom/media/gmp-plugin-openh264/moz.build b/dom/media/gmp-plugin-openh264/moz.build
new file mode 100644
index 0000000000..e85a50673e
--- /dev/null
+++ b/dom/media/gmp-plugin-openh264/moz.build
@@ -0,0 +1,25 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+# largely a copy of dom/media/gmp-fake/moz.build
+
+FINAL_TARGET = "dist/bin/gmp-fakeopenh264/1.0"
+
+FINAL_TARGET_FILES += [
+    "fakeopenh264.info",
+]
+
+SOURCES += [
+    "gmp-fake-openh264.cpp",
+]
+
+SharedLibrary("fakeopenh264")
+
+USE_STATIC_LIBS = True
+NoVisibilityFlags()
+# Don't use STL wrappers; this isn't Gecko code
+DisableStlWrapping()
+NO_PGO = True