StreamBufferMulti.cpp

#include "Headers.h"
#include "StreamBufferMulti.h"

CStreamBufferMulti::CStreamBufferMulti(
    __uint32    numLayers,
    __uint32    size,
    __uint32    sizeHistory,
    __byte          sizeGop
    )
{
    assert(numLayers);
    assert(size);
    assert(sizeHistory < size);

    this->numLayers = numLayers;
    this->size = size;
    this->sizeHistory = sizeHistory;
    this->sizePlay = this->size - this->sizeHistory;
    this->sizeGop = sizeGop;
    this->sizeGopLayer = this->sizeGop * this->numLayers;

    // Create layer buffers
    this->buffers = new CStreamBufferLayer*[this->numLayers];
    for(__uint32 index = 0; index < this->numLayers; index++)
    {
        this->buffers[index] = new CStreamBufferLayer(
            this->size,
            this->sizeHistory
            );
    }
}

CStreamBufferMulti::~CStreamBufferMulti()
{
    for(__uint32 index = 0; index < this->numLayers; index++)
        delete this->buffers[index];
    delete[] this->buffers;
}

void CStreamBufferMulti::Reset(__uint32 index)
{
    // Calculate the base frame for the current layer
    __uint32 layer = this->IndexToLayer(index);
    __uint32 layerBaseIndex = this->IndexToLayerBaseIndex(index);

    // Reset the layer corresponding to the index
    this->buffers[layer]->Reset(this->IndexToLayerIndex(index));

    // Reset all other layers for subsequent frames
    for(__uint32 idx = 1; idx < this->numLayers; idx++)
    {
        // Calculate the next layer
        __uint32 nextLayer = (layer + idx) % this->numLayers;

        // Calculate the next base frame for that layer
        __uint32 baseIndex = layerBaseIndex + idx*this->sizeGop;

        // Reset the layer buffer to the base index
        this->buffers[nextLayer]->Reset(this->IndexToLayerIndex(baseIndex));
    }

    // Set the frame index
    this->currentIndex = index;
}

bool CStreamBufferMulti::Add(__uint32 layer, CStreamFrame frame)
{
    // Add the frame to the buffer layer
    assert(layer == this->IndexToLayer(frame.Index()));
    return this->buffers[layer]->Add(frame, this->IndexToLayerIndex(frame.Index()));
}

void CStreamBufferMulti::Shift()
{
    // Shift the layer buffer of the current index
    assert(this->IndexToLayer(this->currentIndex) < this->numLayers);
    this->buffers[this->IndexToLayer(this->currentIndex)]->Shift();

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

bool CStreamBufferMulti::Has(__uint32 index)
{
    assert(this->IndexToLayer(index) < this->numLayers);
    return this->buffers[this->IndexToLayer(index)]->Has(IndexToLayerIndex(index));
}

bool CStreamBufferMulti::HasCurrentIndex()
{
    assert(this->IndexToLayer(this->currentIndex) < this->numLayers);
    return this->buffers[this->IndexToLayer(this->currentIndex)]->HasCurrentIndex();
}

CStreamFrame* CStreamBufferMulti::CurrentFrame()
{
    assert(this->IndexToLayer(this->currentIndex) < this->numLayers);
    assert(this->buffers[this->IndexToLayer(this->currentIndex)]->CurrentFrame()->Index() == this->currentIndex);
    return this->buffers[this->IndexToLayer(this->currentIndex)]->CurrentFrame();
}

bool CStreamBufferMulti::IsCurrentDecodable()
{
    assert(this->IndexToLayer(this->currentIndex) < this->numLayers);

    // If the frame does not exist, return false
    if(!this->buffers[this->IndexToLayer(this->currentIndex)]->HasCurrentIndex()) return false;

    // If the frame is already decoded, return true
    if(this->buffers[this->IndexToLayer(this->currentIndex)]->IsCurrentDecodable()) return true;

    // Else, try to decode it
    CStreamFrame* frame = this->buffers[this->IndexToLayer(this->currentIndex)]->CurrentFrame();
    assert((frame->AnchorB() != 0) || (frame->AnchorP() != 0));
    assert(frame->Index() == this->currentIndex);

    if((frame->AnchorP()?this->IsDecodable(frame->Index() + frame->AnchorP()):true) &&
        (frame->AnchorB()?this->IsDecodable(frame->Index() + frame->AnchorB()):true))
    {
        this->buffers[this->IndexToLayer(this->currentIndex)]->SetCurrentDecodable();
        return true;
    }
    return false;
}

bool CStreamBufferMulti::IsDecodable(__uint32 index)
{
    assert(this->IndexToLayer(index) < this->numLayers);

    // If the frame does not exist, return false
    if(!this->buffers[this->IndexToLayer(index)]->Has(this->IndexToLayerIndex(index))) return false;

    // If the frame is already decoded, return true
    if(this->buffers[this->IndexToLayer(index)]->IsDecodable(this->IndexToLayerIndex(index))) return true;

    // Else, try to decode it
    CStreamFrame* frame = this->buffers[this->IndexToLayer(index)]->Frame(this->IndexToLayerIndex(index));
    assert(frame);
    assert((frame->AnchorP() != 0) || (frame->AnchorB() != 0));

    if((frame->AnchorP()?this->IsDecodable(frame->Index() + frame->AnchorP()):true) &&
        (frame->AnchorB()?this->IsDecodable(frame->Index() + frame->AnchorB()):true))
    {
        this->buffers[this->IndexToLayer(index)]->SetDecodable(this->IndexToLayerIndex(index));
        return true;
    }
    return false;
}

bool CStreamBufferMulti::IsCurrentIndependent()
{
    assert(this->IndexToLayer(this->currentIndex) < this->numLayers);
    return this->buffers[this->IndexToLayer(this->currentIndex)]->IsCurrentIndependent();
}

void CStreamBufferMulti::Log()
{
    printf("\n\tBuffer @ %u", this->currentIndex);
    for(__uint32 index = 0; index < numLayers; index++)
    {
        printf("\n\t\t%u @ %u [%u]", index, this->buffers[index]->CurrentIndex(), this->LayerIndexToIndex(this->buffers[index]->CurrentIndex(), index));
    }
}