|
1 /* |
|
2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "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 * |
|
14 * Description: Implementation of FileImageExtJpg class. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include "CIHLFileImageExtJpg.h" |
|
21 |
|
22 #include "CIHLBitmap.h" |
|
23 #include "IHLImplementationIds.h" |
|
24 #include <IHLInterfaceIds.h> |
|
25 #include <IclExtJpegApi.h> |
|
26 |
|
27 // Private namespace for constants and functions |
|
28 namespace |
|
29 { |
|
30 // Fixed scale factors |
|
31 enum TScaleFactors |
|
32 { |
|
33 EHalf = 2, |
|
34 EQuarter = 4, |
|
35 EEighth = 8, |
|
36 }; |
|
37 |
|
38 // Panic function |
|
39 _LIT( KIHLExtJpgPanic, "IHLImageExtJpg" ); |
|
40 void Panic( TInt aPanicCode ) { User::Panic( KIHLExtJpgPanic, aPanicCode ); } |
|
41 } |
|
42 |
|
43 // ============================ MEMBER FUNCTIONS =============================== |
|
44 // ----------------------------------------------------------------------------- |
|
45 // |
|
46 // C++ default constructor can NOT contain any code, that |
|
47 // might leave. |
|
48 // ----------------------------------------------------------------------------- |
|
49 CIHLFileImageExtJpg::CIHLFileImageExtJpg( TInt aImageIndex ) |
|
50 :CActive( CActive::EPriorityStandard ), |
|
51 iImageIndex( aImageIndex ) |
|
52 { |
|
53 CActiveScheduler::Add( this ); |
|
54 } |
|
55 |
|
56 // ----------------------------------------------------------------------------- |
|
57 // |
|
58 // Two-phased constructor. |
|
59 // ----------------------------------------------------------------------------- |
|
60 |
|
61 CIHLFileImageExtJpg* CIHLFileImageExtJpg::NewL( RFs& aFs, const TDesC8& aDataBuf, |
|
62 TInt aImageIndex, const TUint32 aOptions ) |
|
63 { |
|
64 CIHLFileImageExtJpg* self = new (ELeave) CIHLFileImageExtJpg( aImageIndex ); |
|
65 CleanupStack::PushL( self ); |
|
66 self->ConstructL( aFs, aDataBuf, aOptions ); |
|
67 CleanupStack::Pop(); // self |
|
68 return self; |
|
69 } |
|
70 |
|
71 CIHLFileImageExtJpg* CIHLFileImageExtJpg::NewL( RFs& aFs, const TDesC& aFilename, |
|
72 TInt aImageIndex, const TUint32 aOptions ) |
|
73 { |
|
74 CIHLFileImageExtJpg* self = new (ELeave) CIHLFileImageExtJpg( aImageIndex ); |
|
75 CleanupStack::PushL( self ); |
|
76 self->ConstructL( aFs, aFilename, aOptions ); |
|
77 CleanupStack::Pop(); // self |
|
78 return self; |
|
79 } |
|
80 |
|
81 // ----------------------------------------------------------------------------- |
|
82 // |
|
83 // Symbian constructor can leave. |
|
84 // ----------------------------------------------------------------------------- |
|
85 |
|
86 |
|
87 void CIHLFileImageExtJpg::ConstructL( RFs& aFs, const TDesC& aFilename, const TUint32 /*aOptions*/ ) |
|
88 { |
|
89 TRAPD( err, iDecoder = CExtJpegDecoder::FileNewL( CExtJpegDecoder::EHwImplementation, aFs, aFilename ) ); |
|
90 |
|
91 if ( err != KErrNone ) |
|
92 { |
|
93 iDecoder = CExtJpegDecoder::FileNewL( CExtJpegDecoder::ESwImplementation, aFs, aFilename ); |
|
94 } |
|
95 |
|
96 ConstructCommonL(); |
|
97 } |
|
98 |
|
99 void CIHLFileImageExtJpg::ConstructL( RFs& aFs, const TDesC8& aDataBuf, const TUint32 /*aOptions*/ ) |
|
100 { |
|
101 TRAPD( err, iDecoder = CExtJpegDecoder::DataNewL( CExtJpegDecoder::EHwImplementation, aFs, aDataBuf ) ); |
|
102 |
|
103 if ( err != KErrNone ) |
|
104 { |
|
105 iDecoder = CExtJpegDecoder::DataNewL( CExtJpegDecoder::ESwImplementation, aFs, aDataBuf ); |
|
106 } |
|
107 |
|
108 ConstructCommonL(); |
|
109 } |
|
110 |
|
111 // ----------------------------------------------------------------------------- |
|
112 // CIHLFileImageExtJpg::ConstructCommonL |
|
113 // ----------------------------------------------------------------------------- |
|
114 void CIHLFileImageExtJpg::ConstructCommonL() |
|
115 { |
|
116 // Check frame count and image index |
|
117 iImageCount = iDecoder->FrameCount(); |
|
118 __ASSERT_ALWAYS( iImageCount > 0, User::Leave( KErrCorrupt ) ); |
|
119 |
|
120 // Get image types |
|
121 iDecoder->ImageType( iImageIndex, iImageType, iImageSubType ); |
|
122 |
|
123 __ASSERT_ALWAYS( iImageIndex >= 0 && iImageIndex < iImageCount, User::Leave( KErrArgument ) ); |
|
124 |
|
125 // cache frame info and set scale sizes |
|
126 iFrameInfo = iDecoder->FrameInfo( iImageIndex ); |
|
127 if( iFrameInfo.iFlags & TFrameInfo::EFullyScaleable ) |
|
128 { |
|
129 iFullyScaleable = ETrue; |
|
130 } |
|
131 } |
|
132 |
|
133 // ----------------------------------------------------------------------------- |
|
134 // Destructor |
|
135 // ----------------------------------------------------------------------------- |
|
136 CIHLFileImageExtJpg::~CIHLFileImageExtJpg() |
|
137 { |
|
138 Cancel(); |
|
139 delete iDecoder; |
|
140 } |
|
141 |
|
142 // ----------------------------------------------------------------------------- |
|
143 // CIHLFileImageExtJpg::Type |
|
144 // ----------------------------------------------------------------------------- |
|
145 TIHLInterfaceType CIHLFileImageExtJpg::Type() const |
|
146 { |
|
147 return TIHLInterfaceType( KIHLInterfaceIdFileImage, |
|
148 KIHLImplementationIdFileImageExtJpg ); |
|
149 } |
|
150 |
|
151 // ----------------------------------------------------------------------------- |
|
152 // CIHLFileImageExtJpg::ImageType |
|
153 // ----------------------------------------------------------------------------- |
|
154 const TUid& CIHLFileImageExtJpg::ImageType() const |
|
155 { |
|
156 return iImageType; |
|
157 } |
|
158 |
|
159 // ----------------------------------------------------------------------------- |
|
160 // CIHLFileImageExtJpg::ImageSubType |
|
161 // ----------------------------------------------------------------------------- |
|
162 const TUid& CIHLFileImageExtJpg::ImageSubType() const |
|
163 { |
|
164 return iImageSubType; |
|
165 } |
|
166 |
|
167 // ----------------------------------------------------------------------------- |
|
168 // CIHLFileImageExtJpg::ImageIndex |
|
169 // ----------------------------------------------------------------------------- |
|
170 TInt CIHLFileImageExtJpg::ImageIndex() const |
|
171 { |
|
172 return iImageIndex; |
|
173 } |
|
174 |
|
175 // ----------------------------------------------------------------------------- |
|
176 // CIHLFileImageExtJpg::ImageCount |
|
177 // ----------------------------------------------------------------------------- |
|
178 TInt CIHLFileImageExtJpg::ImageCount() const |
|
179 { |
|
180 return iImageCount; |
|
181 } |
|
182 |
|
183 // ----------------------------------------------------------------------------- |
|
184 // CIHLFileImageExtJpg::Size |
|
185 // ----------------------------------------------------------------------------- |
|
186 TSize CIHLFileImageExtJpg::Size() const |
|
187 { |
|
188 return iFrameInfo.iOverallSizeInPixels; |
|
189 } |
|
190 |
|
191 // ----------------------------------------------------------------------------- |
|
192 // CIHLFileImageExtJpg::DisplayMode |
|
193 // ----------------------------------------------------------------------------- |
|
194 TDisplayMode CIHLFileImageExtJpg::DisplayMode() const |
|
195 { |
|
196 TDisplayMode displayMode( iFrameInfo.iFrameDisplayMode ); |
|
197 if( iFrameInfo.iFrameDisplayMode <= EGray256 ) |
|
198 { |
|
199 displayMode = EGray256; |
|
200 } |
|
201 else if( iFrameInfo.iFrameDisplayMode <= EColor256 ) |
|
202 { |
|
203 displayMode = EColor256; |
|
204 } |
|
205 |
|
206 return displayMode; |
|
207 } |
|
208 |
|
209 // ----------------------------------------------------------------------------- |
|
210 // CIHLFileImageExtJpg::MaskDisplayMode |
|
211 // ----------------------------------------------------------------------------- |
|
212 TDisplayMode CIHLFileImageExtJpg::MaskDisplayMode() const |
|
213 { |
|
214 if( iFrameInfo.iFlags & TFrameInfo::ETransparencyPossible ) |
|
215 { |
|
216 if( iFrameInfo.iFlags & TFrameInfo::EAlphaChannel ) |
|
217 { |
|
218 return EGray256; |
|
219 } |
|
220 return EGray2; |
|
221 } |
|
222 return ENone; |
|
223 } |
|
224 |
|
225 // ----------------------------------------------------------------------------- |
|
226 // CIHLFileImageExtJpg::BackgroundColor |
|
227 // ----------------------------------------------------------------------------- |
|
228 TRgb CIHLFileImageExtJpg::BackgroundColor() const |
|
229 { |
|
230 return iFrameInfo.iBackgroundColor; |
|
231 } |
|
232 |
|
233 // ----------------------------------------------------------------------------- |
|
234 // CIHLFileImageExtJpg::CustomLoadSizeArray |
|
235 // ----------------------------------------------------------------------------- |
|
236 const RArray<TSize>& CIHLFileImageExtJpg::CustomLoadSizeArray() const |
|
237 { |
|
238 return iLoadSizeArray; |
|
239 } |
|
240 |
|
241 // ----------------------------------------------------------------------------- |
|
242 // CIHLFileImageExtJpg::IsFullyScaleable |
|
243 // ----------------------------------------------------------------------------- |
|
244 TBool CIHLFileImageExtJpg::IsFullyScaleable() const |
|
245 { |
|
246 return iFullyScaleable; |
|
247 } |
|
248 |
|
249 // ----------------------------------------------------------------------------- |
|
250 // CIHLFileImageExtJpg::IsAnimation |
|
251 // ----------------------------------------------------------------------------- |
|
252 TBool CIHLFileImageExtJpg::IsAnimation() const |
|
253 { |
|
254 return iAnimation; |
|
255 } |
|
256 |
|
257 // ----------------------------------------------------------------------------- |
|
258 // CIHLFileImageExtJpg::AnimationFrameCount |
|
259 // ----------------------------------------------------------------------------- |
|
260 TInt CIHLFileImageExtJpg::AnimationFrameCount() const |
|
261 { |
|
262 return iAnimationFrameCount; |
|
263 } |
|
264 |
|
265 // ----------------------------------------------------------------------------- |
|
266 // CIHLFileImageExtJpg::AnimationFrameDelay |
|
267 // ----------------------------------------------------------------------------- |
|
268 TTimeIntervalMicroSeconds32 CIHLFileImageExtJpg::AnimationFrameDelay( TInt aAnimationFrameIndex ) const |
|
269 { |
|
270 //Animation is not supported |
|
271 ( void ) aAnimationFrameIndex; |
|
272 Panic( KErrNotSupported ); |
|
273 return 0; |
|
274 } |
|
275 |
|
276 // ----------------------------------------------------------------------------- |
|
277 // CIHLFileImageExtJpg::Load |
|
278 // ----------------------------------------------------------------------------- |
|
279 TInt CIHLFileImageExtJpg::Load( TRequestStatus& aStatus, MIHLBitmap& aDestination, TInt aFrameIndex ) |
|
280 { |
|
281 iImageIndex = aFrameIndex; |
|
282 return LoadRequest( aStatus, aDestination, iImageIndex ); |
|
283 } |
|
284 |
|
285 // ----------------------------------------------------------------------------- |
|
286 // CIHLFileImageExtJpg::Load |
|
287 // ----------------------------------------------------------------------------- |
|
288 TInt CIHLFileImageExtJpg::Load( TRect aSrcRect, TRequestStatus& aStatus, MIHLBitmap& aDestination, TInt aFrameIndex ) |
|
289 { |
|
290 TRAPD( err, SetCroppingL( aSrcRect ) ); |
|
291 if( err ) |
|
292 { |
|
293 return err; |
|
294 } |
|
295 iImageIndex = aFrameIndex; |
|
296 return LoadRequest( aStatus, aDestination, iImageIndex ); |
|
297 } |
|
298 |
|
299 // ----------------------------------------------------------------------------- |
|
300 // CIHLFileImageExtJpg::LoadAnimation |
|
301 // ----------------------------------------------------------------------------- |
|
302 TInt CIHLFileImageExtJpg::LoadAnimation( TRequestStatus& aStatus, MIHLBitmap& aDestination, |
|
303 TInt aAnimationFrameIndex ) |
|
304 { |
|
305 //Animation is not supported |
|
306 ( void ) aStatus; |
|
307 ( void ) aDestination; |
|
308 ( void ) aAnimationFrameIndex; |
|
309 Panic( KErrNotSupported ); |
|
310 return 0; |
|
311 } |
|
312 |
|
313 // ----------------------------------------------------------------------------- |
|
314 // CIHLFileImageExtJpg::IsBusy |
|
315 // ----------------------------------------------------------------------------- |
|
316 TBool CIHLFileImageExtJpg::IsBusy() const |
|
317 { |
|
318 return ( iImageState != EInactive ); |
|
319 } |
|
320 |
|
321 // ----------------------------------------------------------------------------- |
|
322 // CIHLFileImageExtJpg::CancelLoad |
|
323 // ----------------------------------------------------------------------------- |
|
324 void CIHLFileImageExtJpg::CancelLoad() |
|
325 { |
|
326 Cancel(); |
|
327 } |
|
328 |
|
329 // ----------------------------------------------------------------------------- |
|
330 // CIHLFileImageExtJpg::SetFilter |
|
331 // ----------------------------------------------------------------------------- |
|
332 void CIHLFileImageExtJpg::SetFilter( MIHLFilter* /*aFilter*/ ) |
|
333 { |
|
334 // Not in use |
|
335 } |
|
336 |
|
337 |
|
338 // ----------------------------------------------------------------------------- |
|
339 // CIHLFileImageExtJpg::Decoder |
|
340 // ----------------------------------------------------------------------------- |
|
341 const CExtJpegDecoder& CIHLFileImageExtJpg::Decoder() const |
|
342 { |
|
343 return *iDecoder; |
|
344 } |
|
345 |
|
346 // ----------------------------------------------------------------------------- |
|
347 // CIHLFileImageExtJpg::DoCancel |
|
348 // ----------------------------------------------------------------------------- |
|
349 void CIHLFileImageExtJpg::DoCancel() |
|
350 { |
|
351 iDecoder->Cancel(); |
|
352 |
|
353 // Delete all processed bitmaps |
|
354 ErrorCleanup(); |
|
355 |
|
356 // Complete with cancel |
|
357 iImageState = EInactive; |
|
358 RequestComplete( KErrCancel ); |
|
359 } |
|
360 |
|
361 // ----------------------------------------------------------------------------- |
|
362 // CIHLFileImageExtJpg::RunL |
|
363 // ----------------------------------------------------------------------------- |
|
364 void CIHLFileImageExtJpg::RunL() |
|
365 { |
|
366 __ASSERT_DEBUG( iDestination, Panic( KErrGeneral ) ); |
|
367 User::LeaveIfError( iStatus.Int() ); |
|
368 |
|
369 switch( iImageState ) |
|
370 { |
|
371 case EStartLoad: |
|
372 { |
|
373 // start loading the bitmaps |
|
374 StartLoadL(); |
|
375 break; |
|
376 } |
|
377 case ECompleteLoad: |
|
378 { |
|
379 // complete loading the bitmaps |
|
380 CompleteLoadL(); |
|
381 break; |
|
382 } |
|
383 default: |
|
384 { |
|
385 Panic( KErrTotalLossOfPrecision ); |
|
386 } |
|
387 } |
|
388 } |
|
389 |
|
390 // ----------------------------------------------------------------------------- |
|
391 // CIHLFileImageExtJpg::RunError |
|
392 // ----------------------------------------------------------------------------- |
|
393 TInt CIHLFileImageExtJpg::RunError( TInt aError ) |
|
394 { |
|
395 // Delete all processed bitmaps |
|
396 ErrorCleanup(); |
|
397 |
|
398 // Complete with error |
|
399 iImageState = EInactive; |
|
400 RequestComplete( aError ); |
|
401 return KErrNone; |
|
402 } |
|
403 |
|
404 // ----------------------------------------------------------------------------- |
|
405 // CIHLFileImageExtJpg::LoadRequest |
|
406 // ----------------------------------------------------------------------------- |
|
407 TInt CIHLFileImageExtJpg::LoadRequest( TRequestStatus& aStatus, MIHLBitmap& aDestination, TInt aFrameIndex ) |
|
408 { |
|
409 if( IsBusy() ) |
|
410 { |
|
411 return KErrNotReady; |
|
412 } |
|
413 |
|
414 if( aFrameIndex < 0 || aFrameIndex >= iDecoder->FrameCount() ) |
|
415 { |
|
416 return KErrArgument; |
|
417 } |
|
418 |
|
419 const CFbsBitmap& dstBitmap = aDestination.Bitmap(); |
|
420 if( !dstBitmap.Handle() ) |
|
421 { |
|
422 return KErrArgument; |
|
423 } |
|
424 |
|
425 iImageStatus = &aStatus; |
|
426 *iImageStatus = KRequestPending; |
|
427 |
|
428 iDestination = static_cast<CIHLBitmap*>( &aDestination ); //lint !e826 |
|
429 iFrameIndex = aFrameIndex; |
|
430 |
|
431 // Start the active object |
|
432 iImageState = EStartLoad; |
|
433 SelfComplete(); |
|
434 return KErrNone; |
|
435 } |
|
436 |
|
437 // ----------------------------------------------------------------------------- |
|
438 // CIHLFileImageExtJpg::StartLoadL |
|
439 // ----------------------------------------------------------------------------- |
|
440 void CIHLFileImageExtJpg::StartLoadL() |
|
441 { |
|
442 CFbsBitmap& dstBitmap = iDestination->BitmapModifyable(); |
|
443 CFbsBitmap& dstMask = iDestination->MaskModifyable(); |
|
444 |
|
445 if( MaskDisplayMode() && dstMask.Handle() ) |
|
446 { |
|
447 iDecoder->Convert( &iStatus, dstBitmap, dstMask, iFrameIndex ); |
|
448 } |
|
449 else |
|
450 { |
|
451 dstMask.Reset(); |
|
452 iDecoder->Convert( &iStatus, dstBitmap, iFrameIndex ); |
|
453 } |
|
454 iImageState = ECompleteLoad; |
|
455 SetActive(); |
|
456 } |
|
457 |
|
458 // ----------------------------------------------------------------------------- |
|
459 // CIHLFileImageExtJpg::CompleteLoadL |
|
460 // ----------------------------------------------------------------------------- |
|
461 void CIHLFileImageExtJpg::CompleteLoadL() |
|
462 { |
|
463 // Save source info destination |
|
464 iDestination->SetEditorPtr( this ); |
|
465 iDestination->SetEditorValue( iFrameIndex ); |
|
466 |
|
467 // Normal image ready |
|
468 iDestination = NULL; |
|
469 iImageState = EInactive; |
|
470 RequestComplete( KErrNone ); |
|
471 } |
|
472 |
|
473 // ----------------------------------------------------------------------------- |
|
474 // CIHLFileImageExtJpg::ErrorCleanup |
|
475 // ----------------------------------------------------------------------------- |
|
476 void CIHLFileImageExtJpg::ErrorCleanup() |
|
477 { |
|
478 if( iDestination ) |
|
479 { |
|
480 iDestination = NULL; |
|
481 } |
|
482 } |
|
483 |
|
484 // ----------------------------------------------------------------------------- |
|
485 // CIHLFileImageExtJpg::SelfComplete |
|
486 // ----------------------------------------------------------------------------- |
|
487 void CIHLFileImageExtJpg::SelfComplete() |
|
488 { |
|
489 SetActive(); |
|
490 iStatus = KRequestPending; |
|
491 TRequestStatus* status = &iStatus; |
|
492 User::RequestComplete( status, KErrNone ); |
|
493 } |
|
494 |
|
495 // ----------------------------------------------------------------------------- |
|
496 // CIHLFileImageExtJpg::RequestComplete |
|
497 // ----------------------------------------------------------------------------- |
|
498 void CIHLFileImageExtJpg::RequestComplete( TInt aReason ) |
|
499 { |
|
500 ASSERT( iImageStatus ); |
|
501 User::RequestComplete( iImageStatus, aReason ); |
|
502 } |
|
503 |
|
504 // ----------------------------------------------------------------------------- |
|
505 // CIHLFileImageExtJpg::SetCroppingL |
|
506 // ----------------------------------------------------------------------------- |
|
507 |
|
508 void CIHLFileImageExtJpg::SetCroppingL( TRect aCropRect ) |
|
509 { |
|
510 iDecoder->SetCroppingL( aCropRect ); |
|
511 } |
|
512 |
|
513 // ----------------------------------------------------------------------------- |
|
514 // CIHLFileImageExtJpg::SetStreamingL |
|
515 // ----------------------------------------------------------------------------- |
|
516 |
|
517 void CIHLFileImageExtJpg::SetStreamingL( TSize& aMacroBlockSize ) |
|
518 { |
|
519 iDecoder->SetStreamingL( aMacroBlockSize ); |
|
520 } |
|
521 |
|
522 // ----------------------------------------------------------------------------- |
|
523 // CIHLFileImageExtJpg::SetRotationL |
|
524 // ----------------------------------------------------------------------------- |
|
525 |
|
526 void CIHLFileImageExtJpg::SetRotationL( TInt aDegree ) |
|
527 { |
|
528 iDecoder->SetRotationL( aDegree ); |
|
529 } |
|
530 |
|
531 // ----------------------------------------------------------------------------- |
|
532 // CIHLFileImageExtJpg::SetFlippingL |
|
533 // ----------------------------------------------------------------------------- |
|
534 |
|
535 void CIHLFileImageExtJpg::SetFlippingL() |
|
536 { |
|
537 iDecoder->SetFlippingL(); |
|
538 } |
|
539 |
|
540 // ----------------------------------------------------------------------------- |
|
541 // CIHLFileImageExtJpg::SetMirroringL |
|
542 // ----------------------------------------------------------------------------- |
|
543 |
|
544 void CIHLFileImageExtJpg::SetMirroringL() |
|
545 { |
|
546 iDecoder->SetMirroringL(); |
|
547 } |
|
548 |
|
549 // ----------------------------------------------------------------------------- |
|
550 // CIHLFileImageExtJpg::SetDctDecodingL |
|
551 // ----------------------------------------------------------------------------- |
|
552 |
|
553 void CIHLFileImageExtJpg::SetDctDecodingL() |
|
554 { |
|
555 iDecoder->SetDctDecodingL(); |
|
556 } |
|
557 |
|
558 // ----------------------------------------------------------------------------- |
|
559 // CIHLFileImageExtJpg::ConvertL |
|
560 // ----------------------------------------------------------------------------- |
|
561 |
|
562 void CIHLFileImageExtJpg::ConvertL( |
|
563 TRequestStatus* aRequestStatus, |
|
564 const CVisualFrame* aDestinationFrame, |
|
565 TInt& aNoOfDecodedMBlocks, |
|
566 TInt aFrameNumber ) |
|
567 { |
|
568 iDecoder->ConvertL( |
|
569 aRequestStatus, |
|
570 aDestinationFrame, |
|
571 aNoOfDecodedMBlocks, |
|
572 aFrameNumber ); |
|
573 } |
|
574 |
|
575 // ----------------------------------------------------------------------------- |
|
576 // CIHLFileImageExtJpg::ContinueConvertL |
|
577 // ----------------------------------------------------------------------------- |
|
578 |
|
579 void CIHLFileImageExtJpg::ContinueConvertL( |
|
580 TRequestStatus* aRequestStatus, |
|
581 const CVisualFrame* aDestinationFrame, |
|
582 TInt& aNoOfDecodedMBlocks, |
|
583 TInt aFrameNumber ) |
|
584 { |
|
585 iDecoder->ContinueConvertL( |
|
586 aRequestStatus, |
|
587 aDestinationFrame, |
|
588 aNoOfDecodedMBlocks, |
|
589 aFrameNumber ); |
|
590 } |
|
591 |
|
592 // ----------------------------------------------------------------------------- |
|
593 // CIHLFileImageExtJpg::SupportedFormatsL |
|
594 // ----------------------------------------------------------------------------- |
|
595 |
|
596 TInt CIHLFileImageExtJpg::SupportedFormatsL() |
|
597 { |
|
598 return iDecoder->SupportedFormatsL(); |
|
599 } |
|
600 |
|
601 // ----------------------------------------------------------------------------- |
|
602 // CIHLFileImageExtJpg::CapabilitiesL |
|
603 // ----------------------------------------------------------------------------- |
|
604 |
|
605 TInt CIHLFileImageExtJpg::CapabilitiesL() |
|
606 { |
|
607 return iDecoder->CapabilitiesL(); |
|
608 } |
|
609 |
|
610 //End of file |