--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vtengines/videoteleng/Src/Media/CVtEngDrawDP.cpp Wed Jun 23 18:14:26 2010 +0300
@@ -0,0 +1,2026 @@
+/*
+* Copyright (c) 2004-2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Remote video handler.
+*
+*/
+
+
+// INCLUDE FILES
+
+#include "CVtEngDrawDP.h"
+#include "CVtEngEventManager.h"
+#include "CVtEngSettings.h"
+#include "VtEngUtils.h"
+#include "MVtEngFrameObserver.h"
+#include <videotelephonyvariant.hrh>
+#include <tdisplaysinkparamsdp.h>
+#include <cvtlogger.h>
+#include <Posting_Surface_Factory.h>
+
+#include <cvtimagebitmap.h>
+
+// LOCAL CONSTANTS AND MACROS
+
+// YCbCr conversion constants
+
+// Luma
+static const TUint32 KYLut[ 256 ] =
+ {
+ 0x00000000, 0x00400801, 0x00801002, 0x00C01803,
+ 0x01002004, 0x01402805, 0x01803006, 0x01C03807,
+ 0x02004008, 0x02404809, 0x0280500A, 0x02C0580B,
+ 0x0300600C, 0x0340680D, 0x0380700E, 0x03C0780F,
+ 0x04008010, 0x04408811, 0x04809012, 0x04C09813,
+ 0x0500A014, 0x0540A815, 0x0580B016, 0x05C0B817,
+ 0x0600C018, 0x0640C819, 0x0680D01A, 0x06C0D81B,
+ 0x0700E01C, 0x0740E81D, 0x0780F01E, 0x07C0F81F,
+ 0x08010020, 0x08410821, 0x08811022, 0x08C11823,
+ 0x09012024, 0x09412825, 0x09813026, 0x09C13827,
+ 0x0A014028, 0x0A414829, 0x0A81502A, 0x0AC1582B,
+ 0x0B01602C, 0x0B41682D, 0x0B81702E, 0x0BC1782F,
+ 0x0C018030, 0x0C418831, 0x0C819032, 0x0CC19833,
+ 0x0D01A034, 0x0D41A835, 0x0D81B036, 0x0DC1B837,
+ 0x0E01C038, 0x0E41C839, 0x0E81D03A, 0x0EC1D83B,
+ 0x0F01E03C, 0x0F41E83D, 0x0F81F03E, 0x0FC1F83F,
+ 0x10020040, 0x10420841, 0x10821042, 0x10C21843,
+ 0x11022044, 0x11422845, 0x11823046, 0x11C23847,
+ 0x12024048, 0x12424849, 0x1282504A, 0x12C2584B,
+ 0x1302604C, 0x1342684D, 0x1382704E, 0x13C2784F,
+ 0x14028050, 0x14428851, 0x14829052, 0x14C29853,
+ 0x1502A054, 0x1542A855, 0x1582B056, 0x15C2B857,
+ 0x1602C058, 0x1642C859, 0x1682D05A, 0x16C2D85B,
+ 0x1702E05C, 0x1742E85D, 0x1782F05E, 0x17C2F85F,
+ 0x18030060, 0x18430861, 0x18831062, 0x18C31863,
+ 0x19032064, 0x19432865, 0x19833066, 0x19C33867,
+ 0x1A034068, 0x1A434869, 0x1A83506A, 0x1AC3586B,
+ 0x1B03606C, 0x1B43686D, 0x1B83706E, 0x1BC3786F,
+ 0x1C038070, 0x1C438871, 0x1C839072, 0x1CC39873,
+ 0x1D03A074, 0x1D43A875, 0x1D83B076, 0x1DC3B877,
+ 0x1E03C078, 0x1E43C879, 0x1E83D07A, 0x1EC3D87B,
+ 0x1F03E07C, 0x1F43E87D, 0x1F83F07E, 0x1FC3F87F,
+ 0x20040080, 0x20440881, 0x20841082, 0x20C41883,
+ 0x21042084, 0x21442885, 0x21843086, 0x21C43887,
+ 0x22044088, 0x22444889, 0x2284508A, 0x22C4588B,
+ 0x2304608C, 0x2344688D, 0x2384708E, 0x23C4788F,
+ 0x24048090, 0x24448891, 0x24849092, 0x24C49893,
+ 0x2504A094, 0x2544A895, 0x2584B096, 0x25C4B897,
+ 0x2604C098, 0x2644C899, 0x2684D09A, 0x26C4D89B,
+ 0x2704E09C, 0x2744E89D, 0x2784F09E, 0x27C4F89F,
+ 0x280500A0, 0x284508A1, 0x288510A2, 0x28C518A3,
+ 0x290520A4, 0x294528A5, 0x298530A6, 0x29C538A7,
+ 0x2A0540A8, 0x2A4548A9, 0x2A8550AA, 0x2AC558AB,
+ 0x2B0560AC, 0x2B4568AD, 0x2B8570AE, 0x2BC578AF,
+ 0x2C0580B0, 0x2C4588B1, 0x2C8590B2, 0x2CC598B3,
+ 0x2D05A0B4, 0x2D45A8B5, 0x2D85B0B6, 0x2DC5B8B7,
+ 0x2E05C0B8, 0x2E45C8B9, 0x2E85D0BA, 0x2EC5D8BB,
+ 0x2F05E0BC, 0x2F45E8BD, 0x2F85F0BE, 0x2FC5F8BF,
+ 0x300600C0, 0x304608C1, 0x308610C2, 0x30C618C3,
+ 0x310620C4, 0x314628C5, 0x318630C6, 0x31C638C7,
+ 0x320640C8, 0x324648C9, 0x328650CA, 0x32C658CB,
+ 0x330660CC, 0x334668CD, 0x338670CE, 0x33C678CF,
+ 0x340680D0, 0x344688D1, 0x348690D2, 0x34C698D3,
+ 0x3506A0D4, 0x3546A8D5, 0x3586B0D6, 0x35C6B8D7,
+ 0x3606C0D8, 0x3646C8D9, 0x3686D0DA, 0x36C6D8DB,
+ 0x3706E0DC, 0x3746E8DD, 0x3786F0DE, 0x37C6F8DF,
+ 0x380700E0, 0x384708E1, 0x388710E2, 0x38C718E3,
+ 0x390720E4, 0x394728E5, 0x398730E6, 0x39C738E7,
+ 0x3A0740E8, 0x3A4748E9, 0x3A8750EA, 0x3AC758EB,
+ 0x3B0760EC, 0x3B4768ED, 0x3B8770EE, 0x3BC778EF,
+ 0x3C0780F0, 0x3C4788F1, 0x3C8790F2, 0x3CC798F3,
+ 0x3D07A0F4, 0x3D47A8F5, 0x3D87B0F6, 0x3DC7B8F7,
+ 0x3E07C0F8, 0x3E47C8F9, 0x3E87D0FA, 0x3EC7D8FB,
+ 0x3F07E0FC, 0x3F47E8FD, 0x3F87F0FE, 0x3FC7F8FF
+ };
+
+// Chroma1 (Cb)
+static const TUint32 KCbLut[ 256 ] =
+ {
+ 0x0001531C, 0x00014B1E, 0x00014B20, 0x00014B22,
+ 0x00014324, 0x00014325, 0x00014327, 0x00013B29,
+ 0x00013B2B, 0x00013B2D, 0x0001332E, 0x00013330,
+ 0x00013332, 0x00012B34, 0x00012B35, 0x00012B37,
+ 0x00012339, 0x0001233B, 0x0001233D, 0x00011B3E,
+ 0x00011B40, 0x00011B42, 0x00011344, 0x00011345,
+ 0x00011347, 0x00010B49, 0x00010B4B, 0x00010B4D,
+ 0x0001034E, 0x00010350, 0x00010352, 0x0000FB54,
+ 0x0000FB55, 0x0000FB57, 0x0000F359, 0x0000F35B,
+ 0x0000F35D, 0x0000EB5E, 0x0000EB60, 0x0000EB62,
+ 0x0000E364, 0x0000E366, 0x0000E367, 0x0000DB69,
+ 0x0000DB6B, 0x0000DB6D, 0x0000D36E, 0x0000D370,
+ 0x0000D372, 0x0000CB74, 0x0000CB76, 0x0000CB77,
+ 0x0000C379, 0x0000C37B, 0x0000C37D, 0x0000BB7E,
+ 0x0000BB80, 0x0000BB82, 0x0000B384, 0x0000B386,
+ 0x0000B387, 0x0000AB89, 0x0000AB8B, 0x0000AB8D,
+ 0x0000AB8E, 0x0000A390, 0x0000A392, 0x0000A394,
+ 0x00009B96, 0x00009B97, 0x00009B99, 0x0000939B,
+ 0x0000939D, 0x0000939F, 0x00008BA0, 0x00008BA2,
+ 0x00008BA4, 0x000083A6, 0x000083A7, 0x000083A9,
+ 0x00007BAB, 0x00007BAD, 0x00007BAF, 0x000073B0,
+ 0x000073B2, 0x000073B4, 0x00006BB6, 0x00006BB7,
+ 0x00006BB9, 0x000063BB, 0x000063BD, 0x000063BF,
+ 0x00005BC0, 0x00005BC2, 0x00005BC4, 0x000053C6,
+ 0x000053C7, 0x000053C9, 0x00004BCB, 0x00004BCD,
+ 0x00004BCF, 0x000043D0, 0x000043D2, 0x000043D4,
+ 0x00003BD6, 0x00003BD8, 0x00003BD9, 0x000033DB,
+ 0x000033DD, 0x000033DF, 0x00002BE0, 0x00002BE2,
+ 0x00002BE4, 0x000023E6, 0x000023E8, 0x000023E9,
+ 0x00001BEB, 0x00001BED, 0x00001BEF, 0x000013F0,
+ 0x000013F2, 0x000013F4, 0x00000BF6, 0x00000BF8,
+ 0x00000BF9, 0x000003FB, 0x000003FD, 0x000003FF,
+ 0x00000000, 0x00000001, 0x00000003, 0x00000005,
+ 0x001FF807, 0x001FF808, 0x001FF80A, 0x001FF00C,
+ 0x001FF00E, 0x001FF010, 0x001FE811, 0x001FE813,
+ 0x001FE815, 0x001FE017, 0x001FE018, 0x001FE01A,
+ 0x001FD81C, 0x001FD81E, 0x001FD820, 0x001FD021,
+ 0x001FD023, 0x001FD025, 0x001FC827, 0x001FC828,
+ 0x001FC82A, 0x001FC02C, 0x001FC02E, 0x001FC030,
+ 0x001FB831, 0x001FB833, 0x001FB835, 0x001FB037,
+ 0x001FB039, 0x001FB03A, 0x001FA83C, 0x001FA83E,
+ 0x001FA840, 0x001FA041, 0x001FA043, 0x001FA045,
+ 0x001F9847, 0x001F9849, 0x001F984A, 0x001F904C,
+ 0x001F904E, 0x001F9050, 0x001F8851, 0x001F8853,
+ 0x001F8855, 0x001F8057, 0x001F8059, 0x001F805A,
+ 0x001F785C, 0x001F785E, 0x001F7860, 0x001F7061,
+ 0x001F7063, 0x001F7065, 0x001F6867, 0x001F6869,
+ 0x001F686A, 0x001F606C, 0x001F606E, 0x001F6070,
+ 0x001F5872, 0x001F5873, 0x001F5875, 0x001F5877,
+ 0x001F5079, 0x001F507A, 0x001F507C, 0x001F487E,
+ 0x001F4880, 0x001F4882, 0x001F4083, 0x001F4085,
+ 0x001F4087, 0x001F3889, 0x001F388A, 0x001F388C,
+ 0x001F308E, 0x001F3090, 0x001F3092, 0x001F2893,
+ 0x001F2895, 0x001F2897, 0x001F2099, 0x001F209A,
+ 0x001F209C, 0x001F189E, 0x001F18A0, 0x001F18A2,
+ 0x001F10A3, 0x001F10A5, 0x001F10A7, 0x001F08A9,
+ 0x001F08AB, 0x001F08AC, 0x001F00AE, 0x001F00B0,
+ 0x001F00B2, 0x001EF8B3, 0x001EF8B5, 0x001EF8B7,
+ 0x001EF0B9, 0x001EF0BB, 0x001EF0BC, 0x001EE8BE,
+ 0x001EE8C0, 0x001EE8C2, 0x001EE0C3, 0x001EE0C5,
+ 0x001EE0C7, 0x001ED8C9, 0x001ED8CB, 0x001ED8CC,
+ 0x001ED0CE, 0x001ED0D0, 0x001ED0D2, 0x001EC8D3,
+ 0x001EC8D5, 0x001EC8D7, 0x001EC0D9, 0x001EC0DB,
+ 0x001EC0DC, 0x001EB8DE, 0x001EB8E0, 0x001EB8E2
+ };
+
+// Chroma1 (Cr)
+static const TUint32 KCrLut[ 256 ] =
+ {
+ 0xD302D000, 0xD382C800, 0xD3C2C000, 0xD442B800,
+ 0xD482B800, 0xD502B000, 0xD542A800, 0xD582A800,
+ 0xD602A000, 0xD6429800, 0xD6C29000, 0xD7029000,
+ 0xD7428800, 0xD7C28000, 0xD8028000, 0xD8827800,
+ 0xD8C27000, 0xD9027000, 0xD9826800, 0xD9C26000,
+ 0xDA425800, 0xDA825800, 0xDAC25000, 0xDB424800,
+ 0xDB824800, 0xDC024000, 0xDC423800, 0xDC823800,
+ 0xDD023000, 0xDD422800, 0xDDC22000, 0xDE022000,
+ 0xDE421800, 0xDEC21000, 0xDF021000, 0xDF820800,
+ 0xDFC20000, 0xE041F800, 0xE081F800, 0xE0C1F000,
+ 0xE141E800, 0xE181E800, 0xE201E000, 0xE241D800,
+ 0xE281D800, 0xE301D000, 0xE341C800, 0xE3C1C000,
+ 0xE401C000, 0xE441B800, 0xE4C1B000, 0xE501B000,
+ 0xE581A800, 0xE5C1A000, 0xE601A000, 0xE6819800,
+ 0xE6C19000, 0xE7418800, 0xE7818800, 0xE7C18000,
+ 0xE8417800, 0xE8817800, 0xE9017000, 0xE9416800,
+ 0xE9816800, 0xEA016000, 0xEA415800, 0xEAC15000,
+ 0xEB015000, 0xEB814800, 0xEBC14000, 0xEC014000,
+ 0xEC813800, 0xECC13000, 0xED412800, 0xED812800,
+ 0xEDC12000, 0xEE411800, 0xEE811800, 0xEF011000,
+ 0xEF410800, 0xEF810800, 0xF0010000, 0xF040F800,
+ 0xF0C0F000, 0xF100F000, 0xF140E800, 0xF1C0E000,
+ 0xF200E000, 0xF280D800, 0xF2C0D000, 0xF300D000,
+ 0xF380C800, 0xF3C0C000, 0xF440B800, 0xF480B800,
+ 0xF4C0B000, 0xF540A800, 0xF580A800, 0xF600A000,
+ 0xF6409800, 0xF6C09000, 0xF7009000, 0xF7408800,
+ 0xF7C08000, 0xF8008000, 0xF8807800, 0xF8C07000,
+ 0xF9007000, 0xF9806800, 0xF9C06000, 0xFA405800,
+ 0xFA805800, 0xFAC05000, 0xFB404800, 0xFB804800,
+ 0xFC004000, 0xFC403800, 0xFC803800, 0xFD003000,
+ 0xFD402800, 0xFDC02000, 0xFE002000, 0xFE401800,
+ 0xFEC01000, 0xFF001000, 0xFF800800, 0xFFC00000,
+ 0x00000000, 0x00400000, 0x009FF800, 0x011FF000,
+ 0x015FF000, 0x01DFE800, 0x021FE000, 0x025FE000,
+ 0x02DFD800, 0x031FD000, 0x039FC800, 0x03DFC800,
+ 0x041FC000, 0x049FB800, 0x04DFB800, 0x055FB000,
+ 0x059FA800, 0x05DFA800, 0x065FA000, 0x069F9800,
+ 0x071F9000, 0x075F9000, 0x079F8800, 0x081F8000,
+ 0x085F8000, 0x08DF7800, 0x091F7000, 0x095F7000,
+ 0x09DF6800, 0x0A1F6000, 0x0A9F5800, 0x0ADF5800,
+ 0x0B5F5000, 0x0B9F4800, 0x0BDF4800, 0x0C5F4000,
+ 0x0C9F3800, 0x0D1F3000, 0x0D5F3000, 0x0D9F2800,
+ 0x0E1F2000, 0x0E5F2000, 0x0EDF1800, 0x0F1F1000,
+ 0x0F5F1000, 0x0FDF0800, 0x101F0000, 0x109EF800,
+ 0x10DEF800, 0x111EF000, 0x119EE800, 0x11DEE800,
+ 0x125EE000, 0x129ED800, 0x12DED800, 0x135ED000,
+ 0x139EC800, 0x141EC000, 0x145EC000, 0x149EB800,
+ 0x151EB000, 0x155EB000, 0x15DEA800, 0x161EA000,
+ 0x169E9800, 0x16DE9800, 0x171E9000, 0x179E8800,
+ 0x17DE8800, 0x185E8000, 0x189E7800, 0x18DE7800,
+ 0x195E7000, 0x199E6800, 0x1A1E6000, 0x1A5E6000,
+ 0x1A9E5800, 0x1B1E5000, 0x1B5E5000, 0x1BDE4800,
+ 0x1C1E4000, 0x1C5E4000, 0x1CDE3800, 0x1D1E3000,
+ 0x1D9E2800, 0x1DDE2800, 0x1E1E2000, 0x1E9E1800,
+ 0x1EDE1800, 0x1F5E1000, 0x1F9E0800, 0x1FDE0800,
+ 0x205E0000, 0x209DF800, 0x211DF000, 0x215DF000,
+ 0x21DDE800, 0x221DE000, 0x225DE000, 0x22DDD800,
+ 0x231DD000, 0x239DC800, 0x23DDC800, 0x241DC000,
+ 0x249DB800, 0x24DDB800, 0x255DB000, 0x259DA800,
+ 0x25DDA800, 0x265DA000, 0x269D9800, 0x271D9000,
+ 0x275D9000, 0x279D8800, 0x281D8000, 0x285D8000,
+ 0x28DD7800, 0x291D7000, 0x295D7000, 0x29DD6800,
+ 0x2A1D6000, 0x2A9D5800, 0x2ADD5800, 0x2B1D5000,
+ 0x2B9D4800, 0x2BDD4800, 0x2C5D4000, 0x2C9D3800
+ };
+
+
+// Posting surface factory DLL's name
+_LIT( KDPAPIDLLName, "PostingSurfaceFactory.dll" );
+
+// Reversed enumeration for the bitmaps.
+static const MDisplaySink::TBitmapNo KVtEngBitmapNoReversed[] =
+ {
+ MDisplaySink::ESecondBitmap,
+ MDisplaySink::EFirstBitmap
+ };
+
+// Default posting format (if this or KDefaultPostingFormat420 is not
+// supported, BaseConstructL() will leave with KErrNotSupported)
+const CPostingSurface::TPostingFormat KDefaultPostingFormat422 =
+ CPostingSurface::EYuv422LeBt601Range0;
+
+// Default posting format (if this or KDefaultPostingFormat422 is not
+// supported, BaseConstructL() will leave with KErrNotSupported)
+const CPostingSurface::TPostingFormat KDefaultPostingFormat420 =
+ CPostingSurface::EYuv420PlanarBt601Range0;
+
+// Default posting buffering flags.
+const TUint KDefaultPostingBufferingFlags =
+ // Double buffering
+ CPostingSurface::EDoubleBuffering |
+ // Progressive frames (no interlacing)
+ CPostingSurface::EProgressiveFrames |
+ // Do not allow frameskip
+ CPostingSurface::EDisAllowFrameSkip |
+ // Use internal buffers (allocated by DP)
+ CPostingSurface::EInternalBuffers;
+
+// Default pixel aspect ratio num. Aspect ratio = Num/Denom.
+const TUint16 KDefaultPixelAspectRatioNum = 1;
+
+// Default pixel aspect ratio denom. Aspect ratio = Num/Denom.
+const TUint16 KDefaultPixelAspectRatioDenom = 1;
+
+// LOCAL METHODS
+
+// -----------------------------------------------------------------------------
+// DoConvertYuv420toXRGB0888
+// -----------------------------------------------------------------------------
+//
+inline void DoConvertYuv420toXRGB0888(
+ TInt aWidth, // width in pixels
+ const TUint8*& aSourceDataPtrY1, // pointer to Y data row 1
+ const TUint8*& aSourceDataPtrY2, // pointer to Y data row 2
+ const TUint8*& aSourceDataPtrU, // pointer to U data row
+ const TUint8*& aSourceDataPtrV, // pointer to V data row
+ TUint8* aDestDataPtr1, // pointer to destination row 1
+ TUint8* aDestDataPtr2 // pointer to destination row 2
+ )
+ {
+ TUint32* destDataPtr1 = reinterpret_cast< TUint32* >( aDestDataPtr1 );
+ TUint32* destDataPtr2 = reinterpret_cast< TUint32* >( aDestDataPtr2 );
+ // width assumed to be even
+ TInt pixelsLeft = aWidth / 2;
+
+ TUint32 r, g, b;
+ TUint32 LutY0, LutY1, LutC;
+ TUint32 pixel;
+ TUint32 OverflowMask = 0xC0180300U;
+
+ // One scanline at the time
+ while ( pixelsLeft-- )
+ {
+
+ // row 1, 2 pixels
+
+ LutY0 = KYLut[*aSourceDataPtrY1++];
+ LutY1 = KYLut[*aSourceDataPtrY1++];
+ LutC = KCbLut[*aSourceDataPtrU++];
+ LutC += KCrLut[*aSourceDataPtrV++];
+
+ pixel = LutY0 + LutC;
+
+ if (pixel & OverflowMask)
+ {
+ if (pixel & 0xC0000000U)
+ {
+ if (pixel & 0x80000000U)
+ {
+ pixel &= ~0x3FC00000U;
+ }
+ else
+ {
+ pixel |= 0x3FC00000U;
+ }
+ }
+ if (pixel & 0x00180000U)
+ {
+ if (pixel & 0x00100000U)
+ {
+ pixel &= ~0x0007F800U;
+ }
+ else
+ {
+ pixel |= 0x0007F800U;
+ }
+ }
+ if (pixel & 0x00000300U)
+ {
+ if (pixel & 0x00000200U)
+ {
+ pixel &= ~0x000000FFU;
+ }
+ else
+ {
+ pixel |= 0x000000FFU;
+ }
+ }
+ }
+
+ r = (pixel >> 6) & 0xFF0000;
+ g = (pixel >> 3) & 0x00FF00;
+ b = pixel & 0x0000FF;
+
+ *destDataPtr1++ = 0xFF000000 | r | g | b;
+
+ pixel = LutY1 + LutC;
+
+ if (pixel & OverflowMask)
+ {
+ if (pixel & 0xC0000000U)
+ {
+ if (pixel & 0x80000000U)
+ {
+ pixel &= ~0x3FC00000U;
+ }
+ else
+ {
+ pixel |= 0x3FC00000U;
+ }
+ }
+ if (pixel & 0x00180000U)
+ {
+ if (pixel & 0x00100000U)
+ {
+ pixel &= ~0x0007F800U;
+ }
+ else
+ {
+ pixel |= 0x0007F800U;
+ }
+ }
+ if (pixel & 0x00000300U)
+ {
+ if (pixel & 0x00000200U)
+ {
+ pixel &= ~0x000000FFU;
+ }
+ else
+ {
+ pixel |= 0x000000FFU;
+ }
+ }
+ }
+
+ r = (pixel >> 6) & 0xFF0000;
+ g = (pixel >> 3) & 0x00FF00;
+ b = pixel & 0x0000FF;
+
+ *destDataPtr1++ = 0xFF000000 | r | g | b;
+
+ // row, 2 pixels
+
+ LutY0 = KYLut[*aSourceDataPtrY2++];
+ LutY1 = KYLut[*aSourceDataPtrY2++];
+
+ pixel = LutY0 + LutC;
+
+ if (pixel & OverflowMask)
+ {
+ if (pixel & 0xC0000000U)
+ {
+ if (pixel & 0x80000000U)
+ {
+ pixel &= ~0x3FC00000U;
+ }
+ else
+ {
+ pixel |= 0x3FC00000U;
+ }
+ }
+ if (pixel & 0x00180000U)
+ {
+ if (pixel & 0x00100000U)
+ {
+ pixel &= ~0x0007F800U;
+ }
+ else
+ {
+ pixel |= 0x0007F800U;
+ }
+ }
+ if (pixel & 0x00000300U)
+ {
+ if (pixel & 0x00000200U)
+ {
+ pixel &= ~0x000000FFU;
+ }
+ else
+ {
+ pixel |= 0x000000FFU;
+ }
+ }
+ }
+
+ r = (pixel >> 6) & 0xFF0000;
+ g = (pixel >> 3) & 0x00FF00;
+ b = pixel & 0x0000FF;
+
+ *destDataPtr2++ = 0xFF000000 | r | g | b;
+
+ pixel = LutY1 + LutC;
+
+ if (pixel & OverflowMask)
+ {
+ if (pixel & 0xC0000000U)
+ {
+ if (pixel & 0x80000000U)
+ {
+ pixel &= ~0x3FC00000U;
+ }
+ else
+ {
+ pixel |= 0x3FC00000U;
+ }
+ }
+ if (pixel & 0x00180000U)
+ {
+ if (pixel & 0x00100000U)
+ {
+ pixel &= ~0x0007F800U;
+ }
+ else
+ {
+ pixel |= 0x0007F800U;
+ }
+ }
+ if (pixel & 0x00000300U)
+ {
+ if (pixel & 0x00000200U)
+ {
+ pixel &= ~0x000000FFU;
+ }
+ else
+ {
+ pixel |= 0x000000FFU;
+ }
+ }
+ }
+
+ r = (pixel >> 6) & 0xFF0000;
+ g = (pixel >> 3) & 0x00FF00;
+ b = pixel & 0x0000FF;
+
+ *destDataPtr2++ = 0xFF000000 | r | g | b;
+
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// DoConvertYuv422toXRGB0888
+// -----------------------------------------------------------------------------
+//
+inline void DoConvertYuv422toXRGB0888(
+ TInt aWidth, // width in pixels
+ const TUint8*& aSourceDataPtr, // pointer to source row
+ TUint8* aDestDataPtr // pointer to destination row
+ )
+ {
+ TUint32* destDataPtr = reinterpret_cast< TUint32* >( aDestDataPtr );
+ // width assumed to be even
+ TInt pixelsLeft = aWidth / 2;
+
+ TUint32 r, g, b;
+ TUint32 LutY0, LutY1, LutC;
+ TUint32 pixel;
+ TUint32 OverflowMask = 0xC0180300U;
+
+ // One scanline at the time
+ while ( pixelsLeft-- )
+ {
+
+ LutC = KCbLut[*aSourceDataPtr++];
+ LutY0 = KYLut[*aSourceDataPtr++];
+ LutC += KCrLut[*aSourceDataPtr++];
+ LutY1 = KYLut[*aSourceDataPtr++];
+
+ pixel = LutY0 + LutC;
+
+ if (pixel & OverflowMask)
+ {
+ if (pixel & 0xC0000000U)
+ {
+ if (pixel & 0x80000000U)
+ {
+ pixel &= ~0x3FC00000U;
+ }
+ else
+ {
+ pixel |= 0x3FC00000U;
+ }
+ }
+ if (pixel & 0x00180000U)
+ {
+ if (pixel & 0x00100000U)
+ {
+ pixel &= ~0x0007F800U;
+ }
+ else
+ {
+ pixel |= 0x0007F800U;
+ }
+ }
+ if (pixel & 0x00000300U)
+ {
+ if (pixel & 0x00000200U)
+ {
+ pixel &= ~0x000000FFU;
+ }
+ else
+ {
+ pixel |= 0x000000FFU;
+ }
+ }
+ }
+
+ r = (pixel >> 6) & 0xFF0000;
+ g = (pixel >> 3) & 0x00FF00;
+ b = pixel & 0x0000FF;
+
+ *destDataPtr++ = 0xFF000000 | r | g | b;
+
+ pixel = LutY1 + LutC;
+
+ if (pixel & OverflowMask)
+ {
+ if (pixel & 0xC0000000U)
+ {
+ if (pixel & 0x80000000U)
+ {
+ pixel &= ~0x3FC00000U;
+ }
+ else
+ {
+ pixel |= 0x3FC00000U;
+ }
+ }
+ if (pixel & 0x00180000U)
+ {
+ if (pixel & 0x00100000U)
+ {
+ pixel &= ~0x0007F800U;
+ }
+ else
+ {
+ pixel |= 0x0007F800U;
+ }
+ }
+ if (pixel & 0x00000300U)
+ {
+ if (pixel & 0x00000200U)
+ {
+ pixel &= ~0x000000FFU;
+ }
+ else
+ {
+ pixel |= 0x000000FFU;
+ }
+ }
+ }
+
+ r = (pixel >> 6) & 0xFF0000;
+ g = (pixel >> 3) & 0x00FF00;
+ b = pixel & 0x0000FF;
+
+ *destDataPtr++ = 0xFF000000 | r | g | b;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::NewL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawDP* CVtEngDrawDP::NewL(
+ MDisplaySinkObserver* aObserver )
+ {
+ __VTPRINTENTER( "RVD(DP).NewL" )
+ CVtEngDrawDP* self = new ( ELeave ) CVtEngDrawDP( aObserver );
+ CleanupStack::PushL( self );
+ self->ConstructL( );
+ CleanupStack::Pop();
+ __VTPRINTEXIT( "RVD(DP).NewL" )
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::~CVtEngDrawDP
+// Destructor. Cannot leave.
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawDP::~CVtEngDrawDP()
+ {
+ __VTPRINTENTER( "RVD(DP).~" )
+ Cancel();
+ delete iFrameBuffer;
+ delete iBufferWaiter;
+ delete iPostingSurface;
+ __VTPRINT( DEBUG_MEDIA , "RVD(DP).~ RRegion::Close()" )
+ iClipRegion.Close();
+ CloseDPLibrary();
+
+ delete iTarget;
+ delete iSource;
+ delete iImageScaler;
+ __VTPRINTEXIT( "RVD(DP).~" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CVtEngDraw
+// C++ constructor. Cannot leave.
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawDP::CVtEngDrawDP( MDisplaySinkObserver* aObserver ) :
+ CVtEngDraw( aObserver ), iClipRegion( 1 ),
+ iPostingFormat( KDefaultPostingFormat422 )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseConstructL
+// Base construction.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseConstructL()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseConstructL" )
+ if ( IsFlag( EFlagUIForeground ) )
+ {
+ DoBaseConstructL();
+ }
+ else
+ {
+ SetFlag( EBaseConstructCalled );
+ }
+ __VTPRINTEXIT( "RVD(DP).BaseConstructL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CreateSinkL
+// Instantiates display sink.
+// -----------------------------------------------------------------------------
+//
+MDisplaySink* CVtEngDrawDP::CreateSinkL()
+ {
+ __VTPRINTENTER( "RVD(DP).CreateSinkL" )
+ TDisplaySinkParamsDP params;
+ GetSinkParams( params );
+ MDisplaySink* sink = ::CreateSinkL( params, KNullDesC8 );
+ if ( IsFlag( EBaseConstructCalled ) )
+ {
+ sink->Pause();
+ SetFlag( ESinkParamUpdateRequired | ESinkResumeRequired );
+ }
+ __VTPRINTEXIT( "RVD(DP).CreateSinkL" )
+ return sink;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngRemoteVideo::CVtEngDraw::BaseRefreshL
+// Draw a frame.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseRefreshL()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseRefreshL" )
+ __VTPRINTEXIT( "RVD(DP).BaseRefreshL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseRefreshBitmapsL
+// Refreshes bitmaps sizes and display mode if needed.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseRefreshBitmapsL()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseRefreshBitmapsL" )
+ BaseConstructL();
+ InitializePostingSurfaceL();
+ // set the params for DS
+ UpdateSinkParamsL();
+ ClearFlag( EFirstFrameReceived );
+ __VTPRINTEXIT( "RVD(DP).BaseRefreshBitmapsL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseDoCancel
+// DoCancel for derived class.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseDoCancel()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseDoCancel" )
+ __VTPRINTEXIT( "RVD(DP).BaseDoCancel" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseVerifyConfigL
+// Checks current configuration against DP implementation.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseVerifyConfigL()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseVerifyConfigL" )
+ // Check support for requested size
+ if ( !SupportsSize( iSourceSize ) )
+ {
+ __VTPRINT( DEBUG_MEDIA ,
+ "RVD(DP).BaseVerifyConfigL Size NOT supported" )
+ User::Leave( KErrNotSupported );
+ }
+ RecalculateClipRegionL();
+ __VTPRINTEXIT( "RVD(DP).BaseVerifyConfigL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseRestartL
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseRestartL()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseRestartL" )
+ if ( IsFlag( EFlagUIForeground ) )
+ {
+ RecalculateClipRegionL();
+ iBufferWaiter->FetchBuffer();
+ }
+ __VTPRINTEXIT( "RVD(DP).BaseRestartL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseAbortNow
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseAbortNow()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseAbortNow" )
+ UpdateVtFrame();
+ __VTPRINTEXIT( "RVD(DP).BaseAbortNow" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::StartDrawL
+// Starts the drawing.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseStartDrawL()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseStartDrawL" )
+ if ( IsFlag( EBaseConstructCalled ) )
+ {
+ SetFlag( EBaseBaseStartDrawCalled );
+ }
+ else
+ {
+ DoBaseStartDrawL();
+ }
+ __VTPRINTEXIT( "RVD(DP).BaseStartDrawL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseStopDraw
+// Stop the drawing.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseStopDraw()
+ {
+ // Cancel the timer in any case.
+ __VTPRINTENTER( "RVD(DP).BaseStopDraw" )
+ ClearFlag( EBaseBaseStartDrawCalled );
+ iWatcher->Cancel();
+ if ( iDSA )
+ {
+ ClearFlag( ERemoteVideoDrawing | EStarted );
+ iDSA->Cancel();
+ }
+ iBufferWaiter->Cancel();
+ Cancel();
+ __VTPRINTEXIT( "RVD(DP).BaseStopDraw" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseSetConfigL
+// Sets new configuration.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseSetConfigL( const TVtEngRenderConfig& aConfig )
+ {
+ __VTPRINTENTER( "RVD(DP).BaseSetConfigL" )
+ Mem::FillZ( &iConfig, sizeof( TVtEngRenderConfigDP ) );
+ iConfig = aConfig;
+ if ( IsFlag( EBaseConstructCalled ) )
+ {
+ SetFlag( EBaseSetConfigCalled );
+ }
+ else
+ {
+ ConfigUpdatedL();
+ }
+ __VTPRINTEXIT( "RVD(DP).BaseSetConfigL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseSetUIForegroundL
+// Sets UI foreground status.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseSetUIForegroundL( TBool aForeground )
+ {
+ __VTPRINTENTER( "RVD(DP).BaseSetUIForegroundL" )
+ if( aForeground )
+ {
+ TBool wasSentToBackground( IsFlag( ESentToBackground ) );
+ SetFlag( EFlagUIForeground );
+ ClearFlag( ESentToBackground );
+ if( IsFlag( EDelayedCallsMask ) )
+ {
+ HandleDelayedCallsL();
+ }
+ if ( wasSentToBackground )
+ {
+ BaseRefreshBitmapsL();
+ Restart( RDirectScreenAccess::ETerminateCancel );
+ BaseStartDrawL();
+ }
+ }
+ else
+ {
+ if ( !IsFlag( EBaseConstructCalled ) )
+ {
+ BaseStopDraw();
+ delete iPostingSurface;
+ iPostingSurface = 0;
+ for ( TInt i = MDisplaySink::EFirstBitmap;
+ i < MDisplaySink::EFirstBitmap + KVtEngMaxBuffers; i++ )
+ {
+ iBuffers[ i ].UnSet();
+ }
+ SetFlag( ESentToBackground );
+ }
+ ClearFlag( EFlagUIForeground );
+ }
+ __VTPRINTEXIT( "RVD(DP).BaseSetUIForegroundL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseRequestLastFrame
+// Request update last remote video frame through MVtEngFrameObserver::vtSetFrame
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseRequestLastFrame()
+ {
+ __VTPRINTENTER( "RVD(DP).BaseRequestLastFrame" )
+ UpdateVtFrame();
+ __VTPRINTEXIT( "RVD(DP).BaseRequestLastFrame" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BaseVideoFrameSizeChangedL
+// Called when incoming frame buffer size changes.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BaseVideoFrameSizeChangedL( const TSize& aTo )
+ {
+ __VTPRINTENTER( "RVD(DP).BaseVideoFrameSizeChangedL" )
+ CreateFrameBufferL( aTo );
+ __VTPRINTEXIT( "RVD(DP).BaseVideoFrameSizeChangedL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::Config
+// Returns current configuration.
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderConfig& CVtEngDrawDP::Config()
+ {
+ return iConfig;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::RunL
+// CActive heir execution method.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::RunL()
+ {
+ __VTPRINTENTER( "RVD(DP).RunL" )
+
+ TInt bitmapNo( iStatus.Int() );
+
+ if ( bitmapNo < KErrNone )
+ {
+ __VTPRINT( DEBUG_MEDIA, "RVD(DP).RunL notify rvd problem" )
+ CVtEngEventManager::NotifyEvent( KVtEngRemoteRenderingProblem );
+ return;
+ }
+
+ TVtEngBuffer& buffer = iBuffers[ bitmapNo ];
+
+ if ( !iDSUpdated )
+ {
+ __VTPRINT( DEBUG_MEDIA, "RVD(DP).RunL !Updated" )
+ __VTPRINTEXIT( "RVD(DP).RunL" )
+ return;
+ }
+ else if ( !IsFlag( EFlagUIForeground ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "RVD(DP).RunL !Flag( EFlagUIForeground )" )
+ __VTPRINTEXIT( "RVD(DP).RunL" )
+ if ( iPostingSurface )
+ {
+ iPostingSurface->PostBuffer( buffer.Buffer() );
+ buffer.UnSet();
+ iBufferWaiter->FetchBuffer();
+ }
+ return;
+ }
+ else if ( buffer.Buffer() == NULL )
+ {
+ __VTPRINT( DEBUG_MEDIA, "RVD(DP).RunL signalled with NULL buffer" )
+ TInt result( iBufferWaiter->FetchBuffer() );
+ __VTPRINT2( DEBUG_MEDIA,
+ "RVD(DP).RunL FetchBuffer %d", result )
+ User::LeaveIfError( result );
+ __VTPRINTEXIT( "RVD(DP).RunL" )
+ return;
+ }
+
+ // Image received, reset counter.
+ iCheckpoint = KVtEngWatcherThreshold;
+
+ StoreFrameBuffer( buffer.Buffer() );
+ __VTPRINT2( DEBUG_MEDIA, "RVD(DP).RunL flags=%d", iFlags )
+ TBool firstFrame( !IsFlag ( EFirstFrameReceived ) );
+ SetFlag( EFirstFrameReceived );
+ // Remote video is about to start?
+ if ( !IsFlag( EStarted ) && IsFlag( EReadyInternal ) )
+ {
+ if ( !iDSA->IsActive() )
+ {
+ iDSA->StartL();
+ }
+ SetFlag( EStarted );
+ if ( !iConfig.iClipRect.IsEmpty() )
+ {
+ SetFlag( EReadyForeground );
+ iDSA->Gc()->SetClippingRect( iConfig.iClipRect );
+ RecalculateClipRegionL();
+ }
+ __VTPRINT( DEBUG_MEDIA, "RVD(DP).RunL notify rvd start" )
+ //CVtEngEventManager::NotifyEvent( KVtEngRemoteVideoStarted );
+ }
+ if ( firstFrame )
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngRemoteVideoStarted );
+ }
+ TRAPD( setClipRegResult, SetClipRegionL() );
+ if ( setClipRegResult )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "RVD(DP).RunL SetClipRegionL failed %d",
+ setClipRegResult );
+ }
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).RunL received buffer %d $%x",
+ bitmapNo,
+ reinterpret_cast< TUint >( buffer.Buffer() ) )
+ TInt result
+ ( iPostingSurface->PostBuffer( buffer.Buffer() ) );
+ __VTPRINT2( DEBUG_MEDIA, "RVD(DP).RunL PostBuffer %d", result )
+ buffer.UnSet();
+ if ( iBuffers[ KVtEngBitmapNoReversed[ bitmapNo ] ].IsSet() )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "RVD(DP).RunL reactivating for buffer %d",
+ KVtEngBitmapNoReversed[ bitmapNo ] )
+ Activate();
+ DisplaySink().NextFrame();
+ }
+
+ if ( result == KErrNotReady )
+ {
+ BaseRefreshBitmapsL();
+ result = KErrNone;
+ }
+
+ User::LeaveIfError( result );
+ result = iBufferWaiter->FetchBuffer();
+ __VTPRINT2( DEBUG_MEDIA,
+ "RVD(DP).RunL FetchBuffer %d", result )
+ User::LeaveIfError( result );
+
+ __VTPRINTEXIT( "RVD(DP).RunL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::BufferReady
+// BufferReady
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::BufferReady( CPostingSurface::TPostingBuff* aBuffer )
+ {
+ __VTPRINTENTER( "RVD(DP).BufferReady" )
+ SetAvailableToSink( aBuffer );
+ __VTPRINTEXIT( "RVD(DP).BufferReady" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::FetchError
+// Buffer fetching error
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::FetchError( TInt )
+ {
+ __VTPRINTENTER( "RVD(DP).FetchError" )
+ CVtEngEventManager::NotifyEvent( KVtEngRemoteRenderingProblem );
+ __VTPRINTEXIT( "RVD(DP).FetchError" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::HandleDelayedCallsL
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::HandleDelayedCallsL()
+ {
+ __VTPRINTENTER( "RVD(DP).HandleDelayedCallsL" )
+ if ( IsFlag( EBaseConstructCalled ) )
+ {
+ DoBaseConstructL();
+ }
+ if ( IsFlag( EBaseSetConfigCalled ) )
+ {
+ ConfigUpdatedL();
+ ClearFlag( EBaseSetConfigCalled );
+ }
+ if ( IsFlag( EInitializePostingSurfaceCalled ) )
+ {
+ DoInitializePostingSurfaceL();
+ }
+ if ( IsFlag( ESinkParamUpdateRequired ) )
+ {
+ DoUpdateSinkParamsL();
+ }
+ if ( IsFlag( EBaseBaseStartDrawCalled ) )
+ {
+ DoBaseStartDrawL();
+ }
+ __VTPRINTEXIT( "RVD(DP).HandleDelayedCallsL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::DoBaseConstructL
+// Base construction implementation
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::DoBaseConstructL()
+ {
+ __VTPRINTENTER( "RVD(DP).DoBaseConstructL" )
+
+ if ( !iImageScaler )
+ {
+ iImageScaler =
+ CVtImageScaler::NewL( *this, CVtImageScaler::EBilinear );
+ }
+ delete iBufferWaiter;
+ iBufferWaiter = NULL;
+ delete iPostingSurface;
+ iPostingSurface = NULL;
+
+ // Load DP API library
+ LoadDPLibraryL();
+
+ // Create posting surface instance
+ iPostingSurface = CreatePostingSurfaceL();
+
+ CPostingSurface::TPostingFormat previousPostingFormat( iPostingFormat );
+
+ // Check support for format
+ if ( !SupportsFormat( KDefaultPostingFormat420 ) )
+ {
+ if ( !SupportsFormat( KDefaultPostingFormat422 ) )
+ {
+ __VTPRINT( DEBUG_MEDIA ,
+ "RVD(DP).BaseConstructL Format NOT supported" )
+ User::Leave( KErrNotSupported );
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA , "RVD(DP).BaseConstructL using 422" )
+ iPostingFormat = KDefaultPostingFormat422;
+ }
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA , "RVD(DP).BaseConstructL using 420" )
+ iPostingFormat = KDefaultPostingFormat420;
+ }
+ iPostingSurface->GetCapabilities( iPostingCaps );
+ iBufferWaiter =
+ new ( ELeave ) CVtEngBufferWaiter( *iPostingSurface, *this );
+ for ( TInt i = MDisplaySink::EFirstBitmap;
+ i < MDisplaySink::EFirstBitmap + KVtEngMaxBuffers; i++ )
+ {
+ iBuffers[ i ].UnSet();
+ }
+
+ // If posting for is different from previous, then free frame buffer
+ if ( ( previousPostingFormat != iPostingFormat ) || !iFrameBuffer )
+ {
+ CreateFrameBufferL( iSourceSize );
+ }
+ ClearFlag( EBaseConstructCalled );
+ __VTPRINTEXIT( "RVD(DP).DoBaseConstructL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::UpdateSinkParamsL
+// Updates sink params
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::UpdateSinkParamsL()
+ {
+ __VTPRINTENTER( "RVD(DP).UpdateSinkParamsL" )
+ if ( IsFlag( EBaseConstructCalled ) )
+ {
+ SetFlag( ESinkParamUpdateRequired );
+ }
+ else
+ {
+ DoUpdateSinkParamsL();
+ }
+ __VTPRINTEXIT( "RVD(DP).UpdateSinkParamsL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::DoBaseStartDrawL
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::DoBaseStartDrawL()
+ {
+ __VTPRINTENTER( "RVD(DP).DoBaseStartDrawL" )
+ UpdateVtFrame();
+ if ( iDSA )
+ {
+ SetFlag( EReadyInternal );
+ if ( !iWatcher->IsActive() )
+ {
+ iWatcher->Start( KVtEngWatcherTimeout, KVtEngWatcherTimeout,
+ iCallback );
+ }
+ User::LeaveIfError( iBufferWaiter->FetchBuffer() );
+ SetFlag( ERemoteVideoDrawing );
+ }
+ else
+ {
+ User::Leave( KErrNotReady );
+ }
+ ClearFlag( EBaseBaseStartDrawCalled );
+ __VTPRINTEXIT( "RVD(DP).DoBaseStartDrawL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::DoInitializePostingSurfaceL
+// Initializes posting surface.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::DoInitializePostingSurfaceL()
+ {
+ __VTPRINTENTER( "RVD(DP).DoInitializePostingSurfaceL" )
+ CPostingSurface::TPostingSourceParams postingSourceParams;
+ GetPostingSourceParams( postingSourceParams );
+ CPostingSurface::TPostingParams postingParams;
+ GetPostingParams( postingParams );
+ // Create and start DSA for getting access to DP
+ CreateAndStartDSAL();
+
+ /*S60 Display Posting API has a limitation that only one surface instance can be
+ created at a time. Unfortunately there's no way to check when posting is really
+ free. PostingSurface initialization maybe returns KErrInUse.
+ Please refer to TSW error EAKC-7R3TME.
+ The transition effect between landscape and portrait uses ATID to achieve smooth
+ transition. ATID and PostingSurface share the same buffers and cannot be used
+ simultaneously. PostingSurface initialization maybe returns KErrNotReady.
+ Please refer to TSW error EWXO-7P4DV3.
+ So it probably requires some kind of timer based retry to bypass these cases.*/
+ TInt err;
+ while (1)
+ {
+ __VTPRINT( DEBUG_MEDIA, "RVD(DP).DoInitializePostingSurfaceL Initialize PostingSurface" );
+ TRAP( err, iPostingSurface->InitializeL(postingSourceParams, postingParams) );
+ if ( err == KErrNone)
+ {
+ break;
+ }
+ else
+ {
+ //time interval for each PostingSurface initialization is 0.2 second.
+ __VTPRINT2( DEBUG_MEDIA, "RVD(DP).DoInitializePostingSurfaceL InitPS error = %d", err )
+ User::After(200000);
+ }
+ }
+
+ delete iTarget; iTarget = NULL;
+ iTarget = CVtImageBitmap::NewL(
+ postingParams.iDisplayedRect.Size(), EColor16MU );
+ if ( iSource )
+ {
+ if ( IsFlag( EFrameBufferFilled ) &&
+ !IsFlag( EFrameBufferNeedsConvertAndScale ) )
+ {
+ iImageScaler->ScaleNowL( *iSource, *iTarget );
+ Config().iObserver->vtSetFrame(
+ MVtEngFrameObserver::ERemoteVideoFrame,
+ &iTarget->Bitmap() );
+ }
+ else
+ {
+ Config().iObserver->vtSetFrame(
+ MVtEngFrameObserver::ERemoteVideoFrame, NULL );
+ }
+ }
+ else
+ {
+ //delete iSource; iSource = NULL;
+ iSource = CVtImageBitmap::NewL( iSourceSize, EColor16MU );
+ Config().iObserver->vtSetFrame( MVtEngFrameObserver::ERemoteVideoFrame,
+ NULL );
+ }
+ RecalculateClipRegionL();
+ ClearFlag( EInitializePostingSurfaceCalled );
+ __VTPRINTEXIT( "RVD(DP).DoInitializePostingSurfaceL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::DoUpdateSinkParamsL
+// Updates sink params
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::DoUpdateSinkParamsL()
+ {
+ __VTPRINTENTER( "RVD(DP).DoUpdateSinkParamsL" )
+ TDisplaySinkParamsDP params;
+ GetSinkParams( params );
+ DisplaySink().UpdateSinkParamsL( params, iDSUpdated );
+ ClearFlag( ESinkParamUpdateRequired );
+ if ( IsFlag( ESinkResumeRequired ) )
+ {
+ DisplaySink().Resume();
+ ClearFlag( ESinkResumeRequired );
+ }
+ __VTPRINTEXIT( "RVD(DP).DoUpdateSinkParamsL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::IsAlphaTrashed
+// Checks if the alpha has been trashed on screen buffer.
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::IsAlphaTrashed() const
+ {
+ __VTPRINTENTER( "RVD(DP).IsAlphaTrashed" )
+ TBool isTrashed( EFalse );
+ const CFbsScreenDevice& sdev( *iDSA->ScreenDevice() );
+ if ( sdev.DisplayMode() == EColor16MA )
+ {
+ TRgb color;
+ TPoint point( iClipRegion.BoundingRect().Center() );
+ sdev.GetPixel( color, point );
+ isTrashed = ( color.Alpha() != 0 );
+ }
+ __VTPRINTEXITR( "RVD(DP).IsAlphaTrashed %d", isTrashed )
+ return isTrashed;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SetClipRegionL
+// Sets clipping region for DP.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::SetClipRegionL()
+ {
+ __VTPRINTENTER( "RVD(DP).SetClipRegionL" )
+ if ( iClipRegionUpdated || IsAlphaTrashed() )
+ {
+ iClipRegionUpdated = EFalse;
+ CFbsBitGc* gc = iDSA->Gc();
+ gc->SetClippingRegion( iDSA->DrawingRegion() );
+ gc->SetDrawMode( CGraphicsContext::EDrawModeAND );
+ gc->SetBrushColor( TRgb( 255, 255, 255, 0 ) );
+ gc->Clear();
+ iDSA->ScreenDevice()->Update();
+ User::LeaveIfError(
+ iPostingSurface->SetClipRegion( iClipRegion ) );
+ }
+ __VTPRINTEXIT( "RVD(DP).SetClipRegionL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::InitializePostingSurfaceL
+// Initializes posting surface.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::InitializePostingSurfaceL()
+ {
+ __VTPRINTENTER( "RVD(DP).InitializePostingSurfaceL" )
+ if ( IsFlag( EBaseConstructCalled ) )
+ {
+ SetFlag( EInitializePostingSurfaceCalled );
+ }
+ else
+ {
+ DoInitializePostingSurfaceL();
+ }
+ __VTPRINTEXIT( "RVD(DP).InitializePostingSurfaceL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::GetPostingSourceParams
+// Fills posting source params structure.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::GetPostingSourceParams(
+ CPostingSurface::TPostingSourceParams& aParams ) const
+ {
+ __VTPRINTENTER( "RVD(DP).GetPostingSourceParams" )
+ Mem::FillZ( &aParams, sizeof( CPostingSurface::TPostingSourceParams ) );
+ aParams.iPostingBuffering = KDefaultPostingBufferingFlags;
+ aParams.iBufferType = CPostingSurface::EStandardBuffer;
+ aParams.iPostingUsage = CPostingSurface::EVideoCapture;
+ aParams.iSourceImageSize = iSourceSize;
+ aParams.iPostingFormat = iPostingFormat;
+ aParams.iPixelAspectRatioNum = KDefaultPixelAspectRatioNum;
+ aParams.iPixelAspectRatioDenom = KDefaultPixelAspectRatioDenom;
+ aParams.iContentCopyRestricted = EFalse;
+ __VTPRINTEXIT( "RVD(DP).GetPostingSourceParams" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::GetPostingParams
+// Fills posting params structure.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::GetPostingParams(
+ CPostingSurface::TPostingParams& aParams ) const
+ {
+ __VTPRINTENTER( "RVD(DP).GetPostingParams" )
+ Mem::FillZ( &aParams, sizeof( CPostingSurface::TPostingParams ) );
+
+ aParams.iDisplayedRect = iConfig.iClipRect;
+
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).GetPostingParams DRect.iTl (%d, %d)",
+ aParams.iDisplayedRect.iTl.iX, aParams.iDisplayedRect.iTl.iY );
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).GetPostingParams DRect.iBr (%d, %d)",
+ aParams.iDisplayedRect.iBr.iX, aParams.iDisplayedRect.iBr.iY );
+
+ TRect& dispRect( aParams.iDisplayedRect );
+ dispRect.Move( iConfig.iOffset );
+ FixRectForDP( dispRect );
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).GetPostingParams OffsDRect.iTl (%d, %d)",
+ dispRect.iTl.iX, dispRect.iTl.iY );
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).GetPostingParams OffsDRect.iBr (%d, %d)",
+ dispRect.iBr.iX, dispRect.iBr.iY );
+
+ aParams.iScaleToRect = TRect( aParams.iDisplayedRect.Size() );
+
+ aParams.iInputCrop = iSourceSize;
+
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).GetPostingParams InputCrop.iTl (%d, %d)",
+ aParams.iInputCrop.iTl.iX, aParams.iInputCrop.iTl.iY );
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).GetPostingParams InputCrop.iBr (%d, %d)",
+ aParams.iInputCrop.iBr.iX, aParams.iInputCrop.iBr.iY );
+
+ aParams.iBackGround = iConfig.iBackGround;
+ __VTPRINTEXIT( "RVD(DP).GetPostingParams" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SupportsFormat
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::SupportsFormat(
+ const CPostingSurface::TPostingFormat& aFormat ) const
+ {
+ return iPostingSurface->FormatSupported( aFormat );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SupportsSize
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::SupportsSize( const TSize& aSize ) const
+ {
+ return ( iPostingCaps.iMaxPixelSize.iWidth >= aSize.iWidth ) &&
+ ( iPostingCaps.iMaxPixelSize.iHeight >= aSize.iHeight );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SupportsRotation
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::SupportsRotation(
+ CPostingSurface::TRotationType aRotation ) const
+ {
+ return ( ( aRotation & iPostingCaps.iSupportedRotations ) == aRotation );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SupportsMirroring
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::SupportsMirroring() const
+ {
+ return iPostingCaps.iSupportsMirroring;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SupportsScaling
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::SupportsScaling() const
+ {
+ return iPostingCaps.iSupportsScaling;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SupportsBrightness
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::SupportsBrightness() const
+ {
+ return iPostingCaps.iSupportsBrightnessControl;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SupportsContrast
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::SupportsContrast() const
+ {
+ return iPostingCaps.iSupportsContrastControl;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::GetFrameBufferSize
+// Returns size of frame buffer in bytes for given pixel size and current
+// posting format.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngDrawDP::GetFrameBufferSize( const TSize& aSize ) const
+ {
+ TInt size( -1 );
+ __VTPRINTENTER( "RVD(DP).GetFrameBufferSize" )
+ switch( iPostingFormat )
+ {
+ case KDefaultPostingFormat420:
+ size = ( aSize.iWidth * aSize.iHeight * 3 ) >> 1;
+ break;
+
+ case KDefaultPostingFormat422:
+ size = ( aSize.iWidth * aSize.iHeight ) * 2;
+ break;
+
+ default:
+ break;
+ }
+ __VTPRINTEXITR( "RVD(DP).GetFrameBufferSize %d", size )
+ return size;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::RecalculateClipRegionL
+// Updates clipregion.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::RecalculateClipRegionL()
+ {
+ __VTPRINTENTER( "RVD(DP).RecalculateClipRegionL" )
+ // Clip region needs to be updated
+ iClipRegionUpdated = ETrue;
+ iClipRegion.Clear();
+ TRect clippingRect( iConfig.iClipRect );
+ clippingRect.Move( iConfig.iOffset );
+ FixRectForDP( clippingRect );
+ iClipRegion.AddRect( clippingRect );
+ if ( iClipRegion.CheckError() )
+ {
+ __VTPRINT( DEBUG_MEDIA ,
+ "RVD(DP).RecalculateClipRegionL failed to add cliprect" )
+ User::Leave( KErrNoMemory );
+ }
+
+ if ( IsFlag( EStarted ) && iDSA && iDSA->DrawingRegion() )
+ {
+ iClipRegion.Intersect( *iDSA->DrawingRegion() );
+ if ( iClipRegion.CheckError() )
+ {
+ __VTPRINT( DEBUG_MEDIA ,
+ "RVD(DP).RecalculateClipRegionL failed to intersect" )
+ User::Leave( KErrNoMemory );
+ }
+
+#ifdef VTDEBUG
+
+ TRect bRect( iClipRegion.BoundingRect() );
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).RecalculateClipRegionL BRect.iTl (%d, %d)",
+ bRect.iTl.iX, bRect.iTl.iY );
+ __VTPRINT3( DEBUG_MEDIA, "RVD(DP).RecalculateClipRegionL BRect.iBr (%d, %d)",
+ bRect.iBr.iX, bRect.iBr.iY );
+#endif // VTDEBUG
+ }
+ __VTPRINTEXIT( "RVD(DP).RecalculateClipRegionL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::FixRectForDP
+// Fixes rect for DP (i.e. width is made even and starting X coordinate is made
+// even as well)
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::FixRectForDP( TRect& aRect ) const
+ {
+ __VTPRINTENTER( "RVD(DP).FixRectForDP" )
+ if ( aRect.iTl.iX & 1 )
+ {
+ aRect.Move( 1, 0 );
+ aRect.SetWidth( Max( 0, aRect.Width() - 1 ) );
+ }
+ if ( aRect.Width() & 1 )
+ {
+ aRect.SetWidth( aRect.Width() - 1 );
+ }
+ __VTPRINTEXIT( "RVD(DP).FixRectForDP" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::RecalculateClipRegionL
+// Fills sink params.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::GetSinkParams( TDisplaySinkParamsDP& aSinkParams )
+ {
+ __VTPRINTENTER( "RVD(DP).GetSinkParams" )
+ Mem::FillZ( &aSinkParams, sizeof( TDisplaySinkParamsDP ) );
+ aSinkParams.iThreadId = RThread().Id();
+ aSinkParams.iRequestStatusPtr = &iStatus;
+ aSinkParams.iObserver = iObserver;
+ aSinkParams.iPostingBuffer1 = &iBuffers[ 0 ].Buffer();
+ aSinkParams.iPostingBuffer2 = &iBuffers[ 1 ].Buffer();
+ aSinkParams.iFrameSize = iSourceSize;
+ aSinkParams.iPostingFormat = iPostingFormat;
+ aSinkParams.iFlags = TDisplaySinkParams::EDisplaySinkDP;
+ __VTPRINTEXITR( "RVD(DP).GetSinkParams flags=%d",
+ (TInt) aSinkParams.iFlags )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::DisplaySink
+// Returns reference to sink.
+// -----------------------------------------------------------------------------
+//
+MDisplaySink& CVtEngDrawDP::DisplaySink()
+ {
+ return *iDisplaySink;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::StoreFrameBuffer
+// Stores given frame buffer.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::StoreFrameBuffer(
+ CPostingSurface::TPostingBuff* aPostingBuffer )
+ {
+ __VTPRINTENTER( "RVD(DP).StoreFrameBuffer" )
+ if ( iPostingFormat == KDefaultPostingFormat422 )
+ {
+ const TInt height( iSourceSize.iHeight );
+ const TInt srcStride( aPostingBuffer->GetStride() );
+ const TInt dstStride( iSourceSize.iWidth * 2 );
+ TUint8* dst =
+ const_cast< TUint8* >( iFrameBuffer->Des().Ptr() );
+ const TUint8* src =
+ reinterpret_cast< const TUint8* >( aPostingBuffer->GetBuffer() );
+ for ( TInt y = height - 1; y >= 0; y-- )
+ {
+ dst = Mem::Copy( dst, src, dstStride );
+ src += srcStride;
+ }
+ }
+ else
+ {
+ TInt frameBufferSizeInBytes( GetFrameBufferSize( iSourceSize ) );
+ TPtrC8 postingBufferDesC(
+ reinterpret_cast< const TUint8* >( aPostingBuffer->GetBuffer() ),
+ frameBufferSizeInBytes );
+ *iFrameBuffer = postingBufferDesC;
+ }
+ SetFlag( EFrameBufferFilled | EFrameBufferNeedsConvertAndScale );
+ __VTPRINTEXIT( "RVD(DP).StoreFrameBuffer" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CreateFrameBufferL
+// Creates frame buffer.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::CreateFrameBufferL( const TSize& aSize )
+ {
+ __VTPRINTENTER( "RVD(DP).CreateFrameBufferL" )
+ delete iFrameBuffer; iFrameBuffer = NULL;
+ iFrameBuffer = HBufC8::NewL( GetFrameBufferSize( aSize ) );
+ ClearFlag( EFrameBufferFilled | EFrameBufferNeedsConvertAndScale );
+ __VTPRINTEXIT( "RVD(DP).CreateFrameBufferL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SetAvailableToSink
+// Sets posting buffer available to sink.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::SetAvailableToSink( CPostingSurface::TPostingBuff* aBuffer )
+ {
+ __VTPRINTENTER( "RVD(DP).SetAvailableToSink" )
+ for ( TInt i = MDisplaySink::EFirstBitmap;
+ i < MDisplaySink::EFirstBitmap + KVtEngMaxBuffers; i++ )
+ {
+ if ( !iBuffers[ i ].IsSet() )
+ {
+ __VTPRINT3( DEBUG_MEDIA,
+ "RVD(DP).SetAvailableToSink buffer %d: $%x",
+ i, reinterpret_cast< TUint >( aBuffer->GetBuffer() ) );
+ iBuffers[ i ].Set( aBuffer );
+ Activate();
+ DisplaySink().SetBitmapAvailable(
+ static_cast< MDisplaySink::TBitmapNo >( i ) );
+ break;
+ }
+ }
+ __VTPRINTEXIT( "RVD(DP).SetAvailableToSink" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::SetAvailableToSink
+// Sets posting buffer available to sink.
+// -----------------------------------------------------------------------------
+//
+CPostingSurface* CVtEngDrawDP::CreatePostingSurfaceL()
+ {
+ __VTPRINTENTER( "RVD(DP).CreatePostingSurfaceL" )
+ CPostingSurface* postingSurface = NULL;
+ CPostingSurfaceFactory* ( *createFactoryL )() =
+ reinterpret_cast< CPostingSurfaceFactory*(*)() >( iDPLib->Lookup( 1 ) );
+ if ( createFactoryL )
+ {
+ CPostingSurfaceFactory* factory = createFactoryL();
+ CleanupStack::PushL( factory );
+ postingSurface = factory->NewPostingSurfaceL( EMainDisplay );
+ CleanupStack::PopAndDestroy(); // factory
+ }
+ __VTPRINTEXIT( "RVD(DP).CreatePostingSurfaceL" )
+ return postingSurface;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CloseDPLibrary
+// Close the DP API library and free the allocated instance.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::CloseDPLibrary()
+ {
+ if ( iDPLib )
+ {
+ iDPLib->Close();
+ delete iDPLib;
+ iDPLib = NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::LoadDPLibraryL
+// Loads DP API library.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::LoadDPLibraryL()
+ {
+ CloseDPLibrary();
+ iDPLib = new ( ELeave ) RLibrary();
+ TInt error( iDPLib->Load( KDPAPIDLLName() ) );
+ if ( error )
+ {
+ delete iDPLib;
+ iDPLib = NULL;
+ User::Leave( error );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::Convert420ToVtImg
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::Convert420ToVtImg( HBufC8* aSource,
+ CVtImageBitmap& aTarget )
+ {
+ __VTPRINTENTER( "RVD(DP).Convert420ToVtImg" )
+
+ CFbsBitmap& bitmap( aTarget.Bitmap() );
+ TSize size( bitmap.SizeInPixels() );
+ TInt height( size.iHeight );
+ TInt width( size.iWidth );
+ TInt bytes( bitmap.ScanLineLength( width, bitmap.DisplayMode() ) );
+
+ const TUint8* y1ptr = aSource->Ptr();
+ const TUint8* y2ptr = y1ptr + width;
+ const TUint8* uptr = y1ptr + ( width * height );
+ const TUint8* vptr = uptr + ( width * height ) / 4;
+
+ bitmap.LockHeap();
+
+ TUint8* d1ptr = reinterpret_cast< TUint8* >( bitmap.DataAddress() );
+ TUint8* d2ptr = d1ptr + bytes;
+
+ height /= 2; // divide by 2 because we process to rows at time
+ bytes *= 2; // multiply by 2 so we don't need to do it in loop
+
+ while ( height-- )
+ {
+ DoConvertYuv420toXRGB0888( width, y1ptr, y2ptr, uptr, vptr, d1ptr,
+ d2ptr );
+ y1ptr = y2ptr;
+ y2ptr += width;
+ d1ptr += bytes;
+ d2ptr += bytes;
+ }
+
+ bitmap.UnlockHeap();
+
+ __VTPRINTEXIT( "RVD(DP).Convert420ToVtImg" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::Convert422ToVtImg
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::Convert422ToVtImg( HBufC8* aSource, CVtImageBitmap& aTarget )
+ {
+ __VTPRINTENTER( "RVD(DP).Convert422ToVtImg" )
+ CFbsBitmap& bitmap( aTarget.Bitmap() );
+ TSize size( bitmap.SizeInPixels() );
+ TInt height( size.iHeight );
+ TInt width( size.iWidth );
+ TInt bytes( bitmap.ScanLineLength( width, bitmap.DisplayMode() ) );
+
+ const TUint8* sptr = aSource->Ptr();
+
+ bitmap.LockHeap();
+
+ TUint8* dptr = reinterpret_cast< TUint8* >( bitmap.DataAddress() );
+ while ( height-- )
+ {
+ DoConvertYuv422toXRGB0888( width, sptr, dptr );
+ dptr += bytes;
+ }
+
+ bitmap.UnlockHeap();
+
+ __VTPRINTEXIT( "RVD(DP).Convert422ToVtImg" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::UpdateVtFrame
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::UpdateVtFrame()
+ {
+ __VTPRINTENTER( "RVD(DP).UpdateVtFrame" )
+ if ( IsFlag( EFrameBufferFilled ) )
+ {
+ CFbsBitmap* bitmap = NULL;
+ if ( IsFlag( EFrameBufferNeedsConvertAndScale ) )
+ {
+ if ( iPostingFormat == KDefaultPostingFormat422 )
+ {
+ Convert422ToVtImg( iFrameBuffer, *iSource );
+ }
+ else
+ {
+ Convert420ToVtImg( iFrameBuffer, *iSource );
+ }
+ TRAPD( error, iImageScaler->ScaleNowL( *iSource, *iTarget ) );
+ if ( !error )
+ {
+ bitmap = &iTarget->Bitmap();
+ }
+ ClearFlag( EFrameBufferNeedsConvertAndScale );
+ }
+ else
+ {
+ bitmap = &iTarget->Bitmap();
+ }
+ Config().iObserver->vtSetFrame( MVtEngFrameObserver::ERemoteVideoFrame,
+ bitmap );
+ }
+ __VTPRINTEXIT( "RVD(DP).UpdateVtFrame" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::ScalingFinished
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::ScalingFinished( TInt )
+ {
+ }
+
+// Implementation for CVtEngDrawDP::TVtEngBuffer
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::TVtEngBuffer::TVtEngBuffer
+//
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawDP::TVtEngBuffer::TVtEngBuffer()
+ : iBuffer( 0 )
+ {
+ __VTPRINTENTER( "RVD(DP).Buffer.Ctor" )
+ __VTPRINTEXIT( "RVD(DP).Buffer.Ctor" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::TVtEngBuffer::Set
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::TVtEngBuffer::Set( CPostingSurface::TPostingBuff* aBuffer )
+ {
+ __VTPRINTENTER( "RVD(DP).Buffer.Set" )
+ __VTPRINT2( DEBUG_MEDIA, "RVD(DP).Buffer.Set $%x",
+ reinterpret_cast< TUint >( aBuffer->GetBuffer() ) )
+ iBuffer = aBuffer;
+ __VTPRINTEXIT( "RVD(DP).Buffer.Set" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::TVtEngBuffer::UnSet
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::TVtEngBuffer::UnSet()
+ {
+ __VTPRINTENTER( "RVD(DP).Buffer.UnSet" )
+ iBuffer = 0;
+ __VTPRINTEXIT( "RVD(DP).Buffer.UnSet" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::TVtEngBuffer::IsSet
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawDP::TVtEngBuffer::IsSet() const
+ {
+ return ( iBuffer != 0 );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::TVtEngBuffer::Buffer
+//
+// -----------------------------------------------------------------------------
+//
+CPostingSurface::TPostingBuff*& CVtEngDrawDP::TVtEngBuffer::Buffer()
+ {
+ return iBuffer;
+ }
+
+// Implementation for CVtEngDrawDP::CVtEngBufferWaiter
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CVtEngBufferWaiter::CVtEngBufferWaiter
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawDP::CVtEngBufferWaiter::CVtEngBufferWaiter
+ ( CPostingSurface& aPostingSurface, MVtEngBufferWaiterObserver& aObserver )
+ : CActive( CActive::EPriorityStandard ),
+ iPostingSurface( &aPostingSurface ), iObserver( &aObserver )
+ {
+ __VTPRINTENTER( "RVD(DP).BufferWaiter.Ctor" )
+ CActiveScheduler::Add( this );
+ __VTPRINTEXIT( "RVD(DP).BufferWaiter.Ctor" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CVtEngBufferWaiter::~CVtEngBufferWaiter
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawDP::CVtEngBufferWaiter::~CVtEngBufferWaiter()
+ {
+ __VTPRINTENTER( "RVD(DP).BufferWaiter.~" )
+ Cancel();
+ __VTPRINTEXIT( "RVD(DP).BufferWaiter.~" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CVtEngBufferWaiter::Activate
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::CVtEngBufferWaiter::Activate()
+ {
+ __VTPRINTENTER( "RVD(DP).BufferWaiter.Activate" )
+ iStatus = KRequestPending;
+ SetActive();
+ __VTPRINTEXIT( "RVD(DP).BufferWaiter.Activate" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CVtEngBufferWaiter::FetchBuffer
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngDrawDP::CVtEngBufferWaiter::FetchBuffer()
+ {
+ __VTPRINTENTER( "RVD(DP).BufferWaiter.FetchBuffer" )
+ // do nothing if we're already active
+ if ( IsActive() )
+ {
+ __VTPRINTEXIT( "RVD(DP).BufferWaiter.FetchBuffer" )
+ return KErrNone;
+ }
+ // else start fetching
+ Activate();
+ __VTPRINTEXIT( "RVD(DP).BufferWaiter.FetchBuffer" )
+ return iPostingSurface->WaitForNextBuffer( iStatus );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CVtEngBufferWaiter::RunL
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::CVtEngBufferWaiter::RunL()
+ {
+ __VTPRINTENTER( "RVD(DP).BufferWaiter.RunL" )
+ __VTPRINT2( DEBUG_MEDIA, "RVD(DP).BufferWaiter.RunL %d", iStatus.Int() );
+ TInt result( iStatus.Int() );
+ if ( result == KErrNone )
+ {
+ iObserver->BufferReady( iPostingSurface->NextBuffer() );
+ }
+ else
+ {
+ iObserver->FetchError( result );
+ }
+ __VTPRINTEXIT( "RVD(DP).BufferWaiter.RunL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawDP::CVtEngBufferWaiter::DoCancel
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawDP::CVtEngBufferWaiter::DoCancel()
+ {
+ __VTPRINTENTER( "RVD(DP).BufferWaiter.DoCancel" )
+ iPostingSurface->CancelBuffer();
+ __VTPRINTEXIT( "RVD(DP).BufferWaiter.DoCancel" )
+ }
+
+// End of File