diff options
Diffstat (limited to 'dom/media/gmp-plugin-openh264/gmp-fake-openh264.cpp')
| -rw-r--r-- | dom/media/gmp-plugin-openh264/gmp-fake-openh264.cpp | 429 |
1 files changed, 429 insertions, 0 deletions
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 000000000..7dbc85251 --- /dev/null +++ b/dom/media/gmp-plugin-openh264/gmp-fake-openh264.cpp @@ -0,0 +1,429 @@ +/*! + * \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 <time.h> +#include <cstdio> +#include <cstring> +#include <iostream> +#include <string> +#include <memory> +#include <assert.h> +#include <limits.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" + +#if defined(GMP_FAKE_SUPPORT_DECRYPT) +#include "gmp-decryption.h" +#include "gmp-test-decryptor.h" +#include "gmp-test-storage.h" +#endif + +#if defined(_MSC_VER) +#define PUBLIC_FUNC __declspec(dllexport) +#else +#define PUBLIC_FUNC +#endif + +#define BIG_FRAME 10000 + +static int g_log_level = 0; + +#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) + +#define GL_CRIT 0 +#define GL_ERROR 1 +#define GL_INFO 2 +#define GL_DEBUG 3 + +const char* kLogStrings[] = { + "Critical", + "Error", + "Info", + "Debug" +}; + + +GMPPlatformAPI* g_platform_api = NULL; + +class FakeVideoEncoder; +class FakeVideoDecoder; + +struct EncodedFrame { + uint32_t length_; + 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_; +}; + +#define ENCODED_FRAME_MAGIC 0x4652414d + +class FakeEncoderTask : public GMPTask { + public: + FakeEncoderTask(FakeVideoEncoder* encoder, + GMPVideoi420Frame* frame, + GMPVideoFrameType type) + : encoder_(encoder), frame_(frame), type_(type) {} + + virtual void Run(); + virtual void Destroy() { delete this; } + + FakeVideoEncoder* encoder_; + GMPVideoi420Frame* frame_; + GMPVideoFrameType type_; +}; + +class FakeVideoEncoder : public GMPVideoEncoder { + public: + explicit FakeVideoEncoder (GMPVideoHost* hostAPI) : + host_ (hostAPI), + callback_ (NULL) {} + + virtual void InitEncode (const GMPVideoCodec& codecSettings, + const uint8_t* aCodecSpecific, + uint32_t aCodecSpecificSize, + GMPVideoEncoderCallback* callback, + int32_t numberOfCores, + uint32_t maxPayloadSize) { + callback_ = callback; + + GMPLOG (GL_INFO, "Initialized encoder"); + } + + virtual void Encode (GMPVideoi420Frame* inputImage, + const uint8_t* aCodecSpecificInfo, + uint32_t aCodecSpecificInfoLength, + const GMPVideoFrameType* aFrameTypes, + uint32_t aFrameTypesLength) { + GMPLOG (GL_DEBUG, + __FUNCTION__ + << " size=" + << inputImage->Width() << "x" << inputImage->Height()); + + assert (aFrameTypesLength != 0); + + g_platform_api->runonmainthread(new FakeEncoderTask(this, + inputImage, + aFrameTypes[0])); + } + + void Encode_m (GMPVideoi420Frame* inputImage, + GMPVideoFrameType frame_type) { + if (frame_type == kGMPKeyFrame) { + if (!inputImage) + return; + } + if (!inputImage) { + GMPLOG (GL_ERROR, "no input image"); + return; + } + + // 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); + + // Encode this in a frame that looks a little bit like H.264. + // Note that we don't do PPS or SPS. + // Copy the data. This really should convert this to network byte order. + EncodedFrame eframe; + eframe.length_ = sizeof(eframe) - sizeof(uint32_t); + eframe.h264_compat_ = 5; // Emulate a H.264 IDR NAL. + eframe.magic_ = ENCODED_FRAME_MAGIC; + eframe.width_ = inputImage->Width(); + eframe.height_ = inputImage->Height(); + eframe.y_ = AveragePlane(inputImage->Buffer(kGMPYPlane), + inputImage->AllocatedSize(kGMPYPlane)); + eframe.u_ = AveragePlane(inputImage->Buffer(kGMPUPlane), + inputImage->AllocatedSize(kGMPUPlane)); + eframe.v_ = AveragePlane(inputImage->Buffer(kGMPVPlane), + inputImage->AllocatedSize(kGMPVPlane)); + + eframe.timestamp_ = inputImage->Timestamp(); + + err = f->CreateEmptyFrame (sizeof(eframe) + + (frame_type == kGMPKeyFrame ? sizeof(uint32_t) + BIG_FRAME : 0)); + if (err != GMPNoErr) { + GMPLOG (GL_ERROR, "Error allocating frame data"); + f->Destroy(); + return; + } + memcpy(f->Buffer(), &eframe, sizeof(eframe)); + if (frame_type == kGMPKeyFrame) { + *((uint32_t*) f->Buffer() + sizeof(eframe)) = BIG_FRAME; + } + + f->SetEncodedWidth (inputImage->Width()); + f->SetEncodedHeight (inputImage->Height()); + f->SetTimeStamp (inputImage->Timestamp()); + f->SetFrameType (frame_type); + f->SetCompleteFrame (true); + f->SetBufferType(GMP_BufferLength32); + + GMPLOG (GL_DEBUG, "Encoding complete. type= " + << f->FrameType() + << " length=" + << f->Size() + << " timestamp=" + << f->TimeStamp()); + + // Return the encoded frame. + GMPCodecSpecificInfo info; + memset (&info, 0, sizeof (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"); + } + + virtual void SetChannelParameters (uint32_t aPacketLoss, uint32_t aRTT) { + } + + virtual void SetRates (uint32_t aNewBitRate, uint32_t aFrameRate) { + } + + virtual void SetPeriodicKeyFrames (bool aEnable) { + } + + virtual void EncodingComplete() { + 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_; +}; + +void FakeEncoderTask::Run() { + encoder_->Encode_m(frame_, type_); + frame_->Destroy(); +} + +class FakeDecoderTask : public GMPTask { + public: + FakeDecoderTask(FakeVideoDecoder* decoder, + GMPVideoEncodedFrame* frame, + int64_t time) + : decoder_(decoder), frame_(frame), time_(time) {} + + virtual void Run(); + virtual void Destroy() { delete this; } + + FakeVideoDecoder* decoder_; + GMPVideoEncodedFrame* frame_; + int64_t time_; +}; + +class FakeVideoDecoder : public GMPVideoDecoder { + public: + explicit FakeVideoDecoder (GMPVideoHost* hostAPI) : + host_ (hostAPI), + callback_ (NULL) {} + + virtual ~FakeVideoDecoder() { + } + + virtual void InitDecode (const GMPVideoCodec& codecSettings, + const uint8_t* aCodecSpecific, + uint32_t aCodecSpecificSize, + GMPVideoDecoderCallback* callback, + int32_t coreCount) { + GMPLOG (GL_INFO, "InitDecode"); + + callback_ = callback; + } + + virtual void Decode (GMPVideoEncodedFrame* inputFrame, + bool missingFrames, + const uint8_t* aCodecSpecificInfo, + uint32_t aCodecSpecificInfoLength, + int64_t renderTimeMs = -1) { + GMPLOG (GL_DEBUG, __FUNCTION__ + << "Decoding frame size=" << inputFrame->Size() + << " timestamp=" << inputFrame->TimeStamp()); + g_platform_api->runonmainthread(new FakeDecoderTask(this, inputFrame, renderTimeMs)); + } + + virtual void Reset() { + } + + virtual void Drain() { + } + + virtual void DecodingComplete() { + delete this; + } + + // Return the decoded data back to the parent. + void Decode_m (GMPVideoEncodedFrame* inputFrame, + int64_t renderTimeMs) { + EncodedFrame *eframe; + if (inputFrame->Size() != (sizeof(*eframe))) { + GMPLOG (GL_ERROR, "Couldn't decode frame. Size=" << inputFrame->Size()); + return; + } + eframe = reinterpret_cast<EncodedFrame*>(inputFrame->Buffer()); + + if (eframe->magic_ != ENCODED_FRAME_MAGIC) { + GMPLOG (GL_ERROR, "Couldn't decode frame. Magic=" << eframe->magic_); + return; + } + + int width = eframe->width_; + int height = eframe->height_; + int ystride = eframe->width_; + int uvstride = eframe->width_/2; + + GMPLOG (GL_DEBUG, "Video frame ready for display " + << width + << "x" + << height + << " timestamp=" + << inputFrame->TimeStamp()); + + GMPVideoFrame* ftmp = NULL; + + // 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->y_, + frame->AllocatedSize(kGMPYPlane)); + memset(frame->Buffer(kGMPUPlane), + eframe->u_, + frame->AllocatedSize(kGMPUPlane)); + memset(frame->Buffer(kGMPVPlane), + eframe->v_, + frame->AllocatedSize(kGMPVPlane)); + + GMPLOG (GL_DEBUG, "Allocated size = " + << frame->AllocatedSize (kGMPYPlane)); + frame->SetTimestamp (inputFrame->TimeStamp()); + frame->SetDuration (inputFrame->Duration()); + callback_->Decoded (frame); + + } + + GMPVideoHost* host_; + GMPVideoDecoderCallback* callback_; +}; + +void FakeDecoderTask::Run() { + decoder_->Decode_m(frame_, time_); + frame_->Destroy(); +} + +extern "C" { + + PUBLIC_FUNC GMPErr + GMPInit (GMPPlatformAPI* aPlatformAPI) { + g_platform_api = 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; + } else if (!strcmp (aApiName, GMP_API_VIDEO_ENCODER)) { + *aPluginApi = new FakeVideoEncoder (static_cast<GMPVideoHost*> (aHostAPI)); + return GMPNoErr; +#if defined(GMP_FAKE_SUPPORT_DECRYPT) + } else if (!strcmp (aApiName, GMP_API_DECRYPTOR)) { + *aPluginApi = new FakeDecryptor(static_cast<GMPDecryptorHost*> (aHostAPI)); + return GMPNoErr; + } else if (!strcmp (aApiName, GMP_API_ASYNC_SHUTDOWN)) { + *aPluginApi = new TestAsyncShutdown(static_cast<GMPAsyncShutdownHost*> (aHostAPI)); + return GMPNoErr; +#endif + } + return GMPGenericErr; + } + + PUBLIC_FUNC void + GMPShutdown (void) { + g_platform_api = NULL; + } + +} // extern "C" |