multimediafadapter.cpp

一个详细记录symbian媒体播放的源代码

/**
 *
 * @brief Definition of CMultiMediaFApplication
 *
 * Copyright (c) EMCC Software Ltd 2003
 * @version 1.0
 */

// INCLUDE FILES

// Class includes
#include "MultiMediaFAdapter.h"

// System includes
#include <aknutils.h>			// CompleteWithAppPath
#include <BitmapTransforms.h>	// CBitmapRotator, CBitmapScaler
#include <fbs.h>				// CFbsBitmap
#include <ImageCodecData.h>		// TJpegImageData
#include <ImageConversion.h>	// CImageDecoder, CImageEncoder
#include <ImageData.h>			// CFrameImageData
#include <MultiMediaF.mbg>		// EMbmMultimediafLogo

// User includes
#include "MultiMediaF.hrh"			// Command IDs
#include "MultimediaController.h"	// MMultimediaController

// CONSTANTS
_LIT(KPathOfGifFile, "\\system\\apps\\MultiMediaF\\GifFile.gif");
_LIT(KPathOfSaveJpgFile, "\\system\\apps\\MultiMediaF\\OutputFile.jpg");
_LIT(KMbmPath, "\\system\\apps\\MultiMediaF\\MultiMediaF.mbm");
_LIT8(KJpgMime, "image/jpeg");

const TInt KGifIndex = 0;
const TInt KScaledWidthOne = 50;
const TInt KScaledHeightOne = 50;
const TInt KScaledWidthTwo = 100;
const TInt KScaledHeightTwo = 100;
const TInt KJpgQuality = 65;

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

/**
 * Symbian OS 2 phase constructor.
 * Constructs the CMultiMediaFAdapter using the NewLC method, popping
 * the constructed object from the CleanupStack before returning it.
 *
 * @param aRect The rectangle for this window
 * @return The newly constructed CMultiMediaFAdapter
 */
CMultiMediaFAdapter* CMultiMediaFAdapter::NewL(MMultimediaController& aMultimediaController, TDisplayMode aDeviceDisplayMode)
    {
    CMultiMediaFAdapter* self = CMultiMediaFAdapter::NewLC(aMultimediaController, aDeviceDisplayMode);
    CleanupStack::Pop();
    return self;
    }

/**
 * Symbian OS 2 phase constructor.
 * Constructs the CMultiMediaFAdapter using the constructor and ConstructL
 * method, leaving the constructed object on the CleanupStack before returning it.
 *
 * @param aRect The rectangle for this window
 * @return The newly constructed CMultiMediaFAdapter
 */
