modules/interface/module_common_types.h

/*
 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#ifndef MODULE_COMMON_TYPES_H
#define MODULE_COMMON_TYPES_H

#include <assert.h>
#include <string.h> // memcpy

#include <algorithm>

#include "webrtc/common_types.h"
#include "webrtc/system_wrappers/interface/constructor_magic.h"
#include "webrtc/typedefs.h"

#ifdef _WIN32
    #pragma warning(disable:4351)       // remove warning "new behavior: elements of array
                                        // 'array' will be default initialized"
#endif

namespace webrtc {

struct RTPHeaderExtension
{
    int32_t  transmissionTimeOffset;
    uint32_t absoluteSendTime;
};

struct RTPHeader
{
    bool markerBit;
    uint8_t payloadType;
    uint16_t sequenceNumber;
    uint32_t timestamp;
    uint32_t ssrc;
    uint8_t numCSRCs;
    uint32_t arrOfCSRCs[kRtpCsrcSize];
    uint8_t paddingLength;
    uint16_t headerLength;
    int payload_type_frequency;
    RTPHeaderExtension extension;
};

struct RTPAudioHeader
{
    uint8_t  numEnergy;                         // number of valid entries in arrOfEnergy
    uint8_t  arrOfEnergy[kRtpCsrcSize];   // one energy byte (0-9) per channel
    bool           isCNG;                             // is this CNG
    uint8_t  channel;                           // number of channels 2 = stereo
};

enum {kNoPictureId = -1};
enum {kNoTl0PicIdx = -1};
enum {kNoTemporalIdx = -1};
enum {kNoKeyIdx = -1};
enum {kNoSimulcastIdx = 0};

struct RTPVideoHeaderVP8
{
    void InitRTPVideoHeaderVP8()
    {
        nonReference = false;
        pictureId = kNoPictureId;
        tl0PicIdx = kNoTl0PicIdx;
        temporalIdx = kNoTemporalIdx;
        layerSync = false;
        keyIdx = kNoKeyIdx;
        partitionId = 0;
        beginningOfPartition = false;
    }

    bool           nonReference;   // Frame is discardable.
    int16_t  pictureId;      // Picture ID index, 15 bits;
                                   // kNoPictureId if PictureID does not exist.
    int16_t  tl0PicIdx;      // TL0PIC_IDX, 8 bits;
                                   // kNoTl0PicIdx means no value provided.
    int8_t   temporalIdx;    // Temporal layer index, or kNoTemporalIdx.
    bool           layerSync;      // This frame is a layer sync frame.
                                   // Disabled if temporalIdx == kNoTemporalIdx.
    int            keyIdx;         // 5 bits; kNoKeyIdx means not used.
    int            partitionId;    // VP8 partition ID
    bool           beginningOfPartition;  // True if this packet is the first
                                          // in a VP8 partition. Otherwise false
};
union RTPVideoTypeHeader
{
    RTPVideoHeaderVP8       VP8;
};

enum RtpVideoCodecTypes
{
    kRtpVideoNone,
    kRtpVideoGeneric,
    kRtpVideoVp8
};
struct RTPVideoHeader
{
    uint16_t          width;                  // size
    uint16_t          height;

    bool                    isFirstPacket;   // first packet in frame
    uint8_t           simulcastIdx;    // Index if the simulcast encoder creating
                                             // this frame, 0 if not using simulcast.
    RtpVideoCodecTypes      codec;
    RTPVideoTypeHeader      codecHeader;
};
union RTPTypeHeader
{
    RTPAudioHeader  Audio;
    RTPVideoHeader  Video;
};

struct WebRtcRTPHeader
{
    RTPHeader       header;
    FrameType       frameType;
    RTPTypeHeader   type;
};

class RTPFragmentationHeader
{
public:
    RTPFragmentationHeader() :
        fragmentationVectorSize(0),
        fragmentationOffset(NULL),
        fragmentationLength(NULL),
        fragmentationTimeDiff(NULL),
        fragmentationPlType(NULL)
    {};

    ~RTPFragmentationHeader()
    {
        delete [] fragmentationOffset;
        delete [] fragmentationLength;
        delete [] fragmentationTimeDiff;
        delete [] fragmentationPlType;
    }

    void CopyFrom(const RTPFragmentationHeader& src)
    {
        if(this == &src)
        {
            return;
        }

        if(src.fragmentationVectorSize != fragmentationVectorSize)
        {
            // new size of vectors

            // delete old
            delete [] fragmentationOffset;
            fragmentationOffset = NULL;
            delete [] fragmentationLength;
            fragmentationLength = NULL;
            delete [] fragmentationTimeDiff;
            fragmentationTimeDiff = NULL;
            delete [] fragmentationPlType;
            fragmentationPlType = NULL;

            if(src.fragmentationVectorSize > 0)
            {
                // allocate new
                if(src.fragmentationOffset)
                {
                    fragmentationOffset = new uint32_t[src.fragmentationVectorSize];
                }
                if(src.fragmentationLength)
                {
                    fragmentationLength = new uint32_t[src.fragmentationVectorSize];
                }
                if(src.fragmentationTimeDiff)
                {
                    fragmentationTimeDiff = new uint16_t[src.fragmentationVectorSize];
                }
                if(src.fragmentationPlType)
                {
                    fragmentationPlType = new uint8_t[src.fragmentationVectorSize];
                }
            }
            // set new size
            fragmentationVectorSize =   src.fragmentationVectorSize;
        }

        if(src.fragmentationVectorSize > 0)
        {
            // copy values
            if(src.fragmentationOffset)
            {
                memcpy(fragmentationOffset, src.fragmentationOffset,
                       src.fragmentationVectorSize * sizeof(uint32_t));
            }
            if(src.fragmentationLength)
            {
                memcpy(fragmentationLength, src.fragmentationLength,
                       src.fragmentationVectorSize * sizeof(uint32_t));
            }
            if(src.fragmentationTimeDiff)
            {
                memcpy(fragmentationTimeDiff, src.fragmentationTimeDiff,
                       src.fragmentationVectorSize * sizeof(uint16_t));
            }
            if(src.fragmentationPlType)
            {
                memcpy(fragmentationPlType, src.fragmentationPlType,
                       src.fragmentationVectorSize * sizeof(uint8_t));
            }
        }
    }

    void VerifyAndAllocateFragmentationHeader(const uint16_t size)
    {
        if(fragmentationVectorSize < size)
        {
            uint16_t oldVectorSize = fragmentationVectorSize;
            {
                // offset
                uint32_t* oldOffsets = fragmentationOffset;
                fragmentationOffset = new uint32_t[size];
                memset(fragmentationOffset+oldVectorSize, 0,
                       sizeof(uint32_t)*(size-oldVectorSize));
                // copy old values
                memcpy(fragmentationOffset,oldOffsets, sizeof(uint32_t) * oldVectorSize);
                delete[] oldOffsets;
            }
            // length
            {
                uint32_t* oldLengths = fragmentationLength;
                fragmentationLength = new uint32_t[size];
                memset(fragmentationLength+oldVectorSize, 0,
                       sizeof(uint32_t) * (size- oldVectorSize));
                memcpy(fragmentationLength, oldLengths,
                       sizeof(uint32_t) * oldVectorSize);
                delete[] oldLengths;
            }
            // time diff
            {
                uint16_t* oldTimeDiffs = fragmentationTimeDiff;
                fragmentationTimeDiff = new uint16_t[size];
                memset(fragmentationTimeDiff+oldVectorSize, 0,
                       sizeof(uint16_t) * (size- oldVectorSize));
                memcpy(fragmentationTimeDiff, oldTimeDiffs,
                       sizeof(uint16_t) * oldVectorSize);
                delete[] oldTimeDiffs;
            }
            // payload type
            {
                uint8_t* oldTimePlTypes = fragmentationPlType;
                fragmentationPlType = new uint8_t[size];
                memset(fragmentationPlType+oldVectorSize, 0,
                       sizeof(uint8_t) * (size- oldVectorSize));
                memcpy(fragmentationPlType, oldTimePlTypes,
                       sizeof(uint8_t) * oldVectorSize);
                delete[] oldTimePlTypes;
            }
            fragmentationVectorSize = size;
        }
    }

    uint16_t    fragmentationVectorSize;    // Number of fragmentations
    uint32_t*   fragmentationOffset;        // Offset of pointer to data for each fragm.
    uint32_t*   fragmentationLength;        // Data size for each fragmentation
    uint16_t*   fragmentationTimeDiff;      // Timestamp difference relative "now" for
                                                  // each fragmentation
    uint8_t*    fragmentationPlType;        // Payload type of each fragmentation

private:
    DISALLOW_COPY_AND_ASSIGN(RTPFragmentationHeader);
};

struct RTCPVoIPMetric
{
    // RFC 3611 4.7
    uint8_t     lossRate;
    uint8_t     discardRate;
    uint8_t     burstDensity;
    uint8_t     gapDensity;
    uint16_t    burstDuration;
    uint16_t    gapDuration;
    uint16_t    roundTripDelay;
    uint16_t    endSystemDelay;
    uint8_t     signalLevel;
    uint8_t     noiseLevel;
    uint8_t     RERL;
    uint8_t     Gmin;
    uint8_t     Rfactor;
    uint8_t     extRfactor;
    uint8_t     MOSLQ;
    uint8_t     MOSCQ;
    uint8_t     RXconfig;
    uint16_t    JBnominal;
    uint16_t    JBmax;
    uint16_t    JBabsMax;
};

// Types for the FEC packet masks. The type |kFecMaskRandom| is based on a
// random loss model. The type |kFecMaskBursty| is based on a bursty/consecutive
// loss model. The packet masks are defined in
// modules/rtp_rtcp/fec_private_tables_random(bursty).h
enum FecMaskType {
  kFecMaskRandom,
  kFecMaskBursty,
};

// Struct containing forward error correction settings.
struct FecProtectionParams {
  int fec_rate;
  bool use_uep_protection;
  int max_fec_frames;
  FecMaskType fec_mask_type;
};

// Interface used by the CallStats class to distribute call statistics.
// Callbacks will be triggered as soon as the class has been registered to a
// CallStats object using RegisterStatsObserver.
class CallStatsObserver {
 public:
  virtual void OnRttUpdate(uint32_t rtt_ms) = 0;

  virtual ~CallStatsObserver() {}
};

// class describing a complete, or parts of an encoded frame.
class EncodedVideoData
{
public:
    EncodedVideoData() :
        payloadType(0),
        timeStamp(0),
        renderTimeMs(0),
        encodedWidth(0),
        encodedHeight(0),
        completeFrame(false),
        missingFrame(false),
        payloadData(NULL),
        payloadSize(0),
        bufferSize(0),
        fragmentationHeader(),
        frameType(kVideoFrameDelta),
        codec(kVideoCodecUnknown)
    {};

    EncodedVideoData(const EncodedVideoData& data)
    {
        payloadType         = data.payloadType;
        timeStamp           = data.timeStamp;
        renderTimeMs        = data.renderTimeMs;
        encodedWidth        = data.encodedWidth;
        encodedHeight       = data.encodedHeight;
        completeFrame       = data.completeFrame;
        missingFrame        = data.missingFrame;
        payloadSize         = data.payloadSize;
        fragmentationHeader.CopyFrom(data.fragmentationHeader);
        frameType           = data.frameType;
        codec               = data.codec;
        if (data.payloadSize > 0)
        {
            payloadData = new uint8_t[data.payloadSize];
            memcpy(payloadData, data.payloadData, data.payloadSize);
        }
        else
        {
            payloadData = NULL;
        }
    }


    ~EncodedVideoData()
    {
        delete [] payloadData;
    };

    EncodedVideoData& operator=(const EncodedVideoData& data)
    {
        if (this == &data)
        {
            return *this;
        }
        payloadType         = data.payloadType;
        timeStamp           = data.timeStamp;
        renderTimeMs        = data.renderTimeMs;
        encodedWidth        = data.encodedWidth;
        encodedHeight       = data.encodedHeight;
        completeFrame       = data.completeFrame;
        missingFrame        = data.missingFrame;
        payloadSize         = data.payloadSize;
        fragmentationHeader.CopyFrom(data.fragmentationHeader);
        frameType           = data.frameType;
        codec               = data.codec;
        if (data.payloadSize > 0)
        {
            delete [] payloadData;
            payloadData = new uint8_t[data.payloadSize];
            memcpy(payloadData, data.payloadData, data.payloadSize);
            bufferSize = data.payloadSize;
        }
        return *this;
    };
    void VerifyAndAllocate( const uint32_t size)
    {
        if (bufferSize < size)
        {
            uint8_t* oldPayload = payloadData;
            payloadData = new uint8_t[size];
            memcpy(payloadData, oldPayload, sizeof(uint8_t) * payloadSize);

            bufferSize = size;
            delete[] oldPayload;
        }
    }

    uint8_t               payloadType;
    uint32_t              timeStamp;
    int64_t               renderTimeMs;
    uint32_t              encodedWidth;
    uint32_t              encodedHeight;
    bool                        completeFrame;
    bool                        missingFrame;
    uint8_t*              payloadData;
    uint32_t              payloadSize;
    uint32_t              bufferSize;
    RTPFragmentationHeader      fragmentationHeader;
    FrameType                   frameType;
    VideoCodecType              codec;
};

struct VideoContentMetrics {
  VideoContentMetrics()
      : motion_magnitude(0.0f),
        spatial_pred_err(0.0f),
        spatial_pred_err_h(0.0f),
        spatial_pred_err_v(0.0f) {
  }

  void Reset() {
    motion_magnitude = 0.0f;
    spatial_pred_err = 0.0f;
    spatial_pred_err_h = 0.0f;
    spatial_pred_err_v = 0.0f;
  }
  float motion_magnitude;
  float spatial_pred_err;
  float spatial_pred_err_h;
  float spatial_pred_err_v;
};

/*************************************************
 *
 * VideoFrame class
 *
 * The VideoFrame class allows storing and
 * handling of video frames.
 *
 *
 *************************************************/
