Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef GMPTypes_h
#define GMPTypes_h
#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"
// Headers for typedefs
#include "GMPSanitizedExports.h"
#include "gmp-video-codec.h"
#include "mozilla/ipc/IPDLStructMember.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct NodeIdParts|
//
namespace mozilla {
namespace gmp {
class NodeIdParts final
{
private:
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
NodeIdParts() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT NodeIdParts(
const nsString& _mOrigin,
const nsString& _mTopLevelOrigin,
const nsString& _mGMPName) :
mOrigin_(_mOrigin),
mTopLevelOrigin_(_mTopLevelOrigin),
mGMPName_(_mGMPName)
{
}
MOZ_IMPLICIT NodeIdParts(
nsString&& _mOrigin,
nsString&& _mTopLevelOrigin,
nsString&& _mGMPName) :
mOrigin_(std::move(_mOrigin)),
mTopLevelOrigin_(std::move(_mTopLevelOrigin)),
mGMPName_(std::move(_mGMPName))
{
}
nsString&
mOrigin()
{
return mOrigin_;
}
const nsString&
mOrigin() const
{
return mOrigin_;
}
nsString&
mTopLevelOrigin()
{
return mTopLevelOrigin_;
}
const nsString&
mTopLevelOrigin() const
{
return mTopLevelOrigin_;
}
nsString&
mGMPName()
{
return mGMPName_;
}
const nsString&
mGMPName() const
{
return mGMPName_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> mOrigin_;
::mozilla::ipc::IPDLStructMember<nsString> mTopLevelOrigin_;
::mozilla::ipc::IPDLStructMember<nsString> mGMPName_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::NodeIdParts>
{
typedef ::mozilla::gmp::NodeIdParts paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union NodeIdVariant|
//
namespace mozilla {
namespace gmp {
class NodeIdVariant final
{
public:
enum Type {
T__None,
TnsCString = 1,
TNodeIdParts,
T__Last = TNodeIdParts
};
private:
typedef ::nsCString nsCString;
typedef ::mozilla::gmp::NodeIdParts NodeIdParts;
typedef nsCString nsCString__tdef;
typedef NodeIdParts NodeIdParts__tdef;
union Value {
mozilla::AlignedStorage2<nsCString> VnsCString;
mozilla::AlignedStorage2<NodeIdParts> VNodeIdParts;
};
nsCString*
ptr_nsCString()
{
return ((mValue).VnsCString).addr();
}
const nsCString*
constptr_nsCString() const
{
return ((mValue).VnsCString).addr();
}
NodeIdParts*
ptr_NodeIdParts()
{
return ((mValue).VNodeIdParts).addr();
}
const NodeIdParts*
constptr_NodeIdParts() const
{
return ((mValue).VNodeIdParts).addr();
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT NodeIdVariant() :
mType(T__None)
{
}
MOZ_IMPLICIT NodeIdVariant(const nsCString& aOther);
MOZ_IMPLICIT NodeIdVariant(nsCString&& aOther);
MOZ_IMPLICIT NodeIdVariant(const NodeIdParts& aOther);
MOZ_IMPLICIT NodeIdVariant(NodeIdParts&& aOther);
MOZ_IMPLICIT NodeIdVariant(const NodeIdVariant& aOther);
MOZ_IMPLICIT NodeIdVariant(NodeIdVariant&& aOther);
~NodeIdVariant();
Type
type() const
{
return mType;
}
NodeIdVariant&
operator=(const nsCString& aRhs);
NodeIdVariant&
operator=(nsCString&& aRhs);
NodeIdVariant&
operator=(const NodeIdParts& aRhs);
NodeIdVariant&
operator=(NodeIdParts&& aRhs);
NodeIdVariant&
operator=(const NodeIdVariant& aRhs);
NodeIdVariant&
operator=(NodeIdVariant&& aRhs);
nsCString&
get_nsCString()
{
AssertSanity(TnsCString);
return (*(ptr_nsCString()));
}
const nsCString&
get_nsCString() const
{
AssertSanity(TnsCString);
return (*(constptr_nsCString()));
}
operator nsCString&()
{
return get_nsCString();
}
operator const nsCString&() const
{
return get_nsCString();
}
NodeIdParts&
get_NodeIdParts()
{
AssertSanity(TNodeIdParts);
return (*(ptr_NodeIdParts()));
}
const NodeIdParts&
get_NodeIdParts() const
{
AssertSanity(TNodeIdParts);
return (*(constptr_NodeIdParts()));
}
operator NodeIdParts&()
{
return get_NodeIdParts();
}
operator const NodeIdParts&() const
{
return get_NodeIdParts();
}
private:
Value mValue;
Type mType;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::NodeIdVariant>
{
typedef ::mozilla::gmp::NodeIdVariant paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct GMPVideoEncodedFrameData|
//
namespace mozilla {
namespace gmp {
class GMPVideoEncodedFrameData final
{
private:
typedef ::uint32_t uint32_t;
typedef ::uint64_t uint64_t;
typedef ::GMPBufferType GMPBufferType;
typedef ::mozilla::ipc::Shmem Shmem;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
GMPVideoEncodedFrameData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT GMPVideoEncodedFrameData(
const uint32_t& _mEncodedWidth,
const uint32_t& _mEncodedHeight,
const uint64_t& _mTimestamp,
const uint64_t& _mDuration,
const uint32_t& _mFrameType,
const uint32_t& _mSize,
const GMPBufferType& _mBufferType,
Shmem& _mBuffer,
const bool& _mCompleteFrame) :
mBufferType_(_mBufferType),
mBuffer_(_mBuffer),
mCompleteFrame_(_mCompleteFrame),
mTimestamp_(_mTimestamp),
mDuration_(_mDuration),
mEncodedWidth_(_mEncodedWidth),
mEncodedHeight_(_mEncodedHeight),
mFrameType_(_mFrameType),
mSize_(_mSize)
{
}
MOZ_IMPLICIT GMPVideoEncodedFrameData(
uint32_t&& _mEncodedWidth,
uint32_t&& _mEncodedHeight,
uint64_t&& _mTimestamp,
uint64_t&& _mDuration,
uint32_t&& _mFrameType,
uint32_t&& _mSize,
GMPBufferType&& _mBufferType,
Shmem&& _mBuffer,
bool&& _mCompleteFrame) :
mBufferType_(std::move(_mBufferType)),
mBuffer_(std::move(_mBuffer)),
mCompleteFrame_(std::move(_mCompleteFrame)),
mTimestamp_(std::move(_mTimestamp)),
mDuration_(std::move(_mDuration)),
mEncodedWidth_(std::move(_mEncodedWidth)),
mEncodedHeight_(std::move(_mEncodedHeight)),
mFrameType_(std::move(_mFrameType)),
mSize_(std::move(_mSize))
{
}
uint32_t&
mEncodedWidth()
{
return mEncodedWidth_;
}
const uint32_t&
mEncodedWidth() const
{
return mEncodedWidth_;
}
uint32_t&
mEncodedHeight()
{
return mEncodedHeight_;
}
const uint32_t&
mEncodedHeight() const
{
return mEncodedHeight_;
}
uint64_t&
mTimestamp()
{
return mTimestamp_;
}
const uint64_t&
mTimestamp() const
{
return mTimestamp_;
}
uint64_t&
mDuration()
{
return mDuration_;
}
const uint64_t&
mDuration() const
{
return mDuration_;
}
uint32_t&
mFrameType()
{
return mFrameType_;
}
const uint32_t&
mFrameType() const
{
return mFrameType_;
}
uint32_t&
mSize()
{
return mSize_;
}
const uint32_t&
mSize() const
{
return mSize_;
}
GMPBufferType&
mBufferType()
{
return mBufferType_;
}
const GMPBufferType&
mBufferType() const
{
return mBufferType_;
}
Shmem&
mBuffer()
{
return mBuffer_;
}
Shmem&
mBuffer() const
{
return const_cast<Shmem&>(mBuffer_);
}
bool&
mCompleteFrame()
{
return mCompleteFrame_;
}
const bool&
mCompleteFrame() const
{
return mCompleteFrame_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<GMPBufferType> mBufferType_;
::mozilla::ipc::IPDLStructMember<Shmem> mBuffer_;
::mozilla::ipc::IPDLStructMember<bool> mCompleteFrame_;
::mozilla::ipc::IPDLStructMember<uint64_t> mTimestamp_;
::mozilla::ipc::IPDLStructMember<uint64_t> mDuration_;
::mozilla::ipc::IPDLStructMember<uint32_t> mEncodedWidth_;
::mozilla::ipc::IPDLStructMember<uint32_t> mEncodedHeight_;
::mozilla::ipc::IPDLStructMember<uint32_t> mFrameType_;
::mozilla::ipc::IPDLStructMember<uint32_t> mSize_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::GMPVideoEncodedFrameData>
{
typedef ::mozilla::gmp::GMPVideoEncodedFrameData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct GMPPlaneData|
//
namespace mozilla {
namespace gmp {
class GMPPlaneData final
{
private:
typedef ::int32_t int32_t;
typedef ::mozilla::ipc::Shmem Shmem;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
GMPPlaneData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT GMPPlaneData(
const int32_t& _mSize,
const int32_t& _mStride,
Shmem& _mBuffer) :
mBuffer_(_mBuffer),
mSize_(_mSize),
mStride_(_mStride)
{
}
MOZ_IMPLICIT GMPPlaneData(
int32_t&& _mSize,
int32_t&& _mStride,
Shmem&& _mBuffer) :
mBuffer_(std::move(_mBuffer)),
mSize_(std::move(_mSize)),
mStride_(std::move(_mStride))
{
}
int32_t&
mSize()
{
return mSize_;
}
const int32_t&
mSize() const
{
return mSize_;
}
int32_t&
mStride()
{
return mStride_;
}
const int32_t&
mStride() const
{
return mStride_;
}
Shmem&
mBuffer()
{
return mBuffer_;
}
Shmem&
mBuffer() const
{
return const_cast<Shmem&>(mBuffer_);
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<Shmem> mBuffer_;
::mozilla::ipc::IPDLStructMember<int32_t> mSize_;
::mozilla::ipc::IPDLStructMember<int32_t> mStride_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::GMPPlaneData>
{
typedef ::mozilla::gmp::GMPPlaneData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct GMPVideoi420FrameData|
//
namespace mozilla {
namespace gmp {
class GMPVideoi420FrameData final
{
private:
typedef ::mozilla::gmp::GMPPlaneData GMPPlaneData;
typedef ::int32_t int32_t;
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
GMPVideoi420FrameData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT GMPVideoi420FrameData(
const GMPPlaneData& _mYPlane,
const GMPPlaneData& _mUPlane,
const GMPPlaneData& _mVPlane,
const int32_t& _mWidth,
const int32_t& _mHeight,
const uint64_t& _mTimestamp,
const mozilla::Maybe<uint64_t>& _mUpdatedTimestamp,
const uint64_t& _mDuration) :
mYPlane_(_mYPlane),
mUPlane_(_mUPlane),
mVPlane_(_mVPlane),
mUpdatedTimestamp_(_mUpdatedTimestamp),
mTimestamp_(_mTimestamp),
mDuration_(_mDuration),
mWidth_(_mWidth),
mHeight_(_mHeight)
{
}
MOZ_IMPLICIT GMPVideoi420FrameData(
GMPPlaneData&& _mYPlane,
GMPPlaneData&& _mUPlane,
GMPPlaneData&& _mVPlane,
int32_t&& _mWidth,
int32_t&& _mHeight,
uint64_t&& _mTimestamp,
mozilla::Maybe<uint64_t>&& _mUpdatedTimestamp,
uint64_t&& _mDuration) :
mYPlane_(std::move(_mYPlane)),
mUPlane_(std::move(_mUPlane)),
mVPlane_(std::move(_mVPlane)),
mUpdatedTimestamp_(std::move(_mUpdatedTimestamp)),
mTimestamp_(std::move(_mTimestamp)),
mDuration_(std::move(_mDuration)),
mWidth_(std::move(_mWidth)),
mHeight_(std::move(_mHeight))
{
}
GMPPlaneData&
mYPlane()
{
return mYPlane_;
}
const GMPPlaneData&
mYPlane() const
{
return mYPlane_;
}
GMPPlaneData&
mUPlane()
{
return mUPlane_;
}
const GMPPlaneData&
mUPlane() const
{
return mUPlane_;
}
GMPPlaneData&
mVPlane()
{
return mVPlane_;
}
const GMPPlaneData&
mVPlane() const
{
return mVPlane_;
}
int32_t&
mWidth()
{
return mWidth_;
}
const int32_t&
mWidth() const
{
return mWidth_;
}
int32_t&
mHeight()
{
return mHeight_;
}
const int32_t&
mHeight() const
{
return mHeight_;
}
uint64_t&
mTimestamp()
{
return mTimestamp_;
}
const uint64_t&
mTimestamp() const
{
return mTimestamp_;
}
mozilla::Maybe<uint64_t>&
mUpdatedTimestamp()
{
return mUpdatedTimestamp_;
}
const mozilla::Maybe<uint64_t>&
mUpdatedTimestamp() const
{
return mUpdatedTimestamp_;
}
uint64_t&
mDuration()
{
return mDuration_;
}
const uint64_t&
mDuration() const
{
return mDuration_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<GMPPlaneData> mYPlane_;
::mozilla::ipc::IPDLStructMember<GMPPlaneData> mUPlane_;
::mozilla::ipc::IPDLStructMember<GMPPlaneData> mVPlane_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint64_t>> mUpdatedTimestamp_;
::mozilla::ipc::IPDLStructMember<uint64_t> mTimestamp_;
::mozilla::ipc::IPDLStructMember<uint64_t> mDuration_;
::mozilla::ipc::IPDLStructMember<int32_t> mWidth_;
::mozilla::ipc::IPDLStructMember<int32_t> mHeight_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::GMPVideoi420FrameData>
{
typedef ::mozilla::gmp::GMPVideoi420FrameData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CDMInputBuffer|
//
namespace mozilla {
namespace gmp {
class CDMInputBuffer final
{
private:
typedef ::mozilla::ipc::Shmem Shmem;
typedef ::uint8_t uint8_t;
typedef ::int64_t int64_t;
typedef ::uint32_t uint32_t;
typedef ::cdm::EncryptionScheme EncryptionScheme;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CDMInputBuffer() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CDMInputBuffer(
Shmem& _mData,
const nsTArray<uint8_t>& _mKeyId,
const nsTArray<uint8_t>& _mIV,
const int64_t& _mTimestamp,
const int64_t& _mDuration,
const nsTArray<uint32_t>& _mClearBytes,
const nsTArray<uint32_t>& _mCipherBytes,
const uint8_t& _mCryptByteBlock,
const uint8_t& _mSkipByteBlock,
const EncryptionScheme& _mEncryptionScheme) :
mData_(_mData),
mKeyId_(_mKeyId),
mIV_(_mIV),
mClearBytes_(_mClearBytes),
mCipherBytes_(_mCipherBytes),
mEncryptionScheme_(_mEncryptionScheme),
mTimestamp_(_mTimestamp),
mDuration_(_mDuration),
mCryptByteBlock_(_mCryptByteBlock),
mSkipByteBlock_(_mSkipByteBlock)
{
}
MOZ_IMPLICIT CDMInputBuffer(
Shmem&& _mData,
nsTArray<uint8_t>&& _mKeyId,
nsTArray<uint8_t>&& _mIV,
int64_t&& _mTimestamp,
int64_t&& _mDuration,
nsTArray<uint32_t>&& _mClearBytes,
nsTArray<uint32_t>&& _mCipherBytes,
uint8_t&& _mCryptByteBlock,
uint8_t&& _mSkipByteBlock,
EncryptionScheme&& _mEncryptionScheme) :
mData_(std::move(_mData)),
mKeyId_(std::move(_mKeyId)),
mIV_(std::move(_mIV)),
mClearBytes_(std::move(_mClearBytes)),
mCipherBytes_(std::move(_mCipherBytes)),
mEncryptionScheme_(std::move(_mEncryptionScheme)),
mTimestamp_(std::move(_mTimestamp)),
mDuration_(std::move(_mDuration)),
mCryptByteBlock_(std::move(_mCryptByteBlock)),
mSkipByteBlock_(std::move(_mSkipByteBlock))
{
}
Shmem&
mData()
{
return mData_;
}
Shmem&
mData() const
{
return const_cast<Shmem&>(mData_);
}
nsTArray<uint8_t>&
mKeyId()
{
return mKeyId_;
}
const nsTArray<uint8_t>&
mKeyId() const
{
return mKeyId_;
}
nsTArray<uint8_t>&
mIV()
{
return mIV_;
}
const nsTArray<uint8_t>&
mIV() const
{
return mIV_;
}
int64_t&
mTimestamp()
{
return mTimestamp_;
}
const int64_t&
mTimestamp() const
{
return mTimestamp_;
}
int64_t&
mDuration()
{
return mDuration_;
}
const int64_t&
mDuration() const
{
return mDuration_;
}
nsTArray<uint32_t>&
mClearBytes()
{
return mClearBytes_;
}
const nsTArray<uint32_t>&
mClearBytes() const
{
return mClearBytes_;
}
nsTArray<uint32_t>&
mCipherBytes()
{
return mCipherBytes_;
}
const nsTArray<uint32_t>&
mCipherBytes() const
{
return mCipherBytes_;
}
uint8_t&
mCryptByteBlock()
{
return mCryptByteBlock_;
}
const uint8_t&
mCryptByteBlock() const
{
return mCryptByteBlock_;
}
uint8_t&
mSkipByteBlock()
{
return mSkipByteBlock_;
}
const uint8_t&
mSkipByteBlock() const
{
return mSkipByteBlock_;
}
EncryptionScheme&
mEncryptionScheme()
{
return mEncryptionScheme_;
}
const EncryptionScheme&
mEncryptionScheme() const
{
return mEncryptionScheme_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<Shmem> mData_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mKeyId_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mIV_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint32_t>> mClearBytes_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint32_t>> mCipherBytes_;
::mozilla::ipc::IPDLStructMember<EncryptionScheme> mEncryptionScheme_;
::mozilla::ipc::IPDLStructMember<int64_t> mTimestamp_;
::mozilla::ipc::IPDLStructMember<int64_t> mDuration_;
::mozilla::ipc::IPDLStructMember<uint8_t> mCryptByteBlock_;
::mozilla::ipc::IPDLStructMember<uint8_t> mSkipByteBlock_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMInputBuffer>
{
typedef ::mozilla::gmp::CDMInputBuffer paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CDMVideoDecoderConfig|
//
namespace mozilla {
namespace gmp {
class CDMVideoDecoderConfig final
{
private:
typedef ::uint32_t uint32_t;
typedef ::int32_t int32_t;
typedef ::uint8_t uint8_t;
typedef ::cdm::EncryptionScheme EncryptionScheme;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CDMVideoDecoderConfig() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CDMVideoDecoderConfig(
const uint32_t& _mCodec,
const uint32_t& _mProfile,
const uint32_t& _mFormat,
const int32_t& _mImageWidth,
const int32_t& _mImageHeight,
const nsTArray<uint8_t>& _mExtraData,
const EncryptionScheme& _mEncryptionScheme) :
mExtraData_(_mExtraData),
mEncryptionScheme_(_mEncryptionScheme),
mCodec_(_mCodec),
mProfile_(_mProfile),
mFormat_(_mFormat),
mImageWidth_(_mImageWidth),
mImageHeight_(_mImageHeight)
{
}
MOZ_IMPLICIT CDMVideoDecoderConfig(
uint32_t&& _mCodec,
uint32_t&& _mProfile,
uint32_t&& _mFormat,
int32_t&& _mImageWidth,
int32_t&& _mImageHeight,
nsTArray<uint8_t>&& _mExtraData,
EncryptionScheme&& _mEncryptionScheme) :
mExtraData_(std::move(_mExtraData)),
mEncryptionScheme_(std::move(_mEncryptionScheme)),
mCodec_(std::move(_mCodec)),
mProfile_(std::move(_mProfile)),
mFormat_(std::move(_mFormat)),
mImageWidth_(std::move(_mImageWidth)),
mImageHeight_(std::move(_mImageHeight))
{
}
uint32_t&
mCodec()
{
return mCodec_;
}
const uint32_t&
mCodec() const
{
return mCodec_;
}
uint32_t&
mProfile()
{
return mProfile_;
}
const uint32_t&
mProfile() const
{
return mProfile_;
}
uint32_t&
mFormat()
{
return mFormat_;
}
const uint32_t&
mFormat() const
{
return mFormat_;
}
int32_t&
mImageWidth()
{
return mImageWidth_;
}
const int32_t&
mImageWidth() const
{
return mImageWidth_;
}
int32_t&
mImageHeight()
{
return mImageHeight_;
}
const int32_t&
mImageHeight() const
{
return mImageHeight_;
}
nsTArray<uint8_t>&
mExtraData()
{
return mExtraData_;
}
const nsTArray<uint8_t>&
mExtraData() const
{
return mExtraData_;
}
EncryptionScheme&
mEncryptionScheme()
{
return mEncryptionScheme_;
}
const EncryptionScheme&
mEncryptionScheme() const
{
return mEncryptionScheme_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mExtraData_;
::mozilla::ipc::IPDLStructMember<EncryptionScheme> mEncryptionScheme_;
::mozilla::ipc::IPDLStructMember<uint32_t> mCodec_;
::mozilla::ipc::IPDLStructMember<uint32_t> mProfile_;
::mozilla::ipc::IPDLStructMember<uint32_t> mFormat_;
::mozilla::ipc::IPDLStructMember<int32_t> mImageWidth_;
::mozilla::ipc::IPDLStructMember<int32_t> mImageHeight_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMVideoDecoderConfig>
{
typedef ::mozilla::gmp::CDMVideoDecoderConfig paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CDMKeyInformation|
//
namespace mozilla {
namespace gmp {
class CDMKeyInformation final
{
private:
typedef ::uint8_t uint8_t;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CDMKeyInformation() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CDMKeyInformation(
const nsTArray<uint8_t>& _mKeyId,
const uint32_t& _mStatus,
const uint32_t& _mSystemCode) :
mKeyId_(_mKeyId),
mStatus_(_mStatus),
mSystemCode_(_mSystemCode)
{
}
MOZ_IMPLICIT CDMKeyInformation(
nsTArray<uint8_t>&& _mKeyId,
uint32_t&& _mStatus,
uint32_t&& _mSystemCode) :
mKeyId_(std::move(_mKeyId)),
mStatus_(std::move(_mStatus)),
mSystemCode_(std::move(_mSystemCode))
{
}
nsTArray<uint8_t>&
mKeyId()
{
return mKeyId_;
}
const nsTArray<uint8_t>&
mKeyId() const
{
return mKeyId_;
}
uint32_t&
mStatus()
{
return mStatus_;
}
const uint32_t&
mStatus() const
{
return mStatus_;
}
uint32_t&
mSystemCode()
{
return mSystemCode_;
}
const uint32_t&
mSystemCode() const
{
return mSystemCode_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mKeyId_;
::mozilla::ipc::IPDLStructMember<uint32_t> mStatus_;
::mozilla::ipc::IPDLStructMember<uint32_t> mSystemCode_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMKeyInformation>
{
typedef ::mozilla::gmp::CDMKeyInformation paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CDMVideoPlane|
//
namespace mozilla {
namespace gmp {
class CDMVideoPlane final
{
private:
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CDMVideoPlane() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CDMVideoPlane(
const uint32_t& _mPlaneOffset,
const uint32_t& _mStride) :
mPlaneOffset_(_mPlaneOffset),
mStride_(_mStride)
{
}
MOZ_IMPLICIT CDMVideoPlane(
uint32_t&& _mPlaneOffset,
uint32_t&& _mStride) :
mPlaneOffset_(std::move(_mPlaneOffset)),
mStride_(std::move(_mStride))
{
}
uint32_t&
mPlaneOffset()
{
return mPlaneOffset_;
}
const uint32_t&
mPlaneOffset() const
{
return mPlaneOffset_;
}
uint32_t&
mStride()
{
return mStride_;
}
const uint32_t&
mStride() const
{
return mStride_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<uint32_t> mPlaneOffset_;
::mozilla::ipc::IPDLStructMember<uint32_t> mStride_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMVideoPlane>
{
typedef ::mozilla::gmp::CDMVideoPlane paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CDMVideoFrame|
//
namespace mozilla {
namespace gmp {
class CDMVideoFrame final
{
private:
typedef ::uint32_t uint32_t;
typedef ::int32_t int32_t;
typedef ::mozilla::gmp::CDMVideoPlane CDMVideoPlane;
typedef ::int64_t int64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CDMVideoFrame() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CDMVideoFrame(
const uint32_t& _mFormat,
const int32_t& _mImageWidth,
const int32_t& _mImageHeight,
const CDMVideoPlane& _mYPlane,
const CDMVideoPlane& _mUPlane,
const CDMVideoPlane& _mVPlane,
const int64_t& _mTimestamp,
const int64_t& _mDuration) :
mYPlane_(_mYPlane),
mUPlane_(_mUPlane),
mVPlane_(_mVPlane),
mTimestamp_(_mTimestamp),
mDuration_(_mDuration),
mFormat_(_mFormat),
mImageWidth_(_mImageWidth),
mImageHeight_(_mImageHeight)
{
}
MOZ_IMPLICIT CDMVideoFrame(
uint32_t&& _mFormat,
int32_t&& _mImageWidth,
int32_t&& _mImageHeight,
CDMVideoPlane&& _mYPlane,
CDMVideoPlane&& _mUPlane,
CDMVideoPlane&& _mVPlane,
int64_t&& _mTimestamp,
int64_t&& _mDuration) :
mYPlane_(std::move(_mYPlane)),
mUPlane_(std::move(_mUPlane)),
mVPlane_(std::move(_mVPlane)),
mTimestamp_(std::move(_mTimestamp)),
mDuration_(std::move(_mDuration)),
mFormat_(std::move(_mFormat)),
mImageWidth_(std::move(_mImageWidth)),
mImageHeight_(std::move(_mImageHeight))
{
}
uint32_t&
mFormat()
{
return mFormat_;
}
const uint32_t&
mFormat() const
{
return mFormat_;
}
int32_t&
mImageWidth()
{
return mImageWidth_;
}
const int32_t&
mImageWidth() const
{
return mImageWidth_;
}
int32_t&
mImageHeight()
{
return mImageHeight_;
}
const int32_t&
mImageHeight() const
{
return mImageHeight_;
}
CDMVideoPlane&
mYPlane()
{
return mYPlane_;
}
const CDMVideoPlane&
mYPlane() const
{
return mYPlane_;
}
CDMVideoPlane&
mUPlane()
{
return mUPlane_;
}
const CDMVideoPlane&
mUPlane() const
{
return mUPlane_;
}
CDMVideoPlane&
mVPlane()
{
return mVPlane_;
}
const CDMVideoPlane&
mVPlane() const
{
return mVPlane_;
}
int64_t&
mTimestamp()
{
return mTimestamp_;
}
const int64_t&
mTimestamp() const
{
return mTimestamp_;
}
int64_t&
mDuration()
{
return mDuration_;
}
const int64_t&
mDuration() const
{
return mDuration_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<CDMVideoPlane> mYPlane_;
::mozilla::ipc::IPDLStructMember<CDMVideoPlane> mUPlane_;
::mozilla::ipc::IPDLStructMember<CDMVideoPlane> mVPlane_;
::mozilla::ipc::IPDLStructMember<int64_t> mTimestamp_;
::mozilla::ipc::IPDLStructMember<int64_t> mDuration_;
::mozilla::ipc::IPDLStructMember<uint32_t> mFormat_;
::mozilla::ipc::IPDLStructMember<int32_t> mImageWidth_;
::mozilla::ipc::IPDLStructMember<int32_t> mImageHeight_;
};
} // namespace gmp
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMVideoFrame>
{
typedef ::mozilla::gmp::CDMVideoFrame paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef GMPTypes_h