1 // Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifndef __MBMCODEC_H__

    17 #define __MBMCODEC_H__

    18 

    19 #include <bitdev.h>

    20 #include <icl/imageprocessor.h>

    21 #include <icl/imagecodec.h>

    22 #include <icl/imagecodecdata.h>

    23 

    24 #include "MBMConvert.h"

    25 

    26 

    27 // Constants.

    28 const TInt KMbmRootStreamOffsetPosition = 16;

    29 const TInt KMbmFirstBitmapOffset = KMbmRootStreamOffsetPosition + 4;

    30 const TInt KMbmInfoHeaderSize = 40;

    31 

    32 // Helper classes.

    33 class TMbmReadCodec

    34 	{

    35 public:

    36 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit) = 0;

    37 	void AddPixelRun(TRgb aColor,TInt aNumberOfPixels);

    38 public:

    39 	CImageProcessor* iImageProc;

    40 	};

    41 

    42 class T1BppMbmReadCodec : public TMbmReadCodec

    43 	{

    44 public:

    45 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

    46 	void AddPixelValue(TUint8 aValue);

    47 	};

    48 

    49 class T1BppCompressedMbmReadCodec : public T1BppMbmReadCodec

    50 	{

    51 public:

    52 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

    53 	void AddPixelRun(TUint8 aValue,TInt aNumberOfValues);

    54 	};

    55 

    56 class T2BppMbmReadCodec : public TMbmReadCodec

    57 	{

    58 public:

    59 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

    60 	void AddPixelValue(TUint8 aValue);

    61 	};

    62 

    63 class T2BppCompressedMbmReadCodec : public T2BppMbmReadCodec

    64 	{

    65 public:

    66 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

    67 	void AddPixelRun(TUint8 aValue,TInt aNumberOfQuads);

    68 	};

    69 

    70 class T4BppMbmReadCodec : public TMbmReadCodec

    71 	{

    72 public:

    73 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

    74 	virtual TRgb ColorFromIndex(TInt aIndex) = 0;

    75 	};

    76 

    77 class T4BppCompressedMbmReadCodec : public T4BppMbmReadCodec

    78 	{

    79 public:

    80 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

    81 	void AddPixelRun(TRgb aColor1,TRgb aColor2,TInt aNumberOfPairs);

    82 	};

    83 

    84 class T4BppMonoMbmReadCodec : public T4BppMbmReadCodec

    85 	{

    86 public:

    87 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Gray16(aIndex); }

    88 	};

    89 

    90 class T4BppMonoCompressedMbmReadCodec : public T4BppCompressedMbmReadCodec

    91 	{

    92 public:

    93 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Gray16(aIndex); }

    94 	};

    95 

    96 class T4BppColorMbmReadCodec : public T4BppMbmReadCodec

    97 	{

    98 public:

    99 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Color16(aIndex); }

   100 	};

   101 

   102 class T4BppColorCompressedMbmReadCodec : public T4BppCompressedMbmReadCodec

   103 	{

   104 public:

   105 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Color16(aIndex); }

   106 	};

   107 

   108 class T8BppMbmReadCodec : public TMbmReadCodec

   109 	{

   110 public:

   111 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   112 	virtual TRgb ColorFromIndex(TInt aIndex) = 0;

   113 	};

   114 

   115 class T8BppCompressedMbmReadCodec : public T8BppMbmReadCodec

   116 	{

   117 public:

   118 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   119 	};

   120 

   121 class T8BppMonoMbmReadCodec : public T8BppMbmReadCodec

   122 	{

   123 public:

   124 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Gray256(aIndex); }

   125 	};

   126 

   127 class T8BppMonoCompressedMbmReadCodec : public T8BppCompressedMbmReadCodec

   128 	{

   129 public:

   130 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Gray256(aIndex); }

   131 	};

   132 

   133 class T8BppColorMbmReadCodec : public T8BppMbmReadCodec

   134 	{

   135 public:

   136 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Color256(aIndex); }

   137 	};

   138 

   139 class T8BppColorCompressedMbmReadCodec : public T8BppCompressedMbmReadCodec

   140 	{

   141 public:

   142 	virtual TRgb ColorFromIndex(TInt aIndex) { return TRgb::Color256(aIndex); }

   143 	};

   144 

   145 class T12BppMbmReadCodec : public TMbmReadCodec

   146 	{

   147 public:

   148 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   149 	};

   150 

   151 class T12BppCompressedMbmReadCodec : public TMbmReadCodec

   152 	{

   153 public:

   154 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   155 	};

   156 

   157 class T16BppMbmReadCodec : public TMbmReadCodec

   158 	{

   159 public:

   160 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   161 	};

   162 

   163 class T16BppCompressedMbmReadCodec : public TMbmReadCodec

   164 	{

   165 public:

   166 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   167 	};

   168 

   169 class T24BppMbmReadCodec : public TMbmReadCodec

   170 	{

   171 public:

   172 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   173 	};

   174 

   175 class T24BppCompressedMbmReadCodec : public T24BppMbmReadCodec

   176 	{

   177 public:

   178 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   179 	};

   180 

   181 class T32BppMbmReadCodec : public TMbmReadCodec

   182 	{

   183 public:

   184 	virtual void DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit);

   185 	};

   186 

   187 // MBM Read codec.

   188 class CMbmReadCodec : public CImageProcessorReadCodec

   189 	{

   190 public:

   191 	virtual void InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aFrame, CFbsBitmap* aFrameMask);

   192 

   193 	static CMbmReadCodec* NewL(TUint32 aMbmRootStreamOffset);

   194 

   195 protected:

   196 	virtual ~CMbmReadCodec();

   197 

   198 	virtual void InitFrameHeader(TFrameInfo& aFrameSettings, CFrameImageData& aFrameImageData);

   199 	virtual TFrameState ProcessFrameHeaderL(TBufPtr8& aData);

   200 	virtual TFrameState ProcessFrameL(TBufPtr8& aSrc);

   201 

   202 private:

   203 	CMbmReadCodec(TUint32 aMbmRootStreamOffset);

   204 

   205 	TBool ProcessInfoL(TBufPtr8* aSrc);

   206 	TInt ScanLinePixels(TInt aWidth);

   207 	void SetCodecProcessorL();

   208 	

   209 	static TDisplayMode DisplayModeL(TInt aBitsPerPixel, TUint32 aFlags);

   210 	

   211 protected:

   212 	TFrameInfo* iFrameInfo;

   213 	CFrameImageData *iImageData;

   214 

   215 	TMbmDecodeData* iFrameData;

   216 	TBool iCompressed;

   217 	TInt iByteLength;

   218 	TUint8* iDataPtr;

   219 	TUint8* iStartDataPtr;

   220 	TUint8* iDataPtrLimit;

   221 	TMbmReadCodec* iCodecProc;

   222 	TInt32 iMbmRootStreamOffset;

   223 	TInt iNumberOfFrames;

   224 	TInt iFrameDataRemaining;

   225 	};

   226 

   227 

   228 // Write codec classes.

   229 class TWriteCodecProcessor

   230 	{

   231 public:

   232 	virtual TInt PixelsToBytes(TInt aPixels) = 0;

   233 	virtual TInt BytesToPixels(TInt aBytes) = 0;

   234 	};

   235 

   236 class T1BppWriteCodecProcessor : public TWriteCodecProcessor

   237 	{

   238 public:

   239 	virtual TInt PixelsToBytes(TInt aPixels) { return (aPixels + 7) >> 3; }

   240 	virtual TInt BytesToPixels(TInt aBytes) { return aBytes << 3; }

   241 	};

   242 

   243 class T2BppWriteCodecProcessor : public TWriteCodecProcessor

   244 	{

   245 public:

   246 	virtual TInt PixelsToBytes(TInt aPixels) { return (aPixels + 3) >> 2; }

   247 	virtual TInt BytesToPixels(TInt aBytes) { return aBytes << 2; }

   248 	};

   249 

   250 class T4BppWriteCodecProcessor : public TWriteCodecProcessor

   251 	{

   252 public:

   253 	virtual TInt PixelsToBytes(TInt aPixels) { return (aPixels + 1) >> 1; }

   254 	virtual TInt BytesToPixels(TInt aBytes) { return aBytes << 1; }

   255 	};

   256 

   257 class T8BppWriteCodecProcessor : public TWriteCodecProcessor

   258 	{

   259 public:

   260 	virtual TInt PixelsToBytes(TInt aPixels) { return aPixels; }

   261 	virtual TInt BytesToPixels(TInt aBytes) { return aBytes; }

   262 	};

   263 

   264 class T16BppWriteCodecProcessor : public TWriteCodecProcessor

   265 	{

   266 public:

   267 	virtual TInt PixelsToBytes(TInt aPixels) { return aPixels << 1; }

   268 	virtual TInt BytesToPixels(TInt aBytes) { return aBytes >> 1; }

   269 	};

   270 

   271 class T24BppWriteCodecProcessor : public TWriteCodecProcessor

   272 	{

   273 public:

   274 	virtual TInt PixelsToBytes(TInt aPixels) { return aPixels * 3; }

   275 	virtual TInt BytesToPixels(TInt aBytes) { return aBytes / 3; }

   276 	};

   277 

   278 class T32BppWriteCodecProcessor : public TWriteCodecProcessor

   279 	{

   280 public:

   281 	virtual TInt PixelsToBytes(TInt aPixels) { return aPixels * 4; }

   282 	virtual TInt BytesToPixels(TInt aBytes) { return aBytes / 4; }

   283 	};

   284 

   285 class CMbmWriteCodec : public CImageWriteCodec

   286 	{

   287 public:

   288 	virtual ~CMbmWriteCodec();

   289 

   290 	static CMbmWriteCodec* NewL(TDisplayMode aDisplayMode);

   291 

   292 protected:

   293 	virtual TFrameState ProcessFrameL(TBufPtr8& aDst);

   294 	virtual void InitFrameL(TBufPtr8& aDst, const CFbsBitmap& aFrame);

   295 

   296 	// New functions

   297 	void DoProcessL(const CFbsBitmap& aFrame);

   298 	TInt ScanLinePixels(TInt aWidth);

   299 

   300 private:

   301 	CMbmWriteCodec(TDisplayMode aDisplayMode);

   302 

   303 

   304 protected:

   305 	TRect iSourceRect;

   306 	TPoint iPos;

   307 	TDisplayMode iDisplayMode;

   308 	TWriteCodecProcessor* iCodecProc;

   309 	TUint8* iDataPtr;

   310 	TUint8* iDataPtrLimit;

   311 	TInt iPaddingBytes;

   312 	TInt iBytesToWrite;

   313 	TBool iStreamTablePending;

   314 	};

   315 

   316 

   317 #endif // __MBMCODEC_H__

   318