class VideoFrame
{
public:
    VideoFrame();
    ~VideoFrame();
    /**
    * Verifies that current allocated buffer size is larger than or equal to the input size.
    * If the current buffer size is smaller, a new allocation is made and the old buffer data
    * is copied to the new buffer.
    * Buffer size is updated to minimumSize.
    */
    int32_t VerifyAndAllocate(const uint32_t minimumSize);
    /**
    *    Update length of data buffer in frame. Function verifies that new length is less or
    *    equal to allocated size.
    */
    int32_t SetLength(const uint32_t newLength);
    /*
    *    Swap buffer and size data
    */
    int32_t Swap(uint8_t*& newMemory,
                       uint32_t& newLength,
                       uint32_t& newSize);
    /*
    *    Swap buffer and size data
    */
    int32_t SwapFrame(VideoFrame& videoFrame);
    /**
    *    Copy buffer: If newLength is bigger than allocated size, a new buffer of size length
    *    is allocated.
    */
    int32_t CopyFrame(const VideoFrame& videoFrame);
    /**
    *    Copy buffer: If newLength is bigger than allocated size, a new buffer of size length
    *    is allocated.
    */
    int32_t CopyFrame(uint32_t length, const uint8_t* sourceBuffer);
    /**
    *    Delete VideoFrame and resets members to zero
    */
    void Free();
    /**
    *   Set frame timestamp (90kHz)
    */
    void SetTimeStamp(const uint32_t timeStamp) {_timeStamp = timeStamp;}
    /**
    *   Get pointer to frame buffer
    */
    uint8_t*    Buffer() const {return _buffer;}

