StreamBuffer.cpp

#include "Headers.h"
#include "StreamBuffer.h"

CStreamBuffer::CStreamBuffer(
    __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;
}

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

void CStreamBuffer::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 CStreamBuffer::Add(CStreamFrame frame)
{
    // Add the frame if it fits in the buffer
    if((frame.Index() > ((this->currentIndex >= this->sizeHistory)?(this->currentIndex - this->sizeHistory):0)) && (frame.Index() <= this->currentIndex + this->sizePlay))
    {
        __uint32 idx = (this->size + this->ptrFirst + frame.Index() - this->currentIndex) % this->size;

        // If the slot is empty
        if(0 == this->bitmap[idx])
        {
            // Increase number of frames by 1
            this->count++;
            // Increase number of play frames by 1, if frame in the play region
            this->numPlay += ((frame.Index() >= this->currentIndex)?1:0);
            // Increase number of history frames by 1, if frame in the history region
            this->numHistory += ((frame.Index() < this->currentIndex)?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 anchor frames can be decoded (can decode I and P frames)
            this->coder[idx] =
                (frame.AnchorP()?this->coder[(this->size + idx + frame.AnchorP()) % this->size]:1) &&
                (frame.AnchorB()?this->coder[(this->size + idx + frame.AnchorB()) % this->size]:1);

/*
        Do not perform these checks to increase simulation speed
            (frame.anchorB >= -this->sizeHistory) &&
            (frame.anchorB < this->sizePlay) &&
            (frame.anchorP >= -this->sizeHistory) &&
            (frame.anchorP < this->sizePlay) &&
*/

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

            return true;
        }
        else return false;
    }
    else return false;
}

void CStreamBuffer::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 CStreamBuffer::Has(__uint32 index)
{
    if((index >= this->currentIndex - this->sizeHistory) && (index < this->currentIndex + this->sizePlay))
    {
        return this->bitmap[(this->size + this->ptrFirst + index - this->currentIndex) % this->size];
    }
    else return false;
}

bool CStreamBuffer::IsCurrentDecodable()
{
    // If the frame is already decoded, return true
    if(this->coder[this->ptrFirst]) { assert(this->bitmap[this->ptrFirst]); return true; }

    // Else, if the current frame does not exist, return false
    if(0 == this->bitmap[this->ptrFirst]) { return false; }

    // Else, verify if the anchor frame exist and are decoded
    this->coder[this->ptrFirst] =
        (this->buffer[this->ptrFirst].AnchorP()?this->coder[(this->size + this->ptrFirst + this->buffer[this->ptrFirst].AnchorP()) % this->size]:1) &&
        (this->buffer[this->ptrFirst].AnchorB()?this->coder[(this->size + this->ptrFirst + this->buffer[this->ptrFirst].AnchorB()) % this->size]:1);

    return this->coder[this->ptrFirst];
}