Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 /**
     17  ******************************************************************************
     18  * @file    M4xVSS_internal.c
     19  * @brief    Internal functions of extended Video Studio Service (Video Studio 2.1)
     20  * @note
     21  ******************************************************************************
     22  */
     23 #include "M4OSA_Debug.h"
     24 #include "M4OSA_CharStar.h"
     25 
     26 #include "NXPSW_CompilerSwitches.h"
     27 
     28 #include "M4VSS3GPP_API.h"
     29 #include "M4VSS3GPP_ErrorCodes.h"
     30 
     31 #include "M4xVSS_API.h"
     32 #include "M4xVSS_Internal.h"
     33 
     34 /*for rgb16 color effect*/
     35 #include "M4VIFI_Defines.h"
     36 #include "M4VIFI_Clip.h"
     37 
     38 /**
     39  * component includes */
     40 #include "M4VFL_transition.h"            /**< video effects */
     41 
     42 /* Internal header file of VSS is included because of MMS use case */
     43 #include "M4VSS3GPP_InternalTypes.h"
     44 
     45 /*Exif header files to add image rendering support (cropping, black borders)*/
     46 #include "M4EXIFC_CommonAPI.h"
     47 // StageFright encoders require %16 resolution
     48 #include "M4ENCODER_common.h"
     49 
     50 #define TRANSPARENT_COLOR 0x7E0
     51 
     52 /* Prototype of M4VIFI_xVSS_RGB565toYUV420 function (avoid green effect of transparency color) */
     53 M4VIFI_UInt8 M4VIFI_xVSS_RGB565toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn,
     54                                         M4VIFI_ImagePlane *pPlaneOut);
     55 
     56 
     57 /*special MCS function used only in VideoArtist and VideoStudio to open the media in the normal
     58  mode. That way the media duration is accurate*/
     59 extern M4OSA_ERR M4MCS_open_normalMode(M4MCS_Context pContext, M4OSA_Void* pFileIn,
     60                                          M4VIDEOEDITING_FileType InputFileType,
     61                                          M4OSA_Void* pFileOut, M4OSA_Void* pTempFile);
     62 
     63 
     64 /**
     65  ******************************************************************************
     66  * prototype    M4OSA_ERR M4xVSS_internalStartTranscoding(M4OSA_Context pContext)
     67  * @brief        This function initializes MCS (3GP transcoder) with the given
     68  *                parameters
     69  * @note        The transcoding parameters are given by the internal xVSS context.
     70  *                This context contains a pointer on the current element of the
     71  *                chained list of MCS parameters.
     72  *
     73  * @param    pContext            (IN) Pointer on the xVSS edit context
     74  * @return    M4NO_ERROR:            No error
     75  * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
     76  * @return    M4ERR_ALLOC:        Memory allocation has failed
     77  ******************************************************************************
     78  */
     79 M4OSA_ERR M4xVSS_internalStartTranscoding(M4OSA_Context pContext,
     80                                           M4OSA_UInt32 *rotationDegree)
     81 {
     82     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
     83     M4OSA_ERR err;
     84     M4MCS_Context mcs_context;
     85     M4MCS_OutputParams Params;
     86     M4MCS_EncodingParams Rates;
     87     M4OSA_UInt32 i;
     88     M4VIDEOEDITING_ClipProperties clipProps;
     89 
     90     err = M4MCS_init(&mcs_context, xVSS_context->pFileReadPtr, xVSS_context->pFileWritePtr);
     91     if(err != M4NO_ERROR)
     92     {
     93         M4OSA_TRACE1_1("Error in M4MCS_init: 0x%x", err);
     94         return err;
     95     }
     96 
     97     err = M4MCS_open(mcs_context, xVSS_context->pMCScurrentParams->pFileIn,
     98          xVSS_context->pMCScurrentParams->InputFileType,
     99              xVSS_context->pMCScurrentParams->pFileOut,
    100              xVSS_context->pMCScurrentParams->pFileTemp);
    101     if (err != M4NO_ERROR)
    102     {
    103         M4OSA_TRACE1_1("Error in M4MCS_open: 0x%x", err);
    104         M4MCS_abort(mcs_context);
    105         return err;
    106     }
    107 
    108     /** Get the clip properties
    109      */
    110     err = M4MCS_getInputFileProperties(mcs_context, &clipProps);
    111     if (err != M4NO_ERROR) {
    112         M4OSA_TRACE1_1("Error in M4MCS_getInputFileProperties: 0x%x", err);
    113         M4MCS_abort(mcs_context);
    114         return err;
    115     }
    116     *rotationDegree = clipProps.videoRotationDegrees;
    117 
    118     /**
    119      * Fill MCS parameters with the parameters contained in the current element of the
    120        MCS parameters chained list */
    121     Params.OutputFileType = xVSS_context->pMCScurrentParams->OutputFileType;
    122     Params.OutputVideoFormat = xVSS_context->pMCScurrentParams->OutputVideoFormat;
    123     Params.outputVideoProfile= xVSS_context->pMCScurrentParams->outputVideoProfile;
    124     Params.outputVideoLevel = xVSS_context->pMCScurrentParams->outputVideoLevel;
    125     Params.OutputVideoFrameSize = xVSS_context->pMCScurrentParams->OutputVideoFrameSize;
    126     Params.OutputVideoFrameRate = xVSS_context->pMCScurrentParams->OutputVideoFrameRate;
    127     Params.OutputAudioFormat = xVSS_context->pMCScurrentParams->OutputAudioFormat;
    128     Params.OutputAudioSamplingFrequency =
    129          xVSS_context->pMCScurrentParams->OutputAudioSamplingFrequency;
    130     Params.bAudioMono = xVSS_context->pMCScurrentParams->bAudioMono;
    131     Params.pOutputPCMfile = M4OSA_NULL;
    132     /*FB 2008/10/20: add media rendering parameter to keep aspect ratio*/
    133     switch(xVSS_context->pMCScurrentParams->MediaRendering)
    134     {
    135     case M4xVSS_kResizing:
    136         Params.MediaRendering = M4MCS_kResizing;
    137         break;
    138     case M4xVSS_kCropping:
    139         Params.MediaRendering = M4MCS_kCropping;
    140         break;
    141     case M4xVSS_kBlackBorders:
    142         Params.MediaRendering = M4MCS_kBlackBorders;
    143         break;
    144     default:
    145         break;
    146     }
    147     /**/
    148     // new params after integrating MCS 2.0
    149     // Set the number of audio effects; 0 for now.
    150     Params.nbEffects = 0;
    151 
    152     // Set the audio effect; null for now.
    153     Params.pEffects = NULL;
    154 
    155     // Set the audio effect; null for now.
    156     Params.bDiscardExif = M4OSA_FALSE;
    157 
    158     // Set the audio effect; null for now.
    159     Params.bAdjustOrientation = M4OSA_FALSE;
    160     // new params after integrating MCS 2.0
    161 
    162     /**
    163      * Set output parameters */
    164     err = M4MCS_setOutputParams(mcs_context, &Params);
    165     if (err != M4NO_ERROR)
    166     {
    167         M4OSA_TRACE1_1("Error in M4MCS_setOutputParams: 0x%x", err);
    168         M4MCS_abort(mcs_context);
    169         return err;
    170     }
    171 
    172     Rates.OutputVideoBitrate = xVSS_context->pMCScurrentParams->OutputVideoBitrate;
    173     Rates.OutputAudioBitrate = xVSS_context->pMCScurrentParams->OutputAudioBitrate;
    174     Rates.BeginCutTime = 0;
    175     Rates.EndCutTime = 0;
    176     Rates.OutputFileSize = 0;
    177 
    178     /*FB: transcoding per parts*/
    179     Rates.BeginCutTime = xVSS_context->pMCScurrentParams->BeginCutTime;
    180     Rates.EndCutTime = xVSS_context->pMCScurrentParams->EndCutTime;
    181     Rates.OutputVideoTimescale = xVSS_context->pMCScurrentParams->OutputVideoTimescale;
    182 
    183     err = M4MCS_setEncodingParams(mcs_context, &Rates);
    184     if (err != M4NO_ERROR)
    185     {
    186         M4OSA_TRACE1_1("Error in M4MCS_setEncodingParams: 0x%x", err);
    187         M4MCS_abort(mcs_context);
    188         return err;
    189     }
    190 
    191     err = M4MCS_checkParamsAndStart(mcs_context);
    192     if (err != M4NO_ERROR)
    193     {
    194         M4OSA_TRACE1_1("Error in M4MCS_checkParamsAndStart: 0x%x", err);
    195         M4MCS_abort(mcs_context);
    196         return err;
    197     }
    198 
    199     /**
    200      * Save MCS context to be able to call MCS step function in M4xVSS_step function */
    201     xVSS_context->pMCS_Ctxt = mcs_context;
    202 
    203     return M4NO_ERROR;
    204 }
    205 
    206 /**
    207  ******************************************************************************
    208  * prototype    M4OSA_ERR M4xVSS_internalStopTranscoding(M4OSA_Context pContext)
    209  * @brief        This function cleans up MCS (3GP transcoder)
    210  * @note
    211  *
    212  * @param    pContext            (IN) Pointer on the xVSS edit context
    213  * @return    M4NO_ERROR:            No error
    214  * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
    215  * @return    M4ERR_ALLOC:        Memory allocation has failed
    216  ******************************************************************************
    217  */
    218 M4OSA_ERR M4xVSS_internalStopTranscoding(M4OSA_Context pContext)
    219 {
    220     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
    221     M4OSA_ERR err;
    222 
    223     err = M4MCS_close(xVSS_context->pMCS_Ctxt);
    224     if (err != M4NO_ERROR)
    225     {
    226         M4OSA_TRACE1_1("M4xVSS_internalStopTranscoding: Error in M4MCS_close: 0x%x", err);
    227         M4MCS_abort(xVSS_context->pMCS_Ctxt);
    228         return err;
    229     }
    230 
    231     /**
    232      * Free this MCS instance */
    233     err = M4MCS_cleanUp(xVSS_context->pMCS_Ctxt);
    234     if (err != M4NO_ERROR)
    235     {
    236         M4OSA_TRACE1_1("M4xVSS_internalStopTranscoding: Error in M4MCS_cleanUp: 0x%x", err);
    237         return err;
    238     }
    239 
    240     xVSS_context->pMCS_Ctxt = M4OSA_NULL;
    241 
    242     return M4NO_ERROR;
    243 }
    244 
    245 /**
    246  ******************************************************************************
    247  * M4OSA_ERR M4xVSS_internalConvertAndResizeARGB8888toYUV420(M4OSA_Void* pFileIn,
    248  *                                             M4OSA_FileReadPointer* pFileReadPtr,
    249  *                                                M4VIFI_ImagePlane* pImagePlanes,
    250  *                                                 M4OSA_UInt32 width,
    251  *                                                M4OSA_UInt32 height);
    252  * @brief    It Coverts and resizes a ARGB8888 image to YUV420
    253  * @note
    254  * @param    pFileIn            (IN) The Image input file
    255  * @param    pFileReadPtr    (IN) Pointer on filesystem functions
    256  * @param    pImagePlanes    (IN/OUT) Pointer on YUV420 output planes allocated by the user
    257  *                            ARGB8888 image  will be converted and resized  to output
    258  *                             YUV420 plane size
    259  *@param    width        (IN) width of the ARGB8888
    260  *@param    height            (IN) height of the ARGB8888
    261  * @return    M4NO_ERROR:    No error
    262  * @return    M4ERR_ALLOC: memory error
    263  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
    264  ******************************************************************************
    265  */
    266 
    267 M4OSA_ERR M4xVSS_internalConvertAndResizeARGB8888toYUV420(M4OSA_Void* pFileIn,
    268                                                           M4OSA_FileReadPointer* pFileReadPtr,
    269                                                           M4VIFI_ImagePlane* pImagePlanes,
    270                                                           M4OSA_UInt32 width,M4OSA_UInt32 height)
    271 {
    272     M4OSA_Context pARGBIn;
    273     M4VIFI_ImagePlane rgbPlane1 ,rgbPlane2;
    274     M4OSA_UInt32 frameSize_argb=(width * height * 4);
    275     M4OSA_UInt32 frameSize = (width * height * 3); //Size of RGB888 data.
    276     M4OSA_UInt32 i = 0,j= 0;
    277     M4OSA_ERR err=M4NO_ERROR;
    278 
    279 
    280     M4OSA_UInt8 *pTmpData = (M4OSA_UInt8*) M4OSA_32bitAlignedMalloc(frameSize_argb,
    281          M4VS, (M4OSA_Char*)"Image argb data");
    282         M4OSA_TRACE1_0("M4xVSS_internalConvertAndResizeARGB8888toYUV420 Entering :");
    283     if(pTmpData == M4OSA_NULL) {
    284         M4OSA_TRACE1_0("M4xVSS_internalConvertAndResizeARGB8888toYUV420 :\
    285             Failed to allocate memory for Image clip");
    286         return M4ERR_ALLOC;
    287     }
    288 
    289     M4OSA_TRACE1_2("M4xVSS_internalConvertAndResizeARGB8888toYUV420 :width and height %d %d",
    290         width ,height);
    291     /* Get file size (mandatory for chunk decoding) */
    292     err = pFileReadPtr->openRead(&pARGBIn, pFileIn, M4OSA_kFileRead);
    293     if(err != M4NO_ERROR)
    294     {
    295         M4OSA_TRACE1_2("M4xVSS_internalConvertAndResizeARGB8888toYUV420 :\
    296             Can't open input ARGB8888 file %s, error: 0x%x\n",pFileIn, err);
    297         free(pTmpData);
    298         pTmpData = M4OSA_NULL;
    299         goto cleanup;
    300     }
    301 
    302     err = pFileReadPtr->readData(pARGBIn,(M4OSA_MemAddr8)pTmpData, &frameSize_argb);
    303     if(err != M4NO_ERROR)
    304     {
    305         M4OSA_TRACE1_2("M4xVSS_internalConvertAndResizeARGB8888toYUV420 Can't close ARGB8888\
    306              file %s, error: 0x%x\n",pFileIn, err);
    307         pFileReadPtr->closeRead(pARGBIn);
    308         free(pTmpData);
    309         pTmpData = M4OSA_NULL;
    310         goto cleanup;
    311     }
    312 
    313     err = pFileReadPtr->closeRead(pARGBIn);
    314     if(err != M4NO_ERROR)
    315     {
    316         M4OSA_TRACE1_2("M4xVSS_internalConvertAndResizeARGB8888toYUV420 Can't close ARGB8888 \
    317              file %s, error: 0x%x\n",pFileIn, err);
    318         free(pTmpData);
    319         pTmpData = M4OSA_NULL;
    320         goto cleanup;
    321     }
    322 
    323     rgbPlane1.pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize, M4VS,
    324          (M4OSA_Char*)"Image clip RGB888 data");
    325     if(rgbPlane1.pac_data == M4OSA_NULL)
    326     {
    327         M4OSA_TRACE1_0("M4xVSS_internalConvertAndResizeARGB8888toYUV420 \
    328             Failed to allocate memory for Image clip");
    329         free(pTmpData);
    330         return M4ERR_ALLOC;
    331     }
    332 
    333         rgbPlane1.u_height = height;
    334         rgbPlane1.u_width = width;
    335         rgbPlane1.u_stride = width*3;
    336         rgbPlane1.u_topleft = 0;
    337 
    338 
    339     /** Remove the alpha channel */
    340     for (i=0, j = 0; i < frameSize_argb; i++) {
    341         if ((i % 4) == 0) continue;
    342         rgbPlane1.pac_data[j] = pTmpData[i];
    343         j++;
    344     }
    345         free(pTmpData);
    346 
    347     /* To Check if resizing is required with color conversion */
    348     if(width != pImagePlanes->u_width || height != pImagePlanes->u_height)
    349     {
    350         M4OSA_TRACE1_0("M4xVSS_internalConvertAndResizeARGB8888toYUV420 Resizing :");
    351         frameSize =  ( pImagePlanes->u_width * pImagePlanes->u_height * 3);
    352         rgbPlane2.pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize, M4VS,
    353              (M4OSA_Char*)"Image clip RGB888 data");
    354         if(rgbPlane2.pac_data == M4OSA_NULL)
    355         {
    356             M4OSA_TRACE1_0("Failed to allocate memory for Image clip");
    357             free(pTmpData);
    358             return M4ERR_ALLOC;
    359         }
    360             rgbPlane2.u_height =  pImagePlanes->u_height;
    361             rgbPlane2.u_width = pImagePlanes->u_width;
    362             rgbPlane2.u_stride = pImagePlanes->u_width*3;
    363             rgbPlane2.u_topleft = 0;
    364 
    365         /* Resizing RGB888 to RGB888 */
    366         err = M4VIFI_ResizeBilinearRGB888toRGB888(M4OSA_NULL, &rgbPlane1, &rgbPlane2);
    367         if(err != M4NO_ERROR)
    368         {
    369             M4OSA_TRACE1_1("error when converting from Resize RGB888 to RGB888: 0x%x\n", err);
    370             free(rgbPlane2.pac_data);
    371             free(rgbPlane1.pac_data);
    372             return err;
    373         }
    374         /*Converting Resized RGB888 to YUV420 */
    375         err = M4VIFI_RGB888toYUV420(M4OSA_NULL, &rgbPlane2, pImagePlanes);
    376         if(err != M4NO_ERROR)
    377         {
    378             M4OSA_TRACE1_1("error when converting from RGB888 to YUV: 0x%x\n", err);
    379             free(rgbPlane2.pac_data);
    380             free(rgbPlane1.pac_data);
    381             return err;
    382         }
    383             free(rgbPlane2.pac_data);
    384             free(rgbPlane1.pac_data);
    385 
    386             M4OSA_TRACE1_0("RGB to YUV done");
    387 
    388 
    389     }
    390     else
    391     {
    392         M4OSA_TRACE1_0("M4xVSS_internalConvertAndResizeARGB8888toYUV420 NO  Resizing :");
    393         err = M4VIFI_RGB888toYUV420(M4OSA_NULL, &rgbPlane1, pImagePlanes);
    394         if(err != M4NO_ERROR)
    395         {
    396             M4OSA_TRACE1_1("error when converting from RGB to YUV: 0x%x\n", err);
    397         }
    398             free(rgbPlane1.pac_data);
    399 
    400             M4OSA_TRACE1_0("RGB to YUV done");
    401     }
    402 cleanup:
    403     M4OSA_TRACE1_0("M4xVSS_internalConvertAndResizeARGB8888toYUV420 leaving :");
    404     return err;
    405 }
    406 
    407 /**
    408  ******************************************************************************
    409  * M4OSA_ERR M4xVSS_internalConvertARGB8888toYUV420(M4OSA_Void* pFileIn,
    410  *                                             M4OSA_FileReadPointer* pFileReadPtr,
    411  *                                                M4VIFI_ImagePlane* pImagePlanes,
    412  *                                                 M4OSA_UInt32 width,
    413  *                                                M4OSA_UInt32 height);
    414  * @brief    It Coverts a ARGB8888 image to YUV420
    415  * @note
    416  * @param    pFileIn            (IN) The Image input file
    417  * @param    pFileReadPtr    (IN) Pointer on filesystem functions
    418  * @param    pImagePlanes    (IN/OUT) Pointer on YUV420 output planes allocated by the user
    419  *                            ARGB8888 image  will be converted and resized  to output
    420  *                            YUV420 plane size
    421  * @param    width        (IN) width of the ARGB8888
    422  * @param    height            (IN) height of the ARGB8888
    423  * @return    M4NO_ERROR:    No error
    424  * @return    M4ERR_ALLOC: memory error
    425  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
    426  ******************************************************************************
    427  */
    428 
    429 M4OSA_ERR M4xVSS_internalConvertARGB8888toYUV420(M4OSA_Void* pFileIn,
    430                                                  M4OSA_FileReadPointer* pFileReadPtr,
    431                                                  M4VIFI_ImagePlane** pImagePlanes,
    432                                                  M4OSA_UInt32 width,M4OSA_UInt32 height)
    433 {
    434     M4OSA_ERR err = M4NO_ERROR;
    435     M4VIFI_ImagePlane *yuvPlane = M4OSA_NULL;
    436 
    437     yuvPlane = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane),
    438                 M4VS, (M4OSA_Char*)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV");
    439     if(yuvPlane == M4OSA_NULL) {
    440         M4OSA_TRACE1_0("M4xVSS_internalConvertAndResizeARGB8888toYUV420 :\
    441             Failed to allocate memory for Image clip");
    442         return M4ERR_ALLOC;
    443     }
    444     yuvPlane[0].u_height = height;
    445     yuvPlane[0].u_width = width;
    446     yuvPlane[0].u_stride = width;
    447     yuvPlane[0].u_topleft = 0;
    448     yuvPlane[0].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(yuvPlane[0].u_height \
    449         * yuvPlane[0].u_width * 1.5, M4VS, (M4OSA_Char*)"imageClip YUV data");
    450 
    451     yuvPlane[1].u_height = yuvPlane[0].u_height >>1;
    452     yuvPlane[1].u_width = yuvPlane[0].u_width >> 1;
    453     yuvPlane[1].u_stride = yuvPlane[1].u_width;
    454     yuvPlane[1].u_topleft = 0;
    455     yuvPlane[1].pac_data = (M4VIFI_UInt8*)(yuvPlane[0].pac_data + yuvPlane[0].u_height \
    456         * yuvPlane[0].u_width);
    457 
    458     yuvPlane[2].u_height = yuvPlane[0].u_height >>1;
    459     yuvPlane[2].u_width = yuvPlane[0].u_width >> 1;
    460     yuvPlane[2].u_stride = yuvPlane[2].u_width;
    461     yuvPlane[2].u_topleft = 0;
    462     yuvPlane[2].pac_data = (M4VIFI_UInt8*)(yuvPlane[1].pac_data + yuvPlane[1].u_height \
    463         * yuvPlane[1].u_width);
    464     err = M4xVSS_internalConvertAndResizeARGB8888toYUV420( pFileIn,pFileReadPtr,
    465                                                           yuvPlane, width, height);
    466     if(err != M4NO_ERROR)
    467     {
    468         M4OSA_TRACE1_1("M4xVSS_internalConvertAndResizeARGB8888toYUV420 return error: 0x%x\n", err);
    469         free(yuvPlane);
    470         return err;
    471     }
    472 
    473         *pImagePlanes = yuvPlane;
    474 
    475     M4OSA_TRACE1_0("M4xVSS_internalConvertARGB8888toYUV420 :Leaving");
    476     return err;
    477 
    478 }
    479 
    480 /**
    481  ******************************************************************************
    482  * M4OSA_ERR M4xVSS_PictureCallbackFct (M4OSA_Void* pPictureCtxt,
    483  *                                        M4VIFI_ImagePlane* pImagePlanes,
    484  *                                        M4OSA_UInt32* pPictureDuration);
    485  * @brief    It feeds the PTO3GPP with YUV420 pictures.
    486  * @note    This function is given to the PTO3GPP in the M4PTO3GPP_Params structure
    487  * @param    pContext    (IN) The integrator own context
    488  * @param    pImagePlanes(IN/OUT) Pointer to an array of three valid image planes
    489  * @param    pPictureDuration(OUT) Duration of the returned picture
    490  *
    491  * @return    M4NO_ERROR:    No error
    492  * @return    M4PTO3GPP_WAR_LAST_PICTURE: The returned image is the last one
    493  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
    494  ******************************************************************************
    495  */
    496 M4OSA_ERR M4xVSS_PictureCallbackFct(M4OSA_Void* pPictureCtxt, M4VIFI_ImagePlane* pImagePlanes,
    497                                      M4OSA_Double* pPictureDuration)
    498 {
    499     M4OSA_ERR err = M4NO_ERROR;
    500     M4OSA_UInt8    last_frame_flag = 0;
    501     M4xVSS_PictureCallbackCtxt* pC = (M4xVSS_PictureCallbackCtxt*) (pPictureCtxt);
    502 
    503     /*Used for pan&zoom*/
    504     M4OSA_UInt8 tempPanzoomXa = 0;
    505     M4OSA_UInt8 tempPanzoomXb = 0;
    506     M4AIR_Params Params;
    507     /**/
    508 
    509     /*Used for cropping and black borders*/
    510     M4OSA_Context    pPictureContext = M4OSA_NULL;
    511     M4OSA_FilePosition    pictureSize = 0 ;
    512     M4OSA_UInt8*    pictureBuffer = M4OSA_NULL;
    513     //M4EXIFC_Context pExifContext = M4OSA_NULL;
    514     M4EXIFC_BasicTags pBasicTags;
    515     M4VIFI_ImagePlane pImagePlanes1 = pImagePlanes[0];
    516     M4VIFI_ImagePlane pImagePlanes2 = pImagePlanes[1];
    517     M4VIFI_ImagePlane pImagePlanes3 = pImagePlanes[2];
    518     /**/
    519 
    520     /**
    521      * Check input parameters */
    522     M4OSA_DEBUG_IF2((M4OSA_NULL==pPictureCtxt),        M4ERR_PARAMETER,
    523          "M4xVSS_PictureCallbackFct: pPictureCtxt is M4OSA_NULL");
    524     M4OSA_DEBUG_IF2((M4OSA_NULL==pImagePlanes),        M4ERR_PARAMETER,
    525          "M4xVSS_PictureCallbackFct: pImagePlanes is M4OSA_NULL");
    526     M4OSA_DEBUG_IF2((M4OSA_NULL==pPictureDuration), M4ERR_PARAMETER,
    527          "M4xVSS_PictureCallbackFct: pPictureDuration is M4OSA_NULL");
    528     M4OSA_TRACE1_0("M4xVSS_PictureCallbackFct :Entering");
    529     /*PR P4ME00003181 In case the image number is 0, pan&zoom can not be used*/
    530     if(M4OSA_TRUE == pC->m_pPto3GPPparams->isPanZoom && pC->m_NbImage == 0)
    531     {
    532         pC->m_pPto3GPPparams->isPanZoom = M4OSA_FALSE;
    533     }
    534 
    535     /*If no cropping/black borders or pan&zoom, just decode and resize the picture*/
    536     if(pC->m_mediaRendering == M4xVSS_kResizing && M4OSA_FALSE == pC->m_pPto3GPPparams->isPanZoom)
    537     {
    538         /**
    539          * Convert and resize input ARGB8888 file to YUV420 */
    540         /*To support ARGB8888 : */
    541         M4OSA_TRACE1_2("M4xVSS_PictureCallbackFct 1: width and heght %d %d",
    542             pC->m_pPto3GPPparams->width,pC->m_pPto3GPPparams->height);
    543         err = M4xVSS_internalConvertAndResizeARGB8888toYUV420(pC->m_FileIn,
    544              pC->m_pFileReadPtr, pImagePlanes,pC->m_pPto3GPPparams->width,
    545                 pC->m_pPto3GPPparams->height);
    546         if(err != M4NO_ERROR)
    547         {
    548             M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct: Error when decoding JPEG: 0x%x\n", err);
    549             return err;
    550         }
    551     }
    552     /*In case of cropping, black borders or pan&zoom, call the EXIF reader and the AIR*/
    553     else
    554     {
    555         /**
    556          * Computes ratios */
    557         if(pC->m_pDecodedPlane == M4OSA_NULL)
    558         {
    559             /**
    560              * Convert input ARGB8888 file to YUV420 */
    561              M4OSA_TRACE1_2("M4xVSS_PictureCallbackFct 2: width and heght %d %d",
    562                 pC->m_pPto3GPPparams->width,pC->m_pPto3GPPparams->height);
    563             err = M4xVSS_internalConvertARGB8888toYUV420(pC->m_FileIn, pC->m_pFileReadPtr,
    564                 &(pC->m_pDecodedPlane),pC->m_pPto3GPPparams->width,pC->m_pPto3GPPparams->height);
    565             if(err != M4NO_ERROR)
    566             {
    567                 M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct: Error when decoding JPEG: 0x%x\n", err);
    568                 if(pC->m_pDecodedPlane != M4OSA_NULL)
    569                 {
    570                     /* YUV420 planar is returned but allocation is made only once
    571                         (contigous planes in memory) */
    572                     if(pC->m_pDecodedPlane->pac_data != M4OSA_NULL)
    573                     {
    574                         free(pC->m_pDecodedPlane->pac_data);
    575                     }
    576                     free(pC->m_pDecodedPlane);
    577                     pC->m_pDecodedPlane = M4OSA_NULL;
    578                 }
    579                 return err;
    580             }
    581         }
    582 
    583         /*Initialize AIR Params*/
    584         Params.m_inputCoord.m_x = 0;
    585         Params.m_inputCoord.m_y = 0;
    586         Params.m_inputSize.m_height = pC->m_pDecodedPlane->u_height;
    587         Params.m_inputSize.m_width = pC->m_pDecodedPlane->u_width;
    588         Params.m_outputSize.m_width = pImagePlanes->u_width;
    589         Params.m_outputSize.m_height = pImagePlanes->u_height;
    590         Params.m_bOutputStripe = M4OSA_FALSE;
    591         Params.m_outputOrientation = M4COMMON_kOrientationTopLeft;
    592 
    593         /*Initialize Exif params structure*/
    594         pBasicTags.orientation = M4COMMON_kOrientationUnknown;
    595 
    596         /**
    597         Pan&zoom params*/
    598         if(M4OSA_TRUE == pC->m_pPto3GPPparams->isPanZoom)
    599         {
    600             /*Save ratio values, they can be reused if the new ratios are 0*/
    601             tempPanzoomXa = (M4OSA_UInt8)pC->m_pPto3GPPparams->PanZoomXa;
    602             tempPanzoomXb = (M4OSA_UInt8)pC->m_pPto3GPPparams->PanZoomXb;
    603             /*Check that the ratio is not 0*/
    604             /*Check (a) parameters*/
    605             if(pC->m_pPto3GPPparams->PanZoomXa == 0)
    606             {
    607                 M4OSA_UInt8 maxRatio = 0;
    608                 if(pC->m_pPto3GPPparams->PanZoomTopleftXa >=
    609                      pC->m_pPto3GPPparams->PanZoomTopleftYa)
    610                 {
    611                     /*The ratio is 0, that means the area of the picture defined with (a)
    612                     parameters is bigger than the image size*/
    613                     if(pC->m_pPto3GPPparams->PanZoomTopleftXa + tempPanzoomXa > 1000)
    614                     {
    615                         /*The oversize is maxRatio*/
    616                         maxRatio = pC->m_pPto3GPPparams->PanZoomTopleftXa + tempPanzoomXa - 1000;
    617                     }
    618                 }
    619                 else
    620                 {
    621                     /*The ratio is 0, that means the area of the picture defined with (a)
    622                      parameters is bigger than the image size*/
    623                     if(pC->m_pPto3GPPparams->PanZoomTopleftYa + tempPanzoomXa > 1000)
    624                     {
    625                         /*The oversize is maxRatio*/
    626                         maxRatio = pC->m_pPto3GPPparams->PanZoomTopleftYa + tempPanzoomXa - 1000;
    627                     }
    628                 }
    629                 /*Modify the (a) parameters:*/
    630                 if(pC->m_pPto3GPPparams->PanZoomTopleftXa >= maxRatio)
    631                 {
    632                     /*The (a) topleft parameters can be moved to keep the same area size*/
    633                     pC->m_pPto3GPPparams->PanZoomTopleftXa -= maxRatio;
    634                 }
    635                 else
    636                 {
    637                     /*Move the (a) topleft parameter to 0 but the ratio will be also further
    638                     modified to match the image size*/
    639                     pC->m_pPto3GPPparams->PanZoomTopleftXa = 0;
    640                 }
    641                 if(pC->m_pPto3GPPparams->PanZoomTopleftYa >= maxRatio)
    642                 {
    643                     /*The (a) topleft parameters can be moved to keep the same area size*/
    644                     pC->m_pPto3GPPparams->PanZoomTopleftYa -= maxRatio;
    645                 }
    646                 else
    647                 {
    648                     /*Move the (a) topleft parameter to 0 but the ratio will be also further
    649                      modified to match the image size*/
    650                     pC->m_pPto3GPPparams->PanZoomTopleftYa = 0;
    651                 }
    652                 /*The new ratio is the original one*/
    653                 pC->m_pPto3GPPparams->PanZoomXa = tempPanzoomXa;
    654                 if(pC->m_pPto3GPPparams->PanZoomXa + pC->m_pPto3GPPparams->PanZoomTopleftXa > 1000)
    655                 {
    656                     /*Change the ratio if the area of the picture defined with (a) parameters is
    657                     bigger than the image size*/
    658                     pC->m_pPto3GPPparams->PanZoomXa = 1000 - pC->m_pPto3GPPparams->PanZoomTopleftXa;
    659                 }
    660                 if(pC->m_pPto3GPPparams->PanZoomXa + pC->m_pPto3GPPparams->PanZoomTopleftYa > 1000)
    661                 {
    662                     /*Change the ratio if the area of the picture defined with (a) parameters is
    663                     bigger than the image size*/
    664                     pC->m_pPto3GPPparams->PanZoomXa = 1000 - pC->m_pPto3GPPparams->PanZoomTopleftYa;
    665                 }
    666             }
    667             /*Check (b) parameters*/
    668             if(pC->m_pPto3GPPparams->PanZoomXb == 0)
    669             {
    670                 M4OSA_UInt8 maxRatio = 0;
    671                 if(pC->m_pPto3GPPparams->PanZoomTopleftXb >=
    672                      pC->m_pPto3GPPparams->PanZoomTopleftYb)
    673                 {
    674                     /*The ratio is 0, that means the area of the picture defined with (b)
    675                      parameters is bigger than the image size*/
    676                     if(pC->m_pPto3GPPparams->PanZoomTopleftXb + tempPanzoomXb > 1000)
    677                     {
    678                         /*The oversize is maxRatio*/
    679                         maxRatio = pC->m_pPto3GPPparams->PanZoomTopleftXb + tempPanzoomXb - 1000;
    680                     }
    681                 }
    682                 else
    683                 {
    684                     /*The ratio is 0, that means the area of the picture defined with (b)
    685                      parameters is bigger than the image size*/
    686                     if(pC->m_pPto3GPPparams->PanZoomTopleftYb + tempPanzoomXb > 1000)
    687                     {
    688                         /*The oversize is maxRatio*/
    689                         maxRatio = pC->m_pPto3GPPparams->PanZoomTopleftYb + tempPanzoomXb - 1000;
    690                     }
    691                 }
    692                 /*Modify the (b) parameters:*/
    693                 if(pC->m_pPto3GPPparams->PanZoomTopleftXb >= maxRatio)
    694                 {
    695                     /*The (b) topleft parameters can be moved to keep the same area size*/
    696                     pC->m_pPto3GPPparams->PanZoomTopleftXb -= maxRatio;
    697                 }
    698                 else
    699                 {
    700                     /*Move the (b) topleft parameter to 0 but the ratio will be also further
    701                      modified to match the image size*/
    702                     pC->m_pPto3GPPparams->PanZoomTopleftXb = 0;
    703                 }
    704                 if(pC->m_pPto3GPPparams->PanZoomTopleftYb >= maxRatio)
    705                 {
    706                     /*The (b) topleft parameters can be moved to keep the same area size*/
    707                     pC->m_pPto3GPPparams->PanZoomTopleftYb -= maxRatio;
    708                 }
    709                 else
    710                 {
    711                     /*Move the (b) topleft parameter to 0 but the ratio will be also further
    712                     modified to match the image size*/
    713                     pC->m_pPto3GPPparams->PanZoomTopleftYb = 0;
    714                 }
    715                 /*The new ratio is the original one*/
    716                 pC->m_pPto3GPPparams->PanZoomXb = tempPanzoomXb;
    717                 if(pC->m_pPto3GPPparams->PanZoomXb + pC->m_pPto3GPPparams->PanZoomTopleftXb > 1000)
    718                 {
    719                     /*Change the ratio if the area of the picture defined with (b) parameters is
    720                     bigger than the image size*/
    721                     pC->m_pPto3GPPparams->PanZoomXb = 1000 - pC->m_pPto3GPPparams->PanZoomTopleftXb;
    722                 }
    723                 if(pC->m_pPto3GPPparams->PanZoomXb + pC->m_pPto3GPPparams->PanZoomTopleftYb > 1000)
    724                 {
    725                     /*Change the ratio if the area of the picture defined with (b) parameters is
    726                     bigger than the image size*/
    727                     pC->m_pPto3GPPparams->PanZoomXb = 1000 - pC->m_pPto3GPPparams->PanZoomTopleftYb;
    728                 }
    729             }
    730 
    731             /**
    732              * Computes AIR parameters */
    733 /*        Params.m_inputCoord.m_x = (M4OSA_UInt32)(pC->m_pDecodedPlane->u_width *
    734             (pC->m_pPto3GPPparams->PanZoomTopleftXa +
    735             (M4OSA_Int16)((pC->m_pPto3GPPparams->PanZoomTopleftXb \
    736                 - pC->m_pPto3GPPparams->PanZoomTopleftXa) *
    737             pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage)) / 100;
    738         Params.m_inputCoord.m_y = (M4OSA_UInt32)(pC->m_pDecodedPlane->u_height *
    739             (pC->m_pPto3GPPparams->PanZoomTopleftYa +
    740             (M4OSA_Int16)((pC->m_pPto3GPPparams->PanZoomTopleftYb\
    741                  - pC->m_pPto3GPPparams->PanZoomTopleftYa) *
    742             pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage)) / 100;
    743 
    744         Params.m_inputSize.m_width = (M4OSA_UInt32)(pC->m_pDecodedPlane->u_width *
    745             (pC->m_pPto3GPPparams->PanZoomXa +
    746             (M4OSA_Int16)((pC->m_pPto3GPPparams->PanZoomXb - pC->m_pPto3GPPparams->PanZoomXa) *
    747             pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage)) / 100;
    748 
    749         Params.m_inputSize.m_height =  (M4OSA_UInt32)(pC->m_pDecodedPlane->u_height *
    750             (pC->m_pPto3GPPparams->PanZoomXa +
    751             (M4OSA_Int16)((pC->m_pPto3GPPparams->PanZoomXb - pC->m_pPto3GPPparams->PanZoomXa) *
    752             pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage)) / 100;
    753  */
    754             // Instead of using pC->m_NbImage we have to use (pC->m_NbImage-1) as pC->m_ImageCounter
    755             // will be x-1 max for x no. of frames
    756             Params.m_inputCoord.m_x = (M4OSA_UInt32)((((M4OSA_Double)pC->m_pDecodedPlane->u_width *
    757                 (pC->m_pPto3GPPparams->PanZoomTopleftXa +
    758                 (M4OSA_Double)((M4OSA_Double)(pC->m_pPto3GPPparams->PanZoomTopleftXb\
    759                      - pC->m_pPto3GPPparams->PanZoomTopleftXa) *
    760                 pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage-1)) / 1000));
    761             Params.m_inputCoord.m_y =
    762                  (M4OSA_UInt32)((((M4OSA_Double)pC->m_pDecodedPlane->u_height *
    763                 (pC->m_pPto3GPPparams->PanZoomTopleftYa +
    764                 (M4OSA_Double)((M4OSA_Double)(pC->m_pPto3GPPparams->PanZoomTopleftYb\
    765                      - pC->m_pPto3GPPparams->PanZoomTopleftYa) *
    766                 pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage-1)) / 1000));
    767 
    768             Params.m_inputSize.m_width =
    769                  (M4OSA_UInt32)((((M4OSA_Double)pC->m_pDecodedPlane->u_width *
    770                 (pC->m_pPto3GPPparams->PanZoomXa +
    771                 (M4OSA_Double)((M4OSA_Double)(pC->m_pPto3GPPparams->PanZoomXb\
    772                      - pC->m_pPto3GPPparams->PanZoomXa) *
    773                 pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage-1)) / 1000));
    774 
    775             Params.m_inputSize.m_height =
    776                  (M4OSA_UInt32)((((M4OSA_Double)pC->m_pDecodedPlane->u_height *
    777                 (pC->m_pPto3GPPparams->PanZoomXa +
    778                 (M4OSA_Double)((M4OSA_Double)(pC->m_pPto3GPPparams->PanZoomXb \
    779                     - pC->m_pPto3GPPparams->PanZoomXa) *
    780                 pC->m_ImageCounter) / (M4OSA_Double)pC->m_NbImage-1)) / 1000));
    781 
    782             if((Params.m_inputSize.m_width + Params.m_inputCoord.m_x)\
    783                  > pC->m_pDecodedPlane->u_width)
    784             {
    785                 Params.m_inputSize.m_width = pC->m_pDecodedPlane->u_width \
    786                     - Params.m_inputCoord.m_x;
    787             }
    788 
    789             if((Params.m_inputSize.m_height + Params.m_inputCoord.m_y)\
    790                  > pC->m_pDecodedPlane->u_height)
    791             {
    792                 Params.m_inputSize.m_height = pC->m_pDecodedPlane->u_height\
    793                      - Params.m_inputCoord.m_y;
    794             }
    795 
    796 
    797 
    798             Params.m_inputSize.m_width = (Params.m_inputSize.m_width>>1)<<1;
    799             Params.m_inputSize.m_height = (Params.m_inputSize.m_height>>1)<<1;
    800         }
    801 
    802 
    803 
    804     /**
    805         Picture rendering: Black borders*/
    806 
    807         if(pC->m_mediaRendering == M4xVSS_kBlackBorders)
    808         {
    809             memset((void *)pImagePlanes[0].pac_data,Y_PLANE_BORDER_VALUE,
    810                 (pImagePlanes[0].u_height*pImagePlanes[0].u_stride));
    811             memset((void *)pImagePlanes[1].pac_data,U_PLANE_BORDER_VALUE,
    812                 (pImagePlanes[1].u_height*pImagePlanes[1].u_stride));
    813             memset((void *)pImagePlanes[2].pac_data,V_PLANE_BORDER_VALUE,
    814                 (pImagePlanes[2].u_height*pImagePlanes[2].u_stride));
    815 
    816             /**
    817             First without pan&zoom*/
    818             if(M4OSA_FALSE == pC->m_pPto3GPPparams->isPanZoom)
    819             {
    820                 switch(pBasicTags.orientation)
    821                 {
    822                 default:
    823                 case M4COMMON_kOrientationUnknown:
    824                     Params.m_outputOrientation = M4COMMON_kOrientationTopLeft;
    825                 case M4COMMON_kOrientationTopLeft:
    826                 case M4COMMON_kOrientationTopRight:
    827                 case M4COMMON_kOrientationBottomRight:
    828                 case M4COMMON_kOrientationBottomLeft:
    829                     if((M4OSA_UInt32)((pC->m_pDecodedPlane->u_height * pImagePlanes->u_width)\
    830                          /pC->m_pDecodedPlane->u_width) <= pImagePlanes->u_height)
    831                          //Params.m_inputSize.m_height < Params.m_inputSize.m_width)
    832                     {
    833                         /*it is height so black borders will be on the top and on the bottom side*/
    834                         Params.m_outputSize.m_width = pImagePlanes->u_width;
    835                         Params.m_outputSize.m_height =
    836                              (M4OSA_UInt32)((pC->m_pDecodedPlane->u_height \
    837                                 * pImagePlanes->u_width) /pC->m_pDecodedPlane->u_width);
    838                         /*number of lines at the top*/
    839                         pImagePlanes[0].u_topleft =
    840                             (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_height\
    841                                 -Params.m_outputSize.m_height)>>1))*pImagePlanes[0].u_stride;
    842                         pImagePlanes[0].u_height = Params.m_outputSize.m_height;
    843                         pImagePlanes[1].u_topleft =
    844                              (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_height\
    845                                 -(Params.m_outputSize.m_height>>1)))>>1)*pImagePlanes[1].u_stride;
    846                         pImagePlanes[1].u_height = Params.m_outputSize.m_height>>1;
    847                         pImagePlanes[2].u_topleft =
    848                              (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_height\
    849                                 -(Params.m_outputSize.m_height>>1)))>>1)*pImagePlanes[2].u_stride;
    850                         pImagePlanes[2].u_height = Params.m_outputSize.m_height>>1;
    851                     }
    852                     else
    853                     {
    854                         /*it is width so black borders will be on the left and right side*/
    855                         Params.m_outputSize.m_height = pImagePlanes->u_height;
    856                         Params.m_outputSize.m_width =
    857                              (M4OSA_UInt32)((pC->m_pDecodedPlane->u_width \
    858                                 * pImagePlanes->u_height) /pC->m_pDecodedPlane->u_height);
    859 
    860                         pImagePlanes[0].u_topleft =
    861                             (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_width\
    862                                 -Params.m_outputSize.m_width)>>1));
    863                         pImagePlanes[0].u_width = Params.m_outputSize.m_width;
    864                         pImagePlanes[1].u_topleft =
    865                              (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_width\
    866                                 -(Params.m_outputSize.m_width>>1)))>>1);
    867                         pImagePlanes[1].u_width = Params.m_outputSize.m_width>>1;
    868                         pImagePlanes[2].u_topleft =
    869                              (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_width\
    870                                 -(Params.m_outputSize.m_width>>1)))>>1);
    871                         pImagePlanes[2].u_width = Params.m_outputSize.m_width>>1;
    872                     }
    873                     break;
    874                 case M4COMMON_kOrientationLeftTop:
    875                 case M4COMMON_kOrientationLeftBottom:
    876                 case M4COMMON_kOrientationRightTop:
    877                 case M4COMMON_kOrientationRightBottom:
    878                         if((M4OSA_UInt32)((pC->m_pDecodedPlane->u_width * pImagePlanes->u_width)\
    879                              /pC->m_pDecodedPlane->u_height) < pImagePlanes->u_height)
    880                              //Params.m_inputSize.m_height > Params.m_inputSize.m_width)
    881                         {
    882                             /*it is height so black borders will be on the top and on
    883                              the bottom side*/
    884                             Params.m_outputSize.m_height = pImagePlanes->u_width;
    885                             Params.m_outputSize.m_width =
    886                                  (M4OSA_UInt32)((pC->m_pDecodedPlane->u_width \
    887                                     * pImagePlanes->u_width) /pC->m_pDecodedPlane->u_height);
    888                             /*number of lines at the top*/
    889                             pImagePlanes[0].u_topleft =
    890                                 ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_height\
    891                                     -Params.m_outputSize.m_width))>>1)*pImagePlanes[0].u_stride)+1;
    892                             pImagePlanes[0].u_height = Params.m_outputSize.m_width;
    893                             pImagePlanes[1].u_topleft =
    894                                 ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_height\
    895                                     -(Params.m_outputSize.m_width>>1)))>>1)\
    896                                         *pImagePlanes[1].u_stride)+1;
    897                             pImagePlanes[1].u_height = Params.m_outputSize.m_width>>1;
    898                             pImagePlanes[2].u_topleft =
    899                                 ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_height\
    900                                     -(Params.m_outputSize.m_width>>1)))>>1)\
    901                                         *pImagePlanes[2].u_stride)+1;
    902                             pImagePlanes[2].u_height = Params.m_outputSize.m_width>>1;
    903                         }
    904                         else
    905                         {
    906                             /*it is width so black borders will be on the left and right side*/
    907                             Params.m_outputSize.m_width = pImagePlanes->u_height;
    908                             Params.m_outputSize.m_height =
    909                                  (M4OSA_UInt32)((pC->m_pDecodedPlane->u_height\
    910                                      * pImagePlanes->u_height) /pC->m_pDecodedPlane->u_width);
    911 
    912                             pImagePlanes[0].u_topleft =
    913                                  ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_width\
    914                                     -Params.m_outputSize.m_height))>>1))+1;
    915                             pImagePlanes[0].u_width = Params.m_outputSize.m_height;
    916                             pImagePlanes[1].u_topleft =
    917                                  ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_width\
    918                                     -(Params.m_outputSize.m_height>>1)))>>1))+1;
    919                             pImagePlanes[1].u_width = Params.m_outputSize.m_height>>1;
    920                             pImagePlanes[2].u_topleft =
    921                                  ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_width\
    922                                     -(Params.m_outputSize.m_height>>1)))>>1))+1;
    923                             pImagePlanes[2].u_width = Params.m_outputSize.m_height>>1;
    924                         }
    925                     break;
    926                 }
    927             }
    928 
    929             /**
    930             Secondly with pan&zoom*/
    931             else
    932             {
    933                 switch(pBasicTags.orientation)
    934                 {
    935                 default:
    936                 case M4COMMON_kOrientationUnknown:
    937                     Params.m_outputOrientation = M4COMMON_kOrientationTopLeft;
    938                 case M4COMMON_kOrientationTopLeft:
    939                 case M4COMMON_kOrientationTopRight:
    940                 case M4COMMON_kOrientationBottomRight:
    941                 case M4COMMON_kOrientationBottomLeft:
    942                     /*NO ROTATION*/
    943                     if((M4OSA_UInt32)((pC->m_pDecodedPlane->u_height * pImagePlanes->u_width)\
    944                          /pC->m_pDecodedPlane->u_width) <= pImagePlanes->u_height)
    945                             //Params.m_inputSize.m_height < Params.m_inputSize.m_width)
    946                     {
    947                         /*Black borders will be on the top and bottom of the output video*/
    948                         /*Maximum output height if the input image aspect ratio is kept and if
    949                         the output width is the screen width*/
    950                         M4OSA_UInt32 tempOutputSizeHeight =
    951                             (M4OSA_UInt32)((pC->m_pDecodedPlane->u_height\
    952                                  * pImagePlanes->u_width) /pC->m_pDecodedPlane->u_width);
    953                         M4OSA_UInt32 tempInputSizeHeightMax = 0;
    954                         M4OSA_UInt32 tempFinalInputHeight = 0;
    955                         /*The output width is the screen width*/
    956                         Params.m_outputSize.m_width = pImagePlanes->u_width;
    957                         tempOutputSizeHeight = (tempOutputSizeHeight>>1)<<1;
    958 
    959                         /*Maximum input height according to the maximum output height
    960                         (proportional to the maximum output height)*/
    961                         tempInputSizeHeightMax = (pImagePlanes->u_height\
    962                             *Params.m_inputSize.m_height)/tempOutputSizeHeight;
    963                         tempInputSizeHeightMax = (tempInputSizeHeightMax>>1)<<1;
    964 
    965                         /*Check if the maximum possible input height is contained into the
    966                         input image height*/
    967                         if(tempInputSizeHeightMax <= pC->m_pDecodedPlane->u_height)
    968                         {
    969                             /*The maximum possible input height is contained in the input
    970                             image height,
    971                             that means no black borders, the input pan zoom area will be extended
    972                             so that the input AIR height will be the maximum possible*/
    973                             if(((tempInputSizeHeightMax - Params.m_inputSize.m_height)>>1)\
    974                                  <= Params.m_inputCoord.m_y
    975                                 && ((tempInputSizeHeightMax - Params.m_inputSize.m_height)>>1)\
    976                                      <= pC->m_pDecodedPlane->u_height -(Params.m_inputCoord.m_y\
    977                                          + Params.m_inputSize.m_height))
    978                             {
    979                                 /*The input pan zoom area can be extended symmetrically on the
    980                                 top and bottom side*/
    981                                 Params.m_inputCoord.m_y -= ((tempInputSizeHeightMax \
    982                                     - Params.m_inputSize.m_height)>>1);
    983                             }
    984                             else if(Params.m_inputCoord.m_y < pC->m_pDecodedPlane->u_height\
    985                                 -(Params.m_inputCoord.m_y + Params.m_inputSize.m_height))
    986                             {
    987                                 /*There is not enough place above the input pan zoom area to
    988                                 extend it symmetrically,
    989                                 so extend it to the maximum on the top*/
    990                                 Params.m_inputCoord.m_y = 0;
    991                             }
    992                             else
    993                             {
    994                                 /*There is not enough place below the input pan zoom area to
    995                                 extend it symmetrically,
    996                                 so extend it to the maximum on the bottom*/
    997                                 Params.m_inputCoord.m_y = pC->m_pDecodedPlane->u_height \
    998                                     - tempInputSizeHeightMax;
    999                             }
   1000                             /*The input height of the AIR is the maximum possible height*/
   1001                             Params.m_inputSize.m_height = tempInputSizeHeightMax;
   1002                         }
   1003                         else
   1004                         {
   1005                             /*The maximum possible input height is greater than the input
   1006                             image height,
   1007                             that means black borders are necessary to keep aspect ratio
   1008                             The input height of the AIR is all the input image height*/
   1009                             Params.m_outputSize.m_height =
   1010                                 (tempOutputSizeHeight*pC->m_pDecodedPlane->u_height)\
   1011                                     /Params.m_inputSize.m_height;
   1012                             Params.m_outputSize.m_height = (Params.m_outputSize.m_height>>1)<<1;
   1013                             Params.m_inputCoord.m_y = 0;
   1014                             Params.m_inputSize.m_height = pC->m_pDecodedPlane->u_height;
   1015                             pImagePlanes[0].u_topleft =
   1016                                  (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_height\
   1017                                     -Params.m_outputSize.m_height)>>1))*pImagePlanes[0].u_stride;
   1018                             pImagePlanes[0].u_height = Params.m_outputSize.m_height;
   1019                             pImagePlanes[1].u_topleft =
   1020                                 ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_height\
   1021                                     -(Params.m_outputSize.m_height>>1)))>>1)\
   1022                                         *pImagePlanes[1].u_stride);
   1023                             pImagePlanes[1].u_height = Params.m_outputSize.m_height>>1;
   1024                             pImagePlanes[2].u_topleft =
   1025                                  ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_height\
   1026                                     -(Params.m_outputSize.m_height>>1)))>>1)\
   1027                                         *pImagePlanes[2].u_stride);
   1028                             pImagePlanes[2].u_height = Params.m_outputSize.m_height>>1;
   1029                         }
   1030                     }
   1031                     else
   1032                     {
   1033                         /*Black borders will be on the left and right side of the output video*/
   1034                         /*Maximum output width if the input image aspect ratio is kept and if the
   1035                          output height is the screen height*/
   1036                         M4OSA_UInt32 tempOutputSizeWidth =
   1037                              (M4OSA_UInt32)((pC->m_pDecodedPlane->u_width \
   1038                                 * pImagePlanes->u_height) /pC->m_pDecodedPlane->u_height);
   1039                         M4OSA_UInt32 tempInputSizeWidthMax = 0;
   1040                         M4OSA_UInt32 tempFinalInputWidth = 0;
   1041                         /*The output height is the screen height*/
   1042                         Params.m_outputSize.m_height = pImagePlanes->u_height;
   1043                         tempOutputSizeWidth = (tempOutputSizeWidth>>1)<<1;
   1044 
   1045                         /*Maximum input width according to the maximum output width
   1046                         (proportional to the maximum output width)*/
   1047                         tempInputSizeWidthMax =
   1048                              (pImagePlanes->u_width*Params.m_inputSize.m_width)\
   1049                                 /tempOutputSizeWidth;
   1050                         tempInputSizeWidthMax = (tempInputSizeWidthMax>>1)<<1;
   1051 
   1052                         /*Check if the maximum possible input width is contained into the input
   1053                          image width*/
   1054                         if(tempInputSizeWidthMax <= pC->m_pDecodedPlane->u_width)
   1055                         {
   1056                             /*The maximum possible input width is contained in the input
   1057                             image width,
   1058                             that means no black borders, the input pan zoom area will be extended
   1059                             so that the input AIR width will be the maximum possible*/
   1060                             if(((tempInputSizeWidthMax - Params.m_inputSize.m_width)>>1) \
   1061                                 <= Params.m_inputCoord.m_x
   1062                                 && ((tempInputSizeWidthMax - Params.m_inputSize.m_width)>>1)\
   1063                                      <= pC->m_pDecodedPlane->u_width -(Params.m_inputCoord.m_x \
   1064                                         + Params.m_inputSize.m_width))
   1065                             {
   1066                                 /*The input pan zoom area can be extended symmetrically on the
   1067                                      right and left side*/
   1068                                 Params.m_inputCoord.m_x -= ((tempInputSizeWidthMax\
   1069                                      - Params.m_inputSize.m_width)>>1);
   1070                             }
   1071                             else if(Params.m_inputCoord.m_x < pC->m_pDecodedPlane->u_width\
   1072                                 -(Params.m_inputCoord.m_x + Params.m_inputSize.m_width))
   1073                             {
   1074                                 /*There is not enough place above the input pan zoom area to
   1075                                     extend it symmetrically,
   1076                                 so extend it to the maximum on the left*/
   1077                                 Params.m_inputCoord.m_x = 0;
   1078                             }
   1079                             else
   1080                             {
   1081                                 /*There is not enough place below the input pan zoom area
   1082                                     to extend it symmetrically,
   1083                                 so extend it to the maximum on the right*/
   1084                                 Params.m_inputCoord.m_x = pC->m_pDecodedPlane->u_width \
   1085                                     - tempInputSizeWidthMax;
   1086                             }
   1087                             /*The input width of the AIR is the maximum possible width*/
   1088                             Params.m_inputSize.m_width = tempInputSizeWidthMax;
   1089                         }
   1090                         else
   1091                         {
   1092                             /*The maximum possible input width is greater than the input
   1093                             image width,
   1094                             that means black borders are necessary to keep aspect ratio
   1095                             The input width of the AIR is all the input image width*/
   1096                             Params.m_outputSize.m_width =\
   1097                                  (tempOutputSizeWidth*pC->m_pDecodedPlane->u_width)\
   1098                                     /Params.m_inputSize.m_width;
   1099                             Params.m_outputSize.m_width = (Params.m_outputSize.m_width>>1)<<1;
   1100                             Params.m_inputCoord.m_x = 0;
   1101                             Params.m_inputSize.m_width = pC->m_pDecodedPlane->u_width;
   1102                             pImagePlanes[0].u_topleft =
   1103                                  (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_width\
   1104                                     -Params.m_outputSize.m_width)>>1));
   1105                             pImagePlanes[0].u_width = Params.m_outputSize.m_width;
   1106                             pImagePlanes[1].u_topleft =
   1107                                  (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_width\
   1108                                     -(Params.m_outputSize.m_width>>1)))>>1);
   1109                             pImagePlanes[1].u_width = Params.m_outputSize.m_width>>1;
   1110                             pImagePlanes[2].u_topleft =
   1111                                  (M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_width\
   1112                                     -(Params.m_outputSize.m_width>>1)))>>1);
   1113                             pImagePlanes[2].u_width = Params.m_outputSize.m_width>>1;
   1114                         }
   1115                     }
   1116                     break;
   1117                 case M4COMMON_kOrientationLeftTop:
   1118                 case M4COMMON_kOrientationLeftBottom:
   1119                 case M4COMMON_kOrientationRightTop:
   1120                 case M4COMMON_kOrientationRightBottom:
   1121                     /*ROTATION*/
   1122                     if((M4OSA_UInt32)((pC->m_pDecodedPlane->u_width * pImagePlanes->u_width)\
   1123                          /pC->m_pDecodedPlane->u_height) < pImagePlanes->u_height)
   1124                          //Params.m_inputSize.m_height > Params.m_inputSize.m_width)
   1125                     {
   1126                         /*Black borders will be on the left and right side of the output video*/
   1127                         /*Maximum output height if the input image aspect ratio is kept and if
   1128                         the output height is the screen width*/
   1129                         M4OSA_UInt32 tempOutputSizeHeight =
   1130                         (M4OSA_UInt32)((pC->m_pDecodedPlane->u_width * pImagePlanes->u_width)\
   1131                              /pC->m_pDecodedPlane->u_height);
   1132                         M4OSA_UInt32 tempInputSizeHeightMax = 0;
   1133                         M4OSA_UInt32 tempFinalInputHeight = 0;
   1134                         /*The output width is the screen height*/
   1135                         Params.m_outputSize.m_height = pImagePlanes->u_width;
   1136                         Params.m_outputSize.m_width= pImagePlanes->u_height;
   1137                         tempOutputSizeHeight = (tempOutputSizeHeight>>1)<<1;
   1138 
   1139                         /*Maximum input height according to the maximum output height
   1140                              (proportional to the maximum output height)*/
   1141                         tempInputSizeHeightMax =
   1142                             (pImagePlanes->u_height*Params.m_inputSize.m_width)\
   1143                                 /tempOutputSizeHeight;
   1144                         tempInputSizeHeightMax = (tempInputSizeHeightMax>>1)<<1;
   1145 
   1146                         /*Check if the maximum possible input height is contained into the
   1147                              input image width (rotation included)*/
   1148                         if(tempInputSizeHeightMax <= pC->m_pDecodedPlane->u_width)
   1149                         {
   1150                             /*The maximum possible input height is contained in the input
   1151                             image width (rotation included),
   1152                             that means no black borders, the input pan zoom area will be extended
   1153                             so that the input AIR width will be the maximum possible*/
   1154                             if(((tempInputSizeHeightMax - Params.m_inputSize.m_width)>>1) \
   1155                                 <= Params.m_inputCoord.m_x
   1156                                 && ((tempInputSizeHeightMax - Params.m_inputSize.m_width)>>1)\
   1157                                      <= pC->m_pDecodedPlane->u_width -(Params.m_inputCoord.m_x \
   1158                                         + Params.m_inputSize.m_width))
   1159                             {
   1160                                 /*The input pan zoom area can be extended symmetrically on the
   1161                                  right and left side*/
   1162                                 Params.m_inputCoord.m_x -= ((tempInputSizeHeightMax \
   1163                                     - Params.m_inputSize.m_width)>>1);
   1164                             }
   1165                             else if(Params.m_inputCoord.m_x < pC->m_pDecodedPlane->u_width\
   1166                                 -(Params.m_inputCoord.m_x + Params.m_inputSize.m_width))
   1167                             {
   1168                                 /*There is not enough place on the left of the input pan
   1169                                 zoom area to extend it symmetrically,
   1170                                 so extend it to the maximum on the left*/
   1171                                 Params.m_inputCoord.m_x = 0;
   1172                             }
   1173                             else
   1174                             {
   1175                                 /*There is not enough place on the right of the input pan zoom
   1176                                  area to extend it symmetrically,
   1177                                 so extend it to the maximum on the right*/
   1178                                 Params.m_inputCoord.m_x =
   1179                                      pC->m_pDecodedPlane->u_width - tempInputSizeHeightMax;
   1180                             }
   1181                             /*The input width of the AIR is the maximum possible width*/
   1182                             Params.m_inputSize.m_width = tempInputSizeHeightMax;
   1183                         }
   1184                         else
   1185                         {
   1186                             /*The maximum possible input height is greater than the input
   1187                             image width (rotation included),
   1188                             that means black borders are necessary to keep aspect ratio
   1189                             The input width of the AIR is all the input image width*/
   1190                             Params.m_outputSize.m_width =
   1191                             (tempOutputSizeHeight*pC->m_pDecodedPlane->u_width)\
   1192                                 /Params.m_inputSize.m_width;
   1193                             Params.m_outputSize.m_width = (Params.m_outputSize.m_width>>1)<<1;
   1194                             Params.m_inputCoord.m_x = 0;
   1195                             Params.m_inputSize.m_width = pC->m_pDecodedPlane->u_width;
   1196                             pImagePlanes[0].u_topleft =
   1197                                 ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_height\
   1198                                     -Params.m_outputSize.m_width))>>1)*pImagePlanes[0].u_stride)+1;
   1199                             pImagePlanes[0].u_height = Params.m_outputSize.m_width;
   1200                             pImagePlanes[1].u_topleft =
   1201                             ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_height\
   1202                                 -(Params.m_outputSize.m_width>>1)))>>1)\
   1203                                     *pImagePlanes[1].u_stride)+1;
   1204                             pImagePlanes[1].u_height = Params.m_outputSize.m_width>>1;
   1205                             pImagePlanes[2].u_topleft =
   1206                             ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_height\
   1207                                 -(Params.m_outputSize.m_width>>1)))>>1)\
   1208                                     *pImagePlanes[2].u_stride)+1;
   1209                             pImagePlanes[2].u_height = Params.m_outputSize.m_width>>1;
   1210                         }
   1211                     }
   1212                     else
   1213                     {
   1214                         /*Black borders will be on the top and bottom of the output video*/
   1215                         /*Maximum output width if the input image aspect ratio is kept and if
   1216                          the output width is the screen height*/
   1217                         M4OSA_UInt32 tempOutputSizeWidth =
   1218                         (M4OSA_UInt32)((pC->m_pDecodedPlane->u_height * pImagePlanes->u_height)\
   1219                              /pC->m_pDecodedPlane->u_width);
   1220                         M4OSA_UInt32 tempInputSizeWidthMax = 0;
   1221                         M4OSA_UInt32 tempFinalInputWidth = 0, tempFinalOutputWidth = 0;
   1222                         /*The output height is the screen width*/
   1223                         Params.m_outputSize.m_width = pImagePlanes->u_height;
   1224                         Params.m_outputSize.m_height= pImagePlanes->u_width;
   1225                         tempOutputSizeWidth = (tempOutputSizeWidth>>1)<<1;
   1226 
   1227                         /*Maximum input width according to the maximum output width
   1228                          (proportional to the maximum output width)*/
   1229                         tempInputSizeWidthMax =
   1230                         (pImagePlanes->u_width*Params.m_inputSize.m_height)/tempOutputSizeWidth;
   1231                         tempInputSizeWidthMax = (tempInputSizeWidthMax>>1)<<1;
   1232 
   1233                         /*Check if the maximum possible input width is contained into the input
   1234                          image height (rotation included)*/
   1235                         if(tempInputSizeWidthMax <= pC->m_pDecodedPlane->u_height)
   1236                         {
   1237                             /*The maximum possible input width is contained in the input
   1238                              image height (rotation included),
   1239                             that means no black borders, the input pan zoom area will be extended
   1240                             so that the input AIR height will be the maximum possible*/
   1241                             if(((tempInputSizeWidthMax - Params.m_inputSize.m_height)>>1) \
   1242                                 <= Params.m_inputCoord.m_y
   1243                                 && ((tempInputSizeWidthMax - Params.m_inputSize.m_height)>>1)\
   1244                                      <= pC->m_pDecodedPlane->u_height -(Params.m_inputCoord.m_y \
   1245                                         + Params.m_inputSize.m_height))
   1246                             {
   1247                                 /*The input pan zoom area can be extended symmetrically on
   1248                                 the right and left side*/
   1249                                 Params.m_inputCoord.m_y -= ((tempInputSizeWidthMax \
   1250                                     - Params.m_inputSize.m_height)>>1);
   1251                             }
   1252                             else if(Params.m_inputCoord.m_y < pC->m_pDecodedPlane->u_height\
   1253                                 -(Params.m_inputCoord.m_y + Params.m_inputSize.m_height))
   1254                             {
   1255                                 /*There is not enough place on the top of the input pan zoom
   1256                                 area to extend it symmetrically,
   1257                                 so extend it to the maximum on the top*/
   1258                                 Params.m_inputCoord.m_y = 0;
   1259                             }
   1260                             else
   1261                             {
   1262                                 /*There is not enough place on the bottom of the input pan zoom
   1263                                  area to extend it symmetrically,
   1264                                 so extend it to the maximum on the bottom*/
   1265                                 Params.m_inputCoord.m_y = pC->m_pDecodedPlane->u_height\
   1266                                      - tempInputSizeWidthMax;
   1267                             }
   1268                             /*The input height of the AIR is the maximum possible height*/
   1269                             Params.m_inputSize.m_height = tempInputSizeWidthMax;
   1270                         }
   1271                         else
   1272                         {
   1273                             /*The maximum possible input width is greater than the input\
   1274                              image height (rotation included),
   1275                             that means black borders are necessary to keep aspect ratio
   1276                             The input height of the AIR is all the input image height*/
   1277                             Params.m_outputSize.m_height =
   1278                                 (tempOutputSizeWidth*pC->m_pDecodedPlane->u_height)\
   1279                                     /Params.m_inputSize.m_height;
   1280                             Params.m_outputSize.m_height = (Params.m_outputSize.m_height>>1)<<1;
   1281                             Params.m_inputCoord.m_y = 0;
   1282                             Params.m_inputSize.m_height = pC->m_pDecodedPlane->u_height;
   1283                             pImagePlanes[0].u_topleft =
   1284                                 ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[0].u_width\
   1285                                     -Params.m_outputSize.m_height))>>1))+1;
   1286                             pImagePlanes[0].u_width = Params.m_outputSize.m_height;
   1287                             pImagePlanes[1].u_topleft =
   1288                                 ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[1].u_width\
   1289                                     -(Params.m_outputSize.m_height>>1)))>>1))+1;
   1290                             pImagePlanes[1].u_width = Params.m_outputSize.m_height>>1;
   1291                             pImagePlanes[2].u_topleft =
   1292                                  ((M4xVSS_ABS((M4OSA_Int32)(pImagePlanes[2].u_width\
   1293                                     -(Params.m_outputSize.m_height>>1)))>>1))+1;
   1294                             pImagePlanes[2].u_width = Params.m_outputSize.m_height>>1;
   1295                         }
   1296                     }
   1297                     break;
   1298                 }
   1299             }
   1300 
   1301             /*Width and height have to be even*/
   1302             Params.m_outputSize.m_width = (Params.m_outputSize.m_width>>1)<<1;
   1303             Params.m_outputSize.m_height = (Params.m_outputSize.m_height>>1)<<1;
   1304             Params.m_inputSize.m_width = (Params.m_inputSize.m_width>>1)<<1;
   1305             Params.m_inputSize.m_height = (Params.m_inputSize.m_height>>1)<<1;
   1306             pImagePlanes[0].u_width = (pImagePlanes[0].u_width>>1)<<1;
   1307             pImagePlanes[1].u_width = (pImagePlanes[1].u_width>>1)<<1;
   1308             pImagePlanes[2].u_width = (pImagePlanes[2].u_width>>1)<<1;
   1309             pImagePlanes[0].u_height = (pImagePlanes[0].u_height>>1)<<1;
   1310             pImagePlanes[1].u_height = (pImagePlanes[1].u_height>>1)<<1;
   1311             pImagePlanes[2].u_height = (pImagePlanes[2].u_height>>1)<<1;
   1312 
   1313             /*Check that values are coherent*/
   1314             if(Params.m_inputSize.m_height == Params.m_outputSize.m_height)
   1315             {
   1316                 Params.m_inputSize.m_width = Params.m_outputSize.m_width;
   1317             }
   1318             else if(Params.m_inputSize.m_width == Params.m_outputSize.m_width)
   1319             {
   1320                 Params.m_inputSize.m_height = Params.m_outputSize.m_height;
   1321             }
   1322         }
   1323 
   1324         /**
   1325         Picture rendering: Resizing and Cropping*/
   1326         if(pC->m_mediaRendering != M4xVSS_kBlackBorders)
   1327         {
   1328             switch(pBasicTags.orientation)
   1329             {
   1330             default:
   1331             case M4COMMON_kOrientationUnknown:
   1332                 Params.m_outputOrientation = M4COMMON_kOrientationTopLeft;
   1333             case M4COMMON_kOrientationTopLeft:
   1334             case M4COMMON_kOrientationTopRight:
   1335             case M4COMMON_kOrientationBottomRight:
   1336             case M4COMMON_kOrientationBottomLeft:
   1337                 Params.m_outputSize.m_height = pImagePlanes->u_height;
   1338                 Params.m_outputSize.m_width = pImagePlanes->u_width;
   1339                 break;
   1340             case M4COMMON_kOrientationLeftTop:
   1341             case M4COMMON_kOrientationLeftBottom:
   1342             case M4COMMON_kOrientationRightTop:
   1343             case M4COMMON_kOrientationRightBottom:
   1344                 Params.m_outputSize.m_height = pImagePlanes->u_width;
   1345                 Params.m_outputSize.m_width = pImagePlanes->u_height;
   1346                 break;
   1347             }
   1348         }
   1349 
   1350         /**
   1351         Picture rendering: Cropping*/
   1352         if(pC->m_mediaRendering == M4xVSS_kCropping)
   1353         {
   1354             if((Params.m_outputSize.m_height * Params.m_inputSize.m_width)\
   1355                  /Params.m_outputSize.m_width<Params.m_inputSize.m_height)
   1356             {
   1357                 M4OSA_UInt32 tempHeight = Params.m_inputSize.m_height;
   1358                 /*height will be cropped*/
   1359                 Params.m_inputSize.m_height =  (M4OSA_UInt32)((Params.m_outputSize.m_height \
   1360                     * Params.m_inputSize.m_width) /Params.m_outputSize.m_width);
   1361                 Params.m_inputSize.m_height =  (Params.m_inputSize.m_height>>1)<<1;
   1362                 if(M4OSA_FALSE == pC->m_pPto3GPPparams->isPanZoom)
   1363                 {
   1364                     Params.m_inputCoord.m_y = (M4OSA_Int32)((M4OSA_Int32)\
   1365                         ((pC->m_pDecodedPlane->u_height - Params.m_inputSize.m_height))>>1);
   1366                 }
   1367                 else
   1368                 {
   1369                     Params.m_inputCoord.m_y += (M4OSA_Int32)((M4OSA_Int32)\
   1370                         ((tempHeight - Params.m_inputSize.m_height))>>1);
   1371                 }
   1372             }
   1373             else
   1374             {
   1375                 M4OSA_UInt32 tempWidth= Params.m_inputSize.m_width;
   1376                 /*width will be cropped*/
   1377                 Params.m_inputSize.m_width =  (M4OSA_UInt32)((Params.m_outputSize.m_width \
   1378                     * Params.m_inputSize.m_height) /Params.m_outputSize.m_height);
   1379                 Params.m_inputSize.m_width =  (Params.m_inputSize.m_width>>1)<<1;
   1380                 if(M4OSA_FALSE == pC->m_pPto3GPPparams->isPanZoom)
   1381                 {
   1382                     Params.m_inputCoord.m_x = (M4OSA_Int32)((M4OSA_Int32)\
   1383                         ((pC->m_pDecodedPlane->u_width - Params.m_inputSize.m_width))>>1);
   1384                 }
   1385                 else
   1386                 {
   1387                     Params.m_inputCoord.m_x += (M4OSA_Int32)\
   1388                         (((M4OSA_Int32)(tempWidth - Params.m_inputSize.m_width))>>1);
   1389                 }
   1390             }
   1391         }
   1392 
   1393 
   1394 
   1395         /**
   1396          * Call AIR functions */
   1397         if(M4OSA_NULL == pC->m_air_context)
   1398         {
   1399             err = M4AIR_create(&pC->m_air_context, M4AIR_kYUV420P);
   1400             if(err != M4NO_ERROR)
   1401             {
   1402                 free(pC->m_pDecodedPlane[0].pac_data);
   1403                 free(pC->m_pDecodedPlane);
   1404                 pC->m_pDecodedPlane = M4OSA_NULL;
   1405                 M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct:\
   1406                      Error when initializing AIR: 0x%x", err);
   1407                 return err;
   1408             }
   1409         }
   1410 
   1411         err = M4AIR_configure(pC->m_air_context, &Params);
   1412         if(err != M4NO_ERROR)
   1413         {
   1414             M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct:\
   1415                  Error when configuring AIR: 0x%x", err);
   1416             M4AIR_cleanUp(pC->m_air_context);
   1417             free(pC->m_pDecodedPlane[0].pac_data);
   1418             free(pC->m_pDecodedPlane);
   1419             pC->m_pDecodedPlane = M4OSA_NULL;
   1420             return err;
   1421         }
   1422 
   1423         err = M4AIR_get(pC->m_air_context, pC->m_pDecodedPlane, pImagePlanes);
   1424         if(err != M4NO_ERROR)
   1425         {
   1426             M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct: Error when getting AIR plane: 0x%x", err);
   1427             M4AIR_cleanUp(pC->m_air_context);
   1428             free(pC->m_pDecodedPlane[0].pac_data);
   1429             free(pC->m_pDecodedPlane);
   1430             pC->m_pDecodedPlane = M4OSA_NULL;
   1431             return err;
   1432         }
   1433         pImagePlanes[0] = pImagePlanes1;
   1434         pImagePlanes[1] = pImagePlanes2;
   1435         pImagePlanes[2] = pImagePlanes3;
   1436     }
   1437 
   1438 
   1439     /**
   1440      * Increment the image counter */
   1441     pC->m_ImageCounter++;
   1442 
   1443     /**
   1444      * Check end of sequence */
   1445     last_frame_flag    = (pC->m_ImageCounter >= pC->m_NbImage);
   1446 
   1447     /**
   1448      * Keep the picture duration */
   1449     *pPictureDuration = pC->m_timeDuration;
   1450 
   1451     if (1 == last_frame_flag)
   1452     {
   1453         if(M4OSA_NULL != pC->m_air_context)
   1454         {
   1455             err = M4AIR_cleanUp(pC->m_air_context);
   1456             if(err != M4NO_ERROR)
   1457             {
   1458                 M4OSA_TRACE1_1("M4xVSS_PictureCallbackFct: Error when cleaning AIR: 0x%x", err);
   1459                 return err;
   1460             }
   1461         }
   1462         if(M4OSA_NULL != pC->m_pDecodedPlane)
   1463         {
   1464             free(pC->m_pDecodedPlane[0].pac_data);
   1465             free(pC->m_pDecodedPlane);
   1466             pC->m_pDecodedPlane = M4OSA_NULL;
   1467         }
   1468         return M4PTO3GPP_WAR_LAST_PICTURE;
   1469     }
   1470 
   1471     M4OSA_TRACE1_0("M4xVSS_PictureCallbackFct: Leaving ");
   1472     return M4NO_ERROR;
   1473 }
   1474 
   1475 /**
   1476  ******************************************************************************
   1477  * M4OSA_ERR M4xVSS_internalStartConvertPictureTo3gp(M4OSA_Context pContext)
   1478  * @brief    This function initializes Pto3GPP with the given parameters
   1479  * @note    The "Pictures to 3GPP" parameters are given by the internal xVSS
   1480  *            context. This context contains a pointer on the current element
   1481  *            of the chained list of Pto3GPP parameters.
   1482  * @param    pContext    (IN) The integrator own context
   1483  *
   1484  * @return    M4NO_ERROR:    No error
   1485  * @return    M4PTO3GPP_WAR_LAST_PICTURE: The returned image is the last one
   1486  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   1487  ******************************************************************************
   1488  */
   1489 M4OSA_ERR M4xVSS_internalStartConvertPictureTo3gp(M4OSA_Context pContext)
   1490 {
   1491     /************************************************************************/
   1492     /* Definitions to generate dummy AMR file used to add AMR silence in files generated
   1493      by Pto3GPP */
   1494     #define M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE     13
   1495     /* This constant is defined in M4VSS3GPP_InternalConfig.h */
   1496     extern const M4OSA_UInt8\
   1497          M4VSS3GPP_AMR_AU_SILENCE_FRAME_048[M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE];
   1498 
   1499     /* AMR silent frame used to compute dummy AMR silence file */
   1500     #define M4VSS3GPP_AMR_HEADER_SIZE 6
   1501     const M4OSA_UInt8 M4VSS3GPP_AMR_HEADER[M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE] =
   1502     { 0x23, 0x21, 0x41, 0x4d, 0x52, 0x0a };
   1503     /************************************************************************/
   1504 
   1505     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   1506     M4OSA_ERR err;
   1507     M4PTO3GPP_Context pM4PTO3GPP_Ctxt = M4OSA_NULL;
   1508     M4PTO3GPP_Params Params;
   1509      M4xVSS_PictureCallbackCtxt*    pCallBackCtxt;
   1510     M4OSA_Bool cmpResult=M4OSA_FALSE;
   1511     M4OSA_Context pDummyAMRFile;
   1512     M4OSA_Char out_amr[M4XVSS_MAX_PATH_LEN];
   1513     /*UTF conversion support*/
   1514     M4OSA_Char* pDecodedPath = M4OSA_NULL;
   1515     M4OSA_UInt32 i;
   1516 
   1517     /**
   1518      * Create a M4PTO3GPP instance */
   1519     err = M4PTO3GPP_Init( &pM4PTO3GPP_Ctxt, xVSS_context->pFileReadPtr,
   1520          xVSS_context->pFileWritePtr);
   1521     if (err != M4NO_ERROR)
   1522     {
   1523         M4OSA_TRACE1_1("M4xVSS_internalStartConvertPictureTo3gp returned %ld\n",err);
   1524         return err;
   1525     }
   1526 
   1527     pCallBackCtxt = (M4xVSS_PictureCallbackCtxt*)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_PictureCallbackCtxt),
   1528          M4VS,(M4OSA_Char *) "Pto3gpp callback struct");
   1529     if(pCallBackCtxt == M4OSA_NULL)
   1530     {
   1531         M4OSA_TRACE1_0("Allocation error in M4xVSS_internalStartConvertPictureTo3gp");
   1532         return M4ERR_ALLOC;
   1533     }
   1534 
   1535     Params.OutputVideoFrameSize = xVSS_context->pSettings->xVSS.outputVideoSize;
   1536     Params.OutputVideoFormat = xVSS_context->pSettings->xVSS.outputVideoFormat;
   1537     Params.videoProfile = xVSS_context->pSettings->xVSS.outputVideoProfile;
   1538     Params.videoLevel = xVSS_context->pSettings->xVSS.outputVideoLevel;
   1539 
   1540     /**
   1541      * Generate "dummy" amr file containing silence in temporary folder */
   1542     M4OSA_chrNCopy(out_amr, xVSS_context->pTempPath, M4XVSS_MAX_PATH_LEN - 1);
   1543     strncat((char *)out_amr, (const char *)"dummy.amr\0", 10);
   1544 
   1545     /**
   1546      * UTF conversion: convert the temporary path into the customer format*/
   1547     pDecodedPath = out_amr;
   1548 
   1549     if(xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
   1550             && xVSS_context->UTFConversionContext.pTempOutConversionBuffer != M4OSA_NULL)
   1551     {
   1552         M4OSA_UInt32 length = 0;
   1553         err = M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void*) out_amr,
   1554              (M4OSA_Void*) xVSS_context->UTFConversionContext.pTempOutConversionBuffer, &length);
   1555         if(err != M4NO_ERROR)
   1556         {
   1557             M4OSA_TRACE1_1("M4xVSS_internalStartConvertPictureTo3gp:\
   1558                  M4xVSS_internalConvertFromUTF8 returns err: 0x%x",err);
   1559             return err;
   1560         }
   1561         pDecodedPath = xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
   1562     }
   1563 
   1564     /**
   1565     * End of the conversion, now use the converted path*/
   1566 
   1567     err = xVSS_context->pFileWritePtr->openWrite(&pDummyAMRFile, pDecodedPath, M4OSA_kFileWrite);
   1568 
   1569     /*Commented because of the use of the UTF conversion see above*/
   1570 /*    err = xVSS_context->pFileWritePtr->openWrite(&pDummyAMRFile, out_amr, M4OSA_kFileWrite);
   1571  */
   1572     if(err != M4NO_ERROR)
   1573     {
   1574         M4OSA_TRACE1_2("M4xVSS_internalConvertPictureTo3gp: Can't open output dummy amr file %s,\
   1575              error: 0x%x\n",out_amr, err);
   1576         return err;
   1577     }
   1578 
   1579     err =  xVSS_context->pFileWritePtr->writeData(pDummyAMRFile,
   1580         (M4OSA_Int8*)M4VSS3GPP_AMR_HEADER, M4VSS3GPP_AMR_HEADER_SIZE);
   1581     if(err != M4NO_ERROR)
   1582     {
   1583         M4OSA_TRACE1_2("M4xVSS_internalConvertPictureTo3gp: Can't write output dummy amr file %s,\
   1584              error: 0x%x\n",out_amr, err);
   1585         return err;
   1586     }
   1587 
   1588     err =  xVSS_context->pFileWritePtr->writeData(pDummyAMRFile,
   1589          (M4OSA_Int8*)M4VSS3GPP_AMR_AU_SILENCE_FRAME_048, M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE);
   1590     if(err != M4NO_ERROR)
   1591     {
   1592         M4OSA_TRACE1_2("M4xVSS_internalConvertPictureTo3gp: \
   1593             Can't write output dummy amr file %s, error: 0x%x\n",out_amr, err);
   1594         return err;
   1595     }
   1596 
   1597     err =  xVSS_context->pFileWritePtr->closeWrite(pDummyAMRFile);
   1598     if(err != M4NO_ERROR)
   1599     {
   1600         M4OSA_TRACE1_2("M4xVSS_internalConvertPictureTo3gp: \
   1601             Can't close output dummy amr file %s, error: 0x%x\n",out_amr, err);
   1602         return err;
   1603     }
   1604 
   1605     /**
   1606      * Fill parameters for Pto3GPP with the parameters contained in the current element of the
   1607      * Pto3GPP parameters chained list and with default parameters */
   1608 /*+ New Encoder bitrates */
   1609     if(xVSS_context->pSettings->xVSS.outputVideoBitrate == 0) {
   1610         Params.OutputVideoBitrate    = M4VIDEOEDITING_kVARIABLE_KBPS;
   1611     }
   1612     else {
   1613           Params.OutputVideoBitrate = xVSS_context->pSettings->xVSS.outputVideoBitrate;
   1614     }
   1615     M4OSA_TRACE1_1("M4xVSS_internalStartConvertPicTo3GP: video bitrate = %d",
   1616         Params.OutputVideoBitrate);
   1617 /*- New Encoder bitrates */
   1618     Params.OutputFileMaxSize    = M4PTO3GPP_kUNLIMITED;
   1619     Params.pPictureCallbackFct    = M4xVSS_PictureCallbackFct;
   1620     Params.pPictureCallbackCtxt    = pCallBackCtxt;
   1621     /*FB: change to use the converted path (UTF conversion) see the conversion above*/
   1622     /*Fix :- Adding Audio Track in Image as input :AudioTarckFile Setting to NULL */
   1623     Params.pInputAudioTrackFile    = M4OSA_NULL;//(M4OSA_Void*)pDecodedPath;//out_amr;
   1624     Params.AudioPaddingMode        = M4PTO3GPP_kAudioPaddingMode_Loop;
   1625     Params.AudioFileFormat        = M4VIDEOEDITING_kFileType_AMR;
   1626     Params.pOutput3gppFile        = xVSS_context->pPTo3GPPcurrentParams->pFileOut;
   1627     Params.pTemporaryFile        = xVSS_context->pPTo3GPPcurrentParams->pFileTemp;
   1628     /*+PR No:  blrnxpsw#223*/
   1629     /*Increasing frequency of Frame, calculating Nos of Frame = duration /FPS */
   1630     /*Other changes made is @ M4xVSS_API.c @ line 3841 in M4xVSS_SendCommand*/
   1631     /*If case check for PanZoom removed */
   1632     Params.NbVideoFrames            = (M4OSA_UInt32)
   1633         (xVSS_context->pPTo3GPPcurrentParams->duration \
   1634             / xVSS_context->pPTo3GPPcurrentParams->framerate); /* */
   1635     pCallBackCtxt->m_timeDuration    = xVSS_context->pPTo3GPPcurrentParams->framerate;
   1636     /*-PR No:  blrnxpsw#223*/
   1637     pCallBackCtxt->m_ImageCounter    = 0;
   1638     pCallBackCtxt->m_FileIn            = xVSS_context->pPTo3GPPcurrentParams->pFileIn;
   1639     pCallBackCtxt->m_NbImage        = Params.NbVideoFrames;
   1640     pCallBackCtxt->m_pFileReadPtr    = xVSS_context->pFileReadPtr;
   1641     pCallBackCtxt->m_pDecodedPlane    = M4OSA_NULL;
   1642     pCallBackCtxt->m_pPto3GPPparams    = xVSS_context->pPTo3GPPcurrentParams;
   1643     pCallBackCtxt->m_air_context    = M4OSA_NULL;
   1644     pCallBackCtxt->m_mediaRendering = xVSS_context->pPTo3GPPcurrentParams->MediaRendering;
   1645 
   1646     /**
   1647      * Set the input and output files */
   1648     err = M4PTO3GPP_Open(pM4PTO3GPP_Ctxt, &Params);
   1649     if (err != M4NO_ERROR)
   1650     {
   1651         M4OSA_TRACE1_1("M4PTO3GPP_Open returned: 0x%x\n",err);
   1652         if(pCallBackCtxt != M4OSA_NULL)
   1653         {
   1654             free(pCallBackCtxt);
   1655             pCallBackCtxt = M4OSA_NULL;
   1656         }
   1657         M4PTO3GPP_CleanUp(pM4PTO3GPP_Ctxt);
   1658         return err;
   1659     }
   1660 
   1661     /**
   1662      * Save context to be able to call Pto3GPP step function in M4xVSS_step function */
   1663     xVSS_context->pM4PTO3GPP_Ctxt = pM4PTO3GPP_Ctxt;
   1664     xVSS_context->pCallBackCtxt = pCallBackCtxt;
   1665 
   1666     return M4NO_ERROR;
   1667 }
   1668 
   1669 /**
   1670  ******************************************************************************
   1671  * M4OSA_ERR M4xVSS_internalStopConvertPictureTo3gp(M4OSA_Context pContext)
   1672  * @brief    This function cleans up Pto3GPP
   1673  * @note
   1674  * @param    pContext    (IN) The integrator own context
   1675  *
   1676  * @return    M4NO_ERROR:    No error
   1677  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   1678  ******************************************************************************
   1679  */
   1680 M4OSA_ERR M4xVSS_internalStopConvertPictureTo3gp(M4OSA_Context pContext)
   1681 {
   1682     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   1683     M4OSA_ERR err;
   1684     M4OSA_Char out_amr[M4XVSS_MAX_PATH_LEN];
   1685     /*UTF conversion support*/
   1686     M4OSA_Char* pDecodedPath = M4OSA_NULL;
   1687 
   1688     /**
   1689     * Free the PTO3GPP callback context */
   1690     if(M4OSA_NULL != xVSS_context->pCallBackCtxt)
   1691     {
   1692         free(xVSS_context->pCallBackCtxt);
   1693         xVSS_context->pCallBackCtxt = M4OSA_NULL;
   1694     }
   1695 
   1696     /**
   1697      * Finalize the output file */
   1698     err = M4PTO3GPP_Close(xVSS_context->pM4PTO3GPP_Ctxt);
   1699     if (err != M4NO_ERROR)
   1700     {
   1701         M4OSA_TRACE1_1("M4PTO3GPP_Close returned 0x%x\n",err);
   1702         M4PTO3GPP_CleanUp(xVSS_context->pM4PTO3GPP_Ctxt);
   1703         return err;
   1704     }
   1705 
   1706     /**
   1707      * Free this M4PTO3GPP instance */
   1708     err = M4PTO3GPP_CleanUp(xVSS_context->pM4PTO3GPP_Ctxt);
   1709     if (err != M4NO_ERROR)
   1710     {
   1711         M4OSA_TRACE1_1("M4PTO3GPP_CleanUp returned 0x%x\n",err);
   1712         return err;
   1713     }
   1714 
   1715     /**
   1716      * Remove dummy.amr file */
   1717     M4OSA_chrNCopy(out_amr, xVSS_context->pTempPath, M4XVSS_MAX_PATH_LEN - 1);
   1718     strncat((char *)out_amr, (const char *)"dummy.amr\0", 10);
   1719 
   1720     /**
   1721      * UTF conversion: convert the temporary path into the customer format*/
   1722     pDecodedPath = out_amr;
   1723 
   1724     if(xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
   1725             && xVSS_context->UTFConversionContext.pTempOutConversionBuffer != M4OSA_NULL)
   1726     {
   1727         M4OSA_UInt32 length = 0;
   1728         err = M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void*) out_amr,
   1729              (M4OSA_Void*) xVSS_context->UTFConversionContext.pTempOutConversionBuffer, &length);
   1730         if(err != M4NO_ERROR)
   1731         {
   1732             M4OSA_TRACE1_1("M4xVSS_internalStopConvertPictureTo3gp:\
   1733                  M4xVSS_internalConvertFromUTF8 returns err: 0x%x",err);
   1734             return err;
   1735         }
   1736         pDecodedPath = xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
   1737     }
   1738     /**
   1739     * End of the conversion, now use the decoded path*/
   1740     remove((const char *)pDecodedPath);
   1741 
   1742     /*Commented because of the use of the UTF conversion*/
   1743 /*    remove(out_amr);
   1744  */
   1745 
   1746     xVSS_context->pM4PTO3GPP_Ctxt = M4OSA_NULL;
   1747     xVSS_context->pCallBackCtxt = M4OSA_NULL;
   1748 
   1749     return M4NO_ERROR;
   1750 }
   1751 
   1752 /**
   1753  ******************************************************************************
   1754  * prototype    M4OSA_ERR M4xVSS_internalConvertRGBtoYUV(M4xVSS_FramingStruct* framingCtx)
   1755  * @brief    This function converts an RGB565 plane to YUV420 planar
   1756  * @note    It is used only for framing effect
   1757  *            It allocates output YUV planes
   1758  * @param    framingCtx    (IN) The framing struct containing input RGB565 plane
   1759  *
   1760  * @return    M4NO_ERROR:    No error
   1761  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   1762  * @return    M4ERR_ALLOC: Allocation error (no more memory)
   1763  ******************************************************************************
   1764  */
   1765 M4OSA_ERR M4xVSS_internalConvertRGBtoYUV(M4xVSS_FramingStruct* framingCtx)
   1766 {
   1767     M4OSA_ERR err;
   1768 
   1769     /**
   1770      * Allocate output YUV planes */
   1771     framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane),
   1772          M4VS, (M4OSA_Char *)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV");
   1773     if(framingCtx->FramingYuv == M4OSA_NULL)
   1774     {
   1775         M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV");
   1776         return M4ERR_ALLOC;
   1777     }
   1778     framingCtx->FramingYuv[0].u_width = framingCtx->FramingRgb->u_width;
   1779     framingCtx->FramingYuv[0].u_height = framingCtx->FramingRgb->u_height;
   1780     framingCtx->FramingYuv[0].u_topleft = 0;
   1781     framingCtx->FramingYuv[0].u_stride = framingCtx->FramingRgb->u_width;
   1782     framingCtx->FramingYuv[0].pac_data =
   1783          (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc((framingCtx->FramingYuv[0].u_width\
   1784             *framingCtx->FramingYuv[0].u_height*3)>>1, M4VS, (M4OSA_Char *)\
   1785                 "Alloc for the Convertion output YUV");;
   1786     if(framingCtx->FramingYuv[0].pac_data == M4OSA_NULL)
   1787     {
   1788         M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV");
   1789         return M4ERR_ALLOC;
   1790     }
   1791     framingCtx->FramingYuv[1].u_width = (framingCtx->FramingRgb->u_width)>>1;
   1792     framingCtx->FramingYuv[1].u_height = (framingCtx->FramingRgb->u_height)>>1;
   1793     framingCtx->FramingYuv[1].u_topleft = 0;
   1794     framingCtx->FramingYuv[1].u_stride = (framingCtx->FramingRgb->u_width)>>1;
   1795     framingCtx->FramingYuv[1].pac_data = framingCtx->FramingYuv[0].pac_data \
   1796         + framingCtx->FramingYuv[0].u_width * framingCtx->FramingYuv[0].u_height;
   1797     framingCtx->FramingYuv[2].u_width = (framingCtx->FramingRgb->u_width)>>1;
   1798     framingCtx->FramingYuv[2].u_height = (framingCtx->FramingRgb->u_height)>>1;
   1799     framingCtx->FramingYuv[2].u_topleft = 0;
   1800     framingCtx->FramingYuv[2].u_stride = (framingCtx->FramingRgb->u_width)>>1;
   1801     framingCtx->FramingYuv[2].pac_data = framingCtx->FramingYuv[1].pac_data \
   1802         + framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height;
   1803 
   1804     /**
   1805      * Convert input RGB 565 to YUV 420 to be able to merge it with output video in framing
   1806       effect */
   1807     err = M4VIFI_xVSS_RGB565toYUV420(M4OSA_NULL, framingCtx->FramingRgb, framingCtx->FramingYuv);
   1808     if(err != M4NO_ERROR)
   1809     {
   1810         M4OSA_TRACE1_1("M4xVSS_internalConvertRGBtoYUV:\
   1811              error when converting from RGB to YUV: 0x%x\n", err);
   1812     }
   1813 
   1814     framingCtx->duration = 0;
   1815     framingCtx->previousClipTime = -1;
   1816     framingCtx->previewOffsetClipTime = -1;
   1817 
   1818     /**
   1819      * Only one element in the chained list (no animated image with RGB buffer...) */
   1820     framingCtx->pCurrent = framingCtx;
   1821     framingCtx->pNext = framingCtx;
   1822 
   1823     return M4NO_ERROR;
   1824 }
   1825 
   1826 M4OSA_ERR M4xVSS_internalSetPlaneTransparent(M4OSA_UInt8* planeIn, M4OSA_UInt32 size)
   1827 {
   1828     M4OSA_UInt32 i;
   1829     M4OSA_UInt8* plane = planeIn;
   1830     M4OSA_UInt8 transparent1 = (M4OSA_UInt8)((TRANSPARENT_COLOR & 0xFF00)>>8);
   1831     M4OSA_UInt8 transparent2 = (M4OSA_UInt8)TRANSPARENT_COLOR;
   1832 
   1833     for(i=0; i<(size>>1); i++)
   1834     {
   1835         *plane++ = transparent1;
   1836         *plane++ = transparent2;
   1837     }
   1838 
   1839     return M4NO_ERROR;
   1840 }
   1841 
   1842 
   1843 /**
   1844  ******************************************************************************
   1845  * prototype M4OSA_ERR M4xVSS_internalConvertARBG888toYUV420_FrammingEffect(M4OSA_Context pContext,
   1846  *                                                M4VSS3GPP_EffectSettings* pEffect,
   1847  *                                                M4xVSS_FramingStruct* framingCtx,
   1848                                                   M4VIDEOEDITING_VideoFrameSize OutputVideoResolution)
   1849  *
   1850  * @brief    This function converts ARGB8888 input file  to YUV420 whenused for framming effect
   1851  * @note    The input ARGB8888 file path is contained in the pEffect structure
   1852  *            If the ARGB8888 must be resized to fit output video size, this function
   1853  *            will do it.
   1854  * @param    pContext    (IN) The integrator own context
   1855  * @param    pEffect        (IN) The effect structure containing all informations on
   1856  *                        the file to decode, resizing ...
   1857  * @param    framingCtx    (IN/OUT) Structure in which the output RGB will be stored
   1858  *
   1859  * @return    M4NO_ERROR:    No error
   1860  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   1861  * @return    M4ERR_ALLOC: Allocation error (no more memory)
   1862  * @return    M4ERR_FILE_NOT_FOUND: File not found.
   1863  ******************************************************************************
   1864  */
   1865 
   1866 
   1867 M4OSA_ERR M4xVSS_internalConvertARGB888toYUV420_FrammingEffect(M4OSA_Context pContext,
   1868                                                                M4VSS3GPP_EffectSettings* pEffect,
   1869                                                                M4xVSS_FramingStruct* framingCtx,
   1870                                                                M4VIDEOEDITING_VideoFrameSize\
   1871                                                                OutputVideoResolution)
   1872 {
   1873     M4OSA_ERR err = M4NO_ERROR;
   1874     M4OSA_Context pARGBIn;
   1875     M4OSA_UInt32 file_size;
   1876     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   1877     M4OSA_UInt32 width, height, width_out, height_out;
   1878     M4OSA_Void* pFile = pEffect->xVSS.pFramingFilePath;
   1879     M4OSA_UInt8 transparent1 = (M4OSA_UInt8)((TRANSPARENT_COLOR & 0xFF00)>>8);
   1880     M4OSA_UInt8 transparent2 = (M4OSA_UInt8)TRANSPARENT_COLOR;
   1881     /*UTF conversion support*/
   1882     M4OSA_Char* pDecodedPath = M4OSA_NULL;
   1883     M4OSA_UInt32 i = 0,j = 0;
   1884     M4VIFI_ImagePlane rgbPlane;
   1885     M4OSA_UInt32 frameSize_argb=(framingCtx->width * framingCtx->height * 4);
   1886     M4OSA_UInt32 frameSize;
   1887     M4OSA_UInt32 tempAlphaPercent = 0;
   1888     M4VIFI_UInt8* TempPacData = M4OSA_NULL;
   1889     M4OSA_UInt16 *ptr = M4OSA_NULL;
   1890     M4OSA_UInt32 z = 0;
   1891 
   1892     M4OSA_TRACE3_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect: Entering ");
   1893 
   1894     M4OSA_TRACE1_2("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect width and height %d %d ",
   1895         framingCtx->width,framingCtx->height);
   1896 
   1897     M4OSA_UInt8 *pTmpData = (M4OSA_UInt8*) M4OSA_32bitAlignedMalloc(frameSize_argb, M4VS, (M4OSA_Char*)\
   1898         "Image argb data");
   1899     if(pTmpData == M4OSA_NULL) {
   1900         M4OSA_TRACE1_0("Failed to allocate memory for Image clip");
   1901         return M4ERR_ALLOC;
   1902     }
   1903     /**
   1904      * UTF conversion: convert the file path into the customer format*/
   1905     pDecodedPath = pFile;
   1906 
   1907     if(xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
   1908             && xVSS_context->UTFConversionContext.pTempOutConversionBuffer != M4OSA_NULL)
   1909     {
   1910         M4OSA_UInt32 length = 0;
   1911         err = M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void*) pFile,
   1912              (M4OSA_Void*) xVSS_context->UTFConversionContext.pTempOutConversionBuffer, &length);
   1913         if(err != M4NO_ERROR)
   1914         {
   1915             M4OSA_TRACE1_1("M4xVSS_internalDecodePNG:\
   1916                  M4xVSS_internalConvertFromUTF8 returns err: 0x%x",err);
   1917             free(pTmpData);
   1918             pTmpData = M4OSA_NULL;
   1919             return err;
   1920         }
   1921         pDecodedPath = xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
   1922     }
   1923 
   1924     /**
   1925     * End of the conversion, now use the decoded path*/
   1926 
   1927      /* Open input ARGB8888 file and store it into memory */
   1928     err = xVSS_context->pFileReadPtr->openRead(&pARGBIn, pDecodedPath, M4OSA_kFileRead);
   1929 
   1930     if(err != M4NO_ERROR)
   1931     {
   1932         M4OSA_TRACE1_2("Can't open input ARGB8888 file %s, error: 0x%x\n",pFile, err);
   1933         free(pTmpData);
   1934         pTmpData = M4OSA_NULL;
   1935         return err;
   1936     }
   1937 
   1938     err = xVSS_context->pFileReadPtr->readData(pARGBIn,(M4OSA_MemAddr8)pTmpData, &frameSize_argb);
   1939     if(err != M4NO_ERROR)
   1940     {
   1941         xVSS_context->pFileReadPtr->closeRead(pARGBIn);
   1942         free(pTmpData);
   1943         pTmpData = M4OSA_NULL;
   1944         return err;
   1945     }
   1946 
   1947 
   1948     err =  xVSS_context->pFileReadPtr->closeRead(pARGBIn);
   1949     if(err != M4NO_ERROR)
   1950     {
   1951         M4OSA_TRACE1_2("Can't close input png file %s, error: 0x%x\n",pFile, err);
   1952         free(pTmpData);
   1953         pTmpData = M4OSA_NULL;
   1954         return err;
   1955     }
   1956 
   1957 
   1958     rgbPlane.u_height = framingCtx->height;
   1959     rgbPlane.u_width = framingCtx->width;
   1960     rgbPlane.u_stride = rgbPlane.u_width*3;
   1961     rgbPlane.u_topleft = 0;
   1962 
   1963     frameSize = (rgbPlane.u_width * rgbPlane.u_height * 3); //Size of RGB888 data
   1964     rgbPlane.pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(((frameSize)+ (2 * framingCtx->width)),
   1965          M4VS, (M4OSA_Char*)"Image clip RGB888 data");
   1966     if(rgbPlane.pac_data == M4OSA_NULL)
   1967     {
   1968         M4OSA_TRACE1_0("Failed to allocate memory for Image clip");
   1969         free(pTmpData);
   1970         return M4ERR_ALLOC;
   1971     }
   1972 
   1973     M4OSA_TRACE1_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect:\
   1974           Remove the alpha channel  ");
   1975 
   1976     /* premultiplied alpha % on RGB */
   1977     for (i=0, j = 0; i < frameSize_argb; i += 4) {
   1978         /* this is alpha value */
   1979         if ((i % 4) == 0)
   1980         {
   1981             tempAlphaPercent = pTmpData[i];
   1982         }
   1983 
   1984         /* R */
   1985         rgbPlane.pac_data[j] = pTmpData[i+1];
   1986         j++;
   1987 
   1988         /* G */
   1989         if (tempAlphaPercent > 0) {
   1990             rgbPlane.pac_data[j] = pTmpData[i+2];
   1991             j++;
   1992         } else {/* In case of alpha value 0, make GREEN to 255 */
   1993             rgbPlane.pac_data[j] = 255; //pTmpData[i+2];
   1994             j++;
   1995         }
   1996 
   1997         /* B */
   1998         rgbPlane.pac_data[j] = pTmpData[i+3];
   1999         j++;
   2000     }
   2001 
   2002     free(pTmpData);
   2003     pTmpData = M4OSA_NULL;
   2004 
   2005     /* convert RGB888 to RGB565 */
   2006 
   2007     /* allocate temp RGB 565 buffer */
   2008     TempPacData = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize +
   2009                        (4 * (framingCtx->width + framingCtx->height + 1)),
   2010                         M4VS, (M4OSA_Char*)"Image clip RGB565 data");
   2011     if (TempPacData == M4OSA_NULL) {
   2012         M4OSA_TRACE1_0("Failed to allocate memory for Image clip RGB565 data");
   2013         free(rgbPlane.pac_data);
   2014         return M4ERR_ALLOC;
   2015     }
   2016 
   2017     ptr = (M4OSA_UInt16 *)TempPacData;
   2018     z = 0;
   2019 
   2020     for (i = 0; i < j ; i += 3)
   2021     {
   2022         ptr[z++] = PACK_RGB565(0,   rgbPlane.pac_data[i],
   2023                                     rgbPlane.pac_data[i+1],
   2024                                     rgbPlane.pac_data[i+2]);
   2025     }
   2026 
   2027     /* free the RBG888 and assign RGB565 */
   2028     free(rgbPlane.pac_data);
   2029     rgbPlane.pac_data = TempPacData;
   2030 
   2031     /**
   2032      * Check if output sizes are odd */
   2033     if(rgbPlane.u_height % 2 != 0)
   2034     {
   2035         M4VIFI_UInt8* output_pac_data = rgbPlane.pac_data;
   2036         M4OSA_UInt32 i;
   2037         M4OSA_TRACE1_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect:\
   2038              output height is odd  ");
   2039         output_pac_data +=rgbPlane.u_width * rgbPlane.u_height*2;
   2040 
   2041         for(i=0;i<rgbPlane.u_width;i++)
   2042         {
   2043             *output_pac_data++ = transparent1;
   2044             *output_pac_data++ = transparent2;
   2045         }
   2046 
   2047         /**
   2048          * We just add a white line to the PNG that will be transparent */
   2049         rgbPlane.u_height++;
   2050     }
   2051     if(rgbPlane.u_width % 2 != 0)
   2052     {
   2053         /**
   2054          * We add a new column of white (=transparent), but we need to parse all RGB lines ... */
   2055         M4OSA_UInt32 i;
   2056         M4VIFI_UInt8* newRGBpac_data;
   2057         M4VIFI_UInt8* output_pac_data, *input_pac_data;
   2058 
   2059         rgbPlane.u_width++;
   2060         M4OSA_TRACE1_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect: \
   2061              output width is odd  ");
   2062         /**
   2063          * We need to allocate a new RGB output buffer in which all decoded data
   2064           + white line will be copied */
   2065         newRGBpac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(rgbPlane.u_height*rgbPlane.u_width*2\
   2066             *sizeof(M4VIFI_UInt8), M4VS, (M4OSA_Char *)"New Framing GIF Output pac_data RGB");
   2067 
   2068         if(newRGBpac_data == M4OSA_NULL)
   2069         {
   2070             M4OSA_TRACE1_0("Allocation error in \
   2071                 M4xVSS_internalConvertARGB888toYUV420_FrammingEffect");
   2072             free(rgbPlane.pac_data);
   2073             return M4ERR_ALLOC;
   2074         }
   2075 
   2076         output_pac_data= newRGBpac_data;
   2077         input_pac_data = rgbPlane.pac_data;
   2078 
   2079         for(i=0;i<rgbPlane.u_height;i++)
   2080         {
   2081             memcpy((void *)output_pac_data, (void *)input_pac_data,
   2082                  (rgbPlane.u_width-1)*2);
   2083 
   2084             output_pac_data += ((rgbPlane.u_width-1)*2);
   2085             /* Put the pixel to transparency color */
   2086             *output_pac_data++ = transparent1;
   2087             *output_pac_data++ = transparent2;
   2088 
   2089             input_pac_data += ((rgbPlane.u_width-1)*2);
   2090         }
   2091         free(rgbPlane.pac_data);
   2092         rgbPlane.pac_data = newRGBpac_data;
   2093     }
   2094 
   2095     /* reset stride */
   2096     rgbPlane.u_stride = rgbPlane.u_width*2;
   2097 
   2098     /**
   2099      * Initialize chained list parameters */
   2100     framingCtx->duration = 0;
   2101     framingCtx->previousClipTime = -1;
   2102     framingCtx->previewOffsetClipTime = -1;
   2103 
   2104     /**
   2105      * Only one element in the chained list (no animated image ...) */
   2106     framingCtx->pCurrent = framingCtx;
   2107     framingCtx->pNext = framingCtx;
   2108 
   2109     /**
   2110      * Get output width/height */
   2111      switch(OutputVideoResolution)
   2112     //switch(xVSS_context->pSettings->xVSS.outputVideoSize)
   2113     {
   2114     case M4VIDEOEDITING_kSQCIF:
   2115         width_out = 128;
   2116         height_out = 96;
   2117         break;
   2118     case M4VIDEOEDITING_kQQVGA:
   2119         width_out = 160;
   2120         height_out = 120;
   2121         break;
   2122     case M4VIDEOEDITING_kQCIF:
   2123         width_out = 176;
   2124         height_out = 144;
   2125         break;
   2126     case M4VIDEOEDITING_kQVGA:
   2127         width_out = 320;
   2128         height_out = 240;
   2129         break;
   2130     case M4VIDEOEDITING_kCIF:
   2131         width_out = 352;
   2132         height_out = 288;
   2133         break;
   2134     case M4VIDEOEDITING_kVGA:
   2135         width_out = 640;
   2136         height_out = 480;
   2137         break;
   2138     case M4VIDEOEDITING_kWVGA:
   2139         width_out = 800;
   2140         height_out = 480;
   2141         break;
   2142     case M4VIDEOEDITING_kNTSC:
   2143         width_out = 720;
   2144         height_out = 480;
   2145         break;
   2146     case M4VIDEOEDITING_k640_360:
   2147         width_out = 640;
   2148         height_out = 360;
   2149         break;
   2150     case M4VIDEOEDITING_k854_480:
   2151         // StageFright encoders require %16 resolution
   2152         width_out = M4ENCODER_854_480_Width;
   2153         height_out = 480;
   2154         break;
   2155     case M4VIDEOEDITING_k1280_720:
   2156         width_out = 1280;
   2157         height_out = 720;
   2158         break;
   2159     case M4VIDEOEDITING_k1080_720:
   2160         // StageFright encoders require %16 resolution
   2161         width_out = M4ENCODER_1080_720_Width;
   2162         height_out = 720;
   2163         break;
   2164     case M4VIDEOEDITING_k960_720:
   2165         width_out = 960;
   2166         height_out = 720;
   2167         break;
   2168     case M4VIDEOEDITING_k1920_1080:
   2169         width_out = 1920;
   2170         height_out = M4ENCODER_1920_1080_Height;
   2171         break;
   2172     /**
   2173      * If output video size is not given, we take QCIF size,
   2174      * should not happen, because already done in M4xVSS_sendCommand */
   2175     default:
   2176         width_out = 176;
   2177         height_out = 144;
   2178         break;
   2179     }
   2180 
   2181     /**
   2182      * Allocate output planes structures */
   2183     framingCtx->FramingRgb = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(sizeof(M4VIFI_ImagePlane), M4VS,
   2184          (M4OSA_Char *)"Framing Output plane RGB");
   2185     if(framingCtx->FramingRgb == M4OSA_NULL)
   2186     {
   2187         M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertARGB888toYUV420_FrammingEffect");
   2188         return M4ERR_ALLOC;
   2189     }
   2190     /**
   2191      * Resize RGB if needed */
   2192     if((pEffect->xVSS.bResize) &&
   2193          (rgbPlane.u_width != width_out || rgbPlane.u_height != height_out))
   2194     {
   2195         width = width_out;
   2196         height = height_out;
   2197 
   2198         M4OSA_TRACE1_2("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect: \
   2199              New Width and height %d %d  ",width,height);
   2200 
   2201         framingCtx->FramingRgb->u_height = height_out;
   2202         framingCtx->FramingRgb->u_width = width_out;
   2203         framingCtx->FramingRgb->u_stride = framingCtx->FramingRgb->u_width*2;
   2204         framingCtx->FramingRgb->u_topleft = 0;
   2205 
   2206         framingCtx->FramingRgb->pac_data =
   2207              (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(framingCtx->FramingRgb->u_height*framingCtx->\
   2208                 FramingRgb->u_width*2*sizeof(M4VIFI_UInt8), M4VS,
   2209                   (M4OSA_Char *)"Framing Output pac_data RGB");
   2210 
   2211         if(framingCtx->FramingRgb->pac_data == M4OSA_NULL)
   2212         {
   2213             M4OSA_TRACE1_0("Allocation error in \
   2214                 M4xVSS_internalConvertARGB888toYUV420_FrammingEffect");
   2215             free(framingCtx->FramingRgb);
   2216             free(rgbPlane.pac_data);
   2217             return M4ERR_ALLOC;
   2218         }
   2219 
   2220         M4OSA_TRACE1_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect:  Resizing Needed ");
   2221         M4OSA_TRACE1_2("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect:\
   2222               rgbPlane.u_height & rgbPlane.u_width %d %d",rgbPlane.u_height,rgbPlane.u_width);
   2223 
   2224         //err = M4VIFI_ResizeBilinearRGB888toRGB888(M4OSA_NULL, &rgbPlane,framingCtx->FramingRgb);
   2225         err = M4VIFI_ResizeBilinearRGB565toRGB565(M4OSA_NULL, &rgbPlane,framingCtx->FramingRgb);
   2226 
   2227         if(err != M4NO_ERROR)
   2228         {
   2229             M4OSA_TRACE1_1("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect :\
   2230                 when resizing RGB plane: 0x%x\n", err);
   2231             return err;
   2232         }
   2233 
   2234         if(rgbPlane.pac_data != M4OSA_NULL)
   2235         {
   2236             free(rgbPlane.pac_data);
   2237             rgbPlane.pac_data = M4OSA_NULL;
   2238         }
   2239     }
   2240     else
   2241     {
   2242 
   2243         M4OSA_TRACE1_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect:\
   2244               Resizing Not Needed ");
   2245 
   2246         width = rgbPlane.u_width;
   2247         height = rgbPlane.u_height;
   2248         framingCtx->FramingRgb->u_height = height;
   2249         framingCtx->FramingRgb->u_width = width;
   2250         framingCtx->FramingRgb->u_stride = framingCtx->FramingRgb->u_width*2;
   2251         framingCtx->FramingRgb->u_topleft = 0;
   2252         framingCtx->FramingRgb->pac_data = rgbPlane.pac_data;
   2253     }
   2254 
   2255 
   2256     if(pEffect->xVSS.bResize)
   2257     {
   2258         /**
   2259          * Force topleft to 0 for pure framing effect */
   2260         framingCtx->topleft_x = 0;
   2261         framingCtx->topleft_y = 0;
   2262     }
   2263 
   2264 
   2265     /**
   2266      * Convert  RGB output to YUV 420 to be able to merge it with output video in framing
   2267      effect */
   2268     framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), M4VS,
   2269          (M4OSA_Char *)"Framing Output plane YUV");
   2270     if(framingCtx->FramingYuv == M4OSA_NULL)
   2271     {
   2272         M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertARGB888toYUV420_FrammingEffect");
   2273         free(framingCtx->FramingRgb->pac_data);
   2274         return M4ERR_ALLOC;
   2275     }
   2276 
   2277     // Alloc for Y, U and V planes
   2278     framingCtx->FramingYuv[0].u_width = ((width+1)>>1)<<1;
   2279     framingCtx->FramingYuv[0].u_height = ((height+1)>>1)<<1;
   2280     framingCtx->FramingYuv[0].u_topleft = 0;
   2281     framingCtx->FramingYuv[0].u_stride = ((width+1)>>1)<<1;
   2282     framingCtx->FramingYuv[0].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc
   2283         ((framingCtx->FramingYuv[0].u_width*framingCtx->FramingYuv[0].u_height), M4VS,
   2284             (M4OSA_Char *)"Alloc for the output Y");
   2285     if(framingCtx->FramingYuv[0].pac_data == M4OSA_NULL)
   2286     {
   2287         M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertARGB888toYUV420_FrammingEffect");
   2288         free(framingCtx->FramingYuv);
   2289         free(framingCtx->FramingRgb->pac_data);
   2290         return M4ERR_ALLOC;
   2291     }
   2292     framingCtx->FramingYuv[1].u_width = (((width+1)>>1)<<1)>>1;
   2293     framingCtx->FramingYuv[1].u_height = (((height+1)>>1)<<1)>>1;
   2294     framingCtx->FramingYuv[1].u_topleft = 0;
   2295     framingCtx->FramingYuv[1].u_stride = (((width+1)>>1)<<1)>>1;
   2296 
   2297 
   2298     framingCtx->FramingYuv[1].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(
   2299         framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height, M4VS,
   2300         (M4OSA_Char *)"Alloc for the output U");
   2301     if (framingCtx->FramingYuv[1].pac_data == M4OSA_NULL) {
   2302         free(framingCtx->FramingYuv[0].pac_data);
   2303         free(framingCtx->FramingYuv);
   2304         free(framingCtx->FramingRgb->pac_data);
   2305         return M4ERR_ALLOC;
   2306     }
   2307 
   2308     framingCtx->FramingYuv[2].u_width = (((width+1)>>1)<<1)>>1;
   2309     framingCtx->FramingYuv[2].u_height = (((height+1)>>1)<<1)>>1;
   2310     framingCtx->FramingYuv[2].u_topleft = 0;
   2311     framingCtx->FramingYuv[2].u_stride = (((width+1)>>1)<<1)>>1;
   2312 
   2313 
   2314     framingCtx->FramingYuv[2].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(
   2315         framingCtx->FramingYuv[2].u_width * framingCtx->FramingYuv[0].u_height, M4VS,
   2316         (M4OSA_Char *)"Alloc for the  output V");
   2317     if (framingCtx->FramingYuv[2].pac_data == M4OSA_NULL) {
   2318         free(framingCtx->FramingYuv[1].pac_data);
   2319         free(framingCtx->FramingYuv[0].pac_data);
   2320         free(framingCtx->FramingYuv);
   2321         free(framingCtx->FramingRgb->pac_data);
   2322         return M4ERR_ALLOC;
   2323     }
   2324 
   2325     M4OSA_TRACE3_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect:\
   2326         convert RGB to YUV ");
   2327 
   2328     //err = M4VIFI_RGB888toYUV420(M4OSA_NULL, framingCtx->FramingRgb,  framingCtx->FramingYuv);
   2329     err = M4VIFI_RGB565toYUV420(M4OSA_NULL, framingCtx->FramingRgb,  framingCtx->FramingYuv);
   2330 
   2331     if (err != M4NO_ERROR)
   2332     {
   2333         M4OSA_TRACE1_1("SPS png: error when converting from RGB to YUV: 0x%x\n", err);
   2334     }
   2335     M4OSA_TRACE3_0("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect:  Leaving ");
   2336     return err;
   2337 }
   2338 
   2339 /**
   2340  ******************************************************************************
   2341  * prototype    M4OSA_ERR M4xVSS_internalGenerateEditedFile(M4OSA_Context pContext)
   2342  *
   2343  * @brief    This function prepares VSS for editing
   2344  * @note    It also set special xVSS effect as external effects for the VSS
   2345  * @param    pContext    (IN) The integrator own context
   2346  *
   2347  * @return    M4NO_ERROR:    No error
   2348  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   2349  * @return    M4ERR_ALLOC: Allocation error (no more memory)
   2350  ******************************************************************************
   2351  */
   2352 M4OSA_ERR M4xVSS_internalGenerateEditedFile(M4OSA_Context pContext)
   2353 {
   2354     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   2355     M4VSS3GPP_EditContext pVssCtxt;
   2356     M4OSA_UInt32 i,j;
   2357     M4OSA_ERR err;
   2358 
   2359     /**
   2360      * Create a VSS 3GPP edition instance */
   2361     err = M4VSS3GPP_editInit( &pVssCtxt, xVSS_context->pFileReadPtr, xVSS_context->pFileWritePtr);
   2362     if (err != M4NO_ERROR)
   2363     {
   2364         M4OSA_TRACE1_1("M4xVSS_internalGenerateEditedFile: M4VSS3GPP_editInit returned 0x%x\n",
   2365             err);
   2366         M4VSS3GPP_editCleanUp(pVssCtxt);
   2367         /**
   2368          * Set the VSS context to NULL */
   2369         xVSS_context->pCurrentEditContext = M4OSA_NULL;
   2370         return err;
   2371     }
   2372 
   2373         M4VSS3GPP_InternalEditContext* pVSSContext =
   2374             (M4VSS3GPP_InternalEditContext*)pVssCtxt;
   2375         pVSSContext->xVSS.outputVideoFormat =
   2376             xVSS_context->pSettings->xVSS.outputVideoFormat;
   2377         pVSSContext->xVSS.outputVideoSize =
   2378             xVSS_context->pSettings->xVSS.outputVideoSize ;
   2379         pVSSContext->xVSS.outputAudioFormat =
   2380             xVSS_context->pSettings->xVSS.outputAudioFormat;
   2381         pVSSContext->xVSS.outputAudioSamplFreq =
   2382             xVSS_context->pSettings->xVSS.outputAudioSamplFreq;
   2383         pVSSContext->xVSS.outputVideoBitrate =
   2384             xVSS_context->pSettings->xVSS.outputVideoBitrate ;
   2385         pVSSContext->xVSS.outputAudioBitrate =
   2386             xVSS_context->pSettings->xVSS.outputAudioBitrate ;
   2387         pVSSContext->xVSS.bAudioMono =
   2388             xVSS_context->pSettings->xVSS.bAudioMono;
   2389         pVSSContext->xVSS.outputVideoProfile =
   2390             xVSS_context->pSettings->xVSS.outputVideoProfile;
   2391         pVSSContext->xVSS.outputVideoLevel =
   2392             xVSS_context->pSettings->xVSS.outputVideoLevel;
   2393     /* In case of MMS use case, we fill directly into the VSS context the targeted bitrate */
   2394     if(xVSS_context->targetedBitrate != 0)
   2395     {
   2396         M4VSS3GPP_InternalEditContext* pVSSContext = (M4VSS3GPP_InternalEditContext*)pVssCtxt;
   2397 
   2398         pVSSContext->bIsMMS = M4OSA_TRUE;
   2399         pVSSContext->uiMMSVideoBitrate = xVSS_context->targetedBitrate;
   2400         pVSSContext->MMSvideoFramerate = xVSS_context->pSettings->videoFrameRate;
   2401     }
   2402 
   2403     /*Warning: since the adding of the UTF conversion, pSettings has been changed in the next
   2404     part in  pCurrentEditSettings (there is a specific current editing structure for the saving,
   2405      as for the preview)*/
   2406 
   2407     /**
   2408      * Set the external video effect functions, for saving mode (to be moved to
   2409       M4xVSS_saveStart() ?)*/
   2410     for (i=0; i<xVSS_context->pCurrentEditSettings->uiClipNumber; i++)
   2411     {
   2412         for (j=0; j<xVSS_context->pCurrentEditSettings->nbEffects; j++)
   2413         {
   2414             if (M4xVSS_kVideoEffectType_BlackAndWhite ==
   2415             xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2416             {
   2417                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2418                  M4VSS3GPP_externalVideoEffectColor;
   2419                 //xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
   2420                 // (M4OSA_Void*)M4xVSS_kVideoEffectType_BlackAndWhite;
   2421                 /*commented FB*/
   2422                 /**
   2423                  * We do not need to set the color context, it is already set
   2424                  during sendCommand function */
   2425             }
   2426             if (M4xVSS_kVideoEffectType_Pink ==
   2427                 xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2428             {
   2429                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2430                  M4VSS3GPP_externalVideoEffectColor;
   2431                 //xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
   2432                 // (M4OSA_Void*)M4xVSS_kVideoEffectType_Pink; /**< we don't
   2433                 // use any function context */
   2434                 /*commented FB*/
   2435                 /**
   2436                  * We do not need to set the color context,
   2437                   it is already set during sendCommand function */
   2438             }
   2439             if (M4xVSS_kVideoEffectType_Green ==
   2440                  xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2441             {
   2442                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2443                     M4VSS3GPP_externalVideoEffectColor;
   2444                 //xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
   2445                     // (M4OSA_Void*)M4xVSS_kVideoEffectType_Green;
   2446                      /**< we don't use any function context */
   2447                 /*commented FB*/
   2448                 /**
   2449                  * We do not need to set the color context, it is already set during
   2450                   sendCommand function */
   2451             }
   2452             if (M4xVSS_kVideoEffectType_Sepia ==
   2453                  xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2454             {
   2455                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2456                  M4VSS3GPP_externalVideoEffectColor;
   2457                 //xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
   2458                 // (M4OSA_Void*)M4xVSS_kVideoEffectType_Sepia;
   2459                 /**< we don't use any function context */
   2460                 /*commented FB*/
   2461                 /**
   2462                  * We do not need to set the color context, it is already set during
   2463                  sendCommand function */
   2464             }
   2465             if (M4xVSS_kVideoEffectType_Fifties ==
   2466              xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2467             {
   2468                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2469                  M4VSS3GPP_externalVideoEffectFifties;
   2470                 /**
   2471                  * We do not need to set the framing context, it is already set during
   2472                  sendCommand function */
   2473             }
   2474             if (M4xVSS_kVideoEffectType_Negative ==
   2475              xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2476             {
   2477                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2478                  M4VSS3GPP_externalVideoEffectColor;
   2479                 //xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
   2480                 // (M4OSA_Void*)M4xVSS_kVideoEffectType_Negative;
   2481                  /**< we don't use any function context */
   2482                 /*commented FB*/
   2483                 /**
   2484                  * We do not need to set the color context, it is already set during
   2485                   sendCommand function */
   2486             }
   2487             if (M4xVSS_kVideoEffectType_Framing ==
   2488              xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2489             {
   2490                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2491                  M4VSS3GPP_externalVideoEffectFraming;
   2492                 /**
   2493                  * We do not need to set the framing context, it is already set during
   2494                  sendCommand function */
   2495             }
   2496             if (M4xVSS_kVideoEffectType_ZoomIn ==
   2497              xVSS_context->pSettings->Effects[j].VideoEffectType)
   2498             {
   2499                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2500                  M4VSS3GPP_externalVideoEffectZoom;
   2501                 xVSS_context->pCurrentEditSettings->Effects[j].pExtVideoEffectFctCtxt =
   2502                  (M4OSA_Void*)M4xVSS_kVideoEffectType_ZoomIn; /**< we don't use any
   2503                  function context */
   2504             }
   2505             if (M4xVSS_kVideoEffectType_ZoomOut ==
   2506              xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2507             {
   2508                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2509                  M4VSS3GPP_externalVideoEffectZoom;
   2510                 xVSS_context->pCurrentEditSettings->Effects[j].pExtVideoEffectFctCtxt =
   2511                  (M4OSA_Void*)M4xVSS_kVideoEffectType_ZoomOut; /**< we don't use any
   2512                  function context */
   2513             }
   2514             if (M4xVSS_kVideoEffectType_ColorRGB16 ==
   2515              xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2516             {
   2517                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2518                  M4VSS3GPP_externalVideoEffectColor;
   2519                 //xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
   2520                 // (M4OSA_Void*)M4xVSS_kVideoEffectType_ColorRGB16;
   2521                 /**< we don't use any function context */
   2522                 /**
   2523                  * We do not need to set the color context, it is already set during
   2524                  sendCommand function */
   2525             }
   2526             if (M4xVSS_kVideoEffectType_Gradient ==
   2527              xVSS_context->pCurrentEditSettings->Effects[j].VideoEffectType)
   2528             {
   2529                 xVSS_context->pCurrentEditSettings->Effects[j].ExtVideoEffectFct =
   2530                  M4VSS3GPP_externalVideoEffectColor;
   2531                 //xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
   2532                 // (M4OSA_Void*)M4xVSS_kVideoEffectType_ColorRGB16;
   2533                 /**< we don't use any function context */
   2534                 /**
   2535                  * We do not need to set the color context, it is already set during
   2536                  sendCommand function */
   2537             }
   2538 
   2539         }
   2540     }
   2541 
   2542     /**
   2543      * Open the VSS 3GPP */
   2544     err = M4VSS3GPP_editOpen(pVssCtxt, xVSS_context->pCurrentEditSettings);
   2545     if (err != M4NO_ERROR)
   2546     {
   2547         M4OSA_TRACE1_1("M4xVSS_internalGenerateEditedFile:\
   2548              M4VSS3GPP_editOpen returned 0x%x\n",err);
   2549         M4VSS3GPP_editCleanUp(pVssCtxt);
   2550         /**
   2551          * Set the VSS context to NULL */
   2552         xVSS_context->pCurrentEditContext = M4OSA_NULL;
   2553         return err;
   2554     }
   2555 
   2556     /**
   2557      * Save VSS context to be able to close / free VSS later */
   2558     xVSS_context->pCurrentEditContext = pVssCtxt;
   2559 
   2560     return M4NO_ERROR;
   2561 }
   2562 
   2563 /**
   2564  ******************************************************************************
   2565  * prototype    M4OSA_ERR M4xVSS_internalCloseEditedFile(M4OSA_Context pContext)
   2566  *
   2567  * @brief    This function cleans up VSS
   2568  * @note
   2569  * @param    pContext    (IN) The integrator own context
   2570  *
   2571  * @return    M4NO_ERROR:    No error
   2572  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   2573  ******************************************************************************
   2574  */
   2575 M4OSA_ERR M4xVSS_internalCloseEditedFile(M4OSA_Context pContext)
   2576 {
   2577     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   2578     M4VSS3GPP_EditContext pVssCtxt = xVSS_context->pCurrentEditContext;
   2579     M4OSA_ERR err;
   2580 
   2581     if(xVSS_context->pCurrentEditContext != M4OSA_NULL)
   2582     {
   2583         /**
   2584          * Close the VSS 3GPP */
   2585         err = M4VSS3GPP_editClose(pVssCtxt);
   2586         if (err != M4NO_ERROR)
   2587         {
   2588             M4OSA_TRACE1_1("M4xVSS_internalCloseEditedFile:\
   2589                  M4VSS3GPP_editClose returned 0x%x\n",err);
   2590             M4VSS3GPP_editCleanUp(pVssCtxt);
   2591             /**
   2592              * Set the VSS context to NULL */
   2593             xVSS_context->pCurrentEditContext = M4OSA_NULL;
   2594             return err;
   2595         }
   2596 
   2597         /**
   2598          * Free this VSS3GPP edition instance */
   2599         err = M4VSS3GPP_editCleanUp(pVssCtxt);
   2600         /**
   2601          * Set the VSS context to NULL */
   2602         xVSS_context->pCurrentEditContext = M4OSA_NULL;
   2603         if (err != M4NO_ERROR)
   2604         {
   2605             M4OSA_TRACE1_1("M4xVSS_internalCloseEditedFile: \
   2606                 M4VSS3GPP_editCleanUp returned 0x%x\n",err);
   2607             return err;
   2608         }
   2609     }
   2610 
   2611     return M4NO_ERROR;
   2612 }
   2613 
   2614 /**
   2615  ******************************************************************************
   2616  * prototype    M4OSA_ERR M4xVSS_internalGenerateAudioMixFile(M4OSA_Context pContext)
   2617  *
   2618  * @brief    This function prepares VSS for audio mixing
   2619  * @note    It takes its parameters from the BGM settings in the xVSS internal context
   2620  * @param    pContext    (IN) The integrator own context
   2621  *
   2622  * @return    M4NO_ERROR:    No error
   2623  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   2624  * @return    M4ERR_ALLOC: Allocation error (no more memory)
   2625  ******************************************************************************
   2626  */
   2627 /***
   2628  * FB: the function has been modified since the structure used for the saving is now the
   2629  *  pCurrentEditSettings and not the pSettings
   2630  * This change has been added for the UTF support
   2631  * All the "xVSS_context->pSettings" has been replaced by "xVSS_context->pCurrentEditSettings"
   2632  ***/
   2633 M4OSA_ERR M4xVSS_internalGenerateAudioMixFile(M4OSA_Context pContext)
   2634 {
   2635     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   2636     M4VSS3GPP_AudioMixingSettings* pAudioMixSettings;
   2637     M4VSS3GPP_AudioMixingContext pAudioMixingCtxt;
   2638     M4OSA_ERR err;
   2639     M4VIDEOEDITING_ClipProperties fileProperties;
   2640 
   2641     /**
   2642      * Allocate audio mixing settings structure and fill it with BGM parameters */
   2643     pAudioMixSettings = (M4VSS3GPP_AudioMixingSettings*)M4OSA_32bitAlignedMalloc
   2644         (sizeof(M4VSS3GPP_AudioMixingSettings), M4VS, (M4OSA_Char *)"pAudioMixSettings");
   2645     if(pAudioMixSettings == M4OSA_NULL)
   2646     {
   2647         M4OSA_TRACE1_0("Allocation error in M4xVSS_internalGenerateAudioMixFile");
   2648         return M4ERR_ALLOC;
   2649     }
   2650 
   2651     if(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->FileType ==
   2652          M4VIDEOEDITING_kFileType_3GPP)
   2653     {
   2654         err = M4xVSS_internalGetProperties((M4OSA_Context)xVSS_context,
   2655              (M4OSA_Char*)xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile,
   2656                  &fileProperties);
   2657         if(err != M4NO_ERROR)
   2658         {
   2659             M4OSA_TRACE1_1("M4xVSS_internalGenerateAudioMixFile:\
   2660                  impossible to retrieve audio BGM properties ->\
   2661                      reencoding audio background music", err);
   2662             fileProperties.AudioStreamType =
   2663                  xVSS_context->pCurrentEditSettings->xVSS.outputAudioFormat+1;
   2664                   /* To force BGM encoding */
   2665         }
   2666     }
   2667 
   2668     pAudioMixSettings->bRemoveOriginal = M4OSA_FALSE;
   2669     pAudioMixSettings->AddedAudioFileType =
   2670      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->FileType;
   2671     pAudioMixSettings->pAddedAudioTrackFile =
   2672      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile;
   2673     pAudioMixSettings->uiAddVolume =
   2674      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->uiAddVolume;
   2675 
   2676     pAudioMixSettings->outputAudioFormat = xVSS_context->pSettings->xVSS.outputAudioFormat;
   2677     pAudioMixSettings->outputASF = xVSS_context->pSettings->xVSS.outputAudioSamplFreq;
   2678     pAudioMixSettings->outputAudioBitrate = xVSS_context->pSettings->xVSS.outputAudioBitrate;
   2679     pAudioMixSettings->uiSamplingFrequency =
   2680      xVSS_context->pSettings->xVSS.pBGMtrack->uiSamplingFrequency;
   2681     pAudioMixSettings->uiNumChannels = xVSS_context->pSettings->xVSS.pBGMtrack->uiNumChannels;
   2682 
   2683     pAudioMixSettings->b_DuckingNeedeed =
   2684      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->b_DuckingNeedeed;
   2685     pAudioMixSettings->fBTVolLevel =
   2686      (M4OSA_Float )xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->uiAddVolume/100;
   2687     pAudioMixSettings->InDucking_threshold =
   2688      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->InDucking_threshold;
   2689     pAudioMixSettings->InDucking_lowVolume =
   2690      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->lowVolume/100;
   2691     pAudioMixSettings->fPTVolLevel =
   2692      (M4OSA_Float)xVSS_context->pSettings->PTVolLevel/100;
   2693     pAudioMixSettings->bLoop = xVSS_context->pSettings->xVSS.pBGMtrack->bLoop;
   2694 
   2695     if(xVSS_context->pSettings->xVSS.bAudioMono)
   2696     {
   2697         pAudioMixSettings->outputNBChannels = 1;
   2698     }
   2699     else
   2700     {
   2701         pAudioMixSettings->outputNBChannels = 2;
   2702     }
   2703 
   2704     /**
   2705      * Fill audio mix settings with BGM parameters */
   2706     pAudioMixSettings->uiBeginLoop =
   2707      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->uiBeginLoop;
   2708     pAudioMixSettings->uiEndLoop =
   2709      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->uiEndLoop;
   2710     pAudioMixSettings->uiAddCts =
   2711      xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->uiAddCts;
   2712 
   2713     /**
   2714      * Output file of the audio mixer will be final file (audio mixing is the last step) */
   2715     pAudioMixSettings->pOutputClipFile = xVSS_context->pOutputFile;
   2716     pAudioMixSettings->pTemporaryFile = xVSS_context->pTemporaryFile;
   2717 
   2718     /**
   2719      * Input file of the audio mixer is a temporary file containing all audio/video editions */
   2720     pAudioMixSettings->pOriginalClipFile = xVSS_context->pCurrentEditSettings->pOutputFile;
   2721 
   2722     /**
   2723      * Save audio mixing settings pointer to be able to free it in
   2724      M4xVSS_internalCloseAudioMixedFile function */
   2725     xVSS_context->pAudioMixSettings = pAudioMixSettings;
   2726 
   2727     /**
   2728      * Create a VSS 3GPP audio mixing instance */
   2729     err = M4VSS3GPP_audioMixingInit(&pAudioMixingCtxt, pAudioMixSettings,
   2730          xVSS_context->pFileReadPtr, xVSS_context->pFileWritePtr);
   2731 
   2732     /**
   2733      * Save audio mixing context to be able to call audio mixing step function in
   2734       M4xVSS_step function */
   2735     xVSS_context->pAudioMixContext = pAudioMixingCtxt;
   2736 
   2737     if (err != M4NO_ERROR)
   2738     {
   2739         M4OSA_TRACE1_1("M4xVSS_internalGenerateAudioMixFile:\
   2740              M4VSS3GPP_audioMixingInit returned 0x%x\n",err);
   2741         //M4VSS3GPP_audioMixingCleanUp(pAudioMixingCtxt);
   2742         return err;
   2743     }
   2744 
   2745     return M4NO_ERROR;
   2746 }
   2747 
   2748 /**
   2749  ******************************************************************************
   2750  * prototype    M4OSA_ERR M4xVSS_internalCloseAudioMixedFile(M4OSA_Context pContext)
   2751  *
   2752  * @brief    This function cleans up VSS for audio mixing
   2753  * @note
   2754  * @param    pContext    (IN) The integrator own context
   2755  *
   2756  * @return    M4NO_ERROR:    No error
   2757  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   2758  ******************************************************************************
   2759  */
   2760 M4OSA_ERR M4xVSS_internalCloseAudioMixedFile(M4OSA_Context pContext)
   2761 {
   2762     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   2763     M4OSA_ERR err;
   2764 
   2765     /**
   2766      * Free this VSS3GPP audio mixing instance */
   2767     if(xVSS_context->pAudioMixContext != M4OSA_NULL)
   2768     {
   2769         err = M4VSS3GPP_audioMixingCleanUp(xVSS_context->pAudioMixContext);
   2770         if (err != M4NO_ERROR)
   2771         {
   2772             M4OSA_TRACE1_1("M4xVSS_internalCloseAudioMixedFile:\
   2773                  M4VSS3GPP_audioMixingCleanUp returned 0x%x\n",err);
   2774             return err;
   2775         }
   2776     }
   2777 
   2778     /**
   2779      * Free VSS audio mixing settings */
   2780     if(xVSS_context->pAudioMixSettings != M4OSA_NULL)
   2781     {
   2782         free(xVSS_context->pAudioMixSettings);
   2783         xVSS_context->pAudioMixSettings = M4OSA_NULL;
   2784     }
   2785 
   2786     return M4NO_ERROR;
   2787 }
   2788 
   2789 /**
   2790  ******************************************************************************
   2791  * prototype    M4OSA_ERR M4xVSS_internalFreePreview(M4OSA_Context pContext)
   2792  *
   2793  * @brief    This function cleans up preview edition structure used to generate
   2794  *            preview.3gp file given to the VPS
   2795  * @note    It also free the preview structure given to the VPS
   2796  * @param    pContext    (IN) The integrator own context
   2797  *
   2798  * @return    M4NO_ERROR:    No error
   2799  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   2800  ******************************************************************************
   2801  */
   2802 M4OSA_ERR M4xVSS_internalFreePreview(M4OSA_Context pContext)
   2803 {
   2804     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   2805     M4OSA_UInt8 i;
   2806 
   2807     /**
   2808      * Free clip/transition settings */
   2809     for(i=0; i<xVSS_context->pCurrentEditSettings->uiClipNumber; i++)
   2810     {
   2811         M4xVSS_FreeClipSettings(xVSS_context->pCurrentEditSettings->pClipList[i]);
   2812 
   2813         free((xVSS_context->pCurrentEditSettings->pClipList[i]));
   2814         xVSS_context->pCurrentEditSettings->pClipList[i] = M4OSA_NULL;
   2815 
   2816         /**
   2817          * Because there is 1 less transition than clip number */
   2818         if(i != xVSS_context->pCurrentEditSettings->uiClipNumber-1)
   2819         {
   2820             free((xVSS_context->pCurrentEditSettings->pTransitionList[i]));
   2821             xVSS_context->pCurrentEditSettings->pTransitionList[i] = M4OSA_NULL;
   2822         }
   2823     }
   2824 
   2825     /**
   2826      * Free clip/transition list */
   2827     if(xVSS_context->pCurrentEditSettings->pClipList != M4OSA_NULL)
   2828     {
   2829         free((xVSS_context->pCurrentEditSettings->pClipList));
   2830         xVSS_context->pCurrentEditSettings->pClipList = M4OSA_NULL;
   2831     }
   2832     if(xVSS_context->pCurrentEditSettings->pTransitionList != M4OSA_NULL)
   2833     {
   2834         free((xVSS_context->pCurrentEditSettings->pTransitionList));
   2835         xVSS_context->pCurrentEditSettings->pTransitionList = M4OSA_NULL;
   2836     }
   2837 
   2838     /**
   2839      * Free output preview file path */
   2840     if(xVSS_context->pCurrentEditSettings->pOutputFile != M4OSA_NULL)
   2841     {
   2842         free(xVSS_context->pCurrentEditSettings->pOutputFile);
   2843         xVSS_context->pCurrentEditSettings->pOutputFile = M4OSA_NULL;
   2844     }
   2845 
   2846     /**
   2847      * Free temporary preview file path */
   2848     if(xVSS_context->pCurrentEditSettings->pTemporaryFile != M4OSA_NULL)
   2849     {
   2850         remove((const char *)xVSS_context->pCurrentEditSettings->pTemporaryFile);
   2851         free(xVSS_context->pCurrentEditSettings->pTemporaryFile);
   2852         xVSS_context->pCurrentEditSettings->pTemporaryFile = M4OSA_NULL;
   2853     }
   2854 
   2855     /**
   2856      * Free "local" BGM settings */
   2857     if(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack != M4OSA_NULL)
   2858     {
   2859         if(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile != M4OSA_NULL)
   2860         {
   2861             free(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile);
   2862             xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile = M4OSA_NULL;
   2863         }
   2864         free(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack);
   2865         xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack = M4OSA_NULL;
   2866     }
   2867 
   2868     /**
   2869      * Free current edit settings structure */
   2870     if(xVSS_context->pCurrentEditSettings != M4OSA_NULL)
   2871     {
   2872         free(xVSS_context->pCurrentEditSettings);
   2873         xVSS_context->pCurrentEditSettings = M4OSA_NULL;
   2874     }
   2875 
   2876     /**
   2877      * Free preview effects given to application */
   2878     if(M4OSA_NULL != xVSS_context->pPreviewSettings->Effects)
   2879     {
   2880         free(xVSS_context->pPreviewSettings->Effects);
   2881         xVSS_context->pPreviewSettings->Effects = M4OSA_NULL;
   2882         xVSS_context->pPreviewSettings->nbEffects = 0;
   2883     }
   2884 
   2885     return M4NO_ERROR;
   2886 }
   2887 
   2888 
   2889 /**
   2890  ******************************************************************************
   2891  * prototype    M4OSA_ERR M4xVSS_internalFreeSaving(M4OSA_Context pContext)
   2892  *
   2893  * @brief    This function cleans up saving edition structure used to generate
   2894  *            output.3gp file given to the VPS
   2895  * @note
   2896  * @param    pContext    (IN) The integrator own context
   2897  *
   2898  * @return    M4NO_ERROR:    No error
   2899  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   2900  ******************************************************************************
   2901  */
   2902 M4OSA_ERR M4xVSS_internalFreeSaving(M4OSA_Context pContext)
   2903 {
   2904     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   2905     M4OSA_UInt8 i;
   2906 
   2907     if(xVSS_context->pCurrentEditSettings != M4OSA_NULL)
   2908     {
   2909         /**
   2910          * Free clip/transition settings */
   2911         for(i=0; i<xVSS_context->pCurrentEditSettings->uiClipNumber; i++)
   2912         {
   2913             M4xVSS_FreeClipSettings(xVSS_context->pCurrentEditSettings->pClipList[i]);
   2914 
   2915             free((xVSS_context->pCurrentEditSettings->pClipList[i]));
   2916             xVSS_context->pCurrentEditSettings->pClipList[i] = M4OSA_NULL;
   2917 
   2918             /**
   2919              * Because there is 1 less transition than clip number */
   2920             if(i != xVSS_context->pCurrentEditSettings->uiClipNumber-1)
   2921             {
   2922                 free(\
   2923                     (xVSS_context->pCurrentEditSettings->pTransitionList[i]));
   2924                 xVSS_context->pCurrentEditSettings->pTransitionList[i] = M4OSA_NULL;
   2925             }
   2926         }
   2927 
   2928         /**
   2929          * Free clip/transition list */
   2930         if(xVSS_context->pCurrentEditSettings->pClipList != M4OSA_NULL)
   2931         {
   2932             free((xVSS_context->pCurrentEditSettings->pClipList));
   2933             xVSS_context->pCurrentEditSettings->pClipList = M4OSA_NULL;
   2934         }
   2935         if(xVSS_context->pCurrentEditSettings->pTransitionList != M4OSA_NULL)
   2936         {
   2937             free((xVSS_context->pCurrentEditSettings->pTransitionList));
   2938             xVSS_context->pCurrentEditSettings->pTransitionList = M4OSA_NULL;
   2939         }
   2940 
   2941         if(xVSS_context->pCurrentEditSettings->Effects != M4OSA_NULL)
   2942         {
   2943             free((xVSS_context->pCurrentEditSettings->Effects));
   2944             xVSS_context->pCurrentEditSettings->Effects = M4OSA_NULL;
   2945             xVSS_context->pCurrentEditSettings->nbEffects = 0;
   2946         }
   2947 
   2948         /**
   2949          * Free output saving file path */
   2950         if(xVSS_context->pCurrentEditSettings->pOutputFile != M4OSA_NULL)
   2951         {
   2952             if(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack != M4OSA_NULL)
   2953             {
   2954                 remove((const char *)xVSS_context->pCurrentEditSettings->pOutputFile);
   2955                 free(xVSS_context->pCurrentEditSettings->pOutputFile);
   2956             }
   2957             if(xVSS_context->pOutputFile != M4OSA_NULL)
   2958             {
   2959                 free(xVSS_context->pOutputFile);
   2960                 xVSS_context->pOutputFile = M4OSA_NULL;
   2961             }
   2962             xVSS_context->pSettings->pOutputFile = M4OSA_NULL;
   2963             xVSS_context->pCurrentEditSettings->pOutputFile = M4OSA_NULL;
   2964         }
   2965 
   2966         /**
   2967          * Free temporary saving file path */
   2968         if(xVSS_context->pCurrentEditSettings->pTemporaryFile != M4OSA_NULL)
   2969         {
   2970             remove((const char *)xVSS_context->pCurrentEditSettings->pTemporaryFile);
   2971             free(xVSS_context->pCurrentEditSettings->pTemporaryFile);
   2972             xVSS_context->pCurrentEditSettings->pTemporaryFile = M4OSA_NULL;
   2973         }
   2974 
   2975         /**
   2976          * Free "local" BGM settings */
   2977         if(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack != M4OSA_NULL)
   2978         {
   2979             if(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile != M4OSA_NULL)
   2980             {
   2981                 free(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile);
   2982                 xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack->pFile = M4OSA_NULL;
   2983             }
   2984             free(xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack);
   2985             xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack = M4OSA_NULL;
   2986         }
   2987 
   2988         /**
   2989          * Free current edit settings structure */
   2990         free(xVSS_context->pCurrentEditSettings);
   2991         xVSS_context->pCurrentEditSettings = M4OSA_NULL;
   2992     }
   2993 
   2994     return M4NO_ERROR;
   2995 }
   2996 
   2997 
   2998 /**
   2999  ******************************************************************************
   3000  * prototype    M4OSA_ERR M4xVSS_freeSettings(M4OSA_Context pContext)
   3001  *
   3002  * @brief    This function cleans up an M4VSS3GPP_EditSettings structure
   3003  * @note
   3004  * @param    pSettings    (IN) Pointer on M4VSS3GPP_EditSettings structure to free
   3005  *
   3006  * @return    M4NO_ERROR:    No error
   3007  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   3008  ******************************************************************************
   3009  */
   3010 M4OSA_ERR M4xVSS_freeSettings(M4VSS3GPP_EditSettings* pSettings)
   3011 {
   3012     M4OSA_UInt8 i,j;
   3013 
   3014     /**
   3015      * For each clip ... */
   3016     for(i=0; i<pSettings->uiClipNumber; i++)
   3017     {
   3018         /**
   3019          * ... free clip settings */
   3020         if(pSettings->pClipList[i] != M4OSA_NULL)
   3021         {
   3022             M4xVSS_FreeClipSettings(pSettings->pClipList[i]);
   3023 
   3024             free((pSettings->pClipList[i]));
   3025             pSettings->pClipList[i] = M4OSA_NULL;
   3026         }
   3027 
   3028         /**
   3029          * ... free transition settings */
   3030         if(i < pSettings->uiClipNumber-1) /* Because there is 1 less transition than clip number */
   3031         {
   3032             if(pSettings->pTransitionList[i] != M4OSA_NULL)
   3033             {
   3034                 switch (pSettings->pTransitionList[i]->VideoTransitionType)
   3035                 {
   3036                     case M4xVSS_kVideoTransitionType_AlphaMagic:
   3037 
   3038                         /**
   3039                          * In case of Alpha Magic transition,
   3040                           some extra parameters need to be freed */
   3041                         if(pSettings->pTransitionList[i]->pExtVideoTransitionFctCtxt\
   3042                              != M4OSA_NULL)
   3043                         {
   3044                             free((((M4xVSS_internal_AlphaMagicSettings*)\
   3045                                 pSettings->pTransitionList[i]->pExtVideoTransitionFctCtxt)->\
   3046                                     pPlane->pac_data));
   3047                             ((M4xVSS_internal_AlphaMagicSettings*)pSettings->pTransitionList[i\
   3048                                 ]->pExtVideoTransitionFctCtxt)->pPlane->pac_data = M4OSA_NULL;
   3049 
   3050                             free((((M4xVSS_internal_AlphaMagicSettings*)\
   3051                                 pSettings->pTransitionList[i]->\
   3052                                     pExtVideoTransitionFctCtxt)->pPlane));
   3053                             ((M4xVSS_internal_AlphaMagicSettings*)pSettings->pTransitionList[i]\
   3054                                 ->pExtVideoTransitionFctCtxt)->pPlane = M4OSA_NULL;
   3055 
   3056                             free((pSettings->pTransitionList[i]->\
   3057                                 pExtVideoTransitionFctCtxt));
   3058                             pSettings->pTransitionList[i]->pExtVideoTransitionFctCtxt = M4OSA_NULL;
   3059 
   3060                             for(j=i+1;j<pSettings->uiClipNumber-1;j++)
   3061                             {
   3062                                 if(pSettings->pTransitionList[j] != M4OSA_NULL)
   3063                                 {
   3064                                     if(pSettings->pTransitionList[j]->VideoTransitionType ==
   3065                                      M4xVSS_kVideoTransitionType_AlphaMagic)
   3066                                     {
   3067                                         M4OSA_UInt32 pCmpResult=0;
   3068                                         pCmpResult = strcmp((const char *)pSettings->pTransitionList[i]->\
   3069                                             xVSS.transitionSpecific.pAlphaMagicSettings->\
   3070                                                 pAlphaFilePath,
   3071                                                 (const char *)pSettings->pTransitionList[j]->\
   3072                                                 xVSS.transitionSpecific.pAlphaMagicSettings->\
   3073                                                 pAlphaFilePath);
   3074                                         if(pCmpResult == 0)
   3075                                         {
   3076                                             /* Free extra internal alpha magic structure and put
   3077                                             it to NULL to avoid refreeing it */
   3078                                             free((pSettings->\
   3079                                                 pTransitionList[j]->pExtVideoTransitionFctCtxt));
   3080                                             pSettings->pTransitionList[j]->\
   3081                                                 pExtVideoTransitionFctCtxt = M4OSA_NULL;
   3082                                         }
   3083                                     }
   3084                                 }
   3085                             }
   3086                         }
   3087 
   3088                         if(pSettings->pTransitionList[i]->\
   3089                             xVSS.transitionSpecific.pAlphaMagicSettings != M4OSA_NULL)
   3090                         {
   3091                             if(pSettings->pTransitionList[i]->\
   3092                                 xVSS.transitionSpecific.pAlphaMagicSettings->\
   3093                                     pAlphaFilePath != M4OSA_NULL)
   3094                             {
   3095                                 free(pSettings->\
   3096                                     pTransitionList[i]->\
   3097                                         xVSS.transitionSpecific.pAlphaMagicSettings->\
   3098                                             pAlphaFilePath);
   3099                                 pSettings->pTransitionList[i]->\
   3100                                     xVSS.transitionSpecific.pAlphaMagicSettings->\
   3101                                         pAlphaFilePath = M4OSA_NULL;
   3102                             }
   3103                             free(pSettings->pTransitionList[i]->\
   3104                                 xVSS.transitionSpecific.pAlphaMagicSettings);
   3105                             pSettings->pTransitionList[i]->\
   3106                                 xVSS.transitionSpecific.pAlphaMagicSettings = M4OSA_NULL;
   3107 
   3108                         }
   3109 
   3110                     break;
   3111 
   3112 
   3113                     case M4xVSS_kVideoTransitionType_SlideTransition:
   3114                         if (M4OSA_NULL != pSettings->pTransitionList[i]->\
   3115                             xVSS.transitionSpecific.pSlideTransitionSettings)
   3116                         {
   3117                             free(pSettings->pTransitionList[i]->\
   3118                                 xVSS.transitionSpecific.pSlideTransitionSettings);
   3119                             pSettings->pTransitionList[i]->\
   3120                                 xVSS.transitionSpecific.pSlideTransitionSettings = M4OSA_NULL;
   3121                         }
   3122                         if(pSettings->pTransitionList[i]->pExtVideoTransitionFctCtxt != M4OSA_NULL)
   3123                         {
   3124                             free((pSettings->pTransitionList[i]->\
   3125                                 pExtVideoTransitionFctCtxt));
   3126                             pSettings->pTransitionList[i]->pExtVideoTransitionFctCtxt = M4OSA_NULL;
   3127                         }
   3128                     break;
   3129                                         default:
   3130                     break;
   3131 
   3132                 }
   3133                 /**
   3134                  * Free transition settings structure */
   3135                 free((pSettings->pTransitionList[i]));
   3136                 pSettings->pTransitionList[i] = M4OSA_NULL;
   3137             }
   3138         }
   3139     }
   3140 
   3141     /**
   3142      * Free clip list */
   3143     if(pSettings->pClipList != M4OSA_NULL)
   3144     {
   3145         free((pSettings->pClipList));
   3146         pSettings->pClipList = M4OSA_NULL;
   3147     }
   3148 
   3149     /**
   3150      * Free transition list */
   3151     if(pSettings->pTransitionList != M4OSA_NULL)
   3152     {
   3153         free((pSettings->pTransitionList));
   3154         pSettings->pTransitionList = M4OSA_NULL;
   3155     }
   3156 
   3157     /**
   3158      * RC: Free effects list */
   3159     if(pSettings->Effects != M4OSA_NULL)
   3160     {
   3161         for(i=0; i<pSettings->nbEffects; i++)
   3162         {
   3163             /**
   3164              * For each clip, free framing structure if needed */
   3165             if(pSettings->Effects[i].VideoEffectType == M4xVSS_kVideoEffectType_Framing
   3166                 || pSettings->Effects[i].VideoEffectType == M4xVSS_kVideoEffectType_Text)
   3167             {
   3168 #ifdef DECODE_GIF_ON_SAVING
   3169                 M4xVSS_FramingContext* framingCtx = pSettings->Effects[i].pExtVideoEffectFctCtxt;
   3170 #else
   3171                 M4xVSS_FramingStruct* framingCtx = pSettings->Effects[i].pExtVideoEffectFctCtxt;
   3172                 M4xVSS_FramingStruct* framingCtx_save;
   3173                 M4xVSS_Framing3102Struct* framingCtx_first = framingCtx;
   3174 #endif
   3175 
   3176 #ifdef DECODE_GIF_ON_SAVING
   3177                 if(framingCtx != M4OSA_NULL) /* Bugfix 1.2.0: crash, trying to free non existant
   3178                  pointer */
   3179                 {
   3180                     if(framingCtx->aFramingCtx != M4OSA_NULL)
   3181                     {
   3182                         {
   3183                             if(framingCtx->aFramingCtx->FramingRgb != M4OSA_NULL)
   3184                             {
   3185                                 free(framingCtx->aFramingCtx->\
   3186                                     FramingRgb->pac_data);
   3187                                 framingCtx->aFramingCtx->FramingRgb->pac_data = M4OSA_NULL;
   3188                                 free(framingCtx->aFramingCtx->FramingRgb);
   3189                                 framingCtx->aFramingCtx->FramingRgb = M4OSA_NULL;
   3190                             }
   3191                         }
   3192                         if(framingCtx->aFramingCtx->FramingYuv != M4OSA_NULL)
   3193                         {
   3194                             free(framingCtx->aFramingCtx->\
   3195                                 FramingYuv[0].pac_data);
   3196                             framingCtx->aFramingCtx->FramingYuv[0].pac_data = M4OSA_NULL;
   3197                            free(framingCtx->aFramingCtx->\
   3198                                 FramingYuv[1].pac_data);
   3199                             framingCtx->aFramingCtx->FramingYuv[1].pac_data = M4OSA_NULL;
   3200                            free(framingCtx->aFramingCtx->\
   3201                                 FramingYuv[2].pac_data);
   3202                             framingCtx->aFramingCtx->FramingYuv[2].pac_data = M4OSA_NULL;
   3203                             free(framingCtx->aFramingCtx->FramingYuv);
   3204                             framingCtx->aFramingCtx->FramingYuv = M4OSA_NULL;
   3205                         }
   3206                         free(framingCtx->aFramingCtx);
   3207                         framingCtx->aFramingCtx = M4OSA_NULL;
   3208                     }
   3209                     if(framingCtx->aFramingCtx_last != M4OSA_NULL)
   3210                     {
   3211                         if(framingCtx->aFramingCtx_last->FramingRgb != M4OSA_NULL)
   3212                         {
   3213                             free(framingCtx->aFramingCtx_last->\
   3214                                 FramingRgb->pac_data);
   3215                             framingCtx->aFramingCtx_last->FramingRgb->pac_data = M4OSA_NULL;
   3216                             free(framingCtx->aFramingCtx_last->\
   3217                                 FramingRgb);
   3218                             framingCtx->aFramingCtx_last->FramingRgb = M4OSA_NULL;
   3219                         }
   3220                         if(framingCtx->aFramingCtx_last->FramingYuv != M4OSA_NULL)
   3221                         {
   3222                             free(framingCtx->aFramingCtx_last->\
   3223                                 FramingYuv[0].pac_data);
   3224                             framingCtx->aFramingCtx_last->FramingYuv[0].pac_data = M4OSA_NULL;
   3225                             free(framingCtx->aFramingCtx_last->FramingYuv);
   3226                             framingCtx->aFramingCtx_last->FramingYuv = M4OSA_NULL;
   3227                         }
   3228                         free(framingCtx->aFramingCtx_last);
   3229                         framingCtx->aFramingCtx_last = M4OSA_NULL;
   3230                     }
   3231                     if(framingCtx->pEffectFilePath != M4OSA_NULL)
   3232                     {
   3233                         free(framingCtx->pEffectFilePath);
   3234                         framingCtx->pEffectFilePath = M4OSA_NULL;
   3235                     }
   3236                     /*In case there are still allocated*/
   3237                     if(framingCtx->pSPSContext != M4OSA_NULL)
   3238                     {
   3239                     //    M4SPS_destroy(framingCtx->pSPSContext);
   3240                         framingCtx->pSPSContext = M4OSA_NULL;
   3241                     }
   3242                     /*Alpha blending structure*/
   3243                     if(framingCtx->alphaBlendingStruct  != M4OSA_NULL)
   3244                     {
   3245                         free(framingCtx->alphaBlendingStruct);
   3246                         framingCtx->alphaBlendingStruct = M4OSA_NULL;
   3247                     }
   3248 
   3249                     free(framingCtx);
   3250                     framingCtx = M4OSA_NULL;
   3251                 }
   3252 #else
   3253                 do
   3254                 {
   3255                     if(framingCtx != M4OSA_NULL) /* Bugfix 1.2.0: crash, trying to free non
   3256                     existant pointer */
   3257                     {
   3258                         if(framingCtx->FramingRgb != M4OSA_NULL)
   3259                         {
   3260                             free(framingCtx->FramingRgb->pac_data);
   3261                             framingCtx->FramingRgb->pac_data = M4OSA_NULL;
   3262                             free(framingCtx->FramingRgb);
   3263                             framingCtx->FramingRgb = M4OSA_NULL;
   3264                         }
   3265                         if(framingCtx->FramingYuv != M4OSA_NULL)
   3266                         {
   3267                             free(framingCtx->FramingYuv[0].pac_data);
   3268                             framingCtx->FramingYuv[0].pac_data = M4OSA_NULL;
   3269                             free(framingCtx->FramingYuv);
   3270                             framingCtx->FramingYuv = M4OSA_NULL;
   3271                         }
   3272                         framingCtx_save = framingCtx->pNext;
   3273                         free(framingCtx);
   3274                         framingCtx = M4OSA_NULL;
   3275                         framingCtx = framingCtx_save;
   3276                     }
   3277                     else
   3278                     {
   3279                         /*FB: bug fix P4ME00003002*/
   3280                         break;
   3281                     }
   3282                 } while(framingCtx_first != framingCtx);
   3283 #endif
   3284             }
   3285             else if( M4xVSS_kVideoEffectType_Fifties == pSettings->Effects[i].VideoEffectType)
   3286             {
   3287                 /* Free Fifties context */
   3288                 M4xVSS_FiftiesStruct* FiftiesCtx = pSettings->Effects[i].pExtVideoEffectFctCtxt;
   3289 
   3290                 if(FiftiesCtx != M4OSA_NULL)
   3291                 {
   3292                     free(FiftiesCtx);
   3293                     FiftiesCtx = M4OSA_NULL;
   3294                 }
   3295 
   3296             }
   3297             else if( M4xVSS_kVideoEffectType_ColorRGB16 == pSettings->Effects[i].VideoEffectType
   3298                 || M4xVSS_kVideoEffectType_BlackAndWhite == pSettings->Effects[i].VideoEffectType
   3299                 || M4xVSS_kVideoEffectType_Pink == pSettings->Effects[i].VideoEffectType
   3300                 || M4xVSS_kVideoEffectType_Green == pSettings->Effects[i].VideoEffectType
   3301                 || M4xVSS_kVideoEffectType_Sepia == pSettings->Effects[i].VideoEffectType
   3302                 || M4xVSS_kVideoEffectType_Negative== pSettings->Effects[i].VideoEffectType
   3303                 || M4xVSS_kVideoEffectType_Gradient== pSettings->Effects[i].VideoEffectType)
   3304             {
   3305                 /* Free Color context */
   3306                 M4xVSS_ColorStruct* ColorCtx = pSettings->Effects[i].pExtVideoEffectFctCtxt;
   3307 
   3308                 if(ColorCtx != M4OSA_NULL)
   3309                 {
   3310                     free(ColorCtx);
   3311                     ColorCtx = M4OSA_NULL;
   3312                 }
   3313             }
   3314 
   3315             /* Free simple fields */
   3316             if(pSettings->Effects[i].xVSS.pFramingFilePath != M4OSA_NULL)
   3317             {
   3318                 free(pSettings->Effects[i].xVSS.pFramingFilePath);
   3319                 pSettings->Effects[i].xVSS.pFramingFilePath = M4OSA_NULL;
   3320             }
   3321             if(pSettings->Effects[i].xVSS.pFramingBuffer != M4OSA_NULL)
   3322             {
   3323                 free(pSettings->Effects[i].xVSS.pFramingBuffer);
   3324                 pSettings->Effects[i].xVSS.pFramingBuffer = M4OSA_NULL;
   3325             }
   3326             if(pSettings->Effects[i].xVSS.pTextBuffer != M4OSA_NULL)
   3327             {
   3328                 free(pSettings->Effects[i].xVSS.pTextBuffer);
   3329                 pSettings->Effects[i].xVSS.pTextBuffer = M4OSA_NULL;
   3330             }
   3331         }
   3332         free(pSettings->Effects);
   3333         pSettings->Effects = M4OSA_NULL;
   3334     }
   3335 
   3336     return M4NO_ERROR;
   3337 }
   3338 
   3339 M4OSA_ERR M4xVSS_freeCommand(M4OSA_Context pContext)
   3340 {
   3341     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   3342 //    M4OSA_UInt8 i,j;
   3343 
   3344     /* Free "local" BGM settings */
   3345     if(xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL)
   3346     {
   3347         if(xVSS_context->pSettings->xVSS.pBGMtrack->pFile != M4OSA_NULL)
   3348         {
   3349             free(xVSS_context->pSettings->xVSS.pBGMtrack->pFile);
   3350             xVSS_context->pSettings->xVSS.pBGMtrack->pFile = M4OSA_NULL;
   3351         }
   3352         free(xVSS_context->pSettings->xVSS.pBGMtrack);
   3353         xVSS_context->pSettings->xVSS.pBGMtrack = M4OSA_NULL;
   3354     }
   3355 
   3356     M4xVSS_freeSettings(xVSS_context->pSettings);
   3357 
   3358     if(xVSS_context->pPTo3GPPparamsList != M4OSA_NULL)
   3359     {
   3360         M4xVSS_Pto3GPP_params* pParams = xVSS_context->pPTo3GPPparamsList;
   3361         M4xVSS_Pto3GPP_params* pParams_sauv;
   3362 
   3363         while(pParams != M4OSA_NULL)
   3364         {
   3365             if(pParams->pFileIn != M4OSA_NULL)
   3366             {
   3367                 free(pParams->pFileIn);
   3368                 pParams->pFileIn = M4OSA_NULL;
   3369             }
   3370             if(pParams->pFileOut != M4OSA_NULL)
   3371             {
   3372                 /* Delete temporary file */
   3373                 remove((const char *)pParams->pFileOut);
   3374                 free(pParams->pFileOut);
   3375                 pParams->pFileOut = M4OSA_NULL;
   3376             }
   3377             if(pParams->pFileTemp != M4OSA_NULL)
   3378             {
   3379                 /* Delete temporary file */
   3380 #ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
   3381                 remove((const char *)pParams->pFileTemp);
   3382                 free(pParams->pFileTemp);
   3383 #endif/*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
   3384                 pParams->pFileTemp = M4OSA_NULL;
   3385             }
   3386             pParams_sauv = pParams;
   3387             pParams = pParams->pNext;
   3388             free(pParams_sauv);
   3389             pParams_sauv = M4OSA_NULL;
   3390         }
   3391     }
   3392 
   3393     if(xVSS_context->pMCSparamsList != M4OSA_NULL)
   3394     {
   3395         M4xVSS_MCS_params* pParams = xVSS_context->pMCSparamsList;
   3396         M4xVSS_MCS_params* pParams_sauv;
   3397 
   3398         while(pParams != M4OSA_NULL)
   3399         {
   3400             if(pParams->pFileIn != M4OSA_NULL)
   3401             {
   3402                 free(pParams->pFileIn);
   3403                 pParams->pFileIn = M4OSA_NULL;
   3404             }
   3405             if(pParams->pFileOut != M4OSA_NULL)
   3406             {
   3407                 /* Delete temporary file */
   3408                 remove((const char *)pParams->pFileOut);
   3409                 free(pParams->pFileOut);
   3410                 pParams->pFileOut = M4OSA_NULL;
   3411             }
   3412             if(pParams->pFileTemp != M4OSA_NULL)
   3413             {
   3414                 /* Delete temporary file */
   3415 #ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
   3416                 remove((const char *)pParams->pFileTemp);
   3417                 free(pParams->pFileTemp);
   3418 #endif/*M4xVSS_RESERVED_MOOV_DISK_SPACE*/
   3419                 pParams->pFileTemp = M4OSA_NULL;
   3420             }
   3421             pParams_sauv = pParams;
   3422             pParams = pParams->pNext;
   3423             free(pParams_sauv);
   3424             pParams_sauv = M4OSA_NULL;
   3425         }
   3426     }
   3427 
   3428     if(xVSS_context->pcmPreviewFile != M4OSA_NULL)
   3429     {
   3430         free(xVSS_context->pcmPreviewFile);
   3431         xVSS_context->pcmPreviewFile = M4OSA_NULL;
   3432     }
   3433     if(xVSS_context->pSettings->pOutputFile != M4OSA_NULL
   3434         && xVSS_context->pOutputFile != M4OSA_NULL)
   3435     {
   3436         free(xVSS_context->pSettings->pOutputFile);
   3437         xVSS_context->pSettings->pOutputFile = M4OSA_NULL;
   3438         xVSS_context->pOutputFile = M4OSA_NULL;
   3439     }
   3440 
   3441     /* Reinit all context variables */
   3442     xVSS_context->previousClipNumber = 0;
   3443     xVSS_context->editingStep = M4xVSS_kMicroStateEditing;
   3444     xVSS_context->analyseStep = M4xVSS_kMicroStateAnalysePto3GPP;
   3445     xVSS_context->pPTo3GPPparamsList = M4OSA_NULL;
   3446     xVSS_context->pPTo3GPPcurrentParams = M4OSA_NULL;
   3447     xVSS_context->pMCSparamsList = M4OSA_NULL;
   3448     xVSS_context->pMCScurrentParams = M4OSA_NULL;
   3449     xVSS_context->tempFileIndex = 0;
   3450     xVSS_context->targetedTimescale = 0;
   3451 
   3452     return M4NO_ERROR;
   3453 }
   3454 
   3455 /**
   3456  ******************************************************************************
   3457  * prototype    M4OSA_ERR M4xVSS_internalGetProperties(M4OSA_Context pContext,
   3458  *                                    M4OSA_Char* pFile,
   3459  *                                    M4VIDEOEDITING_ClipProperties *pFileProperties)
   3460  *
   3461  * @brief    This function retrieve properties of an input 3GP file using MCS
   3462  * @note
   3463  * @param    pContext        (IN) The integrator own context
   3464  * @param    pFile            (IN) 3GP file to analyse
   3465  * @param    pFileProperties    (IN/OUT) Pointer on a structure that will contain
   3466  *                            the 3GP file properties
   3467  *
   3468  * @return    M4NO_ERROR:    No error
   3469  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   3470  ******************************************************************************
   3471  */
   3472 M4OSA_ERR M4xVSS_internalGetProperties(M4OSA_Context pContext, M4OSA_Char* pFile,
   3473                                        M4VIDEOEDITING_ClipProperties *pFileProperties)
   3474 {
   3475     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   3476     M4OSA_ERR err;
   3477     M4MCS_Context mcs_context;
   3478 
   3479     err = M4MCS_init(&mcs_context, xVSS_context->pFileReadPtr, xVSS_context->pFileWritePtr);
   3480     if(err != M4NO_ERROR)
   3481     {
   3482         M4OSA_TRACE1_1("M4xVSS_internalGetProperties: Error in M4MCS_init: 0x%x", err);
   3483         return err;
   3484     }
   3485 
   3486     /*open the MCS in the "normal opening" mode to retrieve the exact duration*/
   3487     err = M4MCS_open_normalMode(mcs_context, pFile, M4VIDEOEDITING_kFileType_3GPP,
   3488         M4OSA_NULL, M4OSA_NULL);
   3489     if (err != M4NO_ERROR)
   3490     {
   3491         M4OSA_TRACE1_1("M4xVSS_internalGetProperties: Error in M4MCS_open: 0x%x", err);
   3492         M4MCS_abort(mcs_context);
   3493         return err;
   3494     }
   3495 
   3496     err = M4MCS_getInputFileProperties(mcs_context, pFileProperties);
   3497     if(err != M4NO_ERROR)
   3498     {
   3499         M4OSA_TRACE1_1("Error in M4MCS_getInputFileProperties: 0x%x", err);
   3500         M4MCS_abort(mcs_context);
   3501         return err;
   3502     }
   3503 
   3504     err = M4MCS_abort(mcs_context);
   3505     if (err != M4NO_ERROR)
   3506     {
   3507         M4OSA_TRACE1_1("M4xVSS_internalGetProperties: Error in M4MCS_abort: 0x%x", err);
   3508         return err;
   3509     }
   3510 
   3511     return M4NO_ERROR;
   3512 }
   3513 
   3514 
   3515 /**
   3516  ******************************************************************************
   3517  * prototype    M4OSA_ERR M4xVSS_internalGetTargetedTimeScale(M4OSA_Context pContext,
   3518  *                                                M4OSA_UInt32* pTargetedTimeScale)
   3519  *
   3520  * @brief    This function retrieve targeted time scale
   3521  * @note
   3522  * @param    pContext            (IN)    The integrator own context
   3523  * @param    pTargetedTimeScale    (OUT)    Targeted time scale
   3524  *
   3525  * @return    M4NO_ERROR:    No error
   3526  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   3527  ******************************************************************************
   3528  */
   3529 M4OSA_ERR M4xVSS_internalGetTargetedTimeScale(M4OSA_Context pContext,
   3530                                                  M4VSS3GPP_EditSettings* pSettings,
   3531                                                   M4OSA_UInt32* pTargetedTimeScale)
   3532 {
   3533     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   3534     M4OSA_ERR err;
   3535     M4OSA_UInt32 totalDuration = 0;
   3536     M4OSA_UInt8 i = 0;
   3537     M4OSA_UInt32 tempTimeScale = 0, tempDuration = 0;
   3538 
   3539     for(i=0;i<pSettings->uiClipNumber;i++)
   3540     {
   3541         /*search timescale only in mpeg4 case*/
   3542         if(pSettings->pClipList[i]->FileType == M4VIDEOEDITING_kFileType_3GPP
   3543             || pSettings->pClipList[i]->FileType == M4VIDEOEDITING_kFileType_MP4
   3544             || pSettings->pClipList[i]->FileType == M4VIDEOEDITING_kFileType_M4V)
   3545         {
   3546             M4VIDEOEDITING_ClipProperties fileProperties;
   3547 
   3548             /*UTF conversion support*/
   3549             M4OSA_Char* pDecodedPath = M4OSA_NULL;
   3550 
   3551             /**
   3552             * UTF conversion: convert into the customer format, before being used*/
   3553             pDecodedPath = pSettings->pClipList[i]->pFile;
   3554 
   3555             if(xVSS_context->UTFConversionContext.pConvToUTF8Fct != M4OSA_NULL
   3556                 && xVSS_context->UTFConversionContext.pTempOutConversionBuffer != M4OSA_NULL)
   3557             {
   3558                 M4OSA_UInt32 length = 0;
   3559                 err = M4xVSS_internalConvertFromUTF8(xVSS_context,
   3560                      (M4OSA_Void*) pSettings->pClipList[i]->pFile,
   3561                         (M4OSA_Void*) xVSS_context->UTFConversionContext.pTempOutConversionBuffer,
   3562                              &length);
   3563                 if(err != M4NO_ERROR)
   3564                 {
   3565                     M4OSA_TRACE1_1("M4xVSS_Init:\
   3566                          M4xVSS_internalConvertToUTF8 returns err: 0x%x",err);
   3567                     return err;
   3568                 }
   3569                 pDecodedPath = xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
   3570             }
   3571 
   3572             /*End of the conversion: use the decoded path*/
   3573             err = M4xVSS_internalGetProperties(xVSS_context, pDecodedPath, &fileProperties);
   3574 
   3575             /*get input file properties*/
   3576             /*err = M4xVSS_internalGetProperties(xVSS_context, pSettings->\
   3577                 pClipList[i]->pFile, &fileProperties);*/
   3578             if(M4NO_ERROR != err)
   3579             {
   3580                 M4OSA_TRACE1_1("M4xVSS_internalGetTargetedTimeScale:\
   3581                      M4xVSS_internalGetProperties returned: 0x%x", err);
   3582                 return err;
   3583             }
   3584             if(fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)
   3585             {
   3586                 if(pSettings->pClipList[i]->uiEndCutTime > 0)
   3587                 {
   3588                     if(tempDuration < (pSettings->pClipList[i]->uiEndCutTime \
   3589                         - pSettings->pClipList[i]->uiBeginCutTime))
   3590                     {
   3591                         tempTimeScale = fileProperties.uiVideoTimeScale;
   3592                         tempDuration = (pSettings->pClipList[i]->uiEndCutTime\
   3593                              - pSettings->pClipList[i]->uiBeginCutTime);
   3594                     }
   3595                 }
   3596                 else
   3597                 {
   3598                     if(tempDuration < (fileProperties.uiClipDuration\
   3599                          - pSettings->pClipList[i]->uiBeginCutTime))
   3600                     {
   3601                         tempTimeScale = fileProperties.uiVideoTimeScale;
   3602                         tempDuration = (fileProperties.uiClipDuration\
   3603                              - pSettings->pClipList[i]->uiBeginCutTime);
   3604                     }
   3605                 }
   3606             }
   3607         }
   3608         if(pSettings->pClipList[i]->FileType == M4VIDEOEDITING_kFileType_ARGB8888)
   3609         {
   3610             /*the timescale is 30 for PTO3GP*/
   3611             *pTargetedTimeScale = 30;
   3612             return M4NO_ERROR;
   3613 
   3614         }
   3615     }
   3616 
   3617     if(tempTimeScale >= 30)/*Define a minimum time scale, otherwise if the timescale is not
   3618     enough, there will be an infinite loop in the shell encoder*/
   3619     {
   3620         *pTargetedTimeScale = tempTimeScale;
   3621     }
   3622     else
   3623     {
   3624         *pTargetedTimeScale = 30;
   3625     }
   3626 
   3627     return M4NO_ERROR;
   3628 }
   3629 
   3630 
   3631 /**
   3632  ******************************************************************************
   3633  * prototype    M4VSS3GPP_externalVideoEffectColor(M4OSA_Void *pFunctionContext,
   3634  *                                                    M4VIFI_ImagePlane *PlaneIn,
   3635  *                                                    M4VIFI_ImagePlane *PlaneOut,
   3636  *                                                    M4VSS3GPP_ExternalProgress *pProgress,
   3637  *                                                    M4OSA_UInt32 uiEffectKind)
   3638  *
   3639  * @brief    This function apply a color effect on an input YUV420 planar frame
   3640  * @note
   3641  * @param    pFunctionContext(IN) Contains which color to apply (not very clean ...)
   3642  * @param    PlaneIn            (IN) Input YUV420 planar
   3643  * @param    PlaneOut        (IN/OUT) Output YUV420 planar
   3644  * @param    pProgress        (IN/OUT) Progress indication (0-100)
   3645  * @param    uiEffectKind    (IN) Unused
   3646  *
   3647  * @return    M4VIFI_OK:    No error
   3648  ******************************************************************************
   3649  */
   3650 M4OSA_ERR M4VSS3GPP_externalVideoEffectColor(M4OSA_Void *pFunctionContext,
   3651                                              M4VIFI_ImagePlane *PlaneIn,
   3652                                              M4VIFI_ImagePlane *PlaneOut,
   3653                                              M4VSS3GPP_ExternalProgress *pProgress,
   3654                                              M4OSA_UInt32 uiEffectKind)
   3655 {
   3656     M4VIFI_Int32 plane_number;
   3657     M4VIFI_UInt32 i,j;
   3658     M4VIFI_UInt8 *p_buf_src, *p_buf_dest;
   3659     M4xVSS_ColorStruct* ColorContext = (M4xVSS_ColorStruct*)pFunctionContext;
   3660 
   3661     for (plane_number = 0; plane_number < 3; plane_number++)
   3662     {
   3663         p_buf_src = &(PlaneIn[plane_number].pac_data[PlaneIn[plane_number].u_topleft]);
   3664         p_buf_dest = &(PlaneOut[plane_number].pac_data[PlaneOut[plane_number].u_topleft]);
   3665         for (i = 0; i < PlaneOut[plane_number].u_height; i++)
   3666         {
   3667             /**
   3668              * Chrominance */
   3669             if(plane_number==1 || plane_number==2)
   3670             {
   3671                 //switch ((M4OSA_UInt32)pFunctionContext)
   3672                 // commented because a structure for the effects context exist
   3673                 switch (ColorContext->colorEffectType)
   3674                 {
   3675                     case M4xVSS_kVideoEffectType_BlackAndWhite:
   3676                         memset((void *)p_buf_dest,128,
   3677                          PlaneIn[plane_number].u_width);
   3678                         break;
   3679                     case M4xVSS_kVideoEffectType_Pink:
   3680                         memset((void *)p_buf_dest,255,
   3681                          PlaneIn[plane_number].u_width);
   3682                         break;
   3683                     case M4xVSS_kVideoEffectType_Green:
   3684                         memset((void *)p_buf_dest,0,
   3685                          PlaneIn[plane_number].u_width);
   3686                         break;
   3687                     case M4xVSS_kVideoEffectType_Sepia:
   3688                         if(plane_number==1)
   3689                         {
   3690                             memset((void *)p_buf_dest,117,
   3691                              PlaneIn[plane_number].u_width);
   3692                         }
   3693                         else
   3694                         {
   3695                             memset((void *)p_buf_dest,139,
   3696                              PlaneIn[plane_number].u_width);
   3697                         }
   3698                         break;
   3699                     case M4xVSS_kVideoEffectType_Negative:
   3700                         memcpy((void *)p_buf_dest,
   3701                          (void *)p_buf_src ,PlaneOut[plane_number].u_width);
   3702                         break;
   3703 
   3704                     case M4xVSS_kVideoEffectType_ColorRGB16:
   3705                         {
   3706                             M4OSA_UInt16 r = 0,g = 0,b = 0,y = 0,u = 0,v = 0;
   3707 
   3708                             /*first get the r, g, b*/
   3709                             b = (ColorContext->rgb16ColorData &  0x001f);
   3710                             g = (ColorContext->rgb16ColorData &  0x07e0)>>5;
   3711                             r = (ColorContext->rgb16ColorData &  0xf800)>>11;
   3712 
   3713                             /*keep y, but replace u and v*/
   3714                             if(plane_number==1)
   3715                             {
   3716                                 /*then convert to u*/
   3717                                 u = U16(r, g, b);
   3718                                 memset((void *)p_buf_dest,(M4OSA_UInt8)u,
   3719                                  PlaneIn[plane_number].u_width);
   3720                             }
   3721                             if(plane_number==2)
   3722                             {
   3723                                 /*then convert to v*/
   3724                                 v = V16(r, g, b);
   3725                                 memset((void *)p_buf_dest, (M4OSA_UInt8)v,
   3726                                  PlaneIn[plane_number].u_width);
   3727                             }
   3728                         }
   3729                         break;
   3730                     case M4xVSS_kVideoEffectType_Gradient:
   3731                         {
   3732                             M4OSA_UInt16 r = 0,g = 0,b = 0,y = 0,u = 0,v = 0;
   3733 
   3734                             /*first get the r, g, b*/
   3735                             b = (ColorContext->rgb16ColorData &  0x001f);
   3736                             g = (ColorContext->rgb16ColorData &  0x07e0)>>5;
   3737                             r = (ColorContext->rgb16ColorData &  0xf800)>>11;
   3738 
   3739                             /*for color gradation*/
   3740                             b = (M4OSA_UInt16)( b - ((b*i)/PlaneIn[plane_number].u_height));
   3741                             g = (M4OSA_UInt16)(g - ((g*i)/PlaneIn[plane_number].u_height));
   3742                             r = (M4OSA_UInt16)(r - ((r*i)/PlaneIn[plane_number].u_height));
   3743 
   3744                             /*keep y, but replace u and v*/
   3745                             if(plane_number==1)
   3746                             {
   3747                                 /*then convert to u*/
   3748                                 u = U16(r, g, b);
   3749                                 memset((void *)p_buf_dest,(M4OSA_UInt8)u,
   3750                                  PlaneIn[plane_number].u_width);
   3751                             }
   3752                             if(plane_number==2)
   3753                             {
   3754                                 /*then convert to v*/
   3755                                 v = V16(r, g, b);
   3756                                 memset((void *)p_buf_dest,(M4OSA_UInt8)v,
   3757                                  PlaneIn[plane_number].u_width);
   3758                             }
   3759                         }
   3760                         break;
   3761                         default:
   3762                         break;
   3763                 }
   3764             }
   3765             /**
   3766              * Luminance */
   3767             else
   3768             {
   3769                 //switch ((M4OSA_UInt32)pFunctionContext)
   3770                 // commented because a structure for the effects context exist
   3771                 switch (ColorContext->colorEffectType)
   3772                 {
   3773                 case M4xVSS_kVideoEffectType_Negative:
   3774                     for(j=0;j<PlaneOut[plane_number].u_width;j++)
   3775                     {
   3776                             p_buf_dest[j] = 255 - p_buf_src[j];
   3777                     }
   3778                     break;
   3779                 default:
   3780                     memcpy((void *)p_buf_dest,
   3781                      (void *)p_buf_src ,PlaneOut[plane_number].u_width);
   3782                     break;
   3783                 }
   3784             }
   3785             p_buf_src += PlaneIn[plane_number].u_stride;
   3786             p_buf_dest += PlaneOut[plane_number].u_stride;
   3787         }
   3788     }
   3789 
   3790     return M4VIFI_OK;
   3791 }
   3792 
   3793 /**
   3794  ******************************************************************************
   3795  * prototype    M4VSS3GPP_externalVideoEffectFraming(M4OSA_Void *pFunctionContext,
   3796  *                                                    M4VIFI_ImagePlane *PlaneIn,
   3797  *                                                    M4VIFI_ImagePlane *PlaneOut,
   3798  *                                                    M4VSS3GPP_ExternalProgress *pProgress,
   3799  *                                                    M4OSA_UInt32 uiEffectKind)
   3800  *
   3801  * @brief    This function add a fixed or animated image on an input YUV420 planar frame
   3802  * @note
   3803  * @param    pFunctionContext(IN) Contains which color to apply (not very clean ...)
   3804  * @param    PlaneIn            (IN) Input YUV420 planar
   3805  * @param    PlaneOut        (IN/OUT) Output YUV420 planar
   3806  * @param    pProgress        (IN/OUT) Progress indication (0-100)
   3807  * @param    uiEffectKind    (IN) Unused
   3808  *
   3809  * @return    M4VIFI_OK:    No error
   3810  ******************************************************************************
   3811  */
   3812 M4OSA_ERR M4VSS3GPP_externalVideoEffectFraming( M4OSA_Void *userData,
   3813                                                 M4VIFI_ImagePlane PlaneIn[3],
   3814                                                 M4VIFI_ImagePlane *PlaneOut,
   3815                                                 M4VSS3GPP_ExternalProgress *pProgress,
   3816                                                 M4OSA_UInt32 uiEffectKind )
   3817 {
   3818     M4VIFI_UInt32 x,y;
   3819 
   3820     M4VIFI_UInt8 *p_in_Y = PlaneIn[0].pac_data;
   3821     M4VIFI_UInt8 *p_in_U = PlaneIn[1].pac_data;
   3822     M4VIFI_UInt8 *p_in_V = PlaneIn[2].pac_data;
   3823 
   3824     M4xVSS_FramingStruct* Framing = M4OSA_NULL;
   3825     M4xVSS_FramingStruct* currentFraming = M4OSA_NULL;
   3826     M4VIFI_UInt8 *FramingRGB = M4OSA_NULL;
   3827 
   3828     M4VIFI_UInt8 *p_out0;
   3829     M4VIFI_UInt8 *p_out1;
   3830     M4VIFI_UInt8 *p_out2;
   3831 
   3832     M4VIFI_UInt32 topleft[2];
   3833 
   3834     M4OSA_UInt8 transparent1 = (M4OSA_UInt8)((TRANSPARENT_COLOR & 0xFF00)>>8);
   3835     M4OSA_UInt8 transparent2 = (M4OSA_UInt8)TRANSPARENT_COLOR;
   3836 
   3837 #ifndef DECODE_GIF_ON_SAVING
   3838     Framing = (M4xVSS_FramingStruct *)userData;
   3839     currentFraming = (M4xVSS_FramingStruct *)Framing->pCurrent;
   3840     FramingRGB = Framing->FramingRgb->pac_data;
   3841 #endif /*DECODE_GIF_ON_SAVING*/
   3842 
   3843     /*FB*/
   3844 #ifdef DECODE_GIF_ON_SAVING
   3845     M4OSA_ERR err;
   3846     Framing = (M4xVSS_FramingStruct *)((M4xVSS_FramingContext*)userData)->aFramingCtx;
   3847     currentFraming = (M4xVSS_FramingStruct *)Framing;
   3848     FramingRGB = Framing->FramingRgb->pac_data;
   3849 #endif /*DECODE_GIF_ON_SAVING*/
   3850     /*end FB*/
   3851 
   3852     /**
   3853      * Initialize input / output plane pointers */
   3854     p_in_Y += PlaneIn[0].u_topleft;
   3855     p_in_U += PlaneIn[1].u_topleft;
   3856     p_in_V += PlaneIn[2].u_topleft;
   3857 
   3858     p_out0 = PlaneOut[0].pac_data;
   3859     p_out1 = PlaneOut[1].pac_data;
   3860     p_out2 = PlaneOut[2].pac_data;
   3861 
   3862     /**
   3863      * Depending on time, initialize Framing frame to use */
   3864     if(Framing->previousClipTime == -1)
   3865     {
   3866         Framing->previousClipTime = pProgress->uiOutputTime;
   3867     }
   3868 
   3869     /**
   3870      * If the current clip time has reach the duration of one frame of the framing picture
   3871      * we need to step to next framing picture */
   3872 
   3873     Framing->previousClipTime = pProgress->uiOutputTime;
   3874     FramingRGB = currentFraming->FramingRgb->pac_data;
   3875     topleft[0] = currentFraming->topleft_x;
   3876     topleft[1] = currentFraming->topleft_y;
   3877 
   3878     for( x=0 ;x < PlaneIn[0].u_height ; x++)
   3879     {
   3880         for( y=0 ;y < PlaneIn[0].u_width ; y++)
   3881         {
   3882             /**
   3883              * To handle framing with input size != output size
   3884              * Framing is applyed if coordinates matches between framing/topleft and input plane */
   3885             if( y < (topleft[0] + currentFraming->FramingYuv[0].u_width)  &&
   3886                 y >= topleft[0] &&
   3887                 x < (topleft[1] + currentFraming->FramingYuv[0].u_height) &&
   3888                 x >= topleft[1])
   3889             {
   3890                 /*Alpha blending support*/
   3891                 M4OSA_Float alphaBlending = 1;
   3892                 M4xVSS_internalEffectsAlphaBlending*  alphaBlendingStruct =\
   3893                  (M4xVSS_internalEffectsAlphaBlending*)\
   3894                     ((M4xVSS_FramingContext*)userData)->alphaBlendingStruct;
   3895 
   3896                 if(alphaBlendingStruct != M4OSA_NULL)
   3897                 {
   3898                     if(pProgress->uiProgress \
   3899                     < (M4OSA_UInt32)(alphaBlendingStruct->m_fadeInTime*10))
   3900                     {
   3901                         if(alphaBlendingStruct->m_fadeInTime == 0) {
   3902                             alphaBlending = alphaBlendingStruct->m_start / 100;
   3903                         } else {
   3904                             alphaBlending = ((M4OSA_Float)(alphaBlendingStruct->m_middle\
   3905                              - alphaBlendingStruct->m_start)\
   3906                                 *pProgress->uiProgress/(alphaBlendingStruct->m_fadeInTime*10));
   3907                             alphaBlending += alphaBlendingStruct->m_start;
   3908                             alphaBlending /= 100;
   3909                         }
   3910                     }
   3911                     else if(pProgress->uiProgress >= (M4OSA_UInt32)(alphaBlendingStruct->\
   3912                     m_fadeInTime*10) && pProgress->uiProgress < 1000\
   3913                      - (M4OSA_UInt32)(alphaBlendingStruct->m_fadeOutTime*10))
   3914                     {
   3915                         alphaBlending = (M4OSA_Float)\
   3916                         ((M4OSA_Float)alphaBlendingStruct->m_middle/100);
   3917                     }
   3918                     else if(pProgress->uiProgress >= 1000 - (M4OSA_UInt32)\
   3919                     (alphaBlendingStruct->m_fadeOutTime*10))
   3920                     {
   3921                         if(alphaBlendingStruct->m_fadeOutTime == 0) {
   3922                             alphaBlending = alphaBlendingStruct->m_end / 100;
   3923                         } else {
   3924                             alphaBlending = ((M4OSA_Float)(alphaBlendingStruct->m_middle \
   3925                             - alphaBlendingStruct->m_end))*(1000 - pProgress->uiProgress)\
   3926                             /(alphaBlendingStruct->m_fadeOutTime*10);
   3927                             alphaBlending += alphaBlendingStruct->m_end;
   3928                             alphaBlending /= 100;
   3929                         }
   3930                     }
   3931                 }
   3932                 /**/
   3933 
   3934                 if((*(FramingRGB)==transparent1) && (*(FramingRGB+1)==transparent2))
   3935                 {
   3936                     *( p_out0+y+x*PlaneOut[0].u_stride)=(*(p_in_Y+y+x*PlaneIn[0].u_stride));
   3937                     *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=
   3938                         (*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride));
   3939                     *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=
   3940                         (*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride));
   3941                 }
   3942                 else
   3943                 {
   3944                     *( p_out0+y+x*PlaneOut[0].u_stride)=
   3945                         (*(currentFraming->FramingYuv[0].pac_data+(y-topleft[0])\
   3946                             +(x-topleft[1])*currentFraming->FramingYuv[0].u_stride))*alphaBlending;
   3947                     *( p_out0+y+x*PlaneOut[0].u_stride)+=
   3948                         (*(p_in_Y+y+x*PlaneIn[0].u_stride))*(1-alphaBlending);
   3949                     *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=
   3950                         (*(currentFraming->FramingYuv[1].pac_data+((y-topleft[0])>>1)\
   3951                             +((x-topleft[1])>>1)*currentFraming->FramingYuv[1].u_stride))\
   3952                                 *alphaBlending;
   3953                     *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)+=
   3954                         (*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride))*(1-alphaBlending);
   3955                     *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=
   3956                         (*(currentFraming->FramingYuv[2].pac_data+((y-topleft[0])>>1)\
   3957                             +((x-topleft[1])>>1)*currentFraming->FramingYuv[2].u_stride))\
   3958                                 *alphaBlending;
   3959                     *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)+=
   3960                         (*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride))*(1-alphaBlending);
   3961                 }
   3962                 if( PlaneIn[0].u_width < (topleft[0] + currentFraming->FramingYuv[0].u_width) &&
   3963                     y == PlaneIn[0].u_width-1)
   3964                 {
   3965                     FramingRGB = FramingRGB + 2 \
   3966                         * (topleft[0] + currentFraming->FramingYuv[0].u_width \
   3967                             - PlaneIn[0].u_width + 1);
   3968                 }
   3969                 else
   3970                 {
   3971                     FramingRGB = FramingRGB + 2;
   3972                 }
   3973             }
   3974             /**
   3975              * Just copy input plane to output plane */
   3976             else
   3977             {
   3978                 *( p_out0+y+x*PlaneOut[0].u_stride)=*(p_in_Y+y+x*PlaneIn[0].u_stride);
   3979                 *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=
   3980                     *(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride);
   3981                 *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=
   3982                     *(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride);
   3983             }
   3984         }
   3985     }
   3986 
   3987 
   3988     return M4VIFI_OK;
   3989 }
   3990 
   3991 
   3992 /**
   3993  ******************************************************************************
   3994  * prototype    M4VSS3GPP_externalVideoEffectFifties(M4OSA_Void *pFunctionContext,
   3995  *                                                    M4VIFI_ImagePlane *PlaneIn,
   3996  *                                                    M4VIFI_ImagePlane *PlaneOut,
   3997  *                                                    M4VSS3GPP_ExternalProgress *pProgress,
   3998  *                                                    M4OSA_UInt32 uiEffectKind)
   3999  *
   4000  * @brief    This function make a video look as if it was taken in the fifties
   4001  * @note
   4002  * @param    pUserData       (IN) Context
   4003  * @param    pPlaneIn        (IN) Input YUV420 planar
   4004  * @param    pPlaneOut        (IN/OUT) Output YUV420 planar
   4005  * @param    pProgress        (IN/OUT) Progress indication (0-100)
   4006  * @param    uiEffectKind    (IN) Unused
   4007  *
   4008  * @return    M4VIFI_OK:            No error
   4009  * @return  M4ERR_PARAMETER:    pFiftiesData, pPlaneOut or pProgress are NULL (DEBUG only)
   4010  ******************************************************************************
   4011  */
   4012 M4OSA_ERR M4VSS3GPP_externalVideoEffectFifties( M4OSA_Void *pUserData,
   4013                                                 M4VIFI_ImagePlane *pPlaneIn,
   4014                                                 M4VIFI_ImagePlane *pPlaneOut,
   4015                                                 M4VSS3GPP_ExternalProgress *pProgress,
   4016                                                 M4OSA_UInt32 uiEffectKind )
   4017 {
   4018     M4VIFI_UInt32 x, y, xShift;
   4019     M4VIFI_UInt8 *pInY = pPlaneIn[0].pac_data;
   4020     M4VIFI_UInt8 *pOutY, *pInYbegin;
   4021     M4VIFI_UInt8 *pInCr,* pOutCr;
   4022     M4VIFI_Int32 plane_number;
   4023 
   4024     /* Internal context*/
   4025     M4xVSS_FiftiesStruct* p_FiftiesData = (M4xVSS_FiftiesStruct *)pUserData;
   4026 
   4027     /* Check the inputs (debug only) */
   4028     M4OSA_DEBUG_IF2((p_FiftiesData == M4OSA_NULL),M4ERR_PARAMETER,
   4029          "xVSS: p_FiftiesData is M4OSA_NULL in M4VSS3GPP_externalVideoEffectFifties");
   4030     M4OSA_DEBUG_IF2((pPlaneOut == M4OSA_NULL),M4ERR_PARAMETER,
   4031          "xVSS: p_PlaneOut is M4OSA_NULL in M4VSS3GPP_externalVideoEffectFifties");
   4032     M4OSA_DEBUG_IF2((pProgress == M4OSA_NULL),M4ERR_PARAMETER,
   4033         "xVSS: p_Progress is M4OSA_NULL in M4VSS3GPP_externalVideoEffectFifties");
   4034 
   4035     /* Initialize input / output plane pointers */
   4036     pInY += pPlaneIn[0].u_topleft;
   4037     pOutY = pPlaneOut[0].pac_data;
   4038     pInYbegin  = pInY;
   4039 
   4040     /* Initialize the random */
   4041     if(p_FiftiesData->previousClipTime < 0)
   4042     {
   4043         M4OSA_randInit();
   4044         M4OSA_rand((M4OSA_Int32 *)&(p_FiftiesData->shiftRandomValue), (pPlaneIn[0].u_height) >> 4);
   4045         M4OSA_rand((M4OSA_Int32 *)&(p_FiftiesData->stripeRandomValue), (pPlaneIn[0].u_width)<< 2);
   4046         p_FiftiesData->previousClipTime = pProgress->uiOutputTime;
   4047     }
   4048 
   4049     /* Choose random values if we have reached the duration of a partial effect */
   4050     else if( (pProgress->uiOutputTime - p_FiftiesData->previousClipTime)\
   4051          > p_FiftiesData->fiftiesEffectDuration)
   4052     {
   4053         M4OSA_rand((M4OSA_Int32 *)&(p_FiftiesData->shiftRandomValue), (pPlaneIn[0].u_height) >> 4);
   4054         M4OSA_rand((M4OSA_Int32 *)&(p_FiftiesData->stripeRandomValue), (pPlaneIn[0].u_width)<< 2);
   4055         p_FiftiesData->previousClipTime = pProgress->uiOutputTime;
   4056     }
   4057 
   4058     /* Put in Sepia the chrominance */
   4059     for (plane_number = 1; plane_number < 3; plane_number++)
   4060     {
   4061         pInCr  = pPlaneIn[plane_number].pac_data  + pPlaneIn[plane_number].u_topleft;
   4062         pOutCr = pPlaneOut[plane_number].pac_data + pPlaneOut[plane_number].u_topleft;
   4063 
   4064         for (x = 0; x < pPlaneOut[plane_number].u_height; x++)
   4065         {
   4066             if (1 == plane_number)
   4067                 memset((void *)pOutCr, 117,pPlaneIn[plane_number].u_width); /* U value */
   4068             else
   4069                 memset((void *)pOutCr, 139,pPlaneIn[plane_number].u_width); /* V value */
   4070 
   4071             pInCr  += pPlaneIn[plane_number].u_stride;
   4072             pOutCr += pPlaneOut[plane_number].u_stride;
   4073         }
   4074     }
   4075 
   4076     /* Compute the new pixels values */
   4077     for( x = 0 ; x < pPlaneIn[0].u_height ; x++)
   4078     {
   4079         M4VIFI_UInt8 *p_outYtmp, *p_inYtmp;
   4080 
   4081         /* Compute the xShift (random value) */
   4082         if (0 == (p_FiftiesData->shiftRandomValue % 5 ))
   4083             xShift = (x + p_FiftiesData->shiftRandomValue ) % (pPlaneIn[0].u_height - 1);
   4084         else
   4085             xShift = (x + (pPlaneIn[0].u_height - p_FiftiesData->shiftRandomValue) ) \
   4086                 % (pPlaneIn[0].u_height - 1);
   4087 
   4088         /* Initialize the pointers */
   4089         p_outYtmp = pOutY + 1;                                    /* yShift of 1 pixel */
   4090         p_inYtmp  = pInYbegin + (xShift * pPlaneIn[0].u_stride);  /* Apply the xShift */
   4091 
   4092         for( y = 0 ; y < pPlaneIn[0].u_width ; y++)
   4093         {
   4094             /* Set Y value */
   4095             if (xShift > (pPlaneIn[0].u_height - 4))
   4096                 *p_outYtmp = 40;        /* Add some horizontal black lines between the
   4097                                         two parts of the image */
   4098             else if ( y == p_FiftiesData->stripeRandomValue)
   4099                 *p_outYtmp = 90;        /* Add a random vertical line for the bulk */
   4100             else
   4101                 *p_outYtmp = *p_inYtmp;
   4102 
   4103 
   4104             /* Go to the next pixel */
   4105             p_outYtmp++;
   4106             p_inYtmp++;
   4107 
   4108             /* Restart at the beginning of the line for the last pixel*/
   4109             if (y == (pPlaneIn[0].u_width - 2))
   4110                 p_outYtmp = pOutY;
   4111         }
   4112 
   4113         /* Go to the next line */
   4114         pOutY += pPlaneOut[0].u_stride;
   4115     }
   4116 
   4117     return M4VIFI_OK;
   4118 }
   4119 
   4120 /**
   4121  ******************************************************************************
   4122  * M4OSA_ERR M4VSS3GPP_externalVideoEffectZoom( )
   4123  * @brief    Zoom in/out video effect functions.
   4124  * @note    The external video function is used only if VideoEffectType is set to
   4125  * M4VSS3GPP_kVideoEffectType_ZoomIn or M4VSS3GPP_kVideoEffectType_ZoomOut.
   4126  *
   4127  * @param   pFunctionContext    (IN) The function context, previously set by the integrator
   4128  * @param    pInputPlanes        (IN) Input YUV420 image: pointer to an array of three valid
   4129  *                                    image planes (Y, U and V)
   4130  * @param    pOutputPlanes        (IN/OUT) Output (filtered) YUV420 image: pointer to an array of
   4131  *                                        three valid image planes (Y, U and V)
   4132  * @param    pProgress            (IN) Set of information about the video transition progress.
   4133  * @return    M4NO_ERROR:            No error
   4134  * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
   4135  ******************************************************************************
   4136  */
   4137 
   4138 M4OSA_ERR M4VSS3GPP_externalVideoEffectZoom(
   4139     M4OSA_Void *pFunctionContext,
   4140     M4VIFI_ImagePlane *pInputPlanes,
   4141     M4VIFI_ImagePlane *pOutputPlanes,
   4142     M4VSS3GPP_ExternalProgress *pProgress,
   4143     M4OSA_UInt32 uiEffectKind
   4144 )
   4145 {
   4146     M4OSA_UInt32 boxWidth;
   4147     M4OSA_UInt32 boxHeight;
   4148     M4OSA_UInt32 boxPosX;
   4149     M4OSA_UInt32 boxPosY;
   4150     M4OSA_UInt32 ratio = 0;
   4151     /*  * 1.189207 between ratio */
   4152     /* zoom between x1 and x16 */
   4153     M4OSA_UInt32 ratiotab[17] ={1024,1218,1448,1722,2048,2435,2896,3444,4096,4871,5793,\
   4154                                 6889,8192,9742,11585,13777,16384};
   4155     M4OSA_UInt32 ik;
   4156 
   4157     M4VIFI_ImagePlane boxPlane[3];
   4158 
   4159     if(M4xVSS_kVideoEffectType_ZoomOut == (M4OSA_UInt32)pFunctionContext)
   4160     {
   4161         //ratio = 16 - (15 * pProgress->uiProgress)/1000;
   4162         ratio = 16 - pProgress->uiProgress / 66 ;
   4163     }
   4164     else if(M4xVSS_kVideoEffectType_ZoomIn == (M4OSA_UInt32)pFunctionContext)
   4165     {
   4166         //ratio = 1 + (15 * pProgress->uiProgress)/1000;
   4167         ratio = 1 + pProgress->uiProgress / 66 ;
   4168     }
   4169 
   4170     for(ik=0;ik<3;ik++){
   4171 
   4172         boxPlane[ik].u_stride = pInputPlanes[ik].u_stride;
   4173         boxPlane[ik].pac_data = pInputPlanes[ik].pac_data;
   4174 
   4175         boxHeight = ( pInputPlanes[ik].u_height << 10 ) / ratiotab[ratio];
   4176         boxWidth = ( pInputPlanes[ik].u_width << 10 ) / ratiotab[ratio];
   4177         boxPlane[ik].u_height = (boxHeight)&(~1);
   4178         boxPlane[ik].u_width = (boxWidth)&(~1);
   4179 
   4180         boxPosY = (pInputPlanes[ik].u_height >> 1) - (boxPlane[ik].u_height >> 1);
   4181         boxPosX = (pInputPlanes[ik].u_width >> 1) - (boxPlane[ik].u_width >> 1);
   4182         boxPlane[ik].u_topleft = boxPosY * boxPlane[ik].u_stride + boxPosX;
   4183     }
   4184 
   4185     M4VIFI_ResizeBilinearYUV420toYUV420(M4OSA_NULL, (M4VIFI_ImagePlane*)&boxPlane, pOutputPlanes);
   4186 
   4187     /**
   4188      * Return */
   4189     return(M4NO_ERROR);
   4190 }
   4191 
   4192 /**
   4193  ******************************************************************************
   4194  * prototype    M4xVSS_AlphaMagic( M4OSA_Void *userData,
   4195  *                                    M4VIFI_ImagePlane PlaneIn1[3],
   4196  *                                    M4VIFI_ImagePlane PlaneIn2[3],
   4197  *                                    M4VIFI_ImagePlane *PlaneOut,
   4198  *                                    M4VSS3GPP_ExternalProgress *pProgress,
   4199  *                                    M4OSA_UInt32 uiTransitionKind)
   4200  *
   4201  * @brief    This function apply a color effect on an input YUV420 planar frame
   4202  * @note
   4203  * @param    userData        (IN) Contains a pointer on a settings structure
   4204  * @param    PlaneIn1        (IN) Input YUV420 planar from video 1
   4205  * @param    PlaneIn2        (IN) Input YUV420 planar from video 2
   4206  * @param    PlaneOut        (IN/OUT) Output YUV420 planar
   4207  * @param    pProgress        (IN/OUT) Progress indication (0-100)
   4208  * @param    uiTransitionKind(IN) Unused
   4209  *
   4210  * @return    M4VIFI_OK:    No error
   4211  ******************************************************************************
   4212  */
   4213 M4OSA_ERR M4xVSS_AlphaMagic( M4OSA_Void *userData, M4VIFI_ImagePlane PlaneIn1[3],
   4214                              M4VIFI_ImagePlane PlaneIn2[3], M4VIFI_ImagePlane *PlaneOut,
   4215                              M4VSS3GPP_ExternalProgress *pProgress, M4OSA_UInt32 uiTransitionKind)
   4216 {
   4217 
   4218     M4OSA_ERR err;
   4219 
   4220     M4xVSS_internal_AlphaMagicSettings* alphaContext;
   4221     M4VIFI_Int32 alphaProgressLevel;
   4222 
   4223     M4VIFI_ImagePlane* planeswap;
   4224     M4VIFI_UInt32 x,y;
   4225 
   4226     M4VIFI_UInt8 *p_out0;
   4227     M4VIFI_UInt8 *p_out1;
   4228     M4VIFI_UInt8 *p_out2;
   4229     M4VIFI_UInt8 *alphaMask;
   4230     /* "Old image" */
   4231     M4VIFI_UInt8 *p_in1_Y;
   4232     M4VIFI_UInt8 *p_in1_U;
   4233     M4VIFI_UInt8 *p_in1_V;
   4234     /* "New image" */
   4235     M4VIFI_UInt8 *p_in2_Y;
   4236     M4VIFI_UInt8 *p_in2_U;
   4237     M4VIFI_UInt8 *p_in2_V;
   4238 
   4239     err = M4NO_ERROR;
   4240 
   4241     alphaContext = (M4xVSS_internal_AlphaMagicSettings*)userData;
   4242 
   4243     alphaProgressLevel = (pProgress->uiProgress * 128)/1000;
   4244 
   4245     if( alphaContext->isreverse != M4OSA_FALSE)
   4246     {
   4247         alphaProgressLevel = 128 - alphaProgressLevel;
   4248         planeswap = PlaneIn1;
   4249         PlaneIn1 = PlaneIn2;
   4250         PlaneIn2 = planeswap;
   4251     }
   4252 
   4253     p_out0 = PlaneOut[0].pac_data;
   4254     p_out1 = PlaneOut[1].pac_data;
   4255     p_out2 = PlaneOut[2].pac_data;
   4256 
   4257     alphaMask = alphaContext->pPlane->pac_data;
   4258 
   4259     /* "Old image" */
   4260     p_in1_Y = PlaneIn1[0].pac_data;
   4261     p_in1_U = PlaneIn1[1].pac_data;
   4262     p_in1_V = PlaneIn1[2].pac_data;
   4263     /* "New image" */
   4264     p_in2_Y = PlaneIn2[0].pac_data;
   4265     p_in2_U = PlaneIn2[1].pac_data;
   4266     p_in2_V = PlaneIn2[2].pac_data;
   4267 
   4268      /**
   4269      * For each column ... */
   4270     for( y=0; y<PlaneOut->u_height; y++ )
   4271     {
   4272         /**
   4273          * ... and each row of the alpha mask */
   4274         for( x=0; x<PlaneOut->u_width; x++ )
   4275         {
   4276             /**
   4277              * If the value of the current pixel of the alpha mask is > to the current time
   4278              * ( current time is normalized on [0-255] ) */
   4279             if( alphaProgressLevel < alphaMask[x+y*PlaneOut->u_width] )
   4280             {
   4281                 /* We keep "old image" in output plane */
   4282                 *( p_out0+x+y*PlaneOut[0].u_stride)=*(p_in1_Y+x+y*PlaneIn1[0].u_stride);
   4283                 *( p_out1+(x>>1)+(y>>1)*PlaneOut[1].u_stride)=
   4284                     *(p_in1_U+(x>>1)+(y>>1)*PlaneIn1[1].u_stride);
   4285                 *( p_out2+(x>>1)+(y>>1)*PlaneOut[2].u_stride)=
   4286                     *(p_in1_V+(x>>1)+(y>>1)*PlaneIn1[2].u_stride);
   4287             }
   4288             else
   4289             {
   4290                 /* We take "new image" in output plane */
   4291                 *( p_out0+x+y*PlaneOut[0].u_stride)=*(p_in2_Y+x+y*PlaneIn2[0].u_stride);
   4292                 *( p_out1+(x>>1)+(y>>1)*PlaneOut[1].u_stride)=
   4293                     *(p_in2_U+(x>>1)+(y>>1)*PlaneIn2[1].u_stride);
   4294                 *( p_out2+(x>>1)+(y>>1)*PlaneOut[2].u_stride)=
   4295                     *(p_in2_V+(x>>1)+(y>>1)*PlaneIn2[2].u_stride);
   4296             }
   4297         }
   4298     }
   4299 
   4300     return(err);
   4301 }
   4302 
   4303 /**
   4304  ******************************************************************************
   4305  * prototype    M4xVSS_AlphaMagicBlending( M4OSA_Void *userData,
   4306  *                                    M4VIFI_ImagePlane PlaneIn1[3],
   4307  *                                    M4VIFI_ImagePlane PlaneIn2[3],
   4308  *                                    M4VIFI_ImagePlane *PlaneOut,
   4309  *                                    M4VSS3GPP_ExternalProgress *pProgress,
   4310  *                                    M4OSA_UInt32 uiTransitionKind)
   4311  *
   4312  * @brief    This function apply a color effect on an input YUV420 planar frame
   4313  * @note
   4314  * @param    userData        (IN) Contains a pointer on a settings structure
   4315  * @param    PlaneIn1        (IN) Input YUV420 planar from video 1
   4316  * @param    PlaneIn2        (IN) Input YUV420 planar from video 2
   4317  * @param    PlaneOut        (IN/OUT) Output YUV420 planar
   4318  * @param    pProgress        (IN/OUT) Progress indication (0-100)
   4319  * @param    uiTransitionKind(IN) Unused
   4320  *
   4321  * @return    M4VIFI_OK:    No error
   4322  ******************************************************************************
   4323  */
   4324 M4OSA_ERR M4xVSS_AlphaMagicBlending( M4OSA_Void *userData, M4VIFI_ImagePlane PlaneIn1[3],
   4325                                      M4VIFI_ImagePlane PlaneIn2[3], M4VIFI_ImagePlane *PlaneOut,
   4326                                      M4VSS3GPP_ExternalProgress *pProgress,
   4327                                      M4OSA_UInt32 uiTransitionKind)
   4328 {
   4329     M4OSA_ERR err;
   4330 
   4331     M4xVSS_internal_AlphaMagicSettings* alphaContext;
   4332     M4VIFI_Int32 alphaProgressLevel;
   4333     M4VIFI_Int32 alphaBlendLevelMin;
   4334     M4VIFI_Int32 alphaBlendLevelMax;
   4335     M4VIFI_Int32 alphaBlendRange;
   4336 
   4337     M4VIFI_ImagePlane* planeswap;
   4338     M4VIFI_UInt32 x,y;
   4339     M4VIFI_Int32 alphaMaskValue;
   4340 
   4341     M4VIFI_UInt8 *p_out0;
   4342     M4VIFI_UInt8 *p_out1;
   4343     M4VIFI_UInt8 *p_out2;
   4344     M4VIFI_UInt8 *alphaMask;
   4345     /* "Old image" */
   4346     M4VIFI_UInt8 *p_in1_Y;
   4347     M4VIFI_UInt8 *p_in1_U;
   4348     M4VIFI_UInt8 *p_in1_V;
   4349     /* "New image" */
   4350     M4VIFI_UInt8 *p_in2_Y;
   4351     M4VIFI_UInt8 *p_in2_U;
   4352     M4VIFI_UInt8 *p_in2_V;
   4353 
   4354 
   4355     err = M4NO_ERROR;
   4356 
   4357     alphaContext = (M4xVSS_internal_AlphaMagicSettings*)userData;
   4358 
   4359     alphaProgressLevel = (pProgress->uiProgress * 128)/1000;
   4360 
   4361     if( alphaContext->isreverse != M4OSA_FALSE)
   4362     {
   4363         alphaProgressLevel = 128 - alphaProgressLevel;
   4364         planeswap = PlaneIn1;
   4365         PlaneIn1 = PlaneIn2;
   4366         PlaneIn2 = planeswap;
   4367     }
   4368 
   4369     alphaBlendLevelMin = alphaProgressLevel-alphaContext->blendingthreshold;
   4370 
   4371     alphaBlendLevelMax = alphaProgressLevel+alphaContext->blendingthreshold;
   4372 
   4373     alphaBlendRange = (alphaContext->blendingthreshold)*2;
   4374 
   4375     p_out0 = PlaneOut[0].pac_data;
   4376     p_out1 = PlaneOut[1].pac_data;
   4377     p_out2 = PlaneOut[2].pac_data;
   4378 
   4379     alphaMask = alphaContext->pPlane->pac_data;
   4380 
   4381     /* "Old image" */
   4382     p_in1_Y = PlaneIn1[0].pac_data;
   4383     p_in1_U = PlaneIn1[1].pac_data;
   4384     p_in1_V = PlaneIn1[2].pac_data;
   4385     /* "New image" */
   4386     p_in2_Y = PlaneIn2[0].pac_data;
   4387     p_in2_U = PlaneIn2[1].pac_data;
   4388     p_in2_V = PlaneIn2[2].pac_data;
   4389 
   4390     /* apply Alpha Magic on each pixel */
   4391        for( y=0; y<PlaneOut->u_height; y++ )
   4392     {
   4393         for( x=0; x<PlaneOut->u_width; x++ )
   4394         {
   4395             alphaMaskValue = alphaMask[x+y*PlaneOut->u_width];
   4396             if( alphaBlendLevelMax < alphaMaskValue )
   4397             {
   4398                 /* We keep "old image" in output plane */
   4399                 *( p_out0+x+y*PlaneOut[0].u_stride)=*(p_in1_Y+x+y*PlaneIn1[0].u_stride);
   4400                 *( p_out1+(x>>1)+(y>>1)*PlaneOut[1].u_stride)=
   4401                     *(p_in1_U+(x>>1)+(y>>1)*PlaneIn1[1].u_stride);
   4402                 *( p_out2+(x>>1)+(y>>1)*PlaneOut[2].u_stride)=
   4403                     *(p_in1_V+(x>>1)+(y>>1)*PlaneIn1[2].u_stride);
   4404             }
   4405             else if( (alphaBlendLevelMin < alphaMaskValue)&&
   4406                     (alphaMaskValue <= alphaBlendLevelMax ) )
   4407             {
   4408                 /* We blend "old and new image" in output plane */
   4409                 *( p_out0+x+y*PlaneOut[0].u_stride)=(M4VIFI_UInt8)
   4410                     (( (alphaMaskValue-alphaBlendLevelMin)*( *(p_in1_Y+x+y*PlaneIn1[0].u_stride))
   4411                         +(alphaBlendLevelMax-alphaMaskValue)\
   4412                             *( *(p_in2_Y+x+y*PlaneIn2[0].u_stride)) )/alphaBlendRange );
   4413 
   4414                 *( p_out1+(x>>1)+(y>>1)*PlaneOut[1].u_stride)=(M4VIFI_UInt8)\
   4415                     (( (alphaMaskValue-alphaBlendLevelMin)*( *(p_in1_U+(x>>1)+(y>>1)\
   4416                         *PlaneIn1[1].u_stride))
   4417                             +(alphaBlendLevelMax-alphaMaskValue)*( *(p_in2_U+(x>>1)+(y>>1)\
   4418                                 *PlaneIn2[1].u_stride)) )/alphaBlendRange );
   4419 
   4420                 *( p_out2+(x>>1)+(y>>1)*PlaneOut[2].u_stride)=
   4421                     (M4VIFI_UInt8)(( (alphaMaskValue-alphaBlendLevelMin)\
   4422                         *( *(p_in1_V+(x>>1)+(y>>1)*PlaneIn1[2].u_stride))
   4423                                 +(alphaBlendLevelMax-alphaMaskValue)*( *(p_in2_V+(x>>1)+(y>>1)\
   4424                                     *PlaneIn2[2].u_stride)) )/alphaBlendRange );
   4425 
   4426             }
   4427             else
   4428             {
   4429                 /* We take "new image" in output plane */
   4430                 *( p_out0+x+y*PlaneOut[0].u_stride)=*(p_in2_Y+x+y*PlaneIn2[0].u_stride);
   4431                 *( p_out1+(x>>1)+(y>>1)*PlaneOut[1].u_stride)=
   4432                     *(p_in2_U+(x>>1)+(y>>1)*PlaneIn2[1].u_stride);
   4433                 *( p_out2+(x>>1)+(y>>1)*PlaneOut[2].u_stride)=
   4434                     *(p_in2_V+(x>>1)+(y>>1)*PlaneIn2[2].u_stride);
   4435             }
   4436         }
   4437     }
   4438 
   4439     return(err);
   4440 }
   4441 
   4442 #define M4XXX_SampleAddress(plane, x, y)  ( (plane).pac_data + (plane).u_topleft + (y)\
   4443      * (plane).u_stride + (x) )
   4444 
   4445 static void M4XXX_CopyPlane(M4VIFI_ImagePlane* dest, M4VIFI_ImagePlane* source)
   4446 {
   4447     M4OSA_UInt32    height, width, sourceStride, destStride, y;
   4448     M4OSA_MemAddr8    sourceWalk, destWalk;
   4449 
   4450     /* cache the vars used in the loop so as to avoid them being repeatedly fetched and
   4451      recomputed from memory. */
   4452     height = dest->u_height;
   4453     width = dest->u_width;
   4454 
   4455     sourceWalk = (M4OSA_MemAddr8)M4XXX_SampleAddress(*source, 0, 0);
   4456     sourceStride = source->u_stride;
   4457 
   4458     destWalk = (M4OSA_MemAddr8)M4XXX_SampleAddress(*dest, 0, 0);
   4459     destStride = dest->u_stride;
   4460 
   4461     for (y=0; y<height; y++)
   4462     {
   4463         memcpy((void *)destWalk, (void *)sourceWalk, width);
   4464         destWalk += destStride;
   4465         sourceWalk += sourceStride;
   4466     }
   4467 }
   4468 
   4469 static M4OSA_ERR M4xVSS_VerticalSlideTransition(M4VIFI_ImagePlane* topPlane,
   4470                                                 M4VIFI_ImagePlane* bottomPlane,
   4471                                                 M4VIFI_ImagePlane *PlaneOut,
   4472                                                 M4OSA_UInt32    shiftUV)
   4473 {
   4474     M4OSA_UInt32 i;
   4475 
   4476     /* Do three loops, one for each plane type, in order to avoid having too many buffers
   4477     "hot" at the same time (better for cache). */
   4478     for (i=0; i<3; i++)
   4479     {
   4480         M4OSA_UInt32    topPartHeight, bottomPartHeight, width, sourceStride, destStride, y;
   4481         M4OSA_MemAddr8    sourceWalk, destWalk;
   4482 
   4483         /* cache the vars used in the loop so as to avoid them being repeatedly fetched and
   4484          recomputed from memory. */
   4485         if (0 == i) /* Y plane */
   4486         {
   4487             bottomPartHeight = 2*shiftUV;
   4488         }
   4489         else /* U and V planes */
   4490         {
   4491             bottomPartHeight = shiftUV;
   4492         }
   4493         topPartHeight = PlaneOut[i].u_height - bottomPartHeight;
   4494         width = PlaneOut[i].u_width;
   4495 
   4496         sourceWalk = (M4OSA_MemAddr8)M4XXX_SampleAddress(topPlane[i], 0, bottomPartHeight);
   4497         sourceStride = topPlane[i].u_stride;
   4498 
   4499         destWalk = (M4OSA_MemAddr8)M4XXX_SampleAddress(PlaneOut[i], 0, 0);
   4500         destStride = PlaneOut[i].u_stride;
   4501 
   4502         /* First the part from the top source clip frame. */
   4503         for (y=0; y<topPartHeight; y++)
   4504         {
   4505             memcpy((void *)destWalk, (void *)sourceWalk, width);
   4506             destWalk += destStride;
   4507             sourceWalk += sourceStride;
   4508         }
   4509 
   4510         /* and now change the vars to copy the part from the bottom source clip frame. */
   4511         sourceWalk = (M4OSA_MemAddr8)M4XXX_SampleAddress(bottomPlane[i], 0, 0);
   4512         sourceStride = bottomPlane[i].u_stride;
   4513 
   4514         /* destWalk is already at M4XXX_SampleAddress(PlaneOut[i], 0, topPartHeight) */
   4515 
   4516         for (y=0; y<bottomPartHeight; y++)
   4517         {
   4518             memcpy((void *)destWalk, (void *)sourceWalk, width);
   4519             destWalk += destStride;
   4520             sourceWalk += sourceStride;
   4521         }
   4522     }
   4523     return M4NO_ERROR;
   4524 }
   4525 
   4526 static M4OSA_ERR M4xVSS_HorizontalSlideTransition(M4VIFI_ImagePlane* leftPlane,
   4527                                                   M4VIFI_ImagePlane* rightPlane,
   4528                                                   M4VIFI_ImagePlane *PlaneOut,
   4529                                                   M4OSA_UInt32    shiftUV)
   4530 {
   4531     M4OSA_UInt32 i, y;
   4532     /* If we shifted by exactly 0, or by the width of the target image, then we would get the left
   4533     frame or the right frame, respectively. These cases aren't handled too well by the general
   4534     handling, since they result in 0-size memcopies, so might as well particularize them. */
   4535 
   4536     if (0 == shiftUV)    /* output left frame */
   4537     {
   4538         for (i = 0; i<3; i++) /* for each YUV plane */
   4539         {
   4540             M4XXX_CopyPlane(&(PlaneOut[i]), &(leftPlane[i]));
   4541         }
   4542 
   4543         return M4NO_ERROR;
   4544     }
   4545 
   4546     if (PlaneOut[1].u_width == shiftUV) /* output right frame */
   4547     {
   4548         for (i = 0; i<3; i++) /* for each YUV plane */
   4549         {
   4550             M4XXX_CopyPlane(&(PlaneOut[i]), &(rightPlane[i]));
   4551         }
   4552 
   4553         return M4NO_ERROR;
   4554     }
   4555 
   4556 
   4557     /* Do three loops, one for each plane type, in order to avoid having too many buffers
   4558     "hot" at the same time (better for cache). */
   4559     for (i=0; i<3; i++)
   4560     {
   4561         M4OSA_UInt32    height, leftPartWidth, rightPartWidth;
   4562         M4OSA_UInt32    leftStride,    rightStride,    destStride;
   4563         M4OSA_MemAddr8    leftWalk,    rightWalk,    destWalkLeft, destWalkRight;
   4564 
   4565         /* cache the vars used in the loop so as to avoid them being repeatedly fetched
   4566         and recomputed from memory. */
   4567         height = PlaneOut[i].u_height;
   4568 
   4569         if (0 == i) /* Y plane */
   4570         {
   4571             rightPartWidth = 2*shiftUV;
   4572         }
   4573         else /* U and V planes */
   4574         {
   4575             rightPartWidth = shiftUV;
   4576         }
   4577         leftPartWidth = PlaneOut[i].u_width - rightPartWidth;
   4578 
   4579         leftWalk = (M4OSA_MemAddr8)M4XXX_SampleAddress(leftPlane[i], rightPartWidth, 0);
   4580         leftStride = leftPlane[i].u_stride;
   4581 
   4582         rightWalk = (M4OSA_MemAddr8)M4XXX_SampleAddress(rightPlane[i], 0, 0);
   4583         rightStride = rightPlane[i].u_stride;
   4584 
   4585         destWalkLeft = (M4OSA_MemAddr8)M4XXX_SampleAddress(PlaneOut[i], 0, 0);
   4586         destWalkRight = (M4OSA_MemAddr8)M4XXX_SampleAddress(PlaneOut[i], leftPartWidth, 0);
   4587         destStride = PlaneOut[i].u_stride;
   4588 
   4589         for (y=0; y<height; y++)
   4590         {
   4591             memcpy((void *)destWalkLeft, (void *)leftWalk, leftPartWidth);
   4592             leftWalk += leftStride;
   4593 
   4594             memcpy((void *)destWalkRight, (void *)rightWalk, rightPartWidth);
   4595             rightWalk += rightStride;
   4596 
   4597             destWalkLeft += destStride;
   4598             destWalkRight += destStride;
   4599         }
   4600     }
   4601 
   4602     return M4NO_ERROR;
   4603 }
   4604 
   4605 
   4606 M4OSA_ERR M4xVSS_SlideTransition( M4OSA_Void *userData, M4VIFI_ImagePlane PlaneIn1[3],
   4607                                   M4VIFI_ImagePlane PlaneIn2[3], M4VIFI_ImagePlane *PlaneOut,
   4608                                   M4VSS3GPP_ExternalProgress *pProgress,
   4609                                   M4OSA_UInt32 uiTransitionKind)
   4610 {
   4611     M4xVSS_internal_SlideTransitionSettings* settings =
   4612          (M4xVSS_internal_SlideTransitionSettings*)userData;
   4613     M4OSA_UInt32    shiftUV;
   4614 
   4615     M4OSA_TRACE1_0("inside M4xVSS_SlideTransition");
   4616     if ((M4xVSS_SlideTransition_RightOutLeftIn == settings->direction)
   4617         || (M4xVSS_SlideTransition_LeftOutRightIn == settings->direction) )
   4618     {
   4619         /* horizontal slide */
   4620         shiftUV = ((PlaneOut[1]).u_width * pProgress->uiProgress)/1000;
   4621         M4OSA_TRACE1_2("M4xVSS_SlideTransition upper: shiftUV = %d,progress = %d",
   4622             shiftUV,pProgress->uiProgress );
   4623         if (M4xVSS_SlideTransition_RightOutLeftIn == settings->direction)
   4624         {
   4625             /* Put the previous clip frame right, the next clip frame left, and reverse shiftUV
   4626             (since it's a shift from the left frame) so that we start out on the right
   4627             (i.e. not left) frame, it
   4628             being from the previous clip. */
   4629             return M4xVSS_HorizontalSlideTransition(PlaneIn2, PlaneIn1, PlaneOut,
   4630                  (PlaneOut[1]).u_width - shiftUV);
   4631         }
   4632         else /* Left out, right in*/
   4633         {
   4634             return M4xVSS_HorizontalSlideTransition(PlaneIn1, PlaneIn2, PlaneOut, shiftUV);
   4635         }
   4636     }
   4637     else
   4638     {
   4639         /* vertical slide */
   4640         shiftUV = ((PlaneOut[1]).u_height * pProgress->uiProgress)/1000;
   4641         M4OSA_TRACE1_2("M4xVSS_SlideTransition bottom: shiftUV = %d,progress = %d",shiftUV,
   4642             pProgress->uiProgress );
   4643         if (M4xVSS_SlideTransition_TopOutBottomIn == settings->direction)
   4644         {
   4645             /* Put the previous clip frame top, the next clip frame bottom. */
   4646             return M4xVSS_VerticalSlideTransition(PlaneIn1, PlaneIn2, PlaneOut, shiftUV);
   4647         }
   4648         else /* Bottom out, top in */
   4649         {
   4650             return M4xVSS_VerticalSlideTransition(PlaneIn2, PlaneIn1, PlaneOut,
   4651                 (PlaneOut[1]).u_height - shiftUV);
   4652         }
   4653     }
   4654 
   4655     /* Note: it might be worthwhile to do some parameter checking, see if dimensions match, etc.,
   4656     at least in debug mode. */
   4657 }
   4658 
   4659 
   4660 /**
   4661  ******************************************************************************
   4662  * prototype    M4xVSS_FadeBlackTransition(M4OSA_Void *pFunctionContext,
   4663  *                                                    M4VIFI_ImagePlane *PlaneIn,
   4664  *                                                    M4VIFI_ImagePlane *PlaneOut,
   4665  *                                                    M4VSS3GPP_ExternalProgress *pProgress,
   4666  *                                                    M4OSA_UInt32 uiEffectKind)
   4667  *
   4668  * @brief    This function apply a fade to black and then a fade from black
   4669  * @note
   4670  * @param    pFunctionContext(IN) Contains which color to apply (not very clean ...)
   4671  * @param    PlaneIn            (IN) Input YUV420 planar
   4672  * @param    PlaneOut        (IN/OUT) Output YUV420 planar
   4673  * @param    pProgress        (IN/OUT) Progress indication (0-100)
   4674  * @param    uiEffectKind    (IN) Unused
   4675  *
   4676  * @return    M4VIFI_OK:    No error
   4677  ******************************************************************************
   4678  */
   4679 M4OSA_ERR M4xVSS_FadeBlackTransition(M4OSA_Void *userData, M4VIFI_ImagePlane PlaneIn1[3],
   4680                                      M4VIFI_ImagePlane PlaneIn2[3],
   4681                                      M4VIFI_ImagePlane *PlaneOut,
   4682                                      M4VSS3GPP_ExternalProgress *pProgress,
   4683                                      M4OSA_UInt32 uiTransitionKind)
   4684 {
   4685     M4OSA_Int32 tmp = 0;
   4686     M4OSA_ERR err = M4NO_ERROR;
   4687 
   4688 
   4689     if((pProgress->uiProgress) < 500)
   4690     {
   4691         /**
   4692          * Compute where we are in the effect (scale is 0->1024) */
   4693         tmp = (M4OSA_Int32)((1.0 - ((M4OSA_Float)(pProgress->uiProgress*2)/1000)) * 1024 );
   4694 
   4695         /**
   4696          * Apply the darkening effect */
   4697         err = M4VFL_modifyLumaWithScale( (M4ViComImagePlane*)PlaneIn1,
   4698              (M4ViComImagePlane*)PlaneOut, tmp, M4OSA_NULL);
   4699         if (M4NO_ERROR != err)
   4700         {
   4701             M4OSA_TRACE1_1("M4xVSS_FadeBlackTransition: M4VFL_modifyLumaWithScale returns\
   4702                  error 0x%x, returning M4VSS3GPP_ERR_LUMA_FILTER_ERROR", err);
   4703             return M4VSS3GPP_ERR_LUMA_FILTER_ERROR;
   4704         }
   4705     }
   4706     else
   4707     {
   4708         /**
   4709          * Compute where we are in the effect (scale is 0->1024). */
   4710         tmp = (M4OSA_Int32)( (((M4OSA_Float)(((pProgress->uiProgress-500)*2))/1000)) * 1024 );
   4711 
   4712         /**
   4713          * Apply the darkening effect */
   4714         err = M4VFL_modifyLumaWithScale((M4ViComImagePlane*)PlaneIn2,
   4715              (M4ViComImagePlane*)PlaneOut, tmp, M4OSA_NULL);
   4716         if (M4NO_ERROR != err)
   4717         {
   4718             M4OSA_TRACE1_1("M4xVSS_FadeBlackTransition:\
   4719                  M4VFL_modifyLumaWithScale returns error 0x%x,\
   4720                      returning M4VSS3GPP_ERR_LUMA_FILTER_ERROR", err);
   4721             return M4VSS3GPP_ERR_LUMA_FILTER_ERROR;
   4722         }
   4723     }
   4724 
   4725 
   4726     return M4VIFI_OK;
   4727 }
   4728 
   4729 
   4730 /**
   4731  ******************************************************************************
   4732  * prototype    M4OSA_ERR M4xVSS_internalConvertToUTF8(M4OSA_Context pContext,
   4733  *                                                        M4OSA_Void* pBufferIn,
   4734  *                                                        M4OSA_Void* pBufferOut,
   4735  *                                                        M4OSA_UInt32* convertedSize)
   4736  *
   4737  * @brief    This function convert from the customer format to UTF8
   4738  * @note
   4739  * @param    pContext        (IN)    The integrator own context
   4740  * @param    pBufferIn        (IN)    Buffer to convert
   4741  * @param    pBufferOut        (OUT)    Converted buffer
   4742  * @param    convertedSize    (OUT)    Size of the converted buffer
   4743  *
   4744  * @return    M4NO_ERROR:    No error
   4745  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   4746  ******************************************************************************
   4747  */
   4748 M4OSA_ERR M4xVSS_internalConvertToUTF8(M4OSA_Context pContext, M4OSA_Void* pBufferIn,
   4749                                        M4OSA_Void* pBufferOut, M4OSA_UInt32* convertedSize)
   4750 {
   4751     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   4752     M4OSA_ERR err;
   4753 
   4754     pBufferOut = pBufferIn;
   4755     if(xVSS_context->UTFConversionContext.pConvToUTF8Fct != M4OSA_NULL
   4756         && xVSS_context->UTFConversionContext.pTempOutConversionBuffer != M4OSA_NULL)
   4757     {
   4758         M4OSA_UInt32 ConvertedSize = xVSS_context->UTFConversionContext.m_TempOutConversionSize;
   4759 
   4760         memset((void *)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,0
   4761             ,(M4OSA_UInt32)xVSS_context->UTFConversionContext.m_TempOutConversionSize);
   4762 
   4763         err = xVSS_context->UTFConversionContext.pConvToUTF8Fct((M4OSA_Void*)pBufferIn,
   4764             (M4OSA_UInt8*)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,
   4765                  (M4OSA_UInt32*)&ConvertedSize);
   4766         if(err == M4xVSSWAR_BUFFER_OUT_TOO_SMALL)
   4767         {
   4768             M4OSA_TRACE2_1("M4xVSS_internalConvertToUTF8: pConvToUTF8Fct return 0x%x",err);
   4769 
   4770             /*free too small buffer*/
   4771             free(xVSS_context->\
   4772                 UTFConversionContext.pTempOutConversionBuffer);
   4773 
   4774             /*re-allocate the buffer*/
   4775             xVSS_context->UTFConversionContext.pTempOutConversionBuffer    =
   4776                  (M4OSA_Void*)M4OSA_32bitAlignedMalloc(ConvertedSize*sizeof(M4OSA_UInt8), M4VA,
   4777                      (M4OSA_Char *)"M4xVSS_internalConvertToUTF8: UTF conversion buffer");
   4778             if(M4OSA_NULL == xVSS_context->UTFConversionContext.pTempOutConversionBuffer)
   4779             {
   4780                 M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertToUTF8");
   4781                 return M4ERR_ALLOC;
   4782             }
   4783             xVSS_context->UTFConversionContext.m_TempOutConversionSize = ConvertedSize;
   4784 
   4785             memset((void *)xVSS_context->\
   4786                 UTFConversionContext.pTempOutConversionBuffer,0,(M4OSA_UInt32)xVSS_context->\
   4787                     UTFConversionContext.m_TempOutConversionSize);
   4788 
   4789             err = xVSS_context->UTFConversionContext.pConvToUTF8Fct((M4OSA_Void*)pBufferIn,
   4790                 (M4OSA_Void*)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,
   4791                     (M4OSA_UInt32*)&ConvertedSize);
   4792             if(err != M4NO_ERROR)
   4793             {
   4794                 M4OSA_TRACE1_1("M4xVSS_internalConvertToUTF8: pConvToUTF8Fct return 0x%x",err);
   4795                 return err;
   4796             }
   4797         }
   4798         else if(err != M4NO_ERROR)
   4799         {
   4800             M4OSA_TRACE1_1("M4xVSS_internalConvertToUTF8: pConvToUTF8Fct return 0x%x",err);
   4801             return err;
   4802         }
   4803         /*decoded path*/
   4804         pBufferOut = xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
   4805         (*convertedSize) = ConvertedSize;
   4806     }
   4807     return M4NO_ERROR;
   4808 }
   4809 
   4810 
   4811 /**
   4812  ******************************************************************************
   4813  * prototype    M4OSA_ERR M4xVSS_internalConvertFromUTF8(M4OSA_Context pContext)
   4814  *
   4815  * @brief    This function convert from UTF8 to the customer format
   4816  * @note
   4817  * @param    pContext    (IN) The integrator own context
   4818  * @param    pBufferIn        (IN)    Buffer to convert
   4819  * @param    pBufferOut        (OUT)    Converted buffer
   4820  * @param    convertedSize    (OUT)    Size of the converted buffer
   4821  *
   4822  * @return    M4NO_ERROR:    No error
   4823  * @return    M4ERR_PARAMETER: At least one of the function parameters is null
   4824  ******************************************************************************
   4825  */
   4826 M4OSA_ERR M4xVSS_internalConvertFromUTF8(M4OSA_Context pContext, M4OSA_Void* pBufferIn,
   4827                                         M4OSA_Void* pBufferOut, M4OSA_UInt32* convertedSize)
   4828 {
   4829     M4xVSS_Context* xVSS_context = (M4xVSS_Context*)pContext;
   4830     M4OSA_ERR err;
   4831 
   4832     pBufferOut = pBufferIn;
   4833     if(xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
   4834         && xVSS_context->UTFConversionContext.pTempOutConversionBuffer != M4OSA_NULL)
   4835     {
   4836         M4OSA_UInt32 ConvertedSize = xVSS_context->UTFConversionContext.m_TempOutConversionSize;
   4837 
   4838         memset((void *)xVSS_context->\
   4839             UTFConversionContext.pTempOutConversionBuffer,0,(M4OSA_UInt32)xVSS_context->\
   4840                 UTFConversionContext.m_TempOutConversionSize);
   4841 
   4842         err = xVSS_context->UTFConversionContext.pConvFromUTF8Fct\
   4843             ((M4OSA_Void*)pBufferIn,(M4OSA_UInt8*)xVSS_context->\
   4844                 UTFConversionContext.pTempOutConversionBuffer, (M4OSA_UInt32*)&ConvertedSize);
   4845         if(err == M4xVSSWAR_BUFFER_OUT_TOO_SMALL)
   4846         {
   4847             M4OSA_TRACE2_1("M4xVSS_internalConvertFromUTF8: pConvFromUTF8Fct return 0x%x",err);
   4848 
   4849             /*free too small buffer*/
   4850             free(xVSS_context->\
   4851                 UTFConversionContext.pTempOutConversionBuffer);
   4852 
   4853             /*re-allocate the buffer*/
   4854             xVSS_context->UTFConversionContext.pTempOutConversionBuffer    =
   4855                 (M4OSA_Void*)M4OSA_32bitAlignedMalloc(ConvertedSize*sizeof(M4OSA_UInt8), M4VA,
   4856                      (M4OSA_Char *)"M4xVSS_internalConvertFromUTF8: UTF conversion buffer");
   4857             if(M4OSA_NULL == xVSS_context->UTFConversionContext.pTempOutConversionBuffer)
   4858             {
   4859                 M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertFromUTF8");
   4860                 return M4ERR_ALLOC;
   4861             }
   4862             xVSS_context->UTFConversionContext.m_TempOutConversionSize = ConvertedSize;
   4863 
   4864             memset((void *)xVSS_context->\
   4865                 UTFConversionContext.pTempOutConversionBuffer,0,(M4OSA_UInt32)xVSS_context->\
   4866                     UTFConversionContext.m_TempOutConversionSize);
   4867 
   4868             err = xVSS_context->UTFConversionContext.pConvFromUTF8Fct((M4OSA_Void*)pBufferIn,
   4869                 (M4OSA_Void*)xVSS_context->UTFConversionContext.pTempOutConversionBuffer,
   4870                      (M4OSA_UInt32*)&ConvertedSize);
   4871             if(err != M4NO_ERROR)
   4872             {
   4873                 M4OSA_TRACE1_1("M4xVSS_internalConvertFromUTF8: pConvFromUTF8Fct return 0x%x",err);
   4874                 return err;
   4875             }
   4876         }
   4877         else if(err != M4NO_ERROR)
   4878         {
   4879             M4OSA_TRACE1_1("M4xVSS_internalConvertFromUTF8: pConvFromUTF8Fct return 0x%x",err);
   4880             return err;
   4881         }
   4882         /*decoded path*/
   4883         pBufferOut = xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
   4884         (*convertedSize) = ConvertedSize;
   4885     }
   4886 
   4887 
   4888     return M4NO_ERROR;
   4889 }
   4890