    uint8_t*&   Buffer() {return _buffer;}

    /**
    *   Get allocated buffer size
    */
    uint32_t    Size() const {return _bufferSize;}
    /**
    *   Get frame length
    */
    uint32_t    Length() const {return _bufferLength;}
    /**
    *   Get frame timestamp (90kHz)
    */
    uint32_t    TimeStamp() const {return _timeStamp;}
    /**
    *   Get frame width
    */
    uint32_t    Width() const {return _width;}
    /**
    *   Get frame height
    */
    uint32_t    Height() const {return _height;}
    /**
    *   Set frame width
    */
    void   SetWidth(const uint32_t width)  {_width = width;}
    /**
    *   Set frame height
    */
    void  SetHeight(const uint32_t height) {_height = height;}
    /**
    *   Set render time in miliseconds
    */
    void SetRenderTime(const int64_t renderTimeMs) {_renderTimeMs = renderTimeMs;}
    /**
    *  Get render time in miliseconds
    */
    int64_t    RenderTimeMs() const {return _renderTimeMs;}

private:
    void Set(uint8_t* buffer,
             uint32_t size,
             uint32_t length,
             uint32_t timeStamp);

    uint8_t*          _buffer;          // Pointer to frame buffer
    uint32_t          _bufferSize;      // Allocated buffer size
    uint32_t          _bufferLength;    // Length (in bytes) of buffer
    uint32_t          _timeStamp;       // Timestamp of frame (90kHz)
    uint32_t          _width;
    uint32_t          _height;
    int64_t           _renderTimeMs;
}; // end of VideoFrame class declaration

