1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "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 * Nokia Corporation - Initial contribution

    11 *

    12 * Contributors:

    13 * Ixonos Plc

    14 *

    15 * Description:  

    16 *

    17 */

    18 

    19 

    20 

    21 #include "CJpeg.h"

    22 #include <e32svr.h>

    23 

    24 

    25 const TUint8 KQuantIndex[ 3 ] = { 0,1,1 };

    26 const TUint8 KHuffIndex[ 3 ] = { 0,1,1 };

    27 

    28 

    29 

    30 

    31 const TUint8 KZigZag[] = {

    32 						 0, 8,   1,  2,  9, 16, 24, 17,

    33 						10, 3,   4, 11, 18, 25, 32, 40,

    34 						33, 26, 19, 12,  5,  6, 13, 20,

    35 						27, 34, 41, 48, 56, 49, 42, 35,

    36 						28, 21, 14,  7, 15, 22, 29, 36,

    37 						43, 50, 57, 58, 51, 44, 37, 30,

    38 						23, 31, 38, 45, 52, 59, 60, 53,

    39 						46, 39, 47, 54, 61, 62, 55, 63

    40 						};

    41 

    42 

    43 

    44 

    45 

    46 

    47 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */

    48 /* IMPORTANT: these are only valid for 8-bit data precision! */

    49 

    50 const TUint8 bits_dc_luminance[17] =

    51 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };

    52 const TUint8 val_dc_luminance[] =

    53 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

    54 

    55 const TUint8 bits_dc_chrominance[17] =

    56 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };

    57 const TUint8 val_dc_chrominance[] =

    58 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

    59 

    60 const TUint8 bits_ac_luminance[17] =

    61 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };

    62 const TUint8 val_ac_luminance[] =

    63 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,

    64   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,

    65   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,

    66   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,

    67   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,

    68   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,

    69   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,

    70   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,

    71   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,

    72   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,

    73   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,

    74   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,

    75   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,

    76   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,

    77   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,

    78   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,

    79   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,

    80   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,

    81   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,

    82   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

    83   0xf9, 0xfa 

    84 };

    85 

    86 const TUint8 bits_ac_chrominance[17] =

    87 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };

    88 

    89 const TUint8 val_ac_chrominance[] =

    90 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,

    91   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,

    92   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,

    93   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,

    94   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,

    95   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,

    96   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,

    97   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,

    98   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,

    99   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,

   100   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,

   101   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

   102   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,

   103   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,

   104   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,

   105   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,

   106   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,

   107   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,

   108   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,

   109   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

   110   0xf9, 0xfa 

   111 };

   112 

   113 const TUint8 KExifHeader[] = "Exif";

   114 

   115 class THuffman

   116 	{

   117 	public:

   118 		TInt8 iLength[ 256 ];

   119 		TUint8 iSymbol[ 256 ];

   120 		TUint8 iSearch[ 65536 ];

   121 	};

   122 

   123 

   124 CJpeg* CJpeg::NewL()

   125 	{

   126 	CJpeg* self = NewLC();

   127 	CleanupStack::Pop( self );

   128 	return self;

   129 	}

   130 

   131 

   132 CJpeg* CJpeg::NewLC()

   133 	{

   134 	CJpeg* self = new( ELeave )CJpeg();

   135 	CleanupStack::PushL( self );

   136 	self->ConstructL();

   137 	return self;

   138 	}

   139 

   140 

   141 CJpeg::~CJpeg()

   142 	{

   143 	delete iHuffman[ 0 ];

   144 	delete iHuffman[ 1 ];

   145 	delete iHuffman[ 2 ];

   146 	delete iHuffman[ 3 ];

   147 

   148 	delete iQt[ 0 ];

   149 	delete iQt[ 1 ];

   150 	delete iQt[ 2 ];

   151 	delete iQt[ 3 ];

   152 

   153 	iCurrentQt = NULL;

   154 	iExifData = NULL;

   155 

   156 	//iBlock.Reset();

   157 	delete iBlock;

   158 

   159 	delete iBuffer;

   160 	delete iC[ 0 ];

   161 	delete iC[ 1 ];

   162 	delete iC[ 2 ];

   163 

   164 	//iDebug.Close();

   165 	//iFs.Close();

   166 	}

   167 

   168 CJpeg::CJpeg()

   169 	{

   170 

   171 	}

   172 

   173 void CJpeg::ConstructL()

   174 	{

   175 	}

   176 

   177 

   178 

   179 

   180 void CJpeg::OpenL( const TFileName& aFile )

   181 	{

   182 	if (iBuffer)

   183 		{

   184 		delete iBuffer;

   185 		iBuffer = NULL;

   186 		}

   187 	

   188 	RFs fs;

   189 	User::LeaveIfError( fs.Connect() );

   190 	CleanupClosePushL( fs );

   191 	

   192 	RFile file;

   193 	TInt err = file.Open( fs, aFile, EFileRead | EFileShareReadersOnly );

   194 	if (KErrNone != err)

   195 		{

   196 		User::LeaveIfError( file.Open( fs, aFile, EFileRead | EFileShareAny ) );

   197 		}

   198 	CleanupClosePushL( file );

   199 	

   200 	TInt size;

   201 	file.Size( size );

   202 	iBuffer = new( ELeave )TUint8[ size + 2 ];

   203 	TPtr8 ptr( iBuffer, size );

   204 	file.Read( ptr );

   205 	

   206 	CleanupStack::PopAndDestroy( 2 ); // file, fs

   207 	OpenL( ptr );

   208 	}

   209 

   210 

   211 

   212 void CJpeg::OpenL( const TPtr8& aData )

   213 	{

   214 	//iFs.Connect();

   215 	//iDebug.Replace( iFs, _L("e:\\TestData\\jpdeb.txt"), EFileWrite );

   216 

   217 	EnableRgvConv();

   218 

   219 	iBuffer = (TUint8*)aData.Ptr();

   220 	

   221 	// if used again, all variables should be cleared

   222 	iBuf = 0;

   223 	iBufBits = 0;

   224 	

   225 	delete iHuffman[ 0 ];

   226 	delete iHuffman[ 1 ];

   227 	delete iHuffman[ 2 ];

   228 	delete iHuffman[ 3 ];

   229 	iHuffman[ 0 ] = 0;

   230 	iHuffman[ 1 ] = 0;

   231 	iHuffman[ 2 ] = 0;

   232 	iHuffman[ 3 ] = 0;

   233 

   234 	//iDebug.Write( _L8("d1\n") );

   235 

   236 	//

   237 	// This is only needed if no huffman tables found

   238 	//

   239 	//CreateDefaultHuffmanL();

   240 

   241 

   242 	iQt[ 0 ] = 0;

   243 	iQt[ 1 ] = 0;

   244 	iQt[ 2 ] = 0;

   245 	iQt[ 3 ] = 0;

   246 

   247 	//

   248 

   249 	//TBitmapHandle bm;

   250 	//bm.iData = 0;

   251 

   252 	TBool moreChunks = ETrue;

   253 	TBool possibleChunk = EFalse;

   254 

   255 //	TInt pos;

   256 

   257 	while( moreChunks )

   258 		{

   259 		TUint8 b = iBuffer[ iBufPos++ ];

   260 		if( possibleChunk )

   261 			{

   262 			possibleChunk = EFalse;

   263 			switch( b )

   264 				{

   265 				case 0xd8: // start of image

   266 					{

   267 				    //RDebug::Print( _L("--Jpeg start of image") );

   268 					//iDebug.Write( _L8("d2\n") );

   269 					break;

   270 					}

   271 				case 0xe0: // JFIF application segment

   272 					{

   273 					//RDebug::Print( _L("--Jpeg application segment") );

   274 					//iDebug.Write( _L8("d3\n") );

   275 					break;

   276 					}

   277 				case 0xe1: // APP1 segment, possible EXIF

   278 					{

   279 					//iDebug.Write( _L8("d4\n") );

   280 					//RDebug::Print( _L("--Jpeg app1 segment") );

   281 					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   282 					l -= 2;

   283 

   284 					// this could be used to read exif data:

   285 					//TPtrC8 exifData( iBuffer + iBufPos, l );

   286 

   287 					// Check that there is "Exif" header in the data

   288 					const TUint8* pos = &iBuffer[ iBufPos ];

   289 					if (Mem::Compare(pos, 2, &KExifHeader[0], 2 ))

   290 					{

   291 						iBufPos += l;

   292 						break;

   293 					}

   294 

   295 					// suppose there is exif here

   296 					// exif header is 6 bytes ( 45 78 69 66 00 00 "Exif.." )

   297 					iBufPos += 6;

   298 					l -= 6;

   299 

   300 					iExifData = iBuffer + iBufPos;

   301 					iExifDataLength = l;

   302 

   303 					iBufPos += l;

   304 					break;

   305 					}

   306 				case 0xe2:

   307 				case 0xe3:

   308 				case 0xe4:

   309 				case 0xe5:

   310 				case 0xe6:

   311 				case 0xe7:

   312 				case 0xe8:

   313 				case 0xe9:

   314 				case 0xea:

   315 				case 0xeb:

   316 				case 0xec:

   317 				case 0xed:

   318 				case 0xee:

   319 				case 0xef:

   320 					{

   321 					//iDebug.Write( _L8("d5\n") );

   322 					//

   323 					// Unused segment, skip

   324 					// 

   325 					//RDebug::Print( _L("--Jpeg unused tag %x"), b );

   326 					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   327 

   328 					iBufPos += l-2;

   329 					break;

   330 					}

   331 				case 0xdb: // Quantization table

   332 					{

   333 					//iDebug.Write( _L8("d6\n") );

   334 					

   335 					//RDebug::Print( _L("--Jpeg quant table") );

   336 					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   337 					////RDebug::Print( _L("Start:%x length:%d"), iBufPos-2, l );

   338 					TInt nqt = l / 65;

   339 					TInt i;

   340 

   341 					// one or more quantization table

   342 					for( i=0; i<nqt; i++ )

   343 						{

   344 						TUint8 t = iBuffer[ iBufPos++ ];

   345 						TInt n = t & 15;

   346 

   347 						// not used:

   348 						// TInt precision = n >> 4; 

   349 

   350 						if (iQt[ n ])

   351 						{

   352 							delete iQt[ n ];

   353 							iQt[ n ] = NULL;							

   354 						}

   355 						

   356 						iQt[ n ] = new( ELeave )TUint8[ 64 ];

   357 						TInt j;

   358 						for( j=0; j<64; j++ )

   359 							{

   360 							iQt[ n ][ j ] = iBuffer[ iBufPos++ ];

   361 							//RDebug::Print( _L("Quant %d:first=%d"), j, iQt[ n ][ j ] );

   362 							}

   363 						}

   364 

   365 					break;

   366 					}

   367 				case 0xc0: // start of frame ( SOF )

   368 					{

   369 					//iDebug.Write( _L8("d7\n") );

   370 

   371 					//RDebug::Print( _L("--Jpeg start of frame") );

   372 

   373 					//TInt length = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; 

   374 					iBufPos += 2;

   375 

   376 					////RDebug::Print( _L("Start:%x length:%d"), iBufPos-2, length );

   377 

   378 					// not used:

   379 					// TInt precision = iBuffer[ iBufPos ];

   380 					iBufPos++; 

   381 					

   382 					// height

   383 					TInt t = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   384 					iData.iSize.iHeight = t;

   385 					

   386 					// width

   387 					t = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   388 					iData.iSize.iWidth = t;

   389 					

   390 					// component data

   391 					iNumComponents = iBuffer[ iBufPos++ ];

   392 					

   393 					TInt i;

   394 					for( i=0; i<iNumComponents; i++ )

   395 						{

   396 						TInt compID = iBuffer[ iBufPos++ ];

   397 						

   398 						TInt samplingFactor = iBuffer[ iBufPos++ ];

   399 						TInt quantizationTable = iBuffer[ iBufPos++ ];

   400 						iComponent[ i ].iXFactor = samplingFactor >> 4;

   401 						iComponent[ i ].iYFactor = samplingFactor & 15;

   402 						iComponent[ i ].iQuantTable = quantizationTable;

   403 						iComponent[ i ].iID = compID;

   404 						//RDebug::Print( _L("component %d = %d"), i, compID );

   405 						//RDebug::Print( _L("component %d quanttable=%d"), i, quantizationTable );

   406 						//RDebug::Print( _L("component %d factor = %d,%d"), iComponent[ i ].iXFactor, iComponent[ i ].iYFactor );

   407 						}

   408 					

   409 					TInt xBlocks = 0;

   410 					TInt yBlocks = 0;

   411 

   412 					for( i=0; i<iNumComponents; i++ )

   413 						{

   414 						TInt x = iComponent[ i ].iXFactor;

   415 						TInt y = iComponent[ i ].iYFactor;

   416 						if( x > xBlocks )

   417 							{

   418 							xBlocks = x;

   419 							}

   420 						if( y > yBlocks )

   421 							{

   422 							yBlocks = y;

   423 							}

   424 						}

   425 					

   426 					iData.iBlockSize.iWidth = xBlocks * 8;

   427 					iData.iBlockSize.iHeight = yBlocks * 8;

   428 

   429 					TSize size = iData.iSize;

   430 					size.iWidth /= iData.iBlockSize.iWidth;

   431 					size.iHeight /= iData.iBlockSize.iHeight;

   432 

   433 					if( iData.iSize.iWidth & ( iData.iBlockSize.iWidth - 1 ) )

   434 						{

   435 						size.iWidth++;

   436 						}

   437 

   438 					if( iData.iSize.iHeight & ( iData.iBlockSize.iHeight - 1 ) )

   439 						{

   440 						size.iHeight++;

   441 						}

   442 					

   443 					iData.iSizeInBlocks = size;

   444 

   445 

   446 					break;

   447 					}

   448 				case 0xc1:

   449 					{

   450 					//iDebug.Write( _L8("d8\n") );

   451 					//RDebug::Print( _L("--Jpeg tag 0xc1, extended sequential, unsupported") );

   452 

   453 					// Extended sequential Jpeg, not supported

   454 					User::Leave( KErrNotSupported );

   455 					break;

   456 					};

   457 				case 0xc2:

   458 					{

   459 					//iDebug.Write( _L8("d9\n") );

   460 					//RDebug::Print( _L("--Jpeg tag 0xc2, Progressive DCT, unsupported") );

   461 

   462 					// Progressive DCT jpeg, not supported

   463 					User::Leave( KErrNotSupported );

   464 					break;

   465 					};

   466 				case 0xc3:

   467 					{

   468 					//iDebug.Write( _L8("d10\n") );

   469 					

   470 					//RDebug::Print( _L("--Jpeg tag 0xc1, Lossless, unsupported") );

   471 					// Lossless ( sequential ) Jpeg, not supported

   472 					User::Leave( KErrNotSupported );

   473 					break;

   474 					};

   475 	

   476 				case 0xc5:

   477 				case 0xc6:

   478 				case 0xc7:

   479 				case 0xc8:

   480 				case 0xc9:

   481 				case 0xca:

   482 				case 0xcb:

   483 				case 0xcc:

   484 				case 0xcd:

   485 				case 0xce:

   486 				case 0xcf:

   487 					{

   488 					//iDebug.Write( _L8("d11\n") );

   489 					

   490 					//RDebug::Print( _L("--Jpeg tag %x, unknown"), b );

   491 					User::Leave( KErrNotSupported );

   492 					break;

   493 					};

   494 				case 0xc4: // huffman table

   495 					{

   496 					//iDebug.Write( _L8("d12\n") );

   497 

   498 					//RDebug::Print( _L("--Jpeg huffman table") );

   499 					TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   500 					

   501 					TInt table = 0;

   502 

   503 					TInt n = 0;

   504 

   505 					// one or more huffman tables

   506 					while( n<l-2 )

   507 						{

   508 						THuffman* huff = new( ELeave )THuffman;

   509 					

   510 						table = iBuffer[ iBufPos++ ];

   511 						n++;

   512 						TInt huffSize[ 16 ];

   513 						TInt numSymbols = 0;

   514 						TInt i;

   515 

   516 						for( i=0; i<16; i++ )

   517 							{

   518 							TInt size = iBuffer[ iBufPos++ ];

   519 							huffSize[ i ] = size;

   520 							numSymbols += size;

   521 							n++;

   522 							}

   523 

   524 						////RDebug::Print( _L("       # of symbols %d"), numSymbols );

   525 						

   526 						for( i=0; i<numSymbols; i++ )

   527 							{

   528 							TUint8 v = iBuffer[ iBufPos++ ];

   529 							huff->iSymbol[ i ] = v;

   530 							n++;

   531 							}

   532 						

   533 

   534 						// Generate huffman lookup tables ( huffSize, table )

   535 

   536 

   537 						TInt ll;

   538 						TInt p = 0;

   539 						for( ll=0; ll<16; ll++ )

   540 							{

   541 							for( i=0; i<huffSize[ ll ]; i++ )

   542 								{

   543 								huff->iLength[ p++ ] = ll+1;

   544 								}

   545 							}

   546 

   547 						TInt code = 0;

   548 						huff->iLength[ p ] = 0;

   549 						TInt si = huff->iLength[ 0 ];

   550 						TInt lastP = p;						

   551 						

   552 						TInt hc[ 256 ];

   553 						p = 0;

   554 

   555 						while( huff->iLength[ p ] )

   556 							{

   557 							while( huff->iLength[ p ] == si )

   558 								{

   559 								hc[ p++ ] = code++;

   560 								}

   561 							code *= 2;

   562 							si++;

   563 							}

   564 

   565 						ll = 65536;

   566 						for( i=lastP-1; i>=0; i-- )

   567 							{

   568 							TInt t = 16 - huff->iLength[ i ];

   569 							TInt k = hc[ i ] * ( 1 << t );

   570 							TInt j;

   571 							for( j=k; j<ll; j++ )

   572 								{

   573 								huff->iSearch[ j ] = i;

   574 								}

   575 							ll = k;

   576 							}

   577 

   578 						i = ( table & 16 ) / 8 + ( table & 15 );

   579 						delete iHuffman[ i ];						

   580 						iHuffman[ i ] = huff;

   581 						}

   582 					

   583 					break;

   584 					}

   585 //

   586 				case 0xda: // start of scan ( SOS )

   587 					{

   588 					//iDebug.Write( _L8("d13\n") );

   589 

   590 					//RDebug::Print( _L("--Jpeg start of scan") );

   591 					//TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   592 					iBufPos += 2;

   593 					

   594 					TInt numComponents = iBuffer[ iBufPos++ ];

   595 					//RDebug::Print( _L("JPEG: number of components=%d"), numComponents );

   596 					if( numComponents != iNumComponents )

   597 						{

   598 						// non-interleaved( planar ) not supported

   599 						User::Leave( KErrNotSupported );

   600 						}

   601 					//RDebug::Print( _L("Number of components=%d"), numComponents );

   602 					

   603 					TInt componentHt[ 3 ];

   604 					

   605 					TInt i;

   606 					for( i=0; i<numComponents; i++ )

   607 						{

   608 						TInt componentId = iBuffer[ iBufPos++ ];

   609 						// find index by ID

   610 						TInt index = -1;

   611 						for( TInt j=0; j<iNumComponents; j++ )

   612 							{

   613 							if( iComponent[ j ].iID == componentId )

   614 								{

   615 								index = j;

   616 								}

   617 							}

   618 						if( index == -1 )

   619 							{

   620 							// ID not found

   621 							User::Leave( KErrNotSupported );

   622 							}

   623 						componentHt[ index ] = iBuffer[ iBufPos++ ];

   624 						//RDebug::Print( _L("id=%d, ht=%d"), componentId, componentHt[ i ] );

   625 						}

   626 						

   627 					if( componentHt[ 1 ] == 0 || componentHt[ 2 ] == 0 )

   628 						{

   629 						// images with same huffman for all components

   630 						// not yet supported

   631 						//RDebug::Print( _L("jpeg not supported") );

   632 						User::Leave( KErrNotSupported );

   633 						}						

   634 					

   635 

   636 					if( iHuffman[ 0 ] == NULL )

   637 						{

   638 						// no huffman tables found, create default tables

   639 						CreateDefaultHuffmanL();

   640 						}

   641 					

   642 

   643 					iBufPos += 3;

   644 

   645 					iImageDataStart = iBufPos;

   646 					iRandomScanned = false;

   647 					

   648 					moreChunks = EFalse;

   649 

   650 					break;

   651 					}

   652 				case 0xd9: // end of image ( EOI )

   653 					{

   654 					//RDebug::Print( _L("--Jpeg end of image") );

   655 					// not really used for anything

   656 					// will exit if picture data is read.

   657 					break;

   658 					}				

   659 				case 0xdd: // define restart interval

   660 					{

   661 					//RDebug::Print( _L("--Jpeg define restart interval") );

   662 					

   663 					//TInt l = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   664 					iBufPos += 2;

   665 					

   666 					TInt interval = 256 * iBuffer[ iBufPos ] + iBuffer[ iBufPos + 1 ]; iBufPos += 2;

   667 					//iBufPos += 2;

   668 					//RDebug::Print( _L("       interval = %d"), interval );

   669 					iResetInterval = interval;

   670 					

   671 					// not really used for anything

   672 					// restart markers are just handled when they come

   673 					break;

   674 					}

   675 				case 0x00: // escaped 0xff

   676 					{

   677 					// only comes if file is broken somehow

   678 					break;

   679 					}

   680 				default:

   681 					{

   682 					// unknown jpeg tag

   683 					//RDebug::Print( _L("unknown jpeg tag %x"), b );

   684 					break;

   685 					}

   686 				}

   687 			}

   688 		else if( b == 255 )

   689 			{

   690 			possibleChunk = ETrue;

   691 			}

   692 			

   693 		}

   694 

   695 	PrepareLoadBlockL();

   696 	}

   697 

   698 

   699 

   700 void CJpeg::PrepareLoadBlockL()

   701 	{

   702 	if( iLoadBlockPrepared )

   703 		{

   704 		return;

   705 		}

   706 

   707 	// prepare rgb block bitmap

   708 	iBm.iSize = iData.iBlockSize;

   709 	iBm.iDrawRect = iBm.iSize;

   710 	iBlkPixels = iData.iBlockSize.iWidth * iData.iBlockSize.iHeight;

   711 	iBm.iData = NULL;

   712 	iBm.iType = E16MColor;

   713 	

   714 

   715 	// prepare yuv buffers

   716 	iC[ 0 ] = new( ELeave )TUint8[ 64 * iComponent[ 0 ].iXFactor * iComponent[ 0 ].iYFactor ];

   717 	iC[ 1 ] = new( ELeave )TUint8[ 64 * iComponent[ 1 ].iXFactor * iComponent[ 1 ].iYFactor ];

   718 	iC[ 2 ] = new( ELeave )TUint8[ 64 * iComponent[ 2 ].iXFactor * iComponent[ 2 ].iYFactor ];

   719 

   720 	// prepare yuv->rgb scale

   721 	TInt bw = iBm.iSize.iWidth;

   722 	TInt bh = iBm.iSize.iHeight;

   723 	iYxa = 256 * ( 8 * iComponent[ 0 ].iXFactor ) / bw;

   724 	iYya = 256 * ( 8 * iComponent[ 0 ].iYFactor ) / bh;

   725 	iUxa = 256 * ( 8 * iComponent[ 1 ].iXFactor ) / bw;

   726 	iUya = 256 * ( 8 * iComponent[ 1 ].iYFactor ) / bh;

   727 	iVxa = 256 * ( 8 * iComponent[ 2 ].iXFactor ) / bw;

   728 	iVya = 256 * ( 8 * iComponent[ 2 ].iYFactor ) / bh;

   729 

   730 	//

   731 	// Select YUV -> RGB function

   732 	//

   733 	iYuv2rgbFunc = Yuv2RgbFree;	// default, handles all combinations

   734 	

   735 	if( iComponent[ 0 ].iXFactor == 2 && iComponent[ 0 ].iYFactor == 1 &&

   736 		iComponent[ 1 ].iXFactor == 1 && iComponent[ 1 ].iYFactor == 1 &&

   737 		iComponent[ 2 ].iXFactor == 1 && iComponent[ 2 ].iYFactor == 1 )

   738 		{

   739 		iYuv2rgbFunc = Yuv2Rgb21_11_11;

   740 		}

   741 	else if( iComponent[ 0 ].iXFactor == 2 && iComponent[ 0 ].iYFactor == 2 &&

   742 			 iComponent[ 1 ].iXFactor == 1 && iComponent[ 1 ].iYFactor == 1 &&

   743 			 iComponent[ 2 ].iXFactor == 1 && iComponent[ 2 ].iYFactor == 1 )

   744 		{

   745 		iYuv2rgbFunc = Yuv2Rgb22_11_11;

   746 		}

   747 

   748 	iLoadBlockPrepared = true;

   749 	}

   750 

   751 

   752 

   753 void CJpeg::ScanRandomL()

   754 	{

   755 	if( iRandomScanned )

   756 		{

   757 		return;

   758 		}

   759 	//

   760 	// Set file read position

   761 	//

   762 	iBufPos = iImageDataStart;

   763 	iBufBits = 0;

   764 	iBuf = 0;

   765 

   766 	//

   767 	// Reserve memory for random access tables

   768 	//

   769 	TInt numBlocks = iData.iSizeInBlocks.iWidth * iData.iSizeInBlocks.iHeight;

   770 	iBlock = new( ELeave )TJpegBlock[ numBlocks ];

   771 						

   772 	

   773 	TInt bw = iData.iSizeInBlocks.iWidth;

   774 	TInt bh = iData.iSizeInBlocks.iHeight;

   775 

   776 	TInt bx;

   777 	TInt by;

   778 

   779 	TInt c1 = 0;

   780 	TInt c2 = 0;

   781 	TInt c3 = 0;

   782 

   783 	//TInt blockNum = 0;

   784 

   785 	for( by=0; by<bh; by++ )

   786 		{

   787 		////RDebug::Print( _L("Jpeg scan %d/%d"), by+1,bh );

   788 		

   789 		for( bx=0; bx<bw; bx++ )

   790 			{

   791 

   792 			if( iRst )

   793 				{

   794 				iRst = false;

   795 				iBuf = 0;

   796 				iBufBits = 0;

   797 				

   798 				c1 = 0;

   799 				c2 = 0;

   800 				c3 = 0;

   801 				}

   802 			

   803 			// store information for every block 

   804 			TJpegBlock& block = iBlock[ iNumBlocks++ ];

   805 			

   806 			block.iY = c1;

   807 			block.iU = c2;

   808 			block.iV = c3;

   809 			block.iOffset = iBufPos;

   810 			block.iBuf = iBuf;

   811 			block.iBufBits = iBufBits;

   812 			

   813 			//iBlock.Append( block );

   814 			

   815 			TInt i;

   816 			

   817 			// go fast trough all huffman data

   818 			iCurrentHuffman = 0;

   819 			iCurrentQt = iQt[ 0 ];

   820 			

   821 			// Y-component

   822 			TInt n = iComponent[ 0 ].iXFactor * iComponent[ 0 ].iYFactor;

   823 			iDct[ 0 ] = c1;

   824 			for( i=0; i<n; i++ )

   825 				{

   826 				DecodeBlock();

   827 				}

   828 			c1 = iDct[ 0 ];

   829 			

   830 			iCurrentHuffman = 1;

   831 			iCurrentQt = iQt[ 1 ];

   832 			

   833 			// U-component

   834 			n = iComponent[ 1 ].iXFactor * iComponent[ 1 ].iYFactor;

   835 			iDct[ 0 ] = c2;

   836 			for( i=0; i<n; i++ )

   837 				{

   838 				DecodeBlock();

   839 				}

   840 			c2 = iDct[ 0 ];

   841 

   842 			// V-component

   843 			n = iComponent[ 1 ].iXFactor * iComponent[ 1 ].iYFactor;

   844 			iDct[ 0 ] = c3;

   845 			for( i=0; i<n; i++ )

   846 				{

   847 				DecodeBlock();

   848 				}

   849 			c3 = iDct[ 0 ];

   850 

   851 			}

   852 		}

   853 

   854 	iRandomScanned = true;

   855 	

   856 	}

   857 

   858 

   859 

   860 TBitmapHandle CJpeg::LoadBlockL( const TPoint& aBlock )

   861 	{

   862 	TBitmapHandle bm = iBm;

   863 	bm.iData = new( ELeave )TUint32[ iBlkPixels ];

   864 	CleanupStack::PushL(bm.iData);

   865 	TUint32* rgb = (TUint32*) bm.iData;

   866 	

   867 	TInt blkNum = aBlock.iX + aBlock.iY * iData.iSizeInBlocks.iWidth;

   868 

   869 	if( aBlock.iX < 0 || aBlock.iX >= iData.iSizeInBlocks.iWidth )

   870 		{

   871 		blkNum = -1;

   872 		}

   873 	//if( blkNum < 0 || blkNum >= iBlock.Count() )

   874 	if( blkNum < 0 || blkNum >= iNumBlocks )

   875 		{

   876 		Mem::FillZ( bm.iData, iBlkPixels * sizeof( TUint32 ) );

   877 		return bm;

   878 		}

   879 

   880 	TJpegBlock& blk = iBlock[ blkNum ];

   881 

   882 	iBuf = blk.iBuf;

   883 	iBufBits = blk.iBufBits;

   884 	iBufPos = blk.iOffset;

   885 	

   886 	//

   887 	// Decode block

   888 	//

   889 

   890 	TInt c1 = blk.iY;

   891 	TInt c2 = blk.iU;

   892 	TInt c3 = blk.iV;

   893 	

   894 	

   895 	///////////

   896 	TInt x;

   897 	TInt y;

   898 	TInt xx;

   899 	TInt yy;

   900 	TInt w;

   901 	TInt* p;

   902 

   903 	// Y-component

   904 	iCurrentHuffman = 0;

   905 	iCurrentQt = iQt[ 0 ];	

   906 	xx = iComponent[ 0 ].iXFactor;

   907 	yy = iComponent[ 0 ].iYFactor;

   908 	w = xx * 8;

   909 	p = iBlk;

   910 	iDct[ 0 ] = c1;

   911 

   912 	for( y=0; y<yy; y++ )

   913 		{

   914 		for( x=0; x<xx; x++ )

   915 			{

   916 			DecodeBlock2();

   917 			TUint8* tp = iC[ 0 ] + x*8 + y * 8 * w;

   918 			p = iBlk;

   919 

   920 			for( TInt ty=0; ty<8; ty++ )

   921 				{

   922 				for( TInt tx=0; tx<8; tx++ )

   923 					{

   924 					tp[ tx + ty * w ] = *p++;

   925 					}

   926 				}

   927 			}

   928 		}

   929 	

   930 

   931 	// U-component

   932 	iCurrentHuffman = 1;

   933 	iCurrentQt = iQt[ 1 ];	

   934 	xx = iComponent[ 1 ].iXFactor;

   935 	yy = iComponent[ 1 ].iYFactor;

   936 	w = xx * 8;

   937 	p = iBlk;

   938 	iDct[ 0 ] = c2;

   939 

   940 	for( y=0; y<yy; y++ )

   941 		{

   942 		for( x=0; x<xx; x++ )

   943 			{

   944 			DecodeBlock2();

   945 			TUint8* tp = iC[ 1 ] + x*8 + y * 8 * w;

   946 			p = iBlk;

   947 

   948 			for( TInt ty=0; ty<8; ty++ )

   949 				{

   950 				for( TInt tx=0; tx<8; tx++ )

   951 					{

   952 					tp[ tx + ty * w ] = *p++;

   953 					}

   954 				}

   955 			}

   956 		}

   957 

   958 	// V-component

   959 	iCurrentHuffman = 1;

   960 	iCurrentQt = iQt[ 1 ];	

   961 	xx = iComponent[ 2 ].iXFactor;

   962 	yy = iComponent[ 2 ].iYFactor;

   963 	w = xx * 8;

   964 	iDct[ 0 ] = c3;

   965 	

   966 	for( y=0; y<yy; y++ )

   967 		{

   968 		for( x=0; x<xx; x++ )

   969 			{

   970 			DecodeBlock2();

   971 			TUint8* tp = iC[ 2 ] + x*8 + y * 8 * w;

   972 			

   973 			p = iBlk;

   974 			for( TInt ty=0; ty<8; ty++ )

   975 				{

   976 				for( TInt tx=0; tx<8; tx++ )

   977 					{

   978 					tp[ tx + ty * w ] = *p++;

   979 					}

   980 				}

   981 			}

   982 		}

   983 	///////////

   984 

   985 	//

   986 	// Scaled blit YUV->RGB

   987 	//

   988 

   989 	TInt bw = bm.iSize.iWidth;

   990 	TInt bh = bm.iSize.iHeight;

   991 

   992 	

   993 	TInt y1y = 0;

   994 	TInt y1u = 0;

   995 	TInt y1v = 0;

   996 

   997 	TInt yw = iComponent[ 0 ].iXFactor * 8;

   998 	TInt uw = iComponent[ 1 ].iXFactor * 8;

   999 	TInt vw = iComponent[ 2 ].iXFactor * 8;

  1000 	

  1001 	TUint32* prgb = rgb;

  1002 	for( y=0; y<bh; y++ )

  1003 		{

  1004 		TInt txy = 0;

  1005 		TInt txu = 0;

  1006 		TInt txv = 0;

  1007 		TUint8* ccy = iC[ 0 ] + ( y1y/256 ) * yw;

  1008 		TUint8* ccu = iC[ 1 ] + ( y1u/256 ) * uw;

  1009 		TUint8* ccv = iC[ 2 ] + ( y1v/256 ) * vw;

  1010 

  1011 		for( x=0; x<bw; x++ )

  1012 			{

  1013 

  1014 			TInt cy = ccy[ txy / 256 ];

  1015 			TInt cu = ccu[ txu / 256 ] - 128;

  1016 			TInt cv = ccv[ txv / 256 ] - 128;

  1017 			

  1018 			txy += iYxa;

  1019 			txu += iUxa;

  1020 			txv += iVxa;

  1021 

  1022 			TInt cr = cy + ( 91881 * cv ) / 65536;

  1023 			TInt cg = cy - ( 22554 * cu  +  46802 * cv ) / 65536;

  1024 			TInt cb = cy + ( 116130 * cu ) / 65536;

  1025 			

  1026 			if( cr < 0 ) cr = 0;

  1027 			if( cg < 0 ) cg = 0;

  1028 			if( cb < 0 ) cb = 0;

  1029 			if( cr > 255 ) cr = 255;

  1030 			if( cg > 255 ) cg = 255;

  1031 			if( cb > 255 ) cb = 255;

  1032 

  1033 			//rgb[ x + y * bw ] = cr * 65536 + cg * 256 + cb;

  1034 			*prgb++ = cr * 65536 + cg * 256 + cb;

  1035 			}

  1036 		y1y += iYya;

  1037 		y1u += iUya;

  1038 		y1v += iVya;

  1039 		}

  1040 

  1041 	CleanupStack::Pop();

  1042 	return bm;

  1043 	}

  1044 

  1045 

  1046 

  1047 

  1048 void CJpeg::DecodeBlock()

  1049 	{

  1050 	// //RDebug::Print( _L("DecodeBlock()") );

  1051 	//

  1052 	// Dummy version of block decode

  1053 	// only traverses through huffman data

  1054 	// and collects DC-values

  1055 	//

  1056 	THuffman* h = iHuffman[ iCurrentHuffman ];

  1057 	

  1058 	TInt k;

  1059 	for( k=0; k<64; k++ )

  1060 		{

  1061 		TInt v = Buf16();

  1062 		TInt index = h->iSearch[ v ];

  1063 		TInt symbol = h->iSymbol[ index ];

  1064 		BufFwd( h->iLength[ index ] );

  1065 		

  1066 		TInt nullCount = 0;

  1067 		if( k>0 )

  1068 			{

  1069 			nullCount = symbol >> 4;

  1070 			symbol &= 15;

  1071 			}

  1072 	

  1073 		v = BufBits( symbol );

  1074 		if( v < ( 1 << ( symbol-1 ) ) )

  1075 			{

  1076 			v += 1 - ( 1 << symbol );

  1077 			}

  1078 		

  1079 		if( k )

  1080 			{

  1081 			if( nullCount==0 && v==0 )

  1082 				{

  1083 				k = 64;

  1084 				break;

  1085 				}

  1086 			else if( nullCount==15 && v==0 )

  1087 				{

  1088 				k += 15;

  1089 				}

  1090 			else

  1091 				{

  1092 				k += nullCount;

  1093 				}

  1094 			}

  1095 		else

  1096 			{

  1097 			iDct[ 0 ] += v * iCurrentQt[ 0 ];

  1098 			h = iHuffman[ iCurrentHuffman+2 ];

  1099 			}

  1100 		}

  1101 	}

  1102 

  1103 

  1104 

  1105 void CJpeg::DecodeBlock2()

  1106 	{

  1107 	//

  1108 	// Real block decoder

  1109 	// fills iDct table and calls Idct() function

  1110 	//

  1111 	THuffman* h = iHuffman[ iCurrentHuffman ];

  1112 

  1113 	TInt k;

  1114 	

  1115 	for( k=1; k<64; k++ )

  1116 		{

  1117 		iDct[ k ] = 0;

  1118 		}

  1119 

  1120 	for( k=0; k<64; k++ )

  1121 		{

  1122 		TInt v = Buf16();

  1123 		TInt index = h->iSearch[ v ];

  1124 		TInt symbol = h->iSymbol[ index ];

  1125 		BufFwd( h->iLength[ index ] );

  1126 		

  1127 		TInt nullCount = 0;

  1128 		if( k>0 )

  1129 			{

  1130 			nullCount = symbol >> 4;

  1131 			symbol &= 15;

  1132 			}

  1133 		

  1134 		v = BufBits( symbol );

  1135