/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - Initial contribution
*
* Contributors:
* Ixonos Plc
*
* Description:
*
*/


#include <string.h>
#include "globals.h"
#include "framebuffer.h"

/*
 * Static functions
 */

static void *allocMem(int blkSize, size_t unitSize);

static frmBuf_s *initRefFrame(frmBuf_s *recoBuf, frmBuf_s *refBuf);



/*
 *
 * allocMem:
 *
 * Parameters:
 *      blkSize               Block size
 *      unitSize              unit size
 *
 * Function:
 *      Allocate blkSize*unitSize bytes of memory
 *
 * Returns:
 *      Pointer to allocated memory or NULL
 *
 */
static void *allocMem(int blkSize, size_t unitSize)
{
  void *mem;

  if ((mem = User::Alloc(blkSize*unitSize)) == NULL) {
    PRINT((_L("Cannot allocate memory for frame\n")));     
  }

  return mem;
}


/*
 *
 * frmOpen:
 *
 * Parameters:
 *      mbData                Macroblock state buffer
 *      width                 Width of the frame
 *      height                Height of the frame
 *
 * Function:
 *      Allocate memory for frame buffer and macroblock state buffer.
 *
 * Returns:
 *      Pointer to allocated frame buffer or NULL
 *
 */
frmBuf_s *frmOpen(mbAttributes_s **mbData, int width, int height)
{
//  int numPels = width*height;
  int numBlksPerLine = width/BLK_SIZE;
  int numBlocks = numBlksPerLine*height/BLK_SIZE;
  int numMacroblocks = width/MBK_SIZE*height/MBK_SIZE;
  frmBuf_s *recoBuf;
  mbAttributes_s *mbDataTmp;

  if ((recoBuf = (frmBuf_s *)User::Alloc(sizeof(frmBuf_s))) == NULL)
    return NULL;

  memset(recoBuf, 0, sizeof(frmBuf_s));

  recoBuf->width = width;
  recoBuf->height = height;

  if ((mbDataTmp = (mbAttributes_s *)User::Alloc(sizeof(mbAttributes_s))) == NULL)
    return NULL;

  memset(mbDataTmp, 0, sizeof(mbAttributes_s));

  if ((mbDataTmp->sliceMap = (int *)allocMem(numMacroblocks, sizeof(int))) == NULL)
    return NULL;
  if ((mbDataTmp->mbTypeTable = (int8 *)allocMem(numMacroblocks, sizeof(int8))) == NULL)
    return NULL;
  if ((mbDataTmp->qpTable = (int8 *)allocMem(numMacroblocks, sizeof(int8))) == NULL)
    return NULL;
  if ((mbDataTmp->refIdxTable = (int8 *)allocMem(numBlocks, sizeof(int8))) == NULL)
    return NULL;
  if ((mbDataTmp->cbpTable = (int *)allocMem(numMacroblocks, sizeof(int))) == NULL)
    return NULL;
  if ((mbDataTmp->motVecTable = (motVec_s *)allocMem(numBlocks, sizeof(motVec_s))) == NULL)
    return NULL;
  if ((mbDataTmp->ipModesUpPred = (int8 *)allocMem(numBlksPerLine, sizeof(int8))) == NULL)
    return NULL;

  if ((mbDataTmp->numCoefUpPred[0] = (int8 *)allocMem(numBlksPerLine, sizeof(int8))) == NULL)
    return NULL;
  if ((mbDataTmp->numCoefUpPred[1] = (int8 *)allocMem(numBlksPerLine/2, sizeof(int8))) == NULL)
    return NULL;
  if ((mbDataTmp->numCoefUpPred[2] = (int8 *)allocMem(numBlksPerLine/2, sizeof(int8))) == NULL)
    return NULL;

  if ((mbDataTmp->filterModeTab = (int8 *)allocMem(numMacroblocks, sizeof(int8))) == NULL)
    return NULL;
  if ((mbDataTmp->alphaOffset = (int8 *)allocMem(numMacroblocks, sizeof(int8))) == NULL)
    return NULL;
  if ((mbDataTmp->betaOffset = (int8 *)allocMem(numMacroblocks, sizeof(int8))) == NULL)
    return NULL;

  *mbData = mbDataTmp;

  return recoBuf;
}