// inline implementation of VideoFrame class:
inline
VideoFrame::VideoFrame():
    _buffer(0),
    _bufferSize(0),
    _bufferLength(0),
    _timeStamp(0),
    _width(0),
    _height(0),
    _renderTimeMs(0)
{
    //
}
inline
VideoFrame::~VideoFrame()
{
    if(_buffer)
    {
        delete [] _buffer;
        _buffer = NULL;
    }
}


inline
int32_t
VideoFrame::VerifyAndAllocate(const uint32_t minimumSize)
{
    if (minimumSize < 1)
    {
        return -1;
    }
    if(minimumSize > _bufferSize)
    {
        // create buffer of sufficient size
        uint8_t* newBufferBuffer = new uint8_t[minimumSize];
        if(_buffer)
        {
            // copy old data
            memcpy(newBufferBuffer, _buffer, _bufferSize);
            delete [] _buffer;
        }
        else
        {
            memset(newBufferBuffer, 0, minimumSize * sizeof(uint8_t));
        }
        _buffer = newBufferBuffer;
        _bufferSize = minimumSize;
    }
    return 0;
}

inline
int32_t
VideoFrame::SetLength(const uint32_t newLength)
{
    if (newLength >_bufferSize )
    { // can't accomodate new value
        return -1;
    }
     _bufferLength = newLength;
     return 0;
}

