source: trunk/FrameBuffer.c @ 1472

/*
 * FrameBuffer.c
 * Created by Graham Booker on 1/30/07.
 *
 * This file is part of Perian.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <libavcodec/avcodec.h>
#include <sys/param.h>

#include "FrameBuffer.h"
#include "CommonUtils.h"

void FFusionDataSetup(FFusionData *data, int dataSize, int bufferSize)
{
        memset(data, 0, sizeof(FFusionData));
        int framesSize = sizeof(FrameData) * dataSize;
        data->frames = malloc(framesSize);
        memset(data->frames, 0, framesSize);
        
        int i;
        for(i=0; i<dataSize; i++)
        {
                FrameData *fdata = data->frames + i;
                fdata->buffer = NULL;
                fdata->data = data;
        }
        data->frameSize = dataSize;

        data->ringBuffer = av_malloc(bufferSize);
        data->ringSize = bufferSize;
}

void FFusionDataFree(FFusionData *data)
{
        free(data->frames);
        if(data->previousData != NULL)
        {
                FFusionDataFree(data->previousData);
                free(data->previousData);
        }
        av_free(data->ringBuffer);
}

//Expands both the frame array and the ring buffer.
//Old data is kept in the previousData pointer to be dealloced when done
static void expansion(FFusionData *data, int dataSize)
{
        //Create the prev structure to hold all existing frames
        FFusionData *prev = malloc(sizeof(FFusionData));
        //Move all frames to prev
        memcpy(prev, data, sizeof(FFusionData));
        int i;
        for(i=0; i<data->frameSize; i++)
                data->frames[i].data = prev;
        
        //Create new data
        int newRingSize = MAX(dataSize * 10, data->ringSize * 2);
        FFusionDataSetup(data, data->frameSize * 2, newRingSize);
        //Preserve pointer to old data
        data->previousData = prev;
}

uint8_t *FFusionCreateEntireDataBuffer(FFusionData *data, uint8_t *buffer, int bufferSize)
{
        data->ringBuffer = fast_realloc_with_padding(data->ringBuffer, &data->ringSize, bufferSize);
        if (data->ringBuffer) {
                memcpy(data->ringBuffer, buffer, bufferSize);
        }
        return data->ringBuffer;
}

//Find dataSize bytes in ringbuffer, expand if none available
static uint8_t *createBuffer(FFusionData *data, int dataSize)
{
        if(data->ringWrite >= data->ringRead)
        {
                //Write is after read
                if(data->ringWrite + dataSize + FF_INPUT_BUFFER_PADDING_SIZE < data->ringSize)
                {
                        //Found at end
                        int offset = data->ringWrite;
                        data->ringWrite = offset + dataSize;
                        return data->ringBuffer + offset;
                }
                else
                        //Can't fit at end, loop
                        data->ringWrite = 0;
        }
        if(data->ringWrite + dataSize + FF_INPUT_BUFFER_PADDING_SIZE < data->ringRead)
        {
                //Found at write
                int offset = data->ringWrite;
                data->ringWrite = offset + dataSize;
                return data->ringBuffer + offset;
        }
        else
        {
                expansion(data, dataSize);
                data->ringWrite = dataSize;
                return data->ringBuffer;
        }
}

//Insert buffer into ring buffer
static uint8_t *insertIntoBuffer(FFusionData *data, uint8_t *buffer, int dataSize)
{
        uint8_t *ret = createBuffer(data, dataSize);
        memcpy(ret, buffer, dataSize);
        memset(ret + dataSize, 0, FF_INPUT_BUFFER_PADDING_SIZE);
        return ret;
}

FrameData *FFusionDataAppend(FFusionData *data, uint8_t *buffer, int dataSize, int type)
{
        //Find an available frame
        if((data->frameWrite + 1) % data->frameSize == data->frameRead)
        {
                expansion(data, dataSize);
        }
        
        FrameData *dest = data->frames + data->frameWrite;
        
        if(data->unparsedFrames.buffer == buffer)
        {               
                //This was an unparsed frame, don't memcpy; it's already in the correct place.
                dest->buffer = buffer;
                data->unparsedFrames.buffer += dataSize;
                data->unparsedFrames.dataSize -= dataSize;
        }
        else
        {
                uint8_t *saveBuffer = insertIntoBuffer(data, buffer, dataSize);
                dest->buffer = saveBuffer;
        }
        dest->dataSize = dataSize;
        dest->type = type;
        dest->prereqFrame = NULL;
        dest->decoded = FALSE;
        dest->nextFrame = NULL;
        
        data->frameWrite = (data->frameWrite + 1) % data->frameSize;
        return dest;
}

void FFusionDataSetUnparsed(FFusionData *data, uint8_t *buffer, int bufferSize)
{
        FrameData *unparsed = &(data->unparsedFrames);
        
        if(unparsed->buffer == buffer)
        {
                //This part was already unparsed; don't memcpy again
                unparsed->dataSize = bufferSize;
        }
        else
        {
                unparsed->buffer = insertIntoBuffer(data, buffer, bufferSize);
                if (unparsed->buffer) {
                        unparsed->dataSize = bufferSize;
                }               
        }
}

//Seems to be unused
void FFusionDataReadUnparsed(FFusionData *data)
{
        data->ringWrite -= data->unparsedFrames.dataSize;
        data->unparsedFrames.dataSize = 0;
}

FrameData *FrameDataCheckPrereq(FrameData * toData)
{
        FrameData *prereq = toData->prereqFrame;
        if(prereq && prereq->decoded)
                return NULL;
        return prereq;
}

void FFusionDataMarkRead(FrameData *toData)
{
        if(toData == NULL)
                return;
        
        if(toData->prereqFrame != NULL)
                return;
        
        FFusionData *data = toData->data;
        data->frameRead = toData - data->frames + 1;
        data->ringRead = toData->buffer + toData->dataSize - data->ringBuffer;
        if(data->previousData != NULL)
        {
                //If there's previous data, free it since we are now done with it
                FFusionDataFree(data->previousData);
                free(data->previousData);
                data->previousData = NULL;
        }
}

FrameData *FFusionDataFind(FFusionData *data, int frameNumber)
{
        int i;
        for(i=data->frameRead; i!=data->frameWrite; i = (i + 1) % data->frameSize)
        {
                if(data->frames[i].frameNumber == frameNumber)
                        return data->frames + i;
        }
        if(data->previousData != NULL)
                //Check previous data as well
                return FFusionDataFind(data->previousData, frameNumber);
        
        return NULL;
}