1 /*

     2 * Copyright (c) 2009 Aricent 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 "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Aricent - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 * This is a source file, required for arih264dechwdevice

    16 *

    17 */

    18 

    19 //User includes

    20 #include "arih264dechwdevice.h"

    21 #include "arih264decwrapper.h"

    22 #include "aristatemachine.h"

    23 #include "ariprint.h"

    24 

    25 //

    26 //CAriH264decHwDevice

    27 //

    28 

    29 _LIT( KManufacturer, "Aricent" );

    30 

    31 _LIT( KIdentifier, "H264 Video Decoder" );

    32 

    33 //supported h264 mime types

    34 _LIT8( KH264SupportedMimeType, "video/H264" );

    35 

    36 

    37 //---------------------------------------------------------------------------

    38 //1st phase constructor of CAriH264decHwDevice

    39 //---------------------------------------------------------------------------

    40 //

    41 CMMFVideoDecodeHwDevice* CAriH264decHwDevice::NewL()

    42 	{

    43 	PRINT_ENTRY;

    44 	CAriH264decHwDevice* self = new ( ELeave ) CAriH264decHwDevice;

    45 	CleanupStack::PushL( self );

    46 	self->ConstructL();

    47 	CleanupStack::Pop();

    48 	PRINT_EXIT;

    49 	return self;

    50 	}

    51 

    52 //---------------------------------------------------------------------------

    53 //Destructor

    54 //---------------------------------------------------------------------------

    55 //

    56 CAriH264decHwDevice::~CAriH264decHwDevice()

    57 	{

    58 	PRINT_ENTRY;

    59 	delete iInputFormat;

    60 	delete iEngine;

    61 	delete iCodec;

    62 	delete iState;

    63 

    64     delete iVideoPictureHeader;

    65 

    66 	// This is required becoz user may say exit before start at that point

    67 	// OutputFreeBuffer is not created

    68 	if ( iOutputFreeBuffer )

    69 		{

    70 		for( TInt i = 0 ; i < KMaxOutputBuffers; i++ )

    71 			{

    72             if ( ( iOutputFreeBuffer + i )->iHeader )

    73                 {

    74 			    delete ( iOutputFreeBuffer + i )->iHeader;

    75                 }

    76 			if ( ( iOutputFreeBuffer + i )->iData.iRawData )

    77 				{

    78 				delete

    79 				( TUint8* )( iOutputFreeBuffer + i )->iData.iRawData->Ptr();

    80 				}

    81             if ( ( iOutputFreeBuffer + i )->iData.iRawData )

    82                 {

    83 			    delete ( iOutputFreeBuffer + i )->iData.iRawData;

    84                 }

    85 			}

    86 		delete [] iOutputFreeBuffer;

    87 		}

    88 

    89 	if ( iInputFreeBuffers )

    90 		{

    91 		for ( TInt i = 0 ; i < iBufferOptions.iMinNumInputBuffers; i++ )

    92 			{

    93 			delete [] ( TUint8* )iInputFreeBuffers[i].iData.Ptr();

    94 			delete iInputFreeBuffers[i].iUser;

    95 			}

    96 		delete [] iInputFreeBuffers;

    97 		}

    98 

    99 	if ( iCustomBufferOptions )

   100 		{

   101 		delete iCustomBufferOptions;

   102 		}

   103 

   104     iOutputFreeBufferQueue.Close();

   105 	iInputFreeBufferQueue.Close();

   106 

   107 	iMaxPictureRates.Reset();

   108 	iMaxPictureRates.Close();

   109 	iSupportedFormats.Reset();

   110 	iSupportedFormats.Close();

   111 

   112     iOutputDevice = NULL;

   113     iMMFDevVideoPlayProxy = NULL;

   114     iCustomBufferHandle = NULL;

   115 

   116 	PRINT_EXIT;

   117     }

   118 //---------------------------------------------------------------------------

   119 //Retrieves a custom interface to the device.

   120 //---------------------------------------------------------------------------

   121 //

   122 TAny* CAriH264decHwDevice::CustomInterface( TUid /*aInterface*/ )

   123 	{

   124 	PRINT_ENTRY;

   125 	PRINT_EXIT;

   126 	return NULL;

   127 	}

   128 

   129 //---------------------------------------------------------------------------

   130 //Retrieves decoder information about this hardware device. The device

   131 //creates a CVideoDecoderInfo structure, fills it with correct data,

   132 //pushes it to the cleanup stack and returns it. The client will delete the

   133 //object when it is no longer needed.

   134 //---------------------------------------------------------------------------

   135 //

   136 CVideoDecoderInfo* CAriH264decHwDevice::VideoDecoderInfoLC()

   137 	{

   138     PRINT_ENTRY;

   139 

   140     // construct the video types for iVidTypes

   141 	CCompressedVideoFormat* format = NULL;

   142 	format = CCompressedVideoFormat::NewL( KH264SupportedMimeType );

   143 	CleanupStack::PushL(format);

   144 	TInt status = iSupportedFormats.Append( format );

   145 	if ( status != KErrNone )

   146 		{

   147 		PRINT_MSG( LEVEL_LOW, ( " Format support is not done, retval of "

   148 				"append = %d \n", status ) );

   149 		}

   150 	CleanupStack::Pop( format );

   151 

   152     for ( TUint i = 0; i < KDecoderInfoCount; i++ )

   153 		{

   154 		// max picture rates

   155 		TPictureRateAndSize pictureRateAndSize;

   156 		pictureRateAndSize.iPictureSize = TSize( KMaxFrameWidth,

   157 				                                KMaxFrameHeight );

   158 		pictureRateAndSize.iPictureRate = KPicRate;

   159 		status = iMaxPictureRates.Append(pictureRateAndSize);

   160 		if ( status != KErrNone )

   161 			{

   162 			PRINT_MSG( LEVEL_LOW, ( " error in appendng picturerates = %d \n",

   163 					status ) );

   164 			}

   165 		}

   166     TUint maxBitRate = KMaxBitRate;

   167 	CVideoDecoderInfo* videoDecoderInfo = CVideoDecoderInfo::NewL(

   168             KUidH264DecoderHwDevice,

   169             KManufacturer,

   170             KIdentifier,

   171             TVersion( 1, 0, 0 ),

   172             iSupportedFormats.Array(),

   173             // Non-Accelerated

   174             EFalse,

   175             // Doesnt support Direct Display

   176             EFalse,

   177             TSize( KMaxFrameWidth, KMaxFrameHeight ),

   178             maxBitRate,

   179             iMaxPictureRates.Array(),

   180             //decoder supports picture loss indications

   181             ETrue,

   182             //decoder supports slice loss indications

   183             ETrue );

   184 

   185     CleanupStack::PushL( videoDecoderInfo );

   186 

   187     PRINT_MSG( LEVEL_LOW, ( "Closing maxPictureRates&supportedFormats\n" ) );

   188 

   189     PRINT_EXIT;

   190 

   191     return videoDecoderInfo;

   192 	}

   193 

   194 //---------------------------------------------------------------------------

   195 //Reads header information from a coded data unit.

   196 //---------------------------------------------------------------------------

   197 //

   198 TVideoPictureHeader* CAriH264decHwDevice::GetHeaderInformationL(

   199 								TVideoDataUnitType /*aDataUnitType*/,

   200 								TVideoDataUnitEncapsulation aEncapsulation,

   201 								TVideoInputBuffer* aDataUnit )

   202 	{

   203 	PRINT_ENTRY;

   204     if (!aDataUnit )

   205 	    {

   206 	    PRINT_ERR( "Input argument is not proper, aDataUnit is null \n" );

   207 		User::Leave( KErrArgument );

   208 		}

   209 

   210     if ( aEncapsulation != EDuElementaryStream )

   211     	{

   212     	PRINT_ERR( "aEncapsulation is not supported type \n" );

   213         User::Leave( KErrNotSupported );

   214     	}

   215 

   216     iVideoPictureHeader = new ( ELeave ) TVideoPictureHeader;

   217 

   218 	TRAPD( err, CAriH264decWrapper::GetHeaderInfoL( *aDataUnit,

   219 													*iVideoPictureHeader ) );

   220 

   221     if ( err == KErrNone )

   222     	{

   223     	PRINT_EXIT;

   224         return ( iVideoPictureHeader );

   225     	}

   226 

   227     // An error has occured

   228     delete iVideoPictureHeader;

   229     iVideoPictureHeader = NULL;

   230 

   231     switch ( err )

   232         {

   233         case KErrCorrupt:

   234         case KErrNoMemory:

   235         case KErrArgument:

   236         case KErrNotSupported:

   237             {

   238             PRINT_ERR( "GetHeaderInfoL is returned with error \n" );

   239             User::Leave( err );

   240             break;

   241             }

   242         case KErrUnderflow:

   243             {

   244             PRINT_ERR( "GetHeaderInfoL returnd with error KErrUnderflow\n" );

   245             break;

   246             }

   247         default:

   248             {

   249             PRINT_ERR( "GetHeaderInfoL is returned with error \n" );

   250             User::Leave( KErrGeneral );

   251             }

   252         };

   253 

   254     PRINT_EXIT;

   255 	return NULL;

   256 	}

   257 

   258 //---------------------------------------------------------------------------

   259 //Returns a header from GetHeaderInformationL() back to the decoder so that

   260 //the memory can be freed.

   261 //---------------------------------------------------------------------------

   262 //

   263 void CAriH264decHwDevice::ReturnHeader( TVideoPictureHeader* aHeader )

   264 	{

   265 	PRINT_ENTRY;

   266 	if ( !iState->IsInitialized() )

   267 		{

   268 		if ( iVideoPictureHeader == aHeader )

   269 			{

   270 			delete iVideoPictureHeader;

   271             iVideoPictureHeader = NULL;

   272 			}

   273 		else

   274 			{

   275 			iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrArgument );

   276 			}

   277 		}

   278 	else

   279 		{

   280 		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   281 		}

   282 	PRINT_EXIT;

   283 	}

   284 

   285 //---------------------------------------------------------------------------

   286 //Sets the device input format to a compressed video format.

   287 //---------------------------------------------------------------------------

   288 //

   289 void CAriH264decHwDevice::SetInputFormatL(

   290 								const CCompressedVideoFormat& aFormat,

   291 								TVideoDataUnitType aDataUnitType,

   292 								TVideoDataUnitEncapsulation aEncapsulation,

   293 								TBool aDataInOrder )

   294 	{

   295 	PRINT_ENTRY;

   296 	if ( !iState->IsInitialized() )

   297 		{

   298 		if ( ( !aDataInOrder ) ||

   299              ( aEncapsulation == EDuGenericPayload ) ||

   300              ( aEncapsulation == EDuRtpPayload ) )

   301              User::Leave( KErrNotSupported );

   302 

   303 		if ( ( aFormat.MimeType().FindF( KH264SupportedMimeType ) !=

   304 															 KErrNotFound ) )

   305 

   306 			{

   307 			iInputFormat = CCompressedVideoFormat::NewL( aFormat );

   308 			iDataUnitType  = aDataUnitType;

   309 			iEncapsulation = aEncapsulation;

   310 			}

   311 		else

   312 			{

   313 			PRINT_ERR( "aFormat is not supported \n" );

   314 			User::Leave( KErrNotSupported );

   315 			}

   316 		}

   317 	else

   318 		{

   319 		PRINT_ERR( "istate is not initialized yet\n" );

   320 		User::Leave( KErrNotReady );

   321 		}

   322 	PRINT_EXIT;

   323 	}

   324 

   325 //---------------------------------------------------------------------------

   326 //Sets whether decoding should be synchronized to the current clock source,

   327 //if any, or if pictures should instead be decoded as soon as possible.

   328 //If decoding is synchronized, decoding timestamps are used if available,

   329 //presentation timestamps are used if not. When decoding is not synchronized,

   330 //pictures are decoded as soon as source data is available for them, and the

   331 //decoder has a free output buffer. If a clock source is not available,

   332 //decoding will not be synchronized.

   333 //---------------------------------------------------------------------------

   334 //

   335 void CAriH264decHwDevice::SynchronizeDecoding( TBool /*aSynchronize*/ )

   336 	{

   337 	PRINT_ENTRY;

   338 	PRINT_EXIT;

   339 	return;

   340 	}

   341 

   342 

   343 //---------------------------------------------------------------------------

   344 //Sets the Buffer Options as specified by the client.

   345 //---------------------------------------------------------------------------

   346 //

   347 void CAriH264decHwDevice::SetBufferOptionsL(

   348 						const CMMFDevVideoPlay::TBufferOptions& aOptions )

   349 	{

   350 	PRINT_ENTRY;

   351 	if ( !iState->IsInitialized() )

   352 		{

   353 		TTimeIntervalMicroSeconds zerotime( 0 );

   354         if ( ( aOptions.iMinNumInputBuffers < KMinInputBuffers ) ||

   355              ( aOptions.iPreDecodeBufferSize != 0 ) ||

   356              ( aOptions.iMaxPostDecodeBufferSize != 0 ) ||

   357              ( aOptions.iPreDecoderBufferPeriod != zerotime ) ||

   358              ( aOptions.iPostDecoderBufferPeriod != zerotime ) )

   359         	{

   360             User::Leave( KErrArgument );

   361         	}

   362 

   363 		if ( ( aOptions.iMinNumInputBuffers > KMaxInputBuffers ) ||

   364                ( aOptions.iMaxInputBufferSize > KMaxInputBufferSize ) )

   365 			{

   366 		    User::Leave( KErrNotSupported );

   367 			}

   368 

   369 		iBufferOptions = aOptions;

   370 		}

   371 	else

   372 		{

   373 		PRINT_ERR( "istate is not initialized yet\n" );

   374 		User::Leave( KErrNotReady );

   375 		}

   376 	PRINT_EXIT;

   377 	}

   378 

   379 //---------------------------------------------------------------------------

   380 //Gets the video decoder buffer options actually in use.

   381 //---------------------------------------------------------------------------

   382 //

   383 void CAriH264decHwDevice::GetBufferOptions(

   384 								 CMMFDevVideoPlay::TBufferOptions& aOptions )

   385 	{

   386 	PRINT_ENTRY;

   387 	if ( !iState->IsInitialized() )

   388 		{

   389 		aOptions = iBufferOptions;

   390 		}

   391 	else

   392 		{

   393 		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   394 		}

   395 	PRINT_EXIT;

   396 	}

   397 

   398 //---------------------------------------------------------------------------

   399 //Indicates which HRD/VBV specification is fulfilled in the input stream and

   400 //any related parameters.

   401 //---------------------------------------------------------------------------

   402 //

   403 void CAriH264decHwDevice::SetHrdVbvSpec(

   404 										THrdVbvSpecification /*aHrdVbvSpec*/,

   405 										const TDesC8& /*aHrdVbvParams*/ )

   406 	{

   407 	PRINT_ENTRY;

   408 	PRINT_EXIT;

   409 	iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotSupported );

   410 	}

   411 

   412 //---------------------------------------------------------------------------

   413 //Sets the output post-processor device to use.

   414 //---------------------------------------------------------------------------

   415 //

   416 void CAriH264decHwDevice::SetOutputDevice(

   417 										 CMMFVideoPostProcHwDevice* aDevice )

   418 	{

   419 	PRINT_ENTRY;

   420 	if ( !iState->IsInitialized() )

   421 		{

   422 		if ( !aDevice )

   423 			{

   424 			iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrArgument );

   425 			}

   426 		else

   427 			{

   428 			iOutputDevice = aDevice;

   429 

   430 			// checks whether customBuffer supported by o/p device

   431 			iCustomBufferHandle = ( MMmfVideoBufferManagement* )

   432 	      ( iOutputDevice->CustomInterface( KMmfVideoBuffermanagementUid ) );

   433 			}

   434 		}

   435 	else

   436 		{

   437 		PRINT_ERR( "istate is not initialized yet, "

   438 						"calling MdvppFatalError on iMMFDevVideoPlayProxy\n" );

   439 		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   440 		}

   441 	PRINT_EXIT;

   442 	}

   443 

   444 //---------------------------------------------------------------------------

   445 //Returns the current decoding position, i.e.

   446 //the timestamp for the most recently decoded picture.

   447 //---------------------------------------------------------------------------

   448 //

   449 TTimeIntervalMicroSeconds CAriH264decHwDevice::DecodingPosition()

   450 	{

   451 	PRINT_ENTRY;

   452 	if ( iState->IsInitialized() )

   453 		{

   454 		PRINT_EXIT;

   455 		return iDecodingPosition;

   456 		}

   457 	else

   458 		{

   459 		PRINT_ERR( "iState is not initialised, calling  MdvppFatalError\n" );

   460 		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   461 		return ( TTimeIntervalMicroSeconds( 0 ) );

   462 		}

   463 	}

   464 

   465 //---------------------------------------------------------------------------

   466 //Returns the current pre-decoder buffer size.

   467 //---------------------------------------------------------------------------

   468 //

   469 TUint CAriH264decHwDevice::PreDecoderBufferBytes()

   470 	{

   471 	PRINT_ENTRY;

   472     if ( !( iState->IsInitialized() ) )

   473         {

   474         iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   475 		return ( 0 );

   476         }

   477 

   478     PRINT_EXIT;

   479     return 0;

   480 	}

   481 

   482 //---------------------------------------------------------------------------

   483 //Reads various counters related to the received input bitstream

   484 //and coded data units.

   485 //---------------------------------------------------------------------------

   486 //

   487 void CAriH264decHwDevice::GetBitstreamCounters(

   488 							CMMFDevVideoPlay::TBitstreamCounters& aCounters )

   489 	{

   490 	PRINT_ENTRY;

   491 	if ( iState->IsInitialized() )

   492 		{

   493 		aCounters = iBitstreamCounters;

   494 		//Reset the counters to Zero

   495 		iBitstreamCounters.iLostPackets = 0;

   496 		iBitstreamCounters.iTotalPackets = 0;

   497 		}

   498 	else

   499 		{

   500 		PRINT_ERR( "iState is not initialised, calling  MdvppFatalError\n" );

   501 		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   502 		}

   503 	PRINT_EXIT;

   504 	}

   505 

   506 //---------------------------------------------------------------------------

   507 //Retrieves the number of free input buffers the decoder has available

   508 //---------------------------------------------------------------------------

   509 //

   510 TUint CAriH264decHwDevice::NumFreeBuffers()

   511 	{

   512 	PRINT_ENTRY;

   513 	if ( iState->IsInitialized() )

   514 		{

   515 		if ( iNumberOfInputBuffersAllocated == 0 )

   516 		    {

   517 		    PRINT_EXIT;

   518 		    return ( iBufferOptions.iMinNumInputBuffers );

   519 		    }

   520 		else

   521 		    {

   522 		    PRINT_EXIT;

   523 		    return  ( iInputFreeBufferQueue.Count() );

   524 		    }

   525 		}

   526 	else

   527 		{

   528 		PRINT_ERR( "iState is not initialised, calling  MdvppFatalError\n" );

   529 		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   530 		return( 0 );

   531 		}

   532 	}

   533 

   534 //---------------------------------------------------------------------------

   535 //Returns an input buffer of size aBufferSize. If no buffer is available

   536 //then NULL is returned.

   537 //---------------------------------------------------------------------------

   538 //

   539 TVideoInputBuffer* CAriH264decHwDevice::GetBufferL( TUint aBufferSize )

   540 	{

   541 	PRINT_ENTRY;

   542 	if ( !( iState->IsInitialized() ) )

   543         {

   544         PRINT_ERR( "istate is not initialized yet\n" );

   545         User::Leave( KErrNotReady );

   546 		return NULL;

   547         }

   548 

   549     if ( iState->IsInputEndPending() )

   550 	    {

   551 	    PRINT_ERR( "input is pending\n" );

   552 		User::Leave( KErrNotReady );

   553 		return NULL;

   554 	    }

   555 

   556     if ( aBufferSize > iBufferOptions.iMaxInputBufferSize )

   557         {

   558         PRINT_ERR( "aBufferSize is more than the allowed size\n" );

   559         User::Leave( KErrArgument );

   560         return NULL;

   561         }

   562 

   563 

   564 	TVideoInputBuffer *inBuffer;

   565 

   566     if ( iNumberOfInputBuffersAllocated ==

   567 									     iBufferOptions.iMinNumInputBuffers )

   568         {

   569         if ( iInputFreeBufferQueue.Count() )

   570             {

   571             PRINT_ERR( "CreateInputBufferL returned ETRUE\n" );

   572             // Reallocate the input buffer if needed

   573 			CreateInputBufferL( aBufferSize, ETrue );

   574 			inBuffer = iInputFreeBufferQueue[0];

   575 			iInputFreeBufferQueue.Remove( 0 );

   576 

   577             }

   578         else

   579             {

   580             PRINT_ERR( "No input free buffers available \n" );

   581             return NULL;

   582             }

   583         }

   584     else if ( iNumberOfInputBuffersAllocated <

   585 										 iBufferOptions.iMinNumInputBuffers )

   586         {

   587         PRINT_ERR( "CreateInputBufferL returned EFALSE\n" );

   588         // Allocate new buffer of the requested size

   589         CreateInputBufferL( aBufferSize, EFalse );

   590 

   591         // remove the last created buffer

   592         inBuffer = iInputFreeBufferQueue[ iInputFreeBufferQueue.Count() - 1];

   593 

   594         iInputFreeBufferQueue.Remove( iInputFreeBufferQueue.Count() - 1 );

   595         }

   596     else

   597         {

   598         PRINT_ERR( "iNumberOfInputBuffersAllocated is less "

   599                 		"			iBufferOptions.iMinNumInputBuffers\n" );

   600         User::Leave( KErrGeneral ); // unwanted state;

   601         return NULL;

   602         }

   603 

   604     PRINT_EXIT;

   605 	return inBuffer;

   606 	}

   607 

   608 

   609 //---------------------------------------------------------------------------

   610 //Called by DevVideoPlay to write the coded data.

   611 //Writes a piece of coded video data to the decoder. The data buffer must

   612 //be retrieved from the decoder with GetBufferL()..

   613 //---------------------------------------------------------------------------

   614 //

   615 void CAriH264decHwDevice::WriteCodedDataL( TVideoInputBuffer* aBuffer )

   616 	{

   617 	PRINT_ENTRY;

   618 	if ( !iState->IsInitialized() )

   619 		{

   620 		PRINT_ERR( "istate is not initialized yet \n" );

   621 		User::Leave( KErrNotReady );

   622 		}

   623 

   624     if ( !aBuffer )

   625 		{

   626 		PRINT_ERR( "aBuffer is null \n" );

   627 		User::Leave( KErrArgument );

   628 		}

   629 

   630     if ( aBuffer->iData.Length() == 0 )

   631 	    {

   632 	    PRINT_ERR( "length of aBuffer is zero \n" );

   633 		User::Leave( KErrArgument );

   634 	    }

   635 

   636 	if ( iState->IsInputEndPending() )

   637 		{

   638 		PRINT_ERR( "IsInputEndPending is true \n" );

   639 		User::Leave( KErrEof );

   640 		}

   641 

   642 	if ( !iCodec )

   643 		{

   644 		iCodec = CAriH264decWrapper::NewL( iDataUnitType,

   645 				                           iOutputFormat,

   646 				                           &aBuffer->iData,

   647 				                           iStreamType );

   648 

   649 		iDecoderConfigured = ETrue;

   650 		}

   651 

   652 	if ( ( iDataUnitType == EDuSeveralSegments ) ||

   653 		 ( iDataUnitType == EDuVideoSegment ) )

   654 		{

   655 		iBitstreamCounters.iTotalPackets++;

   656 		}

   657 

   658 	// if custom interface is supported by o/p device get all the buffers

   659 	//and add it to Engine

   660 	if ( !iOutputBuffersCreated )

   661 		{

   662 		// Set Stream information

   663 		if ( !iDecoderConfigured )

   664 			{

   665 			User::Leave( KErrNotReady );

   666 			}

   667 

   668     	if ( !iCustomBufferHandle )

   669     		{

   670 			// Get o/p buffer length for creation

   671 			iCodec->GetParam( CONTROL_CMD_GET_OUTPUTBUFFERLENGTH,

   672 							  ( TAny* )&iOutputBufferSize );

   673 			CreateOutputBuffersL();

   674     		}

   675 		iOutputBuffersCreated = ETrue;

   676 		}

   677 

   678 	// add all the o/p buffers to engine

   679 	if ( !iBufferAdded )

   680 		{

   681 		if ( iCustomBufferHandle )

   682 			{

   683 			TVideoPicture* videoPicture = NULL;

   684 			for ( TInt i = 0;

   685 				  i < iCustomBufferOptions->iNumInputBuffers;

   686 				  i++ )

   687 				{

   688 				videoPicture =

   689 				iCustomBufferHandle->MmvbmGetBufferL(

   690 									     iCustomBufferOptions->iBufferSize );

   691 				if ( videoPicture )

   692 					{

   693 					TRAPD( lErr, videoPicture->iHeader =

   694 									new ( ELeave ) TVideoPictureHeader ) ;

   695 					if ( lErr != KErrNone )

   696                     	{

   697                     	iCustomBufferHandle->MmvbmReleaseBuffer(

   698 															  videoPicture );

   699                     	iMMFDevVideoPlayProxy->MdvppFatalError( this,

   700 															  KErrArgument );

   701                     	}

   702                     else

   703                     	{

   704 					    iEngine->AddOutput( videoPicture );

   705                     	}

   706 					}

   707 				else

   708 					{

   709 					break;

   710 					}

   711 				}

   712 			}

   713 		else

   714 			{

   715 			for( TInt i = 0; i < iOutputFreeBufferQueue.Count(); i++ )

   716 				{

   717 				iEngine->AddOutput( iOutputFreeBufferQueue[0] );

   718 				iOutputFreeBufferQueue.Remove( 0 );

   719 				}

   720 			}

   721 		iBufferAdded = ETrue;

   722 		}

   723 

   724 	iPictureCounters.iTotalPictures++;

   725 	iFilledBufferCounter++;

   726 	TInt err = iEngine->AddInput( aBuffer );

   727 	PRINT_MSG( LEVEL_LOW, ( "WriteCodedDataL, addinput err=%d", err ) );

   728 	PRINT_EXIT;

   729 	}

   730 

   731 //---------------------------------------------------------------------------

   732 //Configures the H264 decoder by passing the required header

   733 //information for the stream that is getting decoded. The header

   734 //structurespecific  to the Decoder is passed as iOptional member.

   735 //---------------------------------------------------------------------------

   736 //

   737 #ifdef SYMBIAN_MDF_API_V2

   738 void CAriH264decHwDevice::ConfigureDecoderL(

   739 							 const TVideoPictureHeader& aVideoPictureHeader )

   740 	{

   741 	PRINT_ENTRY;

   742 	if ( iState->IsInitialized() )

   743 		{

   744 		PRINT_ERR( "iState is already initialised \n" );

   745 		User::Leave( KErrNotReady );

   746 		}

   747 	if ( !iCodec )

   748 		{

   749 		iCodec = CAriH264decWrapper::NewL( iDataUnitType,

   750 				                       iOutputFormat,

   751 				                       aVideoPictureHeader.iOptional,

   752 				                       iStreamType );

   753 

   754 		if ( !iCodec )

   755 			{

   756 			PRINT_ERR( "codec wrapper returned error \n" );

   757 			User::Leave( KErrNotReady );

   758 			}

   759 		iDecoderConfigured = ETrue;

   760 	    iConfigureDecoderCalled = ETrue;

   761 		}

   762 

   763 	iWidthSource = aVideoPictureHeader.iSizeInMemory.iWidth;

   764 	iHeightSource = aVideoPictureHeader.iSizeInMemory.iHeight;

   765 	PRINT_EXIT;

   766 	}

   767 #endif

   768 

   769 

   770 

   771 //---------------------------------------------------------------------------

   772 //Retrieves post-processing information about this hardware device.

   773 //The device creates a CPostProcessorInfo structure, fills it with correct

   774 //data, pushes it to the cleanup stack and returns it. The client will

   775 //delete the object when it is no longer needed.

   776 //---------------------------------------------------------------------------

   777 //

   778 CPostProcessorInfo* CAriH264decHwDevice::PostProcessorInfoLC()

   779 	{

   780 	PRINT_ENTRY;

   781 	//Aricent decoder does not support any post processing functionality

   782 	RArray<TUncompressedVideoFormat> supportedFormats;

   783 	CleanupClosePushL( supportedFormats );

   784 

   785 	RArray<TUint32> supportedCombinations;

   786 	CleanupClosePushL( supportedCombinations );

   787 

   788 	TYuvToRgbCapabilities yuvToRgbCapabilities;

   789 	RArray<TScaleFactor> supportedScaleFactors;

   790 	CleanupClosePushL( supportedScaleFactors );

   791 

   792 	CPostProcessorInfo* info = CPostProcessorInfo::NewL(

   793 		KUidH264DecoderHwDevice,

   794 		KManufacturer,

   795 		KIdentifier,

   796 		TVersion( 1, 0, 0 ),

   797 		supportedFormats.Array(),

   798 		supportedCombinations.Array(),

   799 		EFalse, //Accelerated or not

   800 		EFalse, //supports DSA

   801 		yuvToRgbCapabilities,

   802 		ERotateNone, //supported rotations

   803 		EFalse, //supports Arbitrary scaling

   804 		supportedScaleFactors.Array(),

   805 		EFalse ) //supports antialiased scaling

   806         ;

   807 

   808 	CleanupStack::PushL( info );

   809 

   810 	CleanupStack::Pop( &supportedScaleFactors );

   811 	supportedScaleFactors.Close();

   812 	CleanupStack::Pop( &supportedCombinations );

   813 	supportedCombinations.Close();

   814 	CleanupStack::Pop( &supportedFormats );

   815 	supportedFormats.Close();

   816 

   817 	PRINT_EXIT;

   818 	return info;

   819 	}

   820 

   821 //---------------------------------------------------------------------------

   822 //Retrieves the list of the output formats that the device supports.

   823 //The list can depend on the device source format, and therefore

   824 //SetSourceFormatL() must be called before calling this method.

   825 //---------------------------------------------------------------------------

   826 //

   827 void CAriH264decHwDevice::GetOutputFormatListL(

   828 								 RArray<TUncompressedVideoFormat>& aFormats )

   829 	{

   830 	PRINT_ENTRY;

   831     if ( iState->IsInitialized() )

   832     	{

   833     	PRINT_ERR( "iState is already initialised \n" );

   834         User::Leave( KErrNotReady );

   835     	}

   836 

   837     if ( !iInputFormat )

   838 	    {

   839 		//Input format should be set before calling this function, as output

   840         // format is decided based on input format

   841 	    PRINT_ERR( "iInputFormat is not set yet \n" );

   842 		User::Leave( KErrNotReady );

   843 	    }

   844 

   845 	TUncompressedVideoFormat format;

   846 	format.iDataFormat = EYuvRawData;

   847 	format.iYuvFormat.iYuv2RgbMatrix = NULL;

   848 	format.iYuvFormat.iRgb2YuvMatrix = NULL;

   849 	format.iYuvFormat.iAspectRatioNum = 1;

   850 	format.iYuvFormat.iAspectRatioDenom = 1;

   851 

   852 	aFormats.Reset();

   853 

   854     //The following formats are supported by both H.263 and Mpeg-4

   855 

   856 	//YUV 420 Chroma0 Planar

   857 	format.iYuvFormat.iCoefficients = EYuvBt601Range0;

   858 	format.iYuvFormat.iPattern      = EYuv420Chroma1;

   859 	format.iYuvFormat.iDataLayout   = EYuvDataPlanar;

   860 	aFormats.Append( format );

   861 

   862     //YUV 422 Chroma LE Interleaved

   863     format.iYuvFormat.iPattern      = EYuv422Chroma1;

   864 	format.iYuvFormat.iDataLayout   = EYuvDataInterleavedLE;

   865     aFormats.Append( format );

   866 

   867     //YUV 422 Chroma BE Interleaved

   868     format.iYuvFormat.iDataLayout   = EYuvDataInterleavedBE;

   869     aFormats.Append( format );

   870 

   871     //The following formats are only supported by Mpeg-4

   872     if ( iInputFormat->MimeType().FindF( KH264SupportedMimeType ) !=

   873 															    KErrNotFound )

   874         {

   875         //BT 601.5 Full Range

   876         // YUV 420 Chroma0 Planar

   877         format.iYuvFormat.iCoefficients = EYuvBt601Range1;

   878 	    format.iYuvFormat.iPattern      = EYuv420Chroma1;

   879 	    format.iYuvFormat.iDataLayout   = EYuvDataPlanar;

   880         aFormats.Append( format );

   881 

   882         //YUV 422 Chroma LE Interleaved

   883         format.iYuvFormat.iPattern      = EYuv422Chroma1;

   884 	    format.iYuvFormat.iDataLayout   = EYuvDataInterleavedLE;

   885         aFormats.Append( format );

   886 

   887         //YUV 422 Chroma BE Interleaved

   888         format.iYuvFormat.iDataLayout   = EYuvDataInterleavedBE;

   889         aFormats.Append( format );

   890 

   891         //BT 709 Reduced Range

   892 	    // YUV 420 Chroma0 Planar

   893 	    format.iYuvFormat.iCoefficients = EYuvBt709Range0;

   894 	    format.iYuvFormat.iPattern      = EYuv420Chroma1;

   895 	    format.iYuvFormat.iDataLayout   = EYuvDataPlanar;

   896 	    aFormats.Append( format );

   897 

   898         //YUV 422 Chroma LE Interleaved

   899         format.iYuvFormat.iPattern      = EYuv422Chroma1;

   900 	    format.iYuvFormat.iDataLayout   = EYuvDataInterleavedLE;

   901         aFormats.Append( format );

   902 

   903         //YUV 422 Chroma BE Interleaved

   904         format.iYuvFormat.iDataLayout   = EYuvDataInterleavedBE;

   905         aFormats.Append( format );

   906 

   907         //BT 709 Full Range

   908         // YUV 420 Chroma0 Planar

   909 	    format.iYuvFormat.iCoefficients = EYuvBt709Range1;

   910 	    format.iYuvFormat.iPattern      = EYuv420Chroma1;

   911 	    format.iYuvFormat.iDataLayout   = EYuvDataPlanar;

   912 	    aFormats.Append( format );

   913 

   914         //YUV 422 Chroma LE Interleaved

   915         format.iYuvFormat.iPattern      = EYuv422Chroma1;

   916 	    format.iYuvFormat.iDataLayout   = EYuvDataInterleavedLE;

   917         aFormats.Append( format );

   918 

   919         //YUV 422 Chroma BE Interleaved

   920         format.iYuvFormat.iDataLayout   = EYuvDataInterleavedBE;

   921         aFormats.Append( format );

   922 	    }

   923     PRINT_EXIT;

   924     }

   925 

   926 //---------------------------------------------------------------------------

   927 // Sets the device output format.

   928 //---------------------------------------------------------------------------

   929 //

   930 void CAriH264decHwDevice::SetOutputFormatL(

   931 									const TUncompressedVideoFormat &aFormat )

   932 	{

   933 	PRINT_ENTRY;

   934     if ( iState->IsInitialized() )

   935     	{

   936     	PRINT_ERR( "istate is already initialised \n" );

   937         User::Leave( KErrNotReady );

   938     	}

   939 

   940     if ( !iInputFormat )

   941 	    {

   942 		//Input format should be set before calling this function, as output

   943         // format is decided based on input format

   944 	    PRINT_ERR( "iInputFormat is not set yet \n" );

   945 		User::Leave( KErrNotReady );

   946 	    }

   947 

   948 	// check whether the output format is supported or not. if not

   949     //supported leave

   950 	RArray<TUncompressedVideoFormat> formats;

   951 	CleanupClosePushL( formats );

   952 

   953 	GetOutputFormatListL( formats );

   954 

   955 	TBool flag = EFalse;

   956 

   957 	for ( TInt i = 0; i < formats.Count(); i++ )

   958 		{

   959 		if ( aFormat == formats[i] )

   960 			{

   961 			flag = ETrue;

   962 			break;

   963 			}

   964 		}

   965 	CleanupStack::Pop ( &formats );

   966     formats.Close();

   967 

   968 	if ( !flag )

   969 		{

   970 		PRINT_ERR( "outputformat is not supported \n" );

   971         User::Leave( KErrNotSupported );

   972 		}

   973 

   974     iOutputFormat = aFormat;

   975     PRINT_EXIT;

   976 	}

   977 

   978 //---------------------------------------------------------------------------

   979 // Sets the clock source to use for video timing.

   980 //---------------------------------------------------------------------------

   981 //

   982 void CAriH264decHwDevice::SetClockSource( MMMFClockSource* /*aClock*/ )

   983 	{

   984 	PRINT_ENTRY;

   985     if ( iState->IsInitialized() )

   986     	{

   987     	PRINT_ERR( "iState is initialised,calling MdvppFatalError \n" );

   988 		iMMFDevVideoPlayProxy->MdvppFatalError( this, KErrNotReady );

   989     	}

   990 

   991     PRINT_EXIT;

   992 	return;

   993 	}

   994 

   995 //---------------------------------------------------------------------------

   996 // Sets the device video output destination.

   997 //---------------------------------------------------------------------------

   998 //

   999 void CAriH264decHwDevice::SetVideoDestScreenL( TBool aScreen )

  1000 	{

  1001 	PRINT_ENTRY;

  1002 	if ( !iState->IsInitialized() )

  1003 		{

  1004 		if ( aScreen )

  1005 			{

  1006 			PRINT_ERR( "KErrNotSupported \n" );

  1007 			User::Leave( KErrNotSupported );

  1008 			}

  1009 		}

  1010 	else

  1011 		{

  1012 		PRINT_ERR( "KErrNotSupported \n" );

  1013 		User::Leave( KErrNotReady );

  1014 		}

  1015 	PRINT_EXIT;

  1016 	}

  1017 

  1018 //---------------------------------------------------------------------------

  1019 // Sets the post-processing types to be used.

  1020 //---------------------------------------------------------------------------

  1021 //

  1022 void CAriH264decHwDevice::SetPostProcessTypesL(

  1023 										   TUint32 /*aPostProcCombination*/ )

  1024 	{

  1025 	PRINT_ENTRY;

  1026 	PRINT_ERR( "KErrNotSupported API\n" );

  1027 	PRINT_EXIT;

  1028 	User::Leave( KErrNotSupported );

  1029 	}

  1030 

  1031 //---------------------------------------------------------------------------

  1032 // Sets post-processing options for input (pan-scan ) cropping.

  1033 //---------------------------------------------------------------------------

  1034 //

  1035 void CAriH264decHwDevice::SetInputCropOptionsL( const TRect& /*aRect*/ )

  1036 	{

  1037 	PRINT_ENTRY;

  1038 	PRINT_ERR( "KErrNotSupported API\n" );

  1039 	PRINT_EXIT;

  1040 	User::Leave( KErrNotSupported );

  1041 	}

  1042 

  1043 

  1044 //---------------------------------------------------------------------------

  1045 // Sets post-processing options for YUV to RGB color space conversion

  1046 //---------------------------------------------------------------------------

  1047 //

  1048 void CAriH264decHwDevice::SetYuvToRgbOptionsL(

  1049 										const TYuvToRgbOptions& /*aOptions*/,

  1050 										const TYuvFormat& /*aYuvFormat*/,

  1051 										TRgbFormat /*aRgbFormat*/ )

  1052 	{

  1053 	PRINT_ENTRY;

  1054 	PRINT_ERR( "KErrNotSupported API\n" );

  1055 	PRINT_EXIT;

  1056 	User::Leave( KErrNotSupported );

  1057 	}

  1058 

  1059 //---------------------------------------------------------------------------

  1060 // Sets post-processing options for YUV to RGB color space conversion. Uses

  1061 //the device input and output formats.

  1062 //---------------------------------------------------------------------------

  1063 //

  1064 void CAriH264decHwDevice::SetYuvToRgbOptionsL(

  1065 									   const TYuvToRgbOptions& /*aOptions*/ )

  1066 	{

  1067 	PRINT_ENTRY;

  1068 	PRINT_ERR( "KErrNotSupported API\n" );

  1069 	PRINT_EXIT;

  1070 	User::Leave( KErrNotSupported );

  1071 	}

  1072 

  1073 //---------------------------------------------------------------------------

  1074 // Sets post-processing options for rotation. SetPostProcessTypesL() must be

  1075 //called before this method is used.

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

  1077 //

  1078 void CAriH264decHwDevice::SetRotateOptionsL( TRotationType /*aRotationType*/ )

  1079 	{

  1080 	PRINT_ENTRY;

  1081 	PRINT_ERR( "KErrNotSupported API\n" );

  1082 	PRINT_EXIT;

  1083 	User::Leave( KErrNotSupported );

  1084 	}

  1085 

  1086 //---------------------------------------------------------------------------

  1087 //Sets post-processing options for scaling. SetPostProcessTypesL() must be

  1088 //called before this method is used.

  1089 //---------------------------------------------------------------------------

  1090 //

  1091 void CAriH264decHwDevice::SetScaleOptionsL( const TSize& /*aTargetSize*/,

  1092 											TBool /*aAntiAliasFiltering*/ )

  1093 	{

  1094 	PRINT_ENTRY;

  1095 	PRINT_ERR( "KErrNotSupported API\n" );

  1096 	PRINT_EXIT;

  1097 	User::Leave( KErrNotSupported );

  1098 	}

  1099 

  1100 //---------------------------------------------------------------------------

  1101 //Sets post-processing options for output cropping.

  1102 //---------------------------------------------------------------------------

  1103 //

  1104 void CAriH264decHwDevice::SetOutputCropOptionsL( const TRect& /*aRect*/ )

  1105 	{

  1106 	PRINT_ENTRY;

  1107 	PRINT_ERR( "KErrNotSupported API\n" );

  1108 	PRINT_EXIT;

  1109 	User::Leave( KErrNotSupported );

  1110 	}

  1111 

  1112 

  1113 //---------------------------------------------------------------------------

  1114 //Sets post-processing plug-in specific options.

  1115 //---------------------------------------------------------------------------

  1116 //

  1117 void CAriH264decHwDevice::SetPostProcSpecificOptionsL(

  1118 												 const TDesC8& /*aOptions*/ )

  1119 	{

  1120 	PRINT_ENTRY;

  1121 	PRINT_ERR( "KErrNotSupported API\n" );

  1122 	PRINT_EXIT;

  1123 	User::Leave( KErrNotSupported );

  1124 	}

  1125 

  1126 //---------------------------------------------------------------------------

  1127 //Initializes the device. This method is asynchronous, the device calls

  1128 //MdvppInitializeComplete() of MMFVideoPlayProxy after initialization has

  1129 //completed. After this method has successfully completed, further

  1130 //configuration changes are not possible except where separately noted.

  1131 //---------------------------------------------------------------------------

  1132 //

  1133 void CAriH264decHwDevice::Initialize()

  1134 	{

  1135 	PRINT_ENTRY;