StreamBufferSegment.cpp

#include "Headers.h"
#include "StreamBufferSegment.h"

CStreamBufferSegment::CStreamBufferSegment(
    __uint32    size,
    __uint32    sizeHistory,
    __uint32    sizeSegment
    )
{
    assert(size);
    assert(sizeHistory < size);

    this->size = size;
    this->sizeHistory = sizeHistory;
    this->sizePlay = this->size - this->sizeHistory;
    this->sizeSegment = sizeSegment;

    this->buffer = new CStreamSegment*[this->size];
    for(__uint32 index = 0; index < this->size; index++)
    {
        this->buffer[index] = new CStreamSegment(this->sizeSegment);
    }

    this->currentIndexSegment = 0;
    this->currentIndexFrame = 0;

    this->ptrFirst = 0;
    this->ptrLast = 0;

    this->stream = 0xFFFFFFFF;
}

CStreamBufferSegment::~CStreamBufferSegment()
{
    // Clean the buffer
    for(__uint32 index = 0; index < this->size; index++)
        delete this->buffer[index];
    delete[] this->buffer;
}

void CStreamBufferSegment::Reset(__uint32 stream, __uint32 indexSegment)
{
    // Resets the buffer starting from the specified segment and adds the segment on the first position
    this->ptrLast = this->size - 1;
    this->ptrFirst = this->sizeHistory;

    this->currentIndexSegment = indexSegment;   // Segment index
    this->currentIndexFrame = 0;                // Frame index within the segment

    this->stream = stream;

    // Reset the buffer segments

    // Reset the buffer segments
    for(__uint32 index = (indexSegment < this->sizeHistory)?(this->sizeHistory - indexSegment):0; index < this->size; index++)
        this->buffer[index]->Reset(this->stream, indexSegment + index - this->sizeHistory);
}

bool CStreamBufferSegment::Add(CStreamFrame frame)
{
    if(frame.Stream() != this->stream) return false;

    // Add the segment if it fits in the buffer
    if((frame.Segment() >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (frame.Segment() < this->currentIndexSegment + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + frame.Segment() - this->currentIndexSegment) % this->size;

        // Check the segment
        assert(this->buffer[idx]->Stream() == this->stream);
        assert(this->buffer[idx]->Index() == frame.Segment());

        // Add the frame to the segment
        this->buffer[idx]->Add(frame);

        return true;
    }
    else return false;
}

void CStreamBufferSegment::ShiftFrame()
{
    // Shift the frame
    this->currentIndexFrame = (this->currentIndexFrame + 1) % this->sizeSegment;

    // If current frame moved to next segment, shift the segment
    if(0 == this->currentIndexFrame) this->ShiftSegment();
}

void CStreamBufferSegment::ShiftSegment()
{
    // Shift both the first and last pointers
    this->ptrFirst = (this->ptrFirst + 1) % this->size;
    this->ptrLast = (this->ptrLast + 1) % this->size;

    // Increment the current segment
    this->currentIndexSegment++;

    // Calculate the index of the last segment
    __uint32 index = this->currentIndexSegment + ((this->ptrLast + this->size - this->ptrFirst) % this->size);

    // Reset the last segment
    this->buffer[this->ptrLast]->Reset(this->stream, index);
}

bool CStreamBufferSegment::HasSegment(__uint32 index)
{
    return ((index >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (index < this->currentIndexSegment + this->sizePlay));
}

bool CStreamBufferSegment::IsSegmentReceiving(__uint32 index)
{
    if((index >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (index < this->currentIndexSegment + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + index - this->currentIndexSegment) % this->size;
        return this->buffer[idx]->IsReceiving();
    }
    else return false;
}

bool CStreamBufferSegment::IsSegmentComplete(__uint32 index)
{
    if((index >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (index < this->currentIndexSegment + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + index - this->currentIndexSegment) % this->size;
        return this->buffer[idx]->IsComplete();
    }
    else return false;
}

CStreamSegment* CStreamBufferSegment::GetSegment(__uint32 index)
{
    assert((index >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (index < this->currentIndexSegment + this->sizePlay));

    __uint32 idx = (this->size + this->ptrFirst + index - this->currentIndexSegment) % this->size;
    return this->buffer[idx];
}


void CStreamBufferSegment::SegmentReceiving(__uint32 index, bool receiving)
{
    if((index >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (index < this->currentIndexSegment + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + index - this->currentIndexSegment) % this->size;
        this->buffer[idx]->Receiving(receiving);
    }
}

bool CStreamBufferSegment::HasFrame(__uint32 index)
{
    __uint32 indexSegment = index / this->sizeSegment;
    
    if((indexSegment >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (indexSegment < this->currentIndexSegment + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + indexSegment - this->currentIndexSegment) % this->size;
        __uint32 indexFrame = index % this->sizeSegment;

        if(this->buffer[idx] != NULL) return (*this->buffer[idx])[indexFrame].Valid();
        else return false;
    }
    else return false;
}

bool CStreamBufferSegment::HasCurrentFrame()
{
    return (*this->buffer[this->ptrFirst])[this->currentIndexFrame].Valid();
}

CStreamFrame CStreamBufferSegment::CurrentFrame()
{
    return (*this->buffer[this->ptrFirst])[this->currentIndexFrame];
}

bool CStreamBufferSegment::IsCurrentFrameDecodable()
{
    if(this->buffer[this->ptrFirst] != NULL)
    {
        CStreamFrame* frame = &(*this->buffer[this->ptrFirst])[this->currentIndexFrame];

        if(frame->Valid())
        {
            return
                (frame->AnchorP()?this->IsFrameDecodable(frame->Index() + frame->AnchorP()):1) &&
                (frame->AnchorB()?this->IsFrameDecodable(frame->Index() + frame->AnchorB()):1);
        }
        else return false;
    }
    else return false;
}

bool CStreamBufferSegment::IsFrameDecodable(__uint32 index)
{
    __uint32 indexSegment = index / this->sizeSegment;
    
    if((indexSegment >= ((this->currentIndexSegment > this->sizeHistory)?(this->currentIndexSegment - this->sizeHistory):0)) &&
        (indexSegment < this->currentIndexSegment + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + indexSegment - this->currentIndexSegment) % this->size;

        if(this->buffer[idx] != NULL)
        {
            __uint32 indexFrame = index % this->sizeSegment;
            CStreamFrame* frame = &(*this->buffer[idx])[indexFrame];

            if(frame->Valid())
            {
                return
                    (frame->AnchorP()?this->IsFrameDecodable(frame->Index() + frame->AnchorP()):1) &&
                    (frame->AnchorB()?this->IsFrameDecodable(frame->Index() + frame->AnchorB()):1);
            }
            else return false;
        }
        else return false;
    }
    else return false;
}