StreamBufferLayer.cpp

#include "Headers.h"
#include "StreamBufferLayer.h"

CStreamBufferLayer::CStreamBufferLayer(
    __uint32    size,
    __uint32    sizeHistory
    )
{
    assert(size);
    assert(sizeHistory < size);

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

    this->buffer = new CStreamFrame[this->size];
    this->bitmap = new bool[this->size];
    this->coder = new bool[this->size];

    this->currentIndex = 0;

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

CStreamBufferLayer::~CStreamBufferLayer()
{
    delete[] this->buffer;
    delete[] this->bitmap;
    delete[] this->coder;
}

void CStreamBufferLayer::Reset(__uint32 index)
{
    // Resets the buffer starting from the frame
    this->ptrLast = 0;
    this->ptrFirst = this->sizeHistory;
    this->currentIndex = index;
    
    this->count = 0;
    this->numHistory = 0;
    this->numPlay = 0;

    // Clear the buffer
    for(__uint32 idx = 0; idx < this->size; idx++)
    {
        this->bitmap[idx] = 0;
        this->coder[idx] = 0;
    }
}

bool CStreamBufferLayer::Add(CStreamFrame frame, __uint32 layerIndex)
{
    // Add the frame if it fits in the buffer
    if((layerIndex > ((this->currentIndex >= this->sizeHistory)?this->currentIndex - this->sizeHistory:0)) && (layerIndex <= this->currentIndex + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + layerIndex - this->currentIndex) % this->size;

        // Increase number of frames by 1, if previously the slot was empty
        this->count += (this->bitmap[idx]?0:1);
        // Increase number of play frames by 1, if frame in the play region and previously the slot was empty
        this->numPlay += ((layerIndex >= this->currentIndex)?(this->bitmap[idx]?0:1):0);
        // Increase number of history frames by 1, if frame in the history region and previously the slot was empty
        this->numHistory += ((layerIndex < this->currentIndex)?(this->bitmap[idx]?0:1):0);

        // Save the frame
        this->buffer[idx] = frame;

        // Mark the frame in the bitmap
        this->bitmap[idx] = 1;

        // Set coder to true if the frame is independent
        this->coder[idx] = (frame.AnchorP() == 0) && (frame.AnchorB() == 0);

        assert(this->count <= this->size);

        return true;
    }
    return false;
}

void CStreamBufferLayer::Shift()
{
    // Update the number of frames
    this->numPlay -= (this->bitmap[this->ptrFirst]?1:0);
    this->numHistory += (this->bitmap[this->ptrFirst]?1:0);

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

    // Increment the current frame
    this->currentIndex++;

    // Update the number of frames
    this->count -= (this->bitmap[this->ptrLast]?1:0);
    this->numHistory -= (this->bitmap[this->ptrLast]?1:0);

    // Clear the last entry
    this->bitmap[this->ptrLast] = 0;
    this->coder[this->ptrLast] = 0;
}

bool CStreamBufferLayer::Has(__uint32 index)
{
    if((index > ((this->currentIndex >= this->sizeHistory)?this->currentIndex - this->sizeHistory:0)) && (index <= this->currentIndex + this->sizePlay))
    {
        return this->bitmap[(this->size + this->ptrFirst + index - this->currentIndex) % this->size];
    }
    else return false;
}

CStreamFrame* CStreamBufferLayer::Frame(__uint32 index)
{
    if((index > ((this->currentIndex >= this->sizeHistory)?this->currentIndex - this->sizeHistory:0)) && (index <= this->currentIndex + this->sizePlay))
    {
        return (this->bitmap[(this->size + this->ptrFirst + index - this->currentIndex) % this->size]?
            &this->buffer[(this->size + this->ptrFirst + index - this->currentIndex) % this->size]:NULL);
    }
    else return NULL;
}

bool CStreamBufferLayer::IsCurrentDecodable()
{
    return this->coder[this->ptrFirst];
}

bool CStreamBufferLayer::IsDecodable(__uint32 index)
{
    if((index > ((this->currentIndex >= this->sizeHistory)?this->currentIndex - this->sizeHistory:0)) && (index <= this->currentIndex + this->sizePlay))
    {
        return this->coder[(this->size + this->ptrFirst + index - this->currentIndex) % this->size];
    }
    else return false;
}

void CStreamBufferLayer::SetCurrentDecodable()
{
    this->coder[this->ptrFirst] = true;
}

void CStreamBufferLayer::SetDecodable(__uint32 index)
{
    assert((index > ((this->currentIndex >= this->sizeHistory)?this->currentIndex - this->sizeHistory:0)) && (index <= this->currentIndex + this->sizePlay));
    assert(this->bitmap[(this->size + this->ptrFirst + index - this->currentIndex) % this->size]);

    this->coder[(this->size + this->ptrFirst + index - this->currentIndex) % this->size] = true;
}