inline
int32_t
VideoFrame::SwapFrame(VideoFrame& videoFrame)
{
    uint32_t tmpTimeStamp  = _timeStamp;
    uint32_t tmpWidth      = _width;
    uint32_t tmpHeight     = _height;
    int64_t  tmpRenderTime = _renderTimeMs;

    _timeStamp = videoFrame._timeStamp;
    _width = videoFrame._width;
    _height = videoFrame._height;
    _renderTimeMs = videoFrame._renderTimeMs;

    videoFrame._timeStamp = tmpTimeStamp;
    videoFrame._width = tmpWidth;
    videoFrame._height = tmpHeight;
    videoFrame._renderTimeMs = tmpRenderTime;

    return Swap(videoFrame._buffer, videoFrame._bufferLength, videoFrame._bufferSize);
}

inline
int32_t
VideoFrame::Swap(uint8_t*& newMemory, uint32_t& newLength, uint32_t& newSize)
{
    uint8_t* tmpBuffer = _buffer;
    uint32_t tmpLength = _bufferLength;
    uint32_t tmpSize = _bufferSize;
    _buffer = newMemory;
    _bufferLength = newLength;
    _bufferSize = newSize;
    newMemory = tmpBuffer;
    newLength = tmpLength;
    newSize = tmpSize;
    return 0;
}

