NewChannelMessage.h

// Copyright (c) 2012 The Foundry Visionmongers Ltd. All Rights Reserved.

#ifndef NEW_CHANNEL_MESSAGE_H
#define NEW_CHANNEL_MESSAGE_H

#include <stdint.h>
#include <string>

#include "Message.h"

namespace Foundry
{
namespace Katana
{
class NewFrameMessage;

class NewChannelMessage : public Message
{
public:
    NewChannelMessage(const NewFrameMessage& frame,
                      uint16_t channelID = 0,
                      uint32_t height = 0,
                      uint32_t width = 0,
                      int xorigin = 0,
                      int yorigin = 0,
                      float sampleRate1 = 0.0,
                      float sampleRate2 = 0.0,
                      uint32_t dataSize = 0);

    NewChannelMessage(const uint8_t* frameID,
                      uint16_t channelID = 0,
                      uint32_t height = 0,
                      uint32_t width = 0,
                      int xorigin = 0,
                      int yorigin = 0,
                      float sampleRate1 = 0.0,
                      float sampleRate2 = 0.0,
                      uint32_t dataSize = 0);

    virtual ~NewChannelMessage() {}

    int setChannelName(const std::string& name);

    void setChannelDimensions(uint32_t width, uint32_t height);

    void setChannelOrigin(int ox, int oy);

    void setDataSize(uint32_t dataSize);

    void setChannelID(uint16_t channelID);

    void setSampleRate(const float* sampleRate);

    const uint8_t* frameUUID() const;

    uint16_t channelID() const;
    uint32_t channelHeight() const;
    uint32_t channelWidth() const;
    int channelXOrigin() const;
    int channelYOrigin() const;
    uint32_t channelDataSize() const;
    const std::string& channelName() const;
    uint32_t channelNameLength() const;
    const float* sampleRate() const;
    bool isIdPass() const;

protected:
    explicit NewChannelMessage(FnMessageHandle handle)
        : Message(handle), _channelName()
    {
    }

private:
    NewChannelMessage(const NewChannelMessage& rhs);
    NewChannelMessage& operator=(const NewChannelMessage& rhs);

    mutable std::string _channelName;
};

class NewChannelMessage_v2 : public NewChannelMessage
{
public:
    enum PixelLayout
    {
        ARGB = 0,
        RGBA = 1,
        UNDEFINED = 0xFF
    };

    NewChannelMessage_v2(const uint8_t* frameID,
                         uint16_t channelID = 0,
                         PixelLayout pixelLayout = ARGB,
                         uint32_t height = 0,
                         uint32_t width = 0,
                         int xorigin = 0,
                         int yorigin = 0,
                         float sampleRate1 = 0.0,
                         float sampleRate2 = 0.0,
                         uint32_t dataSize = 0);

    NewChannelMessage_v2(const NewFrameMessage& frame,
                         uint16_t channelID = 0,
                         PixelLayout pixelLayout = ARGB,
                         uint32_t height = 0,
                         uint32_t width = 0,
                         int xorigin = 0,
                         int yorigin = 0,
                         float sampleRate1 = 0.0,
                         float sampleRate2 = 0.0,
                         uint32_t dataSize = 0);

    virtual ~NewChannelMessage_v2() {}

    void setPixelLayout(PixelLayout pixelLayout);
    PixelLayout pixelLayout() const;

private:
    NewChannelMessage_v2(const NewChannelMessage_v2& rhs);
    NewChannelMessage_v2& operator=(const NewChannelMessage_v2& rhs);
};

}  // namespace Katana
}  // namespace Foundry

#endif