//
// Automatically generated by ipdlc.
// Edit at your own risk
//

#ifndef PCameras_h
#define PCameras_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 "mozilla/TimeStamp.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct VideoCaptureCapability|
//
namespace mozilla {
namespace camera {
class VideoCaptureCapability final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    VideoCaptureCapability() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT VideoCaptureCapability(
            const int& _width,
            const int& _height,
            const int& _maxFPS,
            const int& _videoType,
            const bool& _interlaced) :
        width_(_width),
        height_(_height),
        maxFPS_(_maxFPS),
        videoType_(_videoType),
        interlaced_(_interlaced)
    {
    }

    MOZ_IMPLICIT VideoCaptureCapability(
            int&& _width,
            int&& _height,
            int&& _maxFPS,
            int&& _videoType,
            bool&& _interlaced) :
        width_(std::move(_width)),
        height_(std::move(_height)),
        maxFPS_(std::move(_maxFPS)),
        videoType_(std::move(_videoType)),
        interlaced_(std::move(_interlaced))
    {
    }

    int&
    width()
    {
        return width_;
    }
    const int&
    width() const
    {
        return width_;
    }

    int&
    height()
    {
        return height_;
    }
    const int&
    height() const
    {
        return height_;
    }

    int&
    maxFPS()
    {
        return maxFPS_;
    }
    const int&
    maxFPS() const
    {
        return maxFPS_;
    }

    int&
    videoType()
    {
        return videoType_;
    }
    const int&
    videoType() const
    {
        return videoType_;
    }