/*
 *
 * frmOpenRef:
 *
 * Parameters:
 *      width                 Width of the frame
 *      height                Height of the frame
 *
 * Function:
 *      Allocate memory for reference frame buffer
 *
 * Returns:
 *      Pointer to Reference frame or NULL
 *
 */
frmBuf_s *frmOpenRef(int width, int height)
{
//  int numPels = width*height;
  frmBuf_s *ref;

  if ((ref = (frmBuf_s *)User::Alloc(sizeof(frmBuf_s))) == NULL)
    return NULL;

  memset(ref, 0, sizeof(frmBuf_s));

  ref->width      = width;
  ref->height     = height;
  ref->imgPadding = 0;

  ref->forOutput = 0;
  ref->refType = FRM_NON_REF_PIC;

  return ref;
}


/*
 *
 * frmClose:
 *
 * Parameters:
 *      frame                 Frame
 *      mbData                MB state buffers
 *
 * Function:
 *      Deallocate frame buffer and state array memory.
 *
 * Returns:
 *      Nothing
 *
 */
void frmClose(frmBuf_s *recoBuf, mbAttributes_s *mbData)
{
  if (!recoBuf)
    return;

  User::Free(mbData->sliceMap);
  User::Free(mbData->mbTypeTable);
  User::Free(mbData->qpTable);
  User::Free(mbData->refIdxTable);
  User::Free(mbData->cbpTable);
  User::Free(mbData->motVecTable);
  User::Free(mbData->ipModesUpPred);
  User::Free(mbData->numCoefUpPred[0]);
  User::Free(mbData->numCoefUpPred[1]);
  User::Free(mbData->numCoefUpPred[2]);
  User::Free(mbData->filterModeTab);
  User::Free(mbData->alphaOffset);
  User::Free(mbData->betaOffset);
  User::Free(recoBuf);
  User::Free(mbData);
}


/*
 *
 * frmCloseRef:
 *
 * Parameters:
 *      ref                   Reference frame
 *
 * Function:
 *      Deallocate reference frame buffer memory.
 *
 * Returns:
 *      Nothing
 *
 */
void frmCloseRef(frmBuf_s *ref)
{
  if (!ref)
    return;
  
  User::Free(ref);
}


/*
 *
 * initRefFrame:
 *
 * Parameters:
 *      recoBuf                Reconstruction frame
 *      frameBuf               Frame buffer to initialize
 *
 * Function:
 *      Initialize reference frame buffer refBuf using reconstructed buffer
 *      recoBuf. If width and height of the reference buffer do not those
 *      of the reconstructed buffer, reference buffer is reallocated.
 *
 * Returns:
 *      Pointer to reference frame
 *
 */
static frmBuf_s *initRefFrame(frmBuf_s *recoBuf, frmBuf_s *refBuf)
{

  /* If pic size is different, reopen with new size */
  if (!refBuf || refBuf->width != recoBuf->width || refBuf->height != recoBuf->height) {
    frmCloseRef(refBuf);
    if ((refBuf = frmOpenRef(recoBuf->width, recoBuf->height)) == NULL)
      return NULL;
  }

  /* Copy variables */
  *refBuf = *recoBuf;

  return refBuf;
}


/*
 *
 * frmMakeRefFrame:
 *
 * Parameters:
 *      recoBuf               Reconstructed frame
 *      refBuf                Reference frame
 *
 * Function:
 *      Generate reference frame refBuf using reconstructed frame recoBuf.
 *      Function does not copy pixel data, but it simply swaps pointers.
 *
 * Returns:
 *      Pointer to reference frame
 *
 */
frmBuf_s *frmMakeRefFrame(frmBuf_s *recoBuf, frmBuf_s *refBuf)
{

  refBuf = initRefFrame(recoBuf, refBuf);
  if (refBuf == NULL)
    return NULL;

  return refBuf;
}