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) */
53M4VIFI_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*/
59extern 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 */
79M4OSA_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 */
218M4OSA_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
267M4OSA_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    }
402cleanup:
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
429M4OSA_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 */
496M4OSA_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 */
1489M4OSA_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 */
1680M4OSA_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 */
1765M4OSA_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
1826M4OSA_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
1867M4OSA_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 */
2352M4OSA_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 */
2575M4OSA_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 ***/
2633M4OSA_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 */
2760M4OSA_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 */
2802M4OSA_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 */
2902M4OSA_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 */
3010M4OSA_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
3339M4OSA_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 */
3472M4OSA_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 */
3529M4OSA_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 */
3650M4OSA_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 */
3812M4OSA_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 */
4012M4OSA_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
4138M4OSA_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 */
4213M4OSA_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 */
4324M4OSA_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
4445static 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
4469static 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
4526static 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
4606M4OSA_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 */
4679M4OSA_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 */
4748M4OSA_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 */
4826M4OSA_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