CMultiMediaFAdapter* CMultiMediaFAdapter::NewLC(MMultimediaController& aMultimediaController, TDisplayMode aDeviceDisplayMode)
    {
    CMultiMediaFAdapter* self = new (ELeave) CMultiMediaFAdapter(aMultimediaController, aDeviceDisplayMode);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

/**
* Symbian OS 2nd phase constructor.
* Instantiates objects for encoding, decoding, rotating and scaling.
* A bitmap is also instantiated to be used for storing the result of a manipulation
* and used later for display on the screen.
*/
void CMultiMediaFAdapter::ConstructL()
    {
    iScaler = CBitmapScaler::NewL();
    iRotator = CBitmapRotator::NewL();

    ResetImageL();

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

    CActiveScheduler::Add(this);
    }

/**
 * C++ constructor
 *
 * @param aMultimediaController The application controller object used to inform the view to redraw
 * @param aDeviceDisplayMode The display mode (number of colors supported) of the device
 */
CMultiMediaFAdapter::CMultiMediaFAdapter(MMultimediaController& aMultimediaController, TDisplayMode aDeviceDisplayMode) :
	CActive(EPriorityLow),
    iMultimediaController(aMultimediaController),
    iScaleState(EScaleDown),
    iDeviceDisplayMode(aDeviceDisplayMode)
    {
    }

/**
 * Destructor.
 */
CMultiMediaFAdapter::~CMultiMediaFAdapter()
    {
    delete iDecoder;
    delete iEncoder;
    delete iRotator;
    delete iScaler;
    delete iImage;
    delete iJpgImageData;
	iFs.Close();
    }

/**
 * Routes the commands obtained by the AppUi into the MultiMediaFAdapter to
 * perform the user desired image manipulation
 *
 * @param aCommand The command Id from the AppUi used to decided which operation to perform
 */
void CMultiMediaFAdapter::HandleCommandL(TInt aCommand)
	{
	DoCancel(); // clear any pending operations
	switch(aCommand)
		{
		case EDecodeImage:
			iManipulationState = EDecode;
			DecodeOpenAndConvertL();
			break;
		case EEncodeImage:
			iManipulationState = EEncode;
			EncodeOpenAndConvertL();
			break;
		case ERotate90:
			iManipulationState = ERotating;
			Rotate90();
			break;
		case ERotate180:
			iManipulationState = ERotating;
			Rotate180();
			break;
		case ERotate270:
			iManipulationState = ERotating;
			Rotate270();
			break;
		case ERotateH:
			iManipulationState = ERotating;
			RotateMirrorH();
			break;
		case ERotateV:
			iManipulationState = ERotating;
			RotateMirrorV();
			break;
		case EScale:
			iManipulationState = EScaling;
			ScaleImage();
			break;
		case EResetImage:
			iManipulationState = EDoNothing;
			ResetImageL();
			iMultimediaController.RedrawView();
			break;
		}
	}

/**
* From CActive derivation.
* Used to inform client code that a conversion, rotation or scaling operation
* has completed.
* Following this the view is informed to redraw
*
*/
void CMultiMediaFAdapter::RunL()
	{
    switch (iManipulationState)
		{
        case EDecode:
        case EEncode:
        case ERotating:
        case EScaling:
			{
			iManipulationState = EDoNothing;
            iMultimediaController.RedrawView();
            break;
			}
       default:
			break;
		}
	}

/**
 * From CActive derivation
 */

void CMultiMediaFAdapter::DoCancel()
	{
	if (iEncoder)
		{
		iEncoder->Cancel();
		}
	if (iDecoder)
		{
		iDecoder->Cancel();
		}
	iRotator->Cancel();
	iScaler->Cancel();
	}

/**
* From MImageModel derivation
* Image that has been manipulated to be used for rendering by the view
* @return The manipulated image for display
*/
CFbsBitmap& CMultiMediaFAdapter::Image() const
	{
	return *iImage;
	}

/**
* Opens up a handle to an existing GIF file and converts it.
* Uses synchronous CImageDecoder::NewFileL and converts using CImageDecoder::ConvertL
* A CFbsBitmap is the destination of the conversion
* RunL() will be called when this is finished
*/
void CMultiMediaFAdapter::DecodeOpenAndConvertL()
	{
    delete iDecoder;
    iDecoder = 0;

    iDecoder = CImageDecoder::FileNewL(iFs, KPathOfGifFile);

    TFrameInfo frmInfo = iDecoder->FrameInfo(KGifIndex);
    TRect rectOfImage = frmInfo.iFrameCoordsInPixels;

    delete iImage;
    iImage = 0;
    iImage = new (ELeave) CFbsBitmap();
    iImage->Create(rectOfImage.Size(), iDeviceDisplayMode);

    iDecoder->Convert(&iStatus, *iImage, KGifIndex);

    SetActive();
    }

/**
* Creates a new JPG file in preparation for data from a CFbsBitmap.
* Converts CFbsBitmap data into a JPG
* RunL() will be called when this operation is finished
*/
void CMultiMediaFAdapter::EncodeOpenAndConvertL()
	{
	// Create a new file ready for encoding.
	delete iEncoder;
	iEncoder = 0;
	iEncoder = CImageEncoder::FileNewL(iFs, KPathOfSaveJpgFile(), KJpgMime(), CImageEncoder::EOptionNone);

	// Setup the jpg saving information that is required.
	TJpegImageData* jpgData = new (ELeave) TJpegImageData();
	CleanupStack::PushL(jpgData);	// jpgData will be deleted by the Multi Media Framework

	jpgData->iQualityFactor = KJpgQuality;
	jpgData->iSampleScheme = TJpegImageData::EColor420;

	// Create the new image data.
	delete iJpgImageData;
	iJpgImageData = 0;
	iJpgImageData = CFrameImageData::NewL();

	// Set the saving information.
	User::LeaveIfError(iJpgImageData->AppendImageData(jpgData));	// Passes ownership if successful.
	CleanupStack::Pop(jpgData); // jpgData now owned by iJpgImageData.

	// Begin conversion process
	iEncoder->Convert(&iStatus, *iImage, iJpgImageData);
	SetActive();
	}

/**
* Rotates the image 90 degrees in a clockwise direction
* RunL wil be called when this operation is finished
*/
void CMultiMediaFAdapter::Rotate90()
    {
    iRotator->Rotate(&iStatus, *iImage, CBitmapRotator::ERotation90DegreesClockwise);
    SetActive();
    }

/**
* Rotates the image 180 degrees in a clockwise direction
* RunL wil be called when this operation is finished
*/
void CMultiMediaFAdapter::Rotate180()
    {
    iRotator->Rotate(&iStatus, *iImage, CBitmapRotator::ERotation180DegreesClockwise);
    SetActive();
    }

/**
* Rotates the image 270 degrees in a clockwise direction
* RunL wil be called when this operation is finished
*/
void CMultiMediaFAdapter::Rotate270()
    {
    iRotator->Rotate(&iStatus, *iImage, CBitmapRotator::ERotation270DegreesClockwise);
    SetActive();
    }

/**
* Mirrors the image along the horizontal axis.
* RunL wil be called when this operation is finished
*/
void CMultiMediaFAdapter::RotateMirrorH()
    {
    iRotator->Rotate(&iStatus, *iImage, CBitmapRotator::EMirrorHorizontalAxis);
    SetActive();
    }

/**
* Mirrors the image along the vertical axis.
* RunL wil be called when this operation is finished
*/
void CMultiMediaFAdapter::RotateMirrorV()
    {
    iRotator->Rotate(&iStatus, *iImage, CBitmapRotator::EMirrorVerticalAxis);
    SetActive();
    }

/**
* Enlarges or shrinks the image. Choice is the opposite of the last scale operation.
* RunL wil be called when this operation is finished
*/
void CMultiMediaFAdapter::ScaleImage()
    {
    if(iScaleState == EScaleDown)
        {
        iScaler->Scale(&iStatus, *iImage, TSize(KScaledWidthOne, KScaledHeightOne));
        iScaleState = EScaleUp;
        }
    else
        {
        iScaler->Scale(&iStatus, *iImage, TSize(KScaledWidthTwo, KScaledHeightTwo));
        iScaleState = EScaleDown;
        }
    SetActive();
    }

/**
* Resets the image back to its original state
*/
void CMultiMediaFAdapter::ResetImageL()
	{
	delete iImage;
	iImage = 0;
	iImage = new (ELeave) CFbsBitmap();

	TFileName fullname = KMbmPath();
	CompleteWithAppPath(fullname);	// Get drive application is installed on.

	iImage->Load(fullname, EMbmMultimediafLogo);
	}