    bool&
    interlaced()
    {
        return interlaced_;
    }
    const bool&
    interlaced() const
    {
        return interlaced_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<int> width_;
    ::mozilla::ipc::IPDLStructMember<int> height_;
    ::mozilla::ipc::IPDLStructMember<int> maxFPS_;
    ::mozilla::ipc::IPDLStructMember<int> videoType_;
    ::mozilla::ipc::IPDLStructMember<bool> interlaced_;
};
} // namespace camera
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::camera::VideoCaptureCapability>
{
    typedef ::mozilla::camera::VideoCaptureCapability 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 VideoFrameProperties|
//
namespace mozilla {
namespace camera {
class VideoFrameProperties final
{
private:
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::uint32_t uint32_t;
    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
    VideoFrameProperties() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT VideoFrameProperties(
            const TimeStamp& _captureTime,
            const uint32_t& _bufferSize,
            const uint32_t& _rtpTimeStamp,
            const int64_t& _ntpTimeMs,
            const int64_t& _renderTimeMs,
            const int& _rotation,
            const int& _yAllocatedSize,
            const int& _uAllocatedSize,
            const int& _vAllocatedSize,
            const int& _width,
            const int& _height,
            const int& _yStride,
            const int& _uStride,
            const int& _vStride) :
        captureTime_(_captureTime),
        rotation_(_rotation),
        yAllocatedSize_(_yAllocatedSize),
        uAllocatedSize_(_uAllocatedSize),
        vAllocatedSize_(_vAllocatedSize),
        width_(_width),
        height_(_height),
        yStride_(_yStride),
        uStride_(_uStride),
        vStride_(_vStride),
        ntpTimeMs_(_ntpTimeMs),
        renderTimeMs_(_renderTimeMs),
        bufferSize_(_bufferSize),
        rtpTimeStamp_(_rtpTimeStamp)
    {
    }

    MOZ_IMPLICIT VideoFrameProperties(
            TimeStamp&& _captureTime,
            uint32_t&& _bufferSize,
            uint32_t&& _rtpTimeStamp,
            int64_t&& _ntpTimeMs,
            int64_t&& _renderTimeMs,
            int&& _rotation,
            int&& _yAllocatedSize,
            int&& _uAllocatedSize,
            int&& _vAllocatedSize,
            int&& _width,
            int&& _height,
            int&& _yStride,
            int&& _uStride,
            int&& _vStride) :
        captureTime_(std::move(_captureTime)),
        rotation_(std::move(_rotation)),
        yAllocatedSize_(std::move(_yAllocatedSize)),
        uAllocatedSize_(std::move(_uAllocatedSize)),
        vAllocatedSize_(std::move(_vAllocatedSize)),
        width_(std::move(_width)),
        height_(std::move(_height)),
        yStride_(std::move(_yStride)),
        uStride_(std::move(_uStride)),
        vStride_(std::move(_vStride)),
        ntpTimeMs_(std::move(_ntpTimeMs)),
        renderTimeMs_(std::move(_renderTimeMs)),
        bufferSize_(std::move(_bufferSize)),
        rtpTimeStamp_(std::move(_rtpTimeStamp))
    {
    }

    TimeStamp&
    captureTime()
    {
        return captureTime_;
    }
    const TimeStamp&
    captureTime() const
    {
        return captureTime_;
    }

    uint32_t&
    bufferSize()
    {
        return bufferSize_;
    }
    const uint32_t&
    bufferSize() const
    {
        return bufferSize_;
    }

    uint32_t&
    rtpTimeStamp()
    {
        return rtpTimeStamp_;
    }
    const uint32_t&
    rtpTimeStamp() const
    {
        return rtpTimeStamp_;
    }

    int64_t&
    ntpTimeMs()
    {
        return ntpTimeMs_;
    }
    const int64_t&
    ntpTimeMs() const
    {
        return ntpTimeMs_;
    }

    int64_t&
    renderTimeMs()
    {
        return renderTimeMs_;
    }
    const int64_t&
    renderTimeMs() const
    {
        return renderTimeMs_;
    }

    int&
    rotation()
    {
        return rotation_;
    }
    const int&
    rotation() const
    {
        return rotation_;
    }

    int&
    yAllocatedSize()
    {
        return yAllocatedSize_;
    }
    const int&
    yAllocatedSize() const
    {
        return yAllocatedSize_;
    }

    int&
    uAllocatedSize()
    {
        return uAllocatedSize_;
    }
    const int&
    uAllocatedSize() const
    {
        return uAllocatedSize_;
    }

    int&
    vAllocatedSize()
    {
        return vAllocatedSize_;
    }
    const int&
    vAllocatedSize() const
    {
        return vAllocatedSize_;
    }

    int&
    width()
    {
        return width_;
    }
    const int&
    width() const
    {
        return width_;
    }

    int&
    height()
    {
        return height_;
    }
    const int&
    height() const
    {
        return height_;
    }

    int&
    yStride()
    {
        return yStride_;
    }
    const int&
    yStride() const
    {
        return yStride_;
    }

    int&
    uStride()
    {
        return uStride_;
    }
    const int&
    uStride() const
    {
        return uStride_;
    }

    int&
    vStride()
    {
        return vStride_;
    }
    const int&
    vStride() const
    {
        return vStride_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> captureTime_;
    ::mozilla::ipc::IPDLStructMember<int> rotation_;
    ::mozilla::ipc::IPDLStructMember<int> yAllocatedSize_;
    ::mozilla::ipc::IPDLStructMember<int> uAllocatedSize_;
    ::mozilla::ipc::IPDLStructMember<int> vAllocatedSize_;
    ::mozilla::ipc::IPDLStructMember<int> width_;
    ::mozilla::ipc::IPDLStructMember<int> height_;
    ::mozilla::ipc::IPDLStructMember<int> yStride_;
    ::mozilla::ipc::IPDLStructMember<int> uStride_;
    ::mozilla::ipc::IPDLStructMember<int> vStride_;
    ::mozilla::ipc::IPDLStructMember<int64_t> ntpTimeMs_;
    ::mozilla::ipc::IPDLStructMember<int64_t> renderTimeMs_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> bufferSize_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> rtpTimeStamp_;
};
} // namespace camera
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::camera::VideoFrameProperties>
{
    typedef ::mozilla::camera::VideoFrameProperties paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

namespace mozilla {
namespace camera {
class PCamerasParent;
} // namespace camera
} // namespace mozilla
namespace mozilla {
namespace camera {
class PCamerasChild;
} // namespace camera
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PCamerasChild and PCamerasParent
//
namespace mozilla {
namespace camera {
namespace PCameras {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::camera::PCamerasParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::camera::PCamerasChild>* aChild);

enum MessageType {
    PCamerasStart = PCamerasMsgStart << 16,
    Msg_CaptureEnded__ID,
    Msg_DeliverFrame__ID,
    Msg_DeviceChange__ID,
    Msg_ReplyNumberOfCaptureDevices__ID,
    Msg_ReplyNumberOfCapabilities__ID,
    Msg_ReplyAllocateCapture__ID,
    Msg_ReplyGetCaptureCapability__ID,
    Msg_ReplyGetCaptureDevice__ID,
    Msg_ReplyFailure__ID,
    Msg_ReplySuccess__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    Msg_NumberOfCaptureDevices__ID,
    Msg_NumberOfCapabilities__ID,
    Msg_GetCaptureCapability__ID,
    Msg_GetCaptureDevice__ID,
    Msg_AllocateCapture__ID,
    Msg_ReleaseCapture__ID,
    Msg_StartCapture__ID,
    Msg_FocusOnSelectedSource__ID,
    Msg_StopCapture__ID,
    Msg_ReleaseFrame__ID,
    Msg_EnsureInitialized__ID,
    PCamerasEnd
};

mozilla::UniquePtr<IPC::Message>
Msg_CaptureEnded(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_DeliverFrame(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_DeviceChange(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReplyNumberOfCaptureDevices(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReplyNumberOfCapabilities(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReplyAllocateCapture(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReplyGetCaptureCapability(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReplyGetCaptureDevice(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReplyFailure(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReplySuccess(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_NumberOfCaptureDevices(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_NumberOfCapabilities(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_GetCaptureCapability(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_GetCaptureDevice(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_AllocateCapture(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReleaseCapture(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_StartCapture(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_FocusOnSelectedSource(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_StopCapture(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ReleaseFrame(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_EnsureInitialized(IPC::Message::routeid_t routingId);



} // namespace PCameras
} // namespace camera
} // namespace mozilla

#endif // ifndef PCameras_h