inline
int32_t
VideoFrame::CopyFrame(uint32_t length, const uint8_t* sourceBuffer)
{
    if (length > _bufferSize)
    {
        int32_t ret = VerifyAndAllocate(length);
        if (ret < 0)
        {
            return ret;
        }
    }
     memcpy(_buffer, sourceBuffer, length);
    _bufferLength = length;
    return 0;
}

inline
int32_t
VideoFrame::CopyFrame(const VideoFrame& videoFrame)
{
    if(CopyFrame(videoFrame.Length(), videoFrame.Buffer()) != 0)
    {
        return -1;
    }
    _timeStamp = videoFrame._timeStamp;
    _width = videoFrame._width;
    _height = videoFrame._height;
    _renderTimeMs = videoFrame._renderTimeMs;
    return 0;
}

inline
void
VideoFrame::Free()
{
    _timeStamp = 0;
    _bufferLength = 0;
    _bufferSize = 0;
    _height = 0;
    _width = 0;
    _renderTimeMs = 0;

    if(_buffer)
    {
        delete [] _buffer;
        _buffer = NULL;
    }
}


/* This class holds up to 60 ms of super-wideband (32 kHz) stereo audio. It
 * allows for adding and subtracting frames while keeping track of the resulting
 * states.
 *
 * Notes
 * - The total number of samples in |data_| is
 *   samples_per_channel_ * num_channels_
 *
 * - Stereo data is interleaved starting with the left channel.
 *
 * - The +operator assume that you would never add exactly opposite frames when
 *   deciding the resulting state. To do this use the -operator.
 */
class AudioFrame
{
public:
    // Stereo, 32 kHz, 60 ms (2 * 32 * 60)
    static const int kMaxDataSizeSamples = 3840;

    enum VADActivity
    {
        kVadActive  = 0,
        kVadPassive = 1,
        kVadUnknown = 2
    };
    enum SpeechType
    {
        kNormalSpeech = 0,
        kPLC          = 1,
        kCNG          = 2,
        kPLCCNG       = 3,
        kUndefined    = 4
    };

    AudioFrame();
    virtual ~AudioFrame();

    void UpdateFrame(
        int id,
        uint32_t timestamp,
        const int16_t* data,
        int samples_per_channel,
        int sample_rate_hz,
        SpeechType speech_type,
        VADActivity vad_activity,
        int num_channels = 1,
        uint32_t energy = -1);

    AudioFrame& Append(const AudioFrame& rhs);

    void CopyFrom(const AudioFrame& src);

    void Mute();

    AudioFrame& operator>>=(const int rhs);
    AudioFrame& operator+=(const AudioFrame& rhs);
    AudioFrame& operator-=(const AudioFrame& rhs);

    int id_;
    uint32_t timestamp_;
    int16_t data_[kMaxDataSizeSamples];
    int samples_per_channel_;
    int sample_rate_hz_;
    int num_channels_;
    SpeechType speech_type_;
    VADActivity vad_activity_;
    uint32_t energy_;

private:
    DISALLOW_COPY_AND_ASSIGN(AudioFrame);
};

