1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Symbian Foundation License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation for movie processor

    15 *

    16 */

    17 

    18 

    19 //  Include Files

    20 

    21 #include "movieprocessorimpl.h"

    22 #include "statusmonitor.h"

    23 #include "activequeue.h"

    24 #include "mp4parser.h"

    25 #include "mp4composer.h"

    26 #include "videoencoder.h"

    27 #include "yuv2rgb12.h"

    28 #include "yuv2rgb16.h"

    29 #include "yuv2rgb24.h"

    30 #include "VideoProcessorAudioData.h"

    31 #include "DisplayChain.h"

    32 #include "VedRgb2YuvConverter.h"

    33 #include "vedaudiosettings.h"

    34 #include "vedvideosettings.h"

    35 #include "AudSong.h"

    36 #include "audioprocessor.h"

    37 #include "SizeEstimate.h"

    38 #include "vedavcedit.h"

    39 

    40 //  Local Constants

    41 

    42 const TUint KReadBufInitSize = 512; // stream start buffer initial size

    43 //const TInt	KVideoProcessorPriority = CActive::EPriorityHigh;

    44 const TUint KVideoQueueBlocks = 16;

    45 const TUint KVideoQueueBlockSize = 256;

    46 const TInt	KDemuxPriority = CActive::EPriorityHigh;

    47 const TUint	KInitialAudioBufferSize = 1024;

    48 const TUint KInitialVideoBufferSize = 10240;

    49 const TUint KMaxVideoSpeed = 1000;

    50 const TUint KVideoTimeScale = 5000; // for both normal & generated clips

    51 const TUint KAMRAudioTimeScale = 8000;

    52 

    53 const TUint KDiskSafetyLimit = 400000;   // Amount of free disk space to leave unused

    54 

    55 _LIT(KTempFilePath ,"c:\\system\\temp\\");  // path for temp file used in image insertion

    56 

    57 // An assertion macro wrapper to clean up the code a bit

    58 #define VPASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CMovieProcessorImpl"), EInvalidInternalState))

    59 

    60 #ifdef _DEBUG

    61 #include <e32svr.h>

    62 #define PRINT(x) RDebug::Print x;

    63 #else

    64 #define PRINT(x)

    65 #endif

    66 

    67 // ================= MEMBER FUNCTIONS =======================

    68 

    69 // -----------------------------------------------------------------------------

    70 // CMovieProcessorImpl::NewL

    71 // Two-phased constructor.

    72 // -----------------------------------------------------------------------------

    73 //

    74 CMovieProcessorImpl* CMovieProcessorImpl::NewL() 

    75 {

    76 	CMovieProcessorImpl* self = NewLC();

    77 	CleanupStack::Pop(self);

    78 	return self;

    79 }

    80 

    81 CMovieProcessorImpl* CMovieProcessorImpl::NewLC()

    82 {

    83 	CMovieProcessorImpl* self = new (ELeave) CMovieProcessorImpl();

    84 	CleanupStack::PushL(self);

    85 	self->ConstructL();

    86 	return self;

    87 }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CMovieProcessorImpl::CMovieProcessorImpl

    91 // C++ default constructor can NOT contain any code, that

    92 // might leave.

    93 // -----------------------------------------------------------------------------

    94 //

    95 CMovieProcessorImpl::CMovieProcessorImpl()

    96 : CActive(EPriorityNormal), iReadImageDes(0,0), iReadDes(0, 0)

    97 {

    98   // Reset state

    99     iState = EStateIdle;

   100 	iDataFormat = EDataAutoDetect;

   101     iAudioFramesInSample = KVedAudioFramesInSample;

   102 

   103     iStartTransitionEffect = EVedStartTransitionEffectNone; 

   104 	iMiddleTransitionEffect = EVedMiddleTransitionEffectNone; 

   105 	iPreviousMiddleTransitionEffect = EVedMiddleTransitionEffectNone;

   106 	iEndTransitionEffect = EVedEndTransitionEffectNone; 

   107 	iSpeed = KMaxVideoSpeed; 

   108 	iColorEffect = EVedColorEffectNone;

   109     iNumberOfVideoClips=1; 	

   110     iTr.iTrPrevNew = -1;

   111 	iTr.iTrPrevOrig = -1;	

   112     iStartFrameIndex = -1;

   113     iMovieSizeLimit = 0;

   114     iFrameParametersSize = 0;

   115     

   116     // We are now properly initialized

   117     iState = EStateIdle;

   118 	

   119 }

   120 

   121 // -----------------------------------------------------------------------------

   122 // CMovieProcessorImpl::~CMovieProcessorImpl

   123 // Destructor.

   124 // -----------------------------------------------------------------------------

   125 //

   126 CMovieProcessorImpl::~CMovieProcessorImpl()

   127 {

   128 

   129     Cancel();

   130 

   131     TInt error = KErrNone;

   132 

   133 	TRAP(error, DoCloseVideoL());	

   134 

   135     DeleteClipStructures();       

   136 

   137 	if (iFrameParameters)

   138     {

   139 		User::Free(iFrameParameters);			

   140         iFrameParameters = 0; 

   141     }

   142         

   143 	if (iVideoClipParameters)

   144     {

   145 		User::Free(iVideoClipParameters);	

   146         iVideoClipParameters = 0; 

   147     }

   148 

   149     if (iOutAudioBuffer) {

   150 		delete iOutAudioBuffer; 

   151         iOutAudioBuffer=0;    

   152     }

   153 

   154     if (iOutVideoBuffer) {

   155 		delete iOutVideoBuffer; 

   156         iOutVideoBuffer=0;    

   157     }

   158 

   159 	// although this should be released by VideoEditorEngine, 

   160 	// the following is still needed in case of leave 

   161 

   162 	if(iDemux)

   163     {

   164 		delete iDemux;				

   165         iDemux = 0; 

   166     }

   167 

   168 	if(iVideoProcessor)

   169     {

   170 		delete iVideoProcessor;	

   171         iVideoProcessor = 0;	

   172     }

   173 

   174     if (iComposer) {

   175         delete iComposer; 

   176         iComposer = 0;

   177     }

   178     

   179     if (iAudioProcessor)

   180     {

   181         delete iAudioProcessor;

   182         iAudioProcessor = 0;	

   183     }        

   184 

   185 	if(iImageComposer) 

   186 	{

   187 		delete iImageComposer;						

   188 		iImageComposer=0;

   189 	}

   190 	

   191 	if (iImageAvcEdit)

   192 	{

   193 	    delete iImageAvcEdit;

   194 	    iImageAvcEdit = 0;

   195 	}

   196 

   197 	if (iYuvImageBuf)

   198 	{

   199 		User::Free(iYuvImageBuf);

   200 		iYuvImageBuf=0;

   201 	}

   202 

   203     if(iVideoEncoder) 

   204     {

   205 		delete iVideoEncoder;	

   206         iVideoEncoder = 0; 

   207     }

   208 	

   209 	if(iParser)

   210     {

   211         delete iParser;

   212         iParser = 0;

   213     }

   214 	if(iVideoQueue)

   215     {

   216 		delete iVideoQueue;		

   217         iVideoQueue = 0;

   218     }

   219 

   220     if (iWaitScheduler)

   221     {

   222         delete iWaitScheduler;

   223         iWaitScheduler = 0;

   224     }

   225 

   226 	if(iMonitor)

   227     {

   228 		delete iMonitor;			

   229         iMonitor = 0; 	

   230     }

   231     

   232     if (iReadBuf)

   233 		User::Free(iReadBuf);

   234 

   235     if (iRgbBuf)

   236     {

   237         delete iRgbBuf;

   238         iRgbBuf = 0;

   239     }        

   240     

   241     if (iOutBitmap)

   242     {

   243         delete iOutBitmap;

   244         iOutBitmap = 0;

   245     }

   246     

   247     if (iSizeEstimate)

   248     {

   249         delete iSizeEstimate;

   250         iSizeEstimate = 0;

   251     }

   252     

   253     if (iAvcEdit)

   254     {

   255         delete iAvcEdit;

   256         iAvcEdit = 0;

   257     }

   258     

   259     if (iImageYuvConverter)

   260     {

   261         delete iImageYuvConverter;

   262         iImageYuvConverter = 0;

   263     }

   264 

   265 	// for transition effect

   266     if ( iFsConnected )

   267     {

   268         TRAP(error, CloseTransitionInfoL());

   269         iFs.Close();

   270         iFsConnected = EFalse;

   271     }

   272 }

   273 

   274 

   275 // -----------------------------------------------------------------------------

   276 // CMovieProcessorImpl::ConstructL

   277 // Symbian 2nd phase constructor can leave.

   278 // -----------------------------------------------------------------------------

   279 //

   280 void CMovieProcessorImpl::ConstructL()

   281 {	

   282 	

   283 	// Allocate stream reading buffer

   284 	iReadBuf = (TUint8*) User::AllocL(KReadBufInitSize);

   285 	iBufLength = KReadBufInitSize;

   286 	

   287 	iClipFileName.Zero();

   288 	iOutputMovieFileName.Zero();    

   289 

   290     iWaitScheduler = new (ELeave) CActiveSchedulerWait;

   291 

   292     // Add to active scheduler

   293     CActiveScheduler::Add(this);

   294     

   295     iSizeEstimate = CSizeEstimate::NewL(this);

   296 

   297     iState = EStateIdle;

   298 }

   299 

   300 

   301 // -----------------------------------------------------------------------------

   302 // CMovieProcessorImpl::StartMovieL

   303 // Prepares the processor for processing a movie and starts processing  

   304 // (other items were commented in a header).

   305 // -----------------------------------------------------------------------------

   306 //

   307 void CMovieProcessorImpl::StartMovieL(CVedMovieImp* aMovie, const TDesC& aFileName, RFile* aFileHandle,

   308                                       MVedMovieProcessingObserver* aObserver)

   309 {

   310 

   311     PRINT((_L("CMovieProcessorImpl::StartMovieL() begin")))

   312 

   313     // reset member variables

   314     ResetL();

   315 

   316 	// get arguments 

   317 	iMovie = aMovie; 

   318     if (!iMovie)

   319         User::Leave(KErrArgument);

   320 

   321 	iOutputMovieFileName = aFileName;

   322 	iOutputFileHandle = aFileHandle;	

   323     

   324     CVedMovieImp* movie = (iMovie);

   325     iObserver = aObserver;

   326 

   327     if (!iObserver)

   328         User::Leave(KErrArgument);    

   329 

   330     if (iMonitor) 

   331     {

   332         delete iMonitor;

   333         iMonitor = 0;

   334     }    

   335     

   336      // Create a status monitor object:

   337 	iMonitor = new (ELeave) CStatusMonitor(iObserver, this, aMovie);

   338 	iMonitor->ConstructL();

   339 	

   340 	// update movie properties	

   341 	iFramesProcessed=0;

   342 	iNumberOfVideoClips = iMovie->VideoClipCount();

   343     iNumberOfAudioClips = iMovie->AudioClipCount();    

   344 

   345 	// calculate total movie duration for progress bar: video & audio tracks.

   346 	// in milliseconds

   347 	iTotalMovieDuration = TInt64(2) * ( movie->Duration().Int64()/1000 );

   348     

   349     for (TInt i = 0; i < iNumberOfVideoClips; i++)

   350     {

   351         CVedVideoClip* currentClip = movie->VideoClip(i);

   352 		CVedVideoClipInfo* currentInfo = currentClip->Info();

   353 

   354         // Take time to generate a clip into account

   355         if (currentInfo->Class() == EVedVideoClipClassGenerated)

   356         {            

   357             iTotalMovieDuration += currentInfo->Duration().Int64()/1000;

   358         }

   359     }    

   360 

   361 	// set media types

   362 	SetOutputMediaTypesL();

   363 

   364 	// get transcode factors: bitstream mode & time inc. resolution

   365 	GetTranscodeFactorsL();

   366 

   367 	// set video transcoding parameters

   368 	SetupTranscodingL();

   369 	

   370 #ifdef VIDEOEDITORENGINE_AVC_EDITING

   371 	// check if AVC editing is involved

   372 	TBool avcEditing = ( iOutputVideoType == EVideoAVCProfileBaseline );		

   373     for(TInt i = 0; i < movie->VideoClipCount() && avcEditing == EFalse; i++)

   374 	{

   375 		CVedVideoClip* currentClip = movie->VideoClip(i);

   376 		CVedVideoClipInfo* currentInfo = currentClip->Info();

   377 				

   378 		if( currentInfo->Class() == EVedVideoClipClassFile &&

   379 		   (currentInfo->VideoType() == EVedVideoTypeAVCBaselineProfile) )

   380 		{

   381 		    avcEditing = ETrue;

   382 		    break;

   383 	    }

   384 	}		

   385 	

   386 	if (avcEditing)

   387 	{

   388 	    // create AVC editing instance

   389 	    iAvcEdit = CVedAVCEdit::NewL();	    

   390 	}

   391 	

   392 	if (iOutputVideoType == EVideoAVCProfileBaseline)

   393 	{

   394 	    // set level

   395 	    iAvcEdit->SetOutputLevel( GetOutputAVCLevel() );

   396 	}

   397 		

   398 #endif

   399 

   400 	// Check

   401 	//iOutputAudioType = EAudioAMR;						// default is Amr if all are generated

   402 

   403 	if ( iFsConnected == EFalse )

   404 	{

   405         User::LeaveIfError( iFs.Connect() );

   406         iFsConnected = ETrue;

   407 	}

   408 

   409     if (iNumberOfVideoClips)

   410     {

   411         iStartTransitionEffect = aMovie->StartTransitionEffect();

   412         iEndTransitionEffect = aMovie->EndTransitionEffect();	

   413 		CloseTransitionInfoL();

   414     }

   415 

   416 	iImageEncodeProcFinished = 0; // to indicate whether encode images process is finished

   417 	iImageEncodedFlag = 0;  // has an image been encoded

   418 	iFirstTimeProcessing = 0;

   419 	iTotalImagesProcessed = 0;  

   420 	iImageClipCreated = 0;  // has an image clip been created

   421 	

   422 	iImageVideoTimeScale = KVideoTimeScale; // Initializing to standard value

   423 	iGetFrameInProgress = 0;

   424 	iOutputAudioTimeSet = 0;

   425 	iOutputVideoTimeSet = 0;

   426 	iAllGeneratedClips = 0;   // Indicates if all the clips in the movie are generated clips - 0 indicates false

   427 	iEncodeInProgress = 0;     // Indicates encoding is not in progress		

   428 	iFirstClipHasNoDecInfo = EFalse;

   429 	

   430 	// Allocate memory for frame parameters array

   431 	if (iFrameParameters)

   432         User::Free(iFrameParameters);

   433     

   434     iFrameParameters = 0;

   435 	iFrameParameters = (struct TFrameParameters *)User::AllocL(iFrameParametersSize * sizeof(struct TFrameParameters));

   436 	Mem::Fill(iFrameParameters, iFrameParametersSize * sizeof(TFrameParameters), 0);

   437 	

   438 	InitializeClipStructuresL();

   439 	

   440 	// second pass starts here 

   441 	// load first clip properties 

   442 	iVideoClipNumber=0; 

   443     iAudioClipNumber=0;	   

   444 

   445     if (iNumberOfVideoClips)

   446         iVideoClip = movie->VideoClip(iVideoClipNumber);    

   447 

   448 	// if clip is not file-based, then call some other initializer

   449 	TInt firstClipIsGenerated = 0;

   450 	iFirstClipIsGen = EFalse;

   451 

   452 	// what if iNumberOfVideoClips == 0, this will fail !

   453 	if(iNumberOfVideoClips && iVideoClip->Info()->Class() == EVedVideoClipClassGenerated)

   454 	{

   455 		// since frame parameters are not available here, use temporary instantiation for composer

   456 		TemporaryInitializeGeneratedClipL(); 

   457 		// note that we may need to create a parser temporarily

   458 		firstClipIsGenerated = 1;

   459 		iFirstClipIsGen = ETrue;

   460 	}

   461 	else

   462 	{

   463 		InitializeClipL();	// check details inside initialization

   464 	}

   465 

   466 	if(iOutputAudioType == EAudioAMR)

   467 	{

   468 		if( iAudioType == EAudioNone)

   469 			iAudioType = EAudioAMR;

   470 		iAudioFramesInSample = KVedAudioFramesInSample;

   471 	}

   472 

   473 	else if(iOutputAudioType == EAudioAAC)

   474 	{

   475 		if( iAudioType == EAudioNone)

   476 		{

   477 			iAudioType = EAudioAAC;	

   478 			iFirstClipHasNoDecInfo = ETrue; // because it has no audio so it will have no decoder specific Info			

   479 		}

   480 		iAudioFramesInSample = 1;

   481 	}

   482 

   483 

   484 	VPASSERT(!iComposer);

   485     // initialize composer

   486     if (iOutputFileHandle)

   487         iComposer = CMP4Composer::NewL(iOutputFileHandle, (CParser::TVideoFormat)iOutputVideoType, (CParser::TAudioFormat)iOutputAudioType, iAvcEdit);

   488     else

   489 	    iComposer = CMP4Composer::NewL(iOutputMovieFileName, (CParser::TVideoFormat)iOutputVideoType, (CParser::TAudioFormat)iOutputAudioType, iAvcEdit);

   490 

   491     iFramesProcessed = 0;

   492     iStartingProcessing = ETrue;

   493     

   494     VPASSERT(iOutputVideoTimeScale);

   495     VPASSERT(iOutputAudioTimeScale);

   496     VPASSERT(iAudioFramesInSample);    

   497 

   498     // write video & audio descriptions

   499     CComposer::TStreamParameters streamParameters;

   500 

   501 	if(iAllGeneratedClips == 0)  // if all were generated initialize to default

   502 	{

   503 		if (iNumberOfVideoClips) 

   504 		{

   505 			streamParameters = (CComposer::TStreamParameters &)iParser->iStreamParameters;

   506 			TSize tmpSize = iMovie->Resolution();

   507 			streamParameters.iVideoWidth = tmpSize.iWidth;    /* iVideoParameters.iWidth;  */

   508 			streamParameters.iVideoHeight = tmpSize.iHeight;  /* iVideoParameters.iHeight; */

   509 			streamParameters.iHaveAudio = ETrue;    //because u always insert silent amr frames atleast//aac frames

   510 			if(iOutputAudioType == EAudioAMR)

   511 				streamParameters.iAudioFormat = (CComposer::TAudioFormat)CComposer::EAudioFormatAMR;

   512 

   513 			else if(iOutputAudioType == EAudioAAC)

   514 				streamParameters.iAudioFormat = (CComposer::TAudioFormat)CComposer::EAudioFormatAAC;	//if amr out is amr else aac if none it will be none

   515 

   516 		}

   517 		else

   518 		{

   519 		    // No video, only audio; generate black frames. Can't use iParser->iStreamParameters since iParser doesn't exist

   520 		    // SetHeaderDefaults() checked the resolution from movie to iVideoParameters

   521 			streamParameters.iVideoWidth = iVideoParameters.iWidth;

   522 			streamParameters.iVideoHeight = iVideoParameters.iHeight;

   523 		}

   524 	}

   525 	else

   526 	{	

   527 

   528 		/* since all clips inserted are generated */

   529 		iVideoType = iOutputVideoType;		

   530 

   531 		VPASSERT( (iVideoType == EVideoH263Profile0Level10) ||

   532                   (iVideoType == EVideoH263Profile0Level45) ||

   533 		          (iVideoType == EVideoMPEG4) ||

   534 		          (iVideoType == EVideoAVCProfileBaseline) );		

   535 

   536 		streamParameters.iCanSeek = ETrue;

   537 		streamParameters.iNumDemuxChannels = 1; /* Because video will be there */

   538 		TTimeIntervalMicroSeconds movduration = TTimeIntervalMicroSeconds(movie->Duration());

   539 		TInt64 alllength = movduration.Int64();			

   540 		streamParameters.iAudioLength = I64INT(alllength);

   541 		streamParameters.iVideoLength = I64INT(alllength);

   542 		streamParameters.iStreamLength = I64INT(alllength); 

   543 		streamParameters.iVideoWidth = iVideoParameters.iWidth;

   544 		streamParameters.iVideoHeight = iVideoParameters.iHeight;

   545 

   546 		if (iOutputAudioType == EAudioAMR)

   547 		{

   548 			streamParameters.iAudioFormat = (CComposer::TAudioFormat) CComposer::EAudioFormatAMR; 

   549 			streamParameters.iHaveVideo = ETrue;

   550 			streamParameters.iNumDemuxChannels++;

   551 			streamParameters.iAudioFramesInSample = KVedAudioFramesInSample;

   552 			iAudioFramesInSample = KVedAudioFramesInSample;

   553 		}

   554 

   555 		else if (iOutputAudioType == EAudioAAC)

   556 		{

   557 			streamParameters.iAudioFormat = (CComposer::TAudioFormat) CComposer::EAudioFormatAAC; 

   558 			streamParameters.iHaveVideo = ETrue;

   559 			streamParameters.iNumDemuxChannels++;

   560 			streamParameters.iAudioFramesInSample = 1;

   561 			iAudioFramesInSample = 1;	// Same as above

   562 		}

   563 

   564 		else

   565 		{

   566 		

   567 			streamParameters.iAudioFormat = (CComposer::TAudioFormat) CComposer::EAudioFormatNone; 

   568 			streamParameters.iHaveAudio =EFalse;

   569 			streamParameters.iAudioLength =0;	/* reset audio length as it was set to videolength */

   570 			streamParameters.iAudioFramesInSample = KVedAudioFramesInSample;

   571 			iAudioFramesInSample = KVedAudioFramesInSample;

   572 		}

   573 		

   574 		streamParameters.iAudioTimeScale = KAMRAudioTimeScale;

   575 		streamParameters.iVideoTimeScale = iImageVideoTimeScale;

   576 		iOutputVideoTimeScale = iImageVideoTimeScale;

   577 		iOutputAudioTimeScale = KAMRAudioTimeScale;

   578 

   579 	}

   580 	

   581     TAudFileProperties outProp = iMovie->Song()->OutputFileProperties();

   582     

   583     if (iMovie->Song()->ClipCount(KAllTrackIndices) > 0)

   584     {

   585         if ( outProp.iAudioType == EAudAAC_MPEG4)

   586         {

   587             iOutputAudioTimeScale = outProp.iSamplingRate;

   588                

   589         }    

   590     }    

   591 

   592 	streamParameters.iVideoFormat = (CComposer::TVideoFormat)iOutputVideoType;

   593 	streamParameters.iStreamBitrate = iMovie->VideoStandardBitrate();

   594 	iComposer->ComposeHeaderL(streamParameters, iOutputVideoTimeScale, iOutputAudioTimeScale, iAudioFramesInSample);

   595 

   596 	if( firstClipIsGenerated == 1 )

   597 	{

   598 		// since first clip is generated, destroy parser

   599 		iMonitor->PrepareComplete();

   600 		iMonitor->ProcessingStarted(iStartingProcessing);

   601 		iStartingProcessing = EFalse;

   602 		iState = EStateProcessing;

   603 		

   604 		// since first clip is generated, destroy parser

   605 		if(iAllGeneratedClips == 1)

   606 		{

   607 			if(iParser)

   608 			{	

   609 				delete iParser;

   610 				iParser =0;

   611 			}

   612 		}

   613 	}

   614 	    

   615     PRINT((_L("CMovieProcessorImpl::StartMovieL() end")))

   616 	

   617 }

   618 

   619 // -----------------------------------------------------------------------------

   620 // CMovieProcessorImpl::SetOutputMediaTypesL

   621 // Set output audio/video types

   622 // (other items were commented in a header).

   623 // -----------------------------------------------------------------------------

   624 //

   625 void CMovieProcessorImpl::SetOutputMediaTypesL()

   626 {

   627 

   628 	CVedMovieImp* movie = (iMovie);

   629 

   630 	if( movie->VideoType() == EVedVideoTypeH263Profile0Level10 )

   631 		iOutputVideoType = EVideoH263Profile0Level10;

   632 

   633 	else if ( movie->VideoType() == EVedVideoTypeH263Profile0Level45 )

   634 		iOutputVideoType = 	EVideoH263Profile0Level45;

   635 

   636 	else if ( movie->VideoType() == EVedVideoTypeMPEG4SimpleProfile )

   637 		iOutputVideoType = EVideoMPEG4;

   638 	

   639 #ifdef VIDEOEDITORENGINE_AVC_EDITING

   640     else if ( movie->VideoType() == EVedVideoTypeAVCBaselineProfile )

   641 		iOutputVideoType = EVideoAVCProfileBaseline;

   642 #endif

   643 

   644 	else 

   645 		User::Leave(KErrArgument);

   646 

   647 	CAudSong* songPointer = movie->Song();

   648 	if ( songPointer->ClipCount(KAllTrackIndices) > 0 )

   649 	    {

   650     	if( movie->AudioType() == EVedAudioTypeAMR )

   651     		iOutputAudioType = 	EAudioAMR;

   652 

   653     	else if ( movie->AudioType() == EVedAudioTypeAAC_LC )

   654     		iOutputAudioType = EAudioAAC;

   655     	else 

   656 	    	User::Leave(KErrArgument);

   657 	    }

   658     else

   659         {

   660         // no audio

   661         iOutputAudioType = EAudioNone;

   662         }

   663 

   664 }

   665 

   666 // -----------------------------------------------------------------------------

   667 // CMovieProcessorImpl::GetTranscodeFactorsL

   668 // Retrieve bitstream modes for input clips

   669 // (other items were commented in a header).

   670 // -----------------------------------------------------------------------------

   671 //

   672 void CMovieProcessorImpl::GetTranscodeFactorsL()

   673 {

   674 

   675 	if (!iNumberOfVideoClips)

   676 		return;

   677 

   678 	CVedMovieImp* movie = (iMovie);

   679 

   680 	iThumbnailInProgress = ETrue;	

   681 

   682 	InitializeClipStructuresL();

   683 

   684 	for(TInt i = 0; i < movie->VideoClipCount(); i++)

   685 	{

   686 		CVedVideoClip* currentClip = movie->VideoClip(i);

   687 		CVedVideoClipInfo* currentInfo = currentClip->Info();

   688 

   689 		if( currentInfo->Class() == EVedVideoClipClassFile )

   690 		{			

   691 			TVedTranscodeFactor factor;			

   692 

   693             if ( currentInfo->FileHandle() )

   694             {

   695                 iClipFileName.Zero();

   696                 iClipFileHandle = currentInfo->FileHandle();

   697             }

   698             else

   699             {

   700                 iClipFileHandle = NULL;

   701 			    iClipFileName = currentInfo->FileName();

   702             }

   703 			

   704 			InitializeClipL(); // opens the file & parses header

   705 			                   // open demux & decoder

   706 			                   

   707             // Calculate the number of frames in the output clip                   

   708 			iFrameParametersSize += iParser->GetNumberOfVideoFrames();			                   						

   709 

   710 			iState = EStateProcessing;

   711 

   712 			TInt error = iVideoProcessor->GetTranscodeFactorL(factor);

   713 

   714 			if (error != KErrNone)

   715 				User::Leave(error);

   716 			

   717 			if ( ((factor.iStreamType == EVedVideoBitstreamModeMPEG4Resyn)

   718 			    || (factor.iStreamType == EVedVideoBitstreamModeMPEG4DP)

   719 			    || (factor.iStreamType == EVedVideoBitstreamModeMPEG4DP_RVLC)

   720 			    || (factor.iStreamType == EVedVideoBitstreamModeMPEG4Resyn_DP)

   721 			    || (factor.iStreamType == EVedVideoBitstreamModeMPEG4Resyn_DP_RVLC))

   722 			    && ( currentClip->Info()->Resolution() == movie->Resolution() )

   723 			    && ( iOutputVideoType != EVideoAVCProfileBaseline ) )

   724 			    {

   725 			    // we do compressed domain transcoding for this clip, and it has 

   726 			    // other mpeg4 modes than the regular; we need to ensure the VOS/VOL header

   727 			    // has the resync marked flag enabled

   728 			    iMpeg4ModeTranscoded = ETrue;

   729 			    }

   730 

   731 			currentInfo->SetTranscodeFactor(factor);

   732 

   733 			DoCloseVideoL();  // close all

   734 			

   735 			if (iAvcEdit)

   736 			{

   737 			    delete iAvcEdit;

   738 			    iAvcEdit = 0;

   739 			}

   740 		}

   741 		else

   742 		{

   743             // Calculate the number of frames in the output clip 

   744 		    iFrameParametersSize += (TInt) currentInfo->VideoFrameCount();

   745 		}

   746 	}

   747 	

   748 	iThumbnailInProgress = EFalse;

   749 	iState = EStateIdle;

   750 }

   751 

   752 

   753 // -----------------------------------------------------------------------------

   754 // CMovieProcessorImpl::SetupTranscodingL

   755 // Set video transcoding parameters

   756 // (other items were commented in a header).

   757 // -----------------------------------------------------------------------------

   758 //

   759 void CMovieProcessorImpl::SetupTranscodingL()

   760 {

   761 

   762 	if (!iNumberOfVideoClips)

   763 		return;

   764 

   765 	CVedMovieImp* tmovie = (iMovie);

   766 	TBool transitionExists = EFalse;// Assume there are no middle transitions in any clip

   767 	TBool cutExists = EFalse;		// Assuming there is no cut in any clip	

   768 	TBool blackFrames = EFalse;     // Assume there is no need to encode black frames in the end

   769 	TBool firstClipIsGen = EFalse;

   770 	TBool firstClipIsFullTranscoded = EFalse;

   771 	TBool clipFullTranscodingExists = EFalse;

   772 

   773 	// Vos issues if first clip uses encoder

   774 	TBool atleastOneH263 = EFalse;

   775 	TBool atleastOneMPEG4 = EFalse;

   776 //	TBool atleastOneAVC = EFalse;

   777 	TBool differentModesExist = EFalse;

   778 

   779 	// initially assume no mpeg4 files so no streammode

   780 	TVedVideoBitstreamMode streamMode = EVedVideoBitstreamModeUnknown;

   781 	TBool atleastOneGenerated = EFalse; // assuming that there are no generated clips

   782 	TBool allGeneratedClips = ETrue; // asssuming all are generated

   783 	iModeTranslationRequired = EFalse;  // no need for translation in all generated

   784 	

   785 	TSize outputVideoResolution = tmovie->Resolution();	// since movie resolution is minimum resolution

   786 

   787 	for(TInt i = 0; i < tmovie->VideoClipCount(); i++)

   788 	{

   789 		CVedVideoClip* currentClip = tmovie->VideoClip(i);

   790 		CVedVideoClipInfo* currentInfo = currentClip->Info();

   791 		if( currentInfo->Class() == EVedVideoClipClassFile )

   792 		{

   793 			allGeneratedClips = EFalse;	// there is a file based clip

   794 			

   795 			if( (currentInfo->VideoType() == EVedVideoTypeH263Profile0Level10) ||

   796 				(currentInfo->VideoType() == EVedVideoTypeH263Profile0Level45) )

   797 			{

   798 				// if there is even one H263 output is H263

   799 				atleastOneH263 = ETrue;

   800 			}

   801 			else if(currentInfo->VideoType() == EVedVideoTypeAVCBaselineProfile)

   802 			{

   803 //				atleastOneAVC = ETrue;

   804 			}

   805 			else

   806 			{

   807 				if(currentInfo->VideoType() == EVedVideoTypeMPEG4SimpleProfile)	// if there is even one H263 output is H263

   808 				{

   809 					atleastOneMPEG4 = ETrue;

   810 					if(streamMode == EVedVideoBitstreamModeUnknown)

   811 					{	

   812 						// since previously no mpeg4 was found to set streammode	

   813 						streamMode = currentInfo->TranscodeFactor().iStreamType;

   814 					} 

   815 					else

   816 					{

   817 						if(streamMode != currentInfo->TranscodeFactor().iStreamType)  // different modes in Mpeg4

   818 							differentModesExist = ETrue;

   819 					}

   820 				}

   821 				else

   822 				{

   823 					//Error - improper or unsupported type file

   824 					User::Leave(KErrNotSupported);

   825 				}

   826 			}

   827 			

   828 			// Here check if any clip is cut and also if first clip is cut

   829 			TTimeIntervalMicroSeconds cutinTime = TTimeIntervalMicroSeconds(currentClip->CutInTime());

   830 			if(cutinTime != TTimeIntervalMicroSeconds(0)) 

   831 			{   

   832 				// cut does exist so encoder will be used in at least one clip

   833 				if(i==0) // which means cut exists in first clip itself

   834 				{					

   835 					iFirstClipIsCut = ETrue;

   836 				}

   837 				cutExists = ETrue;

   838 			}

   839 

   840 			// check if the clip will be full transcoded also as then we can 

   841 			// decide whether to change VOS bit and to set ModeTranslation as all would be encoded again

   842 			TSize currClipRes = currentInfo->Resolution();

   843 			if(  ( (outputVideoResolution.iWidth != currClipRes.iWidth) && 

   844                    (outputVideoResolution.iHeight != currClipRes.iHeight) ) ||

   845                  ( iOutputVideoType == EVideoMPEG4 && currentInfo->VideoType() == EVedVideoTypeAVCBaselineProfile ) )

   846 			{

   847 				if(i == 0)

   848 				{

   849 					firstClipIsFullTranscoded = ETrue;  //for VOS bit change

   850 				}

   851 				clipFullTranscodingExists = ETrue;

   852 			}

   853 		}

   854 		else

   855 		{

   856 			atleastOneGenerated = ETrue;

   857 			if(i == 0) // then first clip is generated

   858 			{

   859 				firstClipIsGen = ETrue;				

   860 			}

   861 		}

   862 

   863 		if( i != tmovie->VideoClipCount()-1 )

   864 		{

   865 			if(tmovie->MiddleTransitionEffect(i) != EVedMiddleTransitionEffectNone )					

   866 			{											

   867 				// this is required to check if any clips have

   868 				// middle transitions so mode translation will be required	

   869 				transitionExists = ETrue;  // even if all clips are of same mode

   870 			}

   871 		}

   872 	}

   873 

   874 	if( (TVedStartTransitionEffect)tmovie->StartTransitionEffect() != EVedStartTransitionEffectNone )

   875 	{	

   876 	    // even if all clips are of same mode but if it is different than what encoder uses transcoding is needed	

   877 		transitionExists = ETrue;			

   878 	}

   879 	

   880 	if( (TVedEndTransitionEffect)tmovie->EndTransitionEffect() != EVedEndTransitionEffectNone)

   881 	{

   882 	    // even if all clips are of same mode but if it is different than what encoder uses transcoding is needed

   883 		transitionExists = ETrue;

   884 	}

   885     if ( tmovie->Duration().Int64()/1000 > (tmovie->VideoClip(iNumberOfVideoClips-1)->EndTime().Int64()/1000) )

   886     {

   887         // movie is longer than video track => black frames are encoded in the end => even if all clips are of same mode but if it is different than what encoder uses transcoding is needed

   888         blackFrames = ETrue;

   889     }

   890 

   891 	if(iOutputVideoType == EVideoMPEG4)	// if different modes dont exist then if output is Mpeg4

   892 	{								

   893 		PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), output type = MPEG-4")))

   894 

   895 		if(differentModesExist)

   896 		{	

   897 			PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), different modes exist")))

   898 

   899 			// if there are differnet mode Mpeg4's then mode translation is required		

   900 			iModeTranslationRequired = ETrue;		// regardless of there being generated clips

   901 		}

   902 		else

   903 		{

   904 			PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), different modes don't exist")))

   905 

   906 			if(atleastOneGenerated) // if there are any generated clips

   907 			{							

   908 				PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), at least one generated")))

   909 

   910 				if(atleastOneMPEG4)		// if there is one Mpeg4 clip atleast	

   911 				{

   912 					PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), at least one MPEG-4")))

   913 

   914 					if( (streamMode == EVedVideoBitstreamModeMPEG4Regular) ) //generated clips mode will be regular so u need to convert others 

   915 					{	

   916 						PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), streamMode is regular")))

   917 

   918 						// if all are regular mode no need to change mode

   919 						iModeTranslationRequired = EFalse;

   920 					}

   921 					else

   922 					{									

   923 						PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), streamMode != regular")))

   924 

   925 						// to regular (with resync)

   926 						iModeTranslationRequired = ETrue;

   927 					}

   928 				}

   929 				else

   930 				{

   931 					if(atleastOneH263)

   932 					{

   933 						PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), at least one H.263")))

   934 						iModeTranslationRequired = ETrue;

   935 					}

   936 					else

   937 					{		

   938 						PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), all are generated")))

   939 						// all are generated no h263 or mpeg4

   940 						iModeTranslationRequired = EFalse;

   941 					}

   942 				}

   943 			}

   944 			else

   945 			{

   946 				PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), no generated clips")))

   947 

   948 				if(atleastOneH263)

   949 				{

   950 					PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), at least one H.263")))

   951 					iModeTranslationRequired = ETrue;

   952 				}

   953 				else

   954 				{

   955 					PRINT((_L("CMovieProcessorImpl::SetupTranscodingL(), no H.263")))

   956 					// still open if we have MPEG-4 nonregular + encoding

   957 					iModeTranslationRequired = EFalse;

   958 				}

   959 			}

   960 		}

   961 	}

   962 	else

   963 	{  

   964 		// output is H263 or AVC so mode translation not required

   965 		iModeTranslationRequired = EFalse;

   966 	}

   967 

   968 	// make decision of mode translation based on whether there 

   969 	// was a cut or transition or resolution transcoding in any clip

   970 

   971 	if(iOutputVideoType == EVideoMPEG4)	// if output is Mpeg4

   972 	{

   973 		if ((!allGeneratedClips) && (streamMode != EVedVideoBitstreamModeMPEG4Regular)) // in case of differentModesExist, iModeTranslationRequired is already ETrue

   974 	    {

   975 		    // If we need to encode smth but not all (if all generated => no mix), encoding results in regular stream. 

   976 		    // However, if input has nonregular, we need to translate the mode

   977 			if(transitionExists || clipFullTranscodingExists || cutExists || blackFrames) 

   978     			{

   979 				iModeTranslationRequired = ETrue;

   980 	    		}

   981 		}

   982 		// make Decision for changing the Vos of the output movie based on whether the first frame would be encoded

   983 		if(firstClipIsGen || firstClipIsFullTranscoded || ((TVedStartTransitionEffect)tmovie->StartTransitionEffect() != EVedStartTransitionEffectNone) || iFirstClipIsCut )

   984 		{	

   985 			iFirstClipUsesEncoder = ETrue;	// this indicates that you may need to change Vos bit but final decision is 

   986 		}									// done based on whether it was due to cut on the fly

   987 	}

   988 

   989 }

   990 

   991 

   992 

   993 

   994 // -----------------------------------------------------------------------------

   995 // CMovieProcessorImpl::CreateImage3GPFilesL

   996 // creates the necessary 3gp files from the given frames

   997 // (other items were commented in a header).

   998 // -----------------------------------------------------------------------------

   999 //

  1000 TInt CMovieProcessorImpl::CreateImage3GPFilesL(TVideoOperation aCreateMode)

  1001 {   

  1002 

  1003     if (iProcessingCancelled)

  1004         return KErrNone;

  1005 	

  1006 	if(aCreateMode == EVideoEncodeFrame) 

  1007 	{

  1008         // encode frame		

  1009 		TTimeIntervalMicroSeconds inMicroSeconds = TTimeIntervalMicroSeconds(iVideoClip->Info()->Generator()->VideoFrameStartTime(iTotalImagesProcessed));		

  1010 

  1011 		if (!IsActive())

  1012 		{

  1013 			SetActive();

  1014 			iStatus = KRequestPending;

  1015 		}

  1016 		iVideoEncoder->EncodeFrameL(iReadImageDes, iStatus, inMicroSeconds);

  1017 

  1018         // EncodeGiven

  1019         iImageEncodedFlag = 1;

  1020         iEncodeInProgress = 1;

  1021 		

  1022 		return KErrNone;		

  1023 	}

  1024 	else

  1025 	{	

  1026         // a frame has been encoded, write it to output 3gp buffer

  1027 

  1028 		// composer composing the movie

  1029 		if(iStatus == KErrNone)

  1030 		{

  1031 		    TBool isKeyFrame = 0;

  1032 			TPtrC8 buf(iVideoEncoder->GetBufferL(isKeyFrame));

  1033 			

  1034 			TBool modeChanged = EFalse;

  1035 			

  1036 			if ( iTotalImagesProcessed == 1 && iVideoType == EVideoMPEG4 )

  1037 			{

  1038 				modeChanged = ETrue;

  1039 			}

  1040 			

  1041 			/* composing is based on isIntra only */			

  1042 			TBool firstFrame = EFalse;

  1043 			if(iTotalImagesProcessed == 1)

  1044 			{

  1045 				firstFrame = ETrue;

  1046 

  1047 				// VOS header size is parsed in composer for MPEG-4

  1048 	            iMP4SpecificSize = 0;

  1049 			}

  1050 

  1051 			TInt64 durntTest = iVideoClip->Info()->Generator()->VideoFrameDuration(iTotalImagesProcessed-1).Int64();

  1052 			TInt64 durntsix = TInt64(((I64REAL(durntTest)/(TReal)1000)*(TReal) iImageVideoTimeScale) +0.5);

  1053 			TInt durnt = I64INT(durntsix);

  1054 			/* converting to ticks */

  1055 			durnt = (durnt)/1000;

  1056             

  1057             iGeneratedProcessed += durntTest/1000;            

  1058 			IncProgressBar();	/* indicate to gui about progress */

  1059 

  1060 			iImageComposer->WriteFrames((TDesC8&)buf, buf.Size(), durnt, isKeyFrame ,

  1061 				1/*numberOfFrames*/, CMP4Composer::EFrameTypeVideo, iMP4SpecificSize,modeChanged,

  1062 				firstFrame,iVideoClip->Info()->TranscodeFactor().iStreamType, ETrue);				

  1063 			

  1064 			iVideoEncoder->ReturnBuffer();

  1065 		}

  1066 		/* end composing */

  1067 		

  1068 		return KErrNone;

  1069 	}

  1070 }

  1071 

  1072 // -----------------------------------------------------------------------------

  1073 // CMovieProcessorImpl::ProcessImageSetsL

  1074 // Prepares for creating the necessary 3gp files from the given frames

  1075 // (other items were commented in a header).

  1076 // -----------------------------------------------------------------------------

  1077 //

  1078 TInt CMovieProcessorImpl::ProcessImageSetsL(TVideoOperation aCreateMode)

  1079 {

  1080 

  1081     if (iProcessingCancelled)

  1082         return KErrNone;

  1083 

  1084 	if(iTotalImagesProcessed == 0 && iImageEncodeProcFinished == 0)

  1085 	{		

  1086 		TFileName outputFileName = TPtrC(KTempFilePath);

  1087 		iCurrentMovieName = outputFileName;

  1088 		iCurrentMovieName.Append( _L( "Im" ) );

  1089 		iCurrentMovieName.Append( _L( "_nokia_vpi.tmp" ) );

  1090 		

  1091 #ifdef _DEBUG

  1092         if (iOutputVideoType == EVideoAVCProfileBaseline)

  1093 		    VPASSERT(iImageAvcEdit);

  1094 #endif

  1095 

  1096 		iImageComposer = CMP4Composer::NewL(iCurrentMovieName, (CParser::TVideoFormat)iOutputVideoType,

  1097 			                                CParser::EAudioFormatNone,

  1098 			                                iImageAvcEdit);

  1099 

  1100 		CComposer::TStreamParameters innerStreamParameters;

  1101 		/* there will be no video clips initially, so initialize to default parameters of movie */

  1102 		TSize innerRes =(TSize)iVideoClip->Info()->Resolution(); /* resolution from generator */

  1103 		innerStreamParameters.iVideoWidth = innerRes.iWidth;      /* iVideoParameters.iWidth */

  1104 		innerStreamParameters.iVideoHeight = innerRes.iHeight;    /* iVideoParameters.iHeight */;

  1105 		/* width and height are initialised to the proper values from the clip */

  1106 		innerStreamParameters.iStreamBitrate = 25000 /* iStreamBitrate */;

  1107 		

  1108 		/* set the duration of the video clip */

  1109 		TTimeIntervalMicroSeconds iTempVideoLength= TTimeIntervalMicroSeconds(iVideoClip->Info()->Duration());

  1110 		TInt64  iTimeInMicro = (iTempVideoLength.Int64()/1000);

  1111 		innerStreamParameters.iVideoLength= I64INT(iTimeInMicro);       /* set the video length properly */

  1112 		innerStreamParameters.iStreamLength= I64INT(iTimeInMicro);

  1113 		innerStreamParameters.iAudioLength = 0;                         

  1114 		innerStreamParameters.iAudioFormat = (CComposer::TAudioFormat)0;

  1115 		CVedMovieImp* tempm = (iMovie);    

  1116 

  1117 		if(iOutputVideoType == EVideoMPEG4)		

  1118 		{

  1119 			/* initialize to default constants for generated clips in case of MPEG-4 */

  1120 			innerStreamParameters.iVideoFormat = (CComposer::TVideoFormat) CComposer::EVideoFormatMPEG4;

  1121 			TVedTranscodeFactor tempFact;

  1122 			tempFact.iStreamType = EVedVideoBitstreamModeMPEG4Regular;

  1123 			tempFact.iTRes = 29;

  1124 			CVedVideoClip* currentClip = tempm->VideoClip(iVideoClipNumber);

  1125 			CVedVideoClipInfo* currentInfo = currentClip->Info();

  1126 			currentInfo->SetTranscodeFactor(tempFact);			/* set to default values, as initialized above */

  1127 		}

  1128 		else if ( (iOutputVideoType == EVideoH263Profile0Level10) ||

  1129 				  (iOutputVideoType == EVideoH263Profile0Level45) )

  1130 		{

  1131 		

  1132 			innerStreamParameters.iVideoFormat = (CComposer::TVideoFormat)iOutputVideoType;

  1133 		    /* initialize to default constants for generated clips in case of H.263 */

  1134 			TVedTranscodeFactor tempFact;

  1135 			tempFact.iStreamType = EVedVideoBitstreamModeH263;