/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
*************************************************************************
* @file M4MCS_VideoPreProcessing.c
* @brief MCS implementation
* @note This file implements the encoder callback of the MCS.
*************************************************************************
**/
/**
********************************************************************
* Includes
********************************************************************
*/
/* OSAL headers */
#include "M4OSA_Memory.h" /* OSAL memory management */
#include "M4OSA_Debug.h" /* OSAL debug management */
/* Core headers */
#include "M4MCS_InternalTypes.h"
#include "M4MCS_ErrorCodes.h"
/**
* Video preprocessing interface definition */
#include "M4VPP_API.h"
/**
* Video filters */
#include "M4VIFI_FiltersAPI.h" /**< for M4VIFI_ResizeBilinearYUV420toYUV420() */
#ifndef M4MCS_AUDIOONLY
#include "M4AIR_API.h"
#endif /*M4MCS_AUDIOONLY*/
/**/
/*
******************************************************************************
* M4OSA_ERR M4MCS_intApplyVPP(M4VPP_Context pContext, M4VIFI_ImagePlane* pPlaneIn,
* M4VIFI_ImagePlane* pPlaneOut)
* @brief Do the video rendering and the resize (if needed)
* @note It is called by the video encoder
* @param pContext (IN) VPP context, which actually is the MCS internal context in our case
* @param pPlaneIn (IN) Contains the image
* @param pPlaneOut (IN/OUT) Pointer to an array of 3 planes that will contain the output
* YUV420 image
* @return M4NO_ERROR: No error
* @return M4MCS_ERR_VIDEO_DECODE_ERROR: the video decoding failed
* @return M4MCS_ERR_RESIZE_ERROR: the resizing failed
* @return Any error returned by an underlaying module
******************************************************************************
*/
M4OSA_ERR M4MCS_intApplyVPP(M4VPP_Context pContext, M4VIFI_ImagePlane* pPlaneIn,
M4VIFI_ImagePlane* pPlaneOut)
{
M4OSA_ERR err = M4NO_ERROR;
/* This part is used only if video codecs are compiled*/
#ifndef M4MCS_AUDIOONLY
/**
* The VPP context is actually the MCS context! */
M4MCS_InternalContext *pC = (M4MCS_InternalContext*)(pContext);
M4_MediaTime mtCts = pC->dViDecCurrentCts;
/**
* When Closing after an error occured, it may happen that pReaderVideoAU->m_dataAddress has
* not been allocated yet. When closing in pause mode, the decoder can be null.
* We don't want an error to be returned because it would interrupt the close process and
* thus some resources would be locked. So we return M4NO_ERROR.
*/
/* Initialize to black plane the output plane if the media rendering
is black borders */
if(pC->MediaRendering == M4MCS_kBlackBorders)
{
memset((void *)pPlaneOut[0].pac_data,Y_PLANE_BORDER_VALUE,
(pPlaneOut[0].u_height*pPlaneOut[0].u_stride));
memset((void *)pPlaneOut[1].pac_data,U_PLANE_BORDER_VALUE,
(pPlaneOut[1].u_height*pPlaneOut[1].u_stride));
memset((void *)pPlaneOut[2].pac_data,V_PLANE_BORDER_VALUE,
(pPlaneOut[2].u_height*pPlaneOut[2].u_stride));
}
else if ((M4OSA_NULL == pC->ReaderVideoAU.m_dataAddress) ||
(M4OSA_NULL == pC->pViDecCtxt))
{
/**
* We must fill the input of the encoder with a dummy image, because
* encoding noise leads to a huge video AU, and thus a writer buffer overflow. */
memset((void *)pPlaneOut[0].pac_data,0,
pPlaneOut[0].u_stride * pPlaneOut[0].u_height);
memset((void *)pPlaneOut[1].pac_data,0,
pPlaneOut[1].u_stride * pPlaneOut[1].u_height);
memset((void *)pPlaneOut[2].pac_data,0,
pPlaneOut[2].u_stride * pPlaneOut[2].u_height);
M4OSA_TRACE1_0("M4MCS_intApplyVPP: pReaderVideoAU->m_dataAddress is M4OSA_NULL,\
returning M4NO_ERROR");
return M4NO_ERROR;
}
if(pC->isRenderDup == M4OSA_FALSE)
{
/**
* m_pPreResizeFrame different than M4OSA_NULL means that resizing is needed */
if (M4OSA_NULL != pC->pPreResizeFrame)
{
/** FB 2008/10/20:
Used for cropping and black borders*/
M4AIR_Params Params;
M4OSA_TRACE3_0("M4MCS_intApplyVPP: Need to resize");
err = pC->m_pVideoDecoder->m_pFctRender(pC->pViDecCtxt, &mtCts,
pC->pPreResizeFrame, M4OSA_TRUE);
if (M4NO_ERROR != err)
{
M4OSA_TRACE1_1("M4MCS_intApplyVPP: m_pFctRender returns 0x%x!", err);
return err;
}
if(pC->MediaRendering == M4MCS_kResizing)
{
/*
* Call the resize filter. From the intermediate frame to the encoder
* image plane
*/
err = M4VIFI_ResizeBilinearYUV420toYUV420(M4OSA_NULL,
pC->pPreResizeFrame, pPlaneOut);
if (M4NO_ERROR != err)
{
M4OSA_TRACE1_1("M4MCS_intApplyVPP: M4ViFilResizeBilinearYUV420toYUV420\
returns 0x%x!", err);
return err;
}
}
else
{
M4VIFI_ImagePlane pImagePlanesTemp[3];
M4VIFI_ImagePlane* pPlaneTemp;
M4OSA_UInt8* pOutPlaneY = pPlaneOut[0].pac_data +
pPlaneOut[0].u_topleft;
M4OSA_UInt8* pOutPlaneU = pPlaneOut[1].pac_data +
pPlaneOut[1].u_topleft;
M4OSA_UInt8* pOutPlaneV = pPlaneOut[2].pac_data +
pPlaneOut[2].u_topleft;
M4OSA_UInt8* pInPlaneY = M4OSA_NULL;
M4OSA_UInt8* pInPlaneU = M4OSA_NULL;
M4OSA_UInt8* pInPlaneV = M4OSA_NULL;
M4OSA_UInt32 i = 0;
/*FB 2008/10/20: to keep media aspect ratio*/
/*Initialize AIR Params*/
Params.m_inputCoord.m_x = 0;
Params.m_inputCoord.m_y = 0;
Params.m_inputSize.m_height = pC->pPreResizeFrame->u_height;
Params.m_inputSize.m_width = pC->pPreResizeFrame->u_width;
Params.m_outputSize.m_width = pPlaneOut->u_width;
Params.m_outputSize.m_height = pPlaneOut->u_height;
Params.m_bOutputStripe = M4OSA_FALSE;
Params.m_outputOrientation = M4COMMON_kOrientationTopLeft;
/**
Media rendering: Black borders*/
if(pC->MediaRendering == M4MCS_kBlackBorders)
{
pImagePlanesTemp[0].u_width = pPlaneOut[0].u_width;
pImagePlanesTemp[0].u_height = pPlaneOut[0].u_height;
pImagePlanesTemp[0].u_stride = pPlaneOut[0].u_width;
pImagePlanesTemp[0].u_topleft = 0;
pImagePlanesTemp[1].u_width = pPlaneOut[1].u_width;
pImagePlanesTemp[1].u_height = pPlaneOut[1].u_height;
pImagePlanesTemp[1].u_stride = pPlaneOut[1].u_width;
pImagePlanesTemp[1].u_topleft = 0;
pImagePlanesTemp[2].u_width = pPlaneOut[2].u_width;
pImagePlanesTemp[2].u_height = pPlaneOut[2].u_height;
pImagePlanesTemp[2].u_stride = pPlaneOut[2].u_width;
pImagePlanesTemp[2].u_topleft = 0;
/* Allocates plan in local image plane structure */
pImagePlanesTemp[0].pac_data =
(M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[0]\
.u_width * pImagePlanesTemp[0].u_height, M4VS,
(M4OSA_Char *)"M4xVSS_PictureCallbackFct: temporary plane bufferY") ;
if(pImagePlanesTemp[0].pac_data == M4OSA_NULL)
{
M4OSA_TRACE1_0("Error alloc in M4MCS_intApplyVPP");
return M4ERR_ALLOC;
}
pImagePlanesTemp[1].pac_data =
(M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[1]\
.u_width * pImagePlanesTemp[1].u_height, M4VS,
(M4OSA_Char *)"M4xVSS_PictureCallbackFct: temporary plane bufferU") ;
if(pImagePlanesTemp[1].pac_data == M4OSA_NULL)
{
M4OSA_TRACE1_0("Error alloc in M4MCS_intApplyVPP");
return M4ERR_ALLOC;
}
pImagePlanesTemp[2].pac_data =
(M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[2]\
.u_width * pImagePlanesTemp[2].u_height,
M4VS,(M4OSA_Char *)"M4xVSS_PictureCallbackFct: temporary plane bufferV") ;
if(pImagePlanesTemp[2].pac_data == M4OSA_NULL)
{
M4OSA_TRACE1_0("Error alloc in M4MCS_intApplyVPP");
return M4ERR_ALLOC;
}
pInPlaneY = pImagePlanesTemp[0].pac_data ;
pInPlaneU = pImagePlanesTemp[1].pac_data ;
pInPlaneV = pImagePlanesTemp[2].pac_data ;
memset((void *)pImagePlanesTemp[0].pac_data,Y_PLANE_BORDER_VALUE,
(pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride));
memset((void *)pImagePlanesTemp[1].pac_data,U_PLANE_BORDER_VALUE,
(pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride));
memset((void *)pImagePlanesTemp[2].pac_data,V_PLANE_BORDER_VALUE,
(pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride));
if((M4OSA_UInt32)((pC->pPreResizeFrame->u_height * pPlaneOut->u_width)\
/pC->pPreResizeFrame->u_width) <= pPlaneOut->u_height)
//Params.m_inputSize.m_height < Params.m_inputSize.m_width)
{
/*it is height so black borders will be on the top and on the bottom side*/
Params.m_outputSize.m_width = pPlaneOut->u_width;
Params.m_outputSize.m_height =
(M4OSA_UInt32)
((pC->pPreResizeFrame->u_height * pPlaneOut->u_width)\
/pC->pPreResizeFrame->u_width);
/*number of lines at the top*/
pImagePlanesTemp[0].u_topleft =
(M4MCS_ABS((M4OSA_Int32)
(pImagePlanesTemp[0].u_height\
-Params.m_outputSize.m_height)>>1)) *
pImagePlanesTemp[0].u_stride;
pImagePlanesTemp[0].u_height = Params.m_outputSize.m_height;
pImagePlanesTemp[1].u_topleft =
(M4MCS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_height\
-(Params.m_outputSize.m_height>>1)))>>1)\
* pImagePlanesTemp[1].u_stride;
pImagePlanesTemp[1].u_height = Params.m_outputSize.m_height>>1;
pImagePlanesTemp[2].u_topleft =
(M4MCS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_height\
-(Params.m_outputSize.m_height>>1)))>>1)\
* pImagePlanesTemp[2].u_stride;
pImagePlanesTemp[2].u_height = Params.m_outputSize.m_height>>1;
}
else
{
/*it is width so black borders will be on the left and right side*/
Params.m_outputSize.m_height = pPlaneOut->u_height;
Params.m_outputSize.m_width =
(M4OSA_UInt32)((pC->pPreResizeFrame->u_width
* pPlaneOut->u_height)\
/pC->pPreResizeFrame->u_height);
pImagePlanesTemp[0].u_topleft =
(M4MCS_ABS((M4OSA_Int32)(pImagePlanesTemp[0].u_width-\
Params.m_outputSize.m_width)>>1));
pImagePlanesTemp[0].u_width = Params.m_outputSize.m_width;
pImagePlanesTemp[1].u_topleft =
(M4MCS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_width-\
(Params.m_outputSize.m_width>>1)))>>1);
pImagePlanesTemp[1].u_width = Params.m_outputSize.m_width>>1;
pImagePlanesTemp[2].u_topleft =
(M4MCS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_width-\
(Params.m_outputSize.m_width>>1)))>>1);
pImagePlanesTemp[2].u_width = Params.m_outputSize.m_width>>1;
}
/*Width and height have to be even*/
Params.m_outputSize.m_width = (Params.m_outputSize.m_width>>1)<<1;
Params.m_outputSize.m_height = (Params.m_outputSize.m_height>>1)<<1;
Params.m_inputSize.m_width = (Params.m_inputSize.m_width>>1)<<1;
Params.m_inputSize.m_height = (Params.m_inputSize.m_height>>1)<<1;
pImagePlanesTemp[0].u_width = (pImagePlanesTemp[0].u_width>>1)<<1;
pImagePlanesTemp[1].u_width = (pImagePlanesTemp[1].u_width>>1)<<1;
pImagePlanesTemp[2].u_width = (pImagePlanesTemp[2].u_width>>1)<<1;
pImagePlanesTemp[0].u_height = (pImagePlanesTemp[0].u_height>>1)<<1;
pImagePlanesTemp[1].u_height = (pImagePlanesTemp[1].u_height>>1)<<1;
pImagePlanesTemp[2].u_height = (pImagePlanesTemp[2].u_height>>1)<<1;
/*Check that values are coherent*/
if(Params.m_inputSize.m_height == Params.m_outputSize.m_height)
{
Params.m_inputSize.m_width = Params.m_outputSize.m_width;
}
else if(Params.m_inputSize.m_width == Params.m_outputSize.m_width)
{
Params.m_inputSize.m_height = Params.m_outputSize.m_height;
}
pPlaneTemp = pImagePlanesTemp;
}
/**
Media rendering: Cropping*/
if(pC->MediaRendering == M4MCS_kCropping)
{
Params.m_outputSize.m_height = pPlaneOut->u_height;
Params.m_outputSize.m_width = pPlaneOut->u_width;
if((Params.m_outputSize.m_height * Params.m_inputSize.m_width)\
/Params.m_outputSize.m_width<Params.m_inputSize.m_height)
{
/*height will be cropped*/
Params.m_inputSize.m_height =
(M4OSA_UInt32)((Params.m_outputSize.m_height \
* Params.m_inputSize.m_width) /
Params.m_outputSize.m_width);
Params.m_inputSize.m_height =
(Params.m_inputSize.m_height>>1)<<1;
Params.m_inputCoord.m_y =
(M4OSA_Int32)((M4OSA_Int32)
((pC->pPreResizeFrame->u_height\
- Params.m_inputSize.m_height))>>1);
}
else
{
/*width will be cropped*/
Params.m_inputSize.m_width =
(M4OSA_UInt32)((Params.m_outputSize.m_width\
* Params.m_inputSize.m_height) /
Params.m_outputSize.m_height);
Params.m_inputSize.m_width =
(Params.m_inputSize.m_width>>1)<<1;
Params.m_inputCoord.m_x =
(M4OSA_Int32)((M4OSA_Int32)
((pC->pPreResizeFrame->u_width\
- Params.m_inputSize.m_width))>>1);
}
pPlaneTemp = pPlaneOut;
}
/**
* Call AIR functions */
if(M4OSA_NULL == pC->m_air_context)
{
err = M4AIR_create(&pC->m_air_context, M4AIR_kYUV420P);
if(err != M4NO_ERROR)
{
M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct:\
Error when initializing AIR: 0x%x", err);
return err;
}
}
err = M4AIR_configure(pC->m_air_context, &Params);
if(err != M4NO_ERROR)
{
M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct:\
Error when configuring AIR: 0x%x", err);
M4AIR_cleanUp(pC->m_air_context);
return err;
}
err = M4AIR_get(pC->m_air_context, pC->pPreResizeFrame,
pPlaneTemp);
if(err != M4NO_ERROR)
{
M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct:\
Error when getting AIR plane: 0x%x", err);
M4AIR_cleanUp(pC->m_air_context);
return err;
}
if(pC->MediaRendering == M4MCS_kBlackBorders)
{
for(i=0; i<pPlaneOut[0].u_height; i++)
{
memcpy( (void *)pOutPlaneY,
(void *)pInPlaneY,
pPlaneOut[0].u_width);
pInPlaneY += pPlaneOut[0].u_width;
pOutPlaneY += pPlaneOut[0].u_stride;
}
for(i=0; i<pPlaneOut[1].u_height; i++)
{
memcpy( (void *)pOutPlaneU,
(void *)pInPlaneU,
pPlaneOut[1].u_width);
pInPlaneU += pPlaneOut[1].u_width;
pOutPlaneU += pPlaneOut[1].u_stride;
}
for(i=0; i<pPlaneOut[2].u_height; i++)
{
memcpy( (void *)pOutPlaneV,
(void *)pInPlaneV,
pPlaneOut[2].u_width);
pInPlaneV += pPlaneOut[2].u_width;
pOutPlaneV += pPlaneOut[2].u_stride;
}
for(i=0; i<3; i++)
{
if(pImagePlanesTemp[i].pac_data != M4OSA_NULL)
{
free(
pImagePlanesTemp[i].pac_data);
pImagePlanesTemp[i].pac_data = M4OSA_NULL;
}
}
}
}
}
else
{
M4OSA_TRACE3_0("M4MCS_intApplyVPP: Don't need resizing");
err = pC->m_pVideoDecoder->m_pFctRender(pC->pViDecCtxt,
&mtCts, pPlaneOut,
M4OSA_TRUE);
if (M4NO_ERROR != err)
{
M4OSA_TRACE1_1("M4MCS_intApplyVPP: m_pFctRender returns 0x%x!", err);
return err;
}
}
pC->lastDecodedPlane = pPlaneOut;
}
else
{
/* Copy last decoded plane to output plane */
memcpy((void *)pPlaneOut[0].pac_data,
(void *)pC->lastDecodedPlane[0].pac_data,
(pPlaneOut[0].u_height * pPlaneOut[0].u_width));
memcpy((void *)pPlaneOut[1].pac_data,
(void *)pC->lastDecodedPlane[1].pac_data,
(pPlaneOut[1].u_height * pPlaneOut[1].u_width));
memcpy((void *)pPlaneOut[2].pac_data,
(void *)pC->lastDecodedPlane[2].pac_data,
(pPlaneOut[2].u_height * pPlaneOut[2].u_width));
pC->lastDecodedPlane = pPlaneOut;
}
#endif /*M4MCS_AUDIOONLY*/
M4OSA_TRACE3_0("M4MCS_intApplyVPP: returning M4NO_ERROR");
return M4NO_ERROR;
}