inline
AudioFrame::AudioFrame()
    :
    id_(-1),
    timestamp_(0),
    data_(),
    samples_per_channel_(0),
    sample_rate_hz_(0),
    num_channels_(1),
    speech_type_(kUndefined),
    vad_activity_(kVadUnknown),
    energy_(0xffffffff)
{
}

inline
AudioFrame::~AudioFrame()
{
}

inline
void
AudioFrame::UpdateFrame(
    int id,
    uint32_t timestamp,
    const int16_t* data,
    int samples_per_channel,
    int sample_rate_hz,
    SpeechType speech_type,
    VADActivity vad_activity,
    int num_channels,
    uint32_t energy)
{
    id_            = id;
    timestamp_     = timestamp;
    samples_per_channel_ = samples_per_channel;
    sample_rate_hz_ = sample_rate_hz;
    speech_type_    = speech_type;
    vad_activity_   = vad_activity;
    num_channels_  = num_channels;
    energy_        = energy;

    const int length = samples_per_channel * num_channels;
    assert(length <= kMaxDataSizeSamples && length >= 0);
    if(data != NULL)
    {
        memcpy(data_, data, sizeof(int16_t) * length);
    }
    else
    {
        memset(data_, 0, sizeof(int16_t) * length);
    }
}

inline void AudioFrame::CopyFrom(const AudioFrame& src)
{
    if(this == &src)
    {
        return;
    }
    id_               = src.id_;
    timestamp_        = src.timestamp_;
    samples_per_channel_ = src.samples_per_channel_;
    sample_rate_hz_    = src.sample_rate_hz_;
    speech_type_       = src.speech_type_;
    vad_activity_      = src.vad_activity_;
    num_channels_     = src.num_channels_;
    energy_           = src.energy_;

    const int length = samples_per_channel_ * num_channels_;
    assert(length <= kMaxDataSizeSamples && length >= 0);
    memcpy(data_, src.data_, sizeof(int16_t) * length);
}

inline
void
AudioFrame::Mute()
{
  memset(data_, 0, samples_per_channel_ * num_channels_ * sizeof(int16_t));
}

inline
AudioFrame&
AudioFrame::operator>>=(const int rhs)
{
    assert((num_channels_ > 0) && (num_channels_ < 3));
    if((num_channels_ > 2) ||
        (num_channels_ < 1))
    {
        return *this;
    }
    for(int i = 0; i < samples_per_channel_ * num_channels_; i++)
    {
        data_[i] = static_cast<int16_t>(data_[i] >> rhs);
    }
    return *this;
}

inline
AudioFrame&
AudioFrame::Append(const AudioFrame& rhs)
{
    // Sanity check
    assert((num_channels_ > 0) && (num_channels_ < 3));
    if((num_channels_ > 2) ||
        (num_channels_ < 1))
    {
        return *this;
    }
    if(num_channels_ != rhs.num_channels_)
    {
        return *this;
    }
    if((vad_activity_ == kVadActive) ||
        rhs.vad_activity_ == kVadActive)
    {
        vad_activity_ = kVadActive;
    }
    else if((vad_activity_ == kVadUnknown) ||
        rhs.vad_activity_ == kVadUnknown)
    {
        vad_activity_ = kVadUnknown;
    }
    if(speech_type_ != rhs.speech_type_)
    {
        speech_type_ = kUndefined;
    }

    int offset = samples_per_channel_ * num_channels_;
    for(int i = 0;
        i < rhs.samples_per_channel_ * rhs.num_channels_;
        i++)
    {
        data_[offset+i] = rhs.data_[i];
    }
    samples_per_channel_ += rhs.samples_per_channel_;
    return *this;
}

// merge vectors
inline
AudioFrame&
AudioFrame::operator+=(const AudioFrame& rhs)
{
    // Sanity check
    assert((num_channels_ > 0) && (num_channels_ < 3));
    if((num_channels_ > 2) ||
        (num_channels_ < 1))
    {
        return *this;
    }
    if(num_channels_ != rhs.num_channels_)
    {
        return *this;
    }
    bool noPrevData = false;
    if(samples_per_channel_ != rhs.samples_per_channel_)
    {
        if(samples_per_channel_ == 0)
        {
            // special case we have no data to start with
            samples_per_channel_ = rhs.samples_per_channel_;
            noPrevData = true;
        } else
        {
          return *this;
        }
    }

    if((vad_activity_ == kVadActive) ||
        rhs.vad_activity_ == kVadActive)
    {
        vad_activity_ = kVadActive;
    }
    else if((vad_activity_ == kVadUnknown) ||
        rhs.vad_activity_ == kVadUnknown)
    {
        vad_activity_ = kVadUnknown;
    }

    if(speech_type_ != rhs.speech_type_)
    {
        speech_type_ = kUndefined;
    }

    if(noPrevData)
    {
        memcpy(data_, rhs.data_,
          sizeof(int16_t) * rhs.samples_per_channel_ * num_channels_);
    } else
    {
      // IMPROVEMENT this can be done very fast in assembly
      for(int i = 0; i < samples_per_channel_ * num_channels_; i++)
      {
          int32_t wrapGuard = static_cast<int32_t>(data_[i]) +
              static_cast<int32_t>(rhs.data_[i]);
          if(wrapGuard < -32768)
          {
              data_[i] = -32768;
          }else if(wrapGuard > 32767)
          {
              data_[i] = 32767;
          }else
          {
              data_[i] = (int16_t)wrapGuard;
          }
      }
    }
    energy_ = 0xffffffff;
    return *this;
}

inline
AudioFrame&
AudioFrame::operator-=(const AudioFrame& rhs)
{
    // Sanity check
    assert((num_channels_ > 0) && (num_channels_ < 3));
    if((num_channels_ > 2)||
        (num_channels_ < 1))
    {
        return *this;
    }
    if((samples_per_channel_ != rhs.samples_per_channel_) ||
        (num_channels_ != rhs.num_channels_))
    {
        return *this;
    }
    if((vad_activity_ != kVadPassive) ||
        rhs.vad_activity_ != kVadPassive)
    {
        vad_activity_ = kVadUnknown;
    }
    speech_type_ = kUndefined;

    for(int i = 0; i < samples_per_channel_ * num_channels_; i++)
    {
        int32_t wrapGuard = static_cast<int32_t>(data_[i]) -
            static_cast<int32_t>(rhs.data_[i]);
        if(wrapGuard < -32768)
        {
            data_[i] = -32768;
        }
        else if(wrapGuard > 32767)
        {
            data_[i] = 32767;
        }
        else
        {
            data_[i] = (int16_t)wrapGuard;
        }
    }
    energy_ = 0xffffffff;
    return *this;
}

inline bool IsNewerSequenceNumber(uint16_t sequence_number,
                                  uint16_t prev_sequence_number) {
  return sequence_number != prev_sequence_number &&
      static_cast<uint16_t>(sequence_number - prev_sequence_number) < 0x8000;
}

inline bool IsNewerTimestamp(uint32_t timestamp, uint32_t prev_timestamp) {
  return timestamp != prev_timestamp &&
      static_cast<uint32_t>(timestamp - prev_timestamp) < 0x80000000;
}

inline uint16_t LatestSequenceNumber(uint16_t sequence_number1,
                                     uint16_t sequence_number2) {
  return IsNewerSequenceNumber(sequence_number1, sequence_number2) ?
      sequence_number1 : sequence_number2;
}

inline uint32_t LatestTimestamp(uint32_t timestamp1, uint32_t timestamp2) {
  return IsNewerTimestamp(timestamp1, timestamp2) ? timestamp1 :
      timestamp2;
}

}  // namespace webrtc

#endif // MODULE_COMMON_TYPES_H