svtools/source/filter.vcl/igif/gifread.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: gifread.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #define _GIFPRIVATE
  35
  36 #include "decode.hxx"
  37 #include "gifread.hxx"
  38
  39 // -----------
  40 // - Defines -
  41 // -----------
  42
  43 #define NO_PENDING( rStm ) ( ( rStm ).GetError() != ERRCODE_IO_PENDING )
  44
  45 // -------------
  46 // - GIFReader -
  47 // -------------
  48
  49 GIFReader::GIFReader( SvStream& rStm ) :
  50             aGPalette           ( 256 ),
  51             aLPalette           ( 256 ),
  52             rIStm                       ( rStm ),
  53             pAcc8                       ( NULL ),
  54             pAcc1                       ( NULL ),
  55             nLastPos            ( rStm.Tell() ),
  56             nLogWidth100        ( 0UL ),
  57             nLogHeight100       ( 0UL ),
  58             nLoops                      ( 1 ),
  59             eActAction          ( GLOBAL_HEADER_READING ),
  60             bGCTransparent      ( FALSE ),
  61             bImGraphicReady     ( FALSE )
  62 {
  63     maUpperName = UniString::CreateFromAscii( "SVIGIF", 6 );
  64     pSrcBuf = new BYTE[ 256 ];
  65     ClearImageExtensions();
  66 }
  67
  68 // ------------------------------------------------------------------------
  69
  70 GIFReader::~GIFReader()
  71 {
  72     aImGraphic.SetContext( NULL );
  73
  74     if( pAcc1 )
  75         aBmp1.ReleaseAccess( pAcc1 );
  76
  77     if( pAcc8 )
  78         aBmp8.ReleaseAccess( pAcc8 );
  79
  80     delete[] pSrcBuf;
  81 }
  82
  83 // ------------------------------------------------------------------------
  84
  85 void GIFReader::ClearImageExtensions()
  86 {
  87     nGCDisposalMethod = 0;
  88     bGCTransparent = FALSE;
  89     nTimer = 0;
  90 }
  91
  92 // ------------------------------------------------------------------------
  93
  94 BOOL GIFReader::CreateBitmaps( long nWidth, long nHeight, BitmapPalette* pPal,
  95                                BOOL bWatchForBackgroundColor )
  96 {
  97     const Size aSize( nWidth, nHeight );
  98
  99     if( bGCTransparent )
 100     {
 101         const Color aWhite( COL_WHITE );
 102
 103         aBmp1 = Bitmap( aSize, 1 );
 104
 105         if( !aAnimation.Count() )
 106             aBmp1.Erase( aWhite );
 107
 108         pAcc1 = aBmp1.AcquireWriteAccess();
 109
 110         if( pAcc1 )
 111         {
 112             cTransIndex1 = (BYTE) pAcc1->GetBestPaletteIndex( aWhite );
 113             cNonTransIndex1 = cTransIndex1 ? 0 : 1;
 114         }
 115         else
 116             bStatus = FALSE;
 117     }
 118
 119     if( bStatus )
 120     {
 121         aBmp8 = Bitmap( aSize, 8, pPal );
 122
 123         if( !!aBmp8 && bWatchForBackgroundColor && aAnimation.Count() )
 124             aBmp8.Erase( (*pPal)[ nBackgroundColor ] );
 125         else
 126           aBmp8.Erase( Color( COL_WHITE ) );
 127
 128         pAcc8 = aBmp8.AcquireWriteAccess();
 129         bStatus = ( pAcc8 != NULL );
 130     }
 131
 132     return bStatus;
 133 }
 134
 135 // ------------------------------------------------------------------------
 136
 137 BOOL GIFReader::ReadGlobalHeader()
 138 {
 139     char        pBuf[ 7 ];
 140     BYTE        nRF;
 141     BYTE        nAspect;
 142     BOOL        bRet = FALSE;
 143
 144     rIStm.Read( pBuf, 6 );
 145     if( NO_PENDING( rIStm ) )
 146     {
 147         pBuf[ 6 ] = 0;
 148         if( !strcmp( pBuf, "GIF87a" ) || !strcmp( pBuf, "GIF89a" ) )
 149         {
 150             rIStm.Read( pBuf, 7 );
 151             if( NO_PENDING( rIStm ) )
 152             {
 153                 SvMemoryStream aMemStm;
 154
 155                 aMemStm.SetBuffer( pBuf, 7, FALSE, 7 );
 156                 aMemStm >> nGlobalWidth;
 157                 aMemStm >> nGlobalHeight;
 158                 aMemStm >> nRF;
 159                 aMemStm >> nBackgroundColor;
 160                 aMemStm >> nAspect;
 161
 162                 bGlobalPalette = (BOOL) ( nRF & 0x80 );
 163
 164                 if( bGlobalPalette )
 165                     ReadPaletteEntries( &aGPalette, 1 << ( ( nRF & 7 ) + 1 ) );
 166                 else
 167                     nBackgroundColor = 0;
 168
 169                 if( NO_PENDING( rIStm ) )
 170                     bRet = TRUE;
 171             }
 172         }
 173         else
 174             bStatus = FALSE;
 175     }
 176
 177     return bRet;
 178 }
 179
 180 // ------------------------------------------------------------------------
 181
 182 void GIFReader::ReadPaletteEntries( BitmapPalette* pPal, ULONG nCount )
 183 {
 184     const ULONG nLen = 3UL * nCount;
 185     BYTE*               pBuf = new BYTE[ nLen ];
 186
 187     rIStm.Read( pBuf, nLen );
 188     if( NO_PENDING( rIStm ) )
 189     {
 190         BYTE* pTmp = pBuf;
 191
 192         for( ULONG i = 0UL; i < nCount; )
 193         {
 194             BitmapColor& rColor = (*pPal)[ (USHORT) i++ ];
 195
 196             rColor.SetRed( *pTmp++ );
 197             rColor.SetGreen( *pTmp++ );
 198             rColor.SetBlue( *pTmp++ );
 199         }
 200
 201         // nach Moeglichkeit noch einige Standardfarben unterbringen
 202         if( nCount < 256UL )
 203         {
 204             (*pPal)[ 255UL ] = Color( COL_WHITE );
 205
 206             if( nCount < 255UL )
 207                 (*pPal)[ 254UL ] = Color( COL_BLACK );
 208         }
 209     }
 210
 211     delete[] pBuf;
 212 }
 213
 214 // ------------------------------------------------------------------------
 215
 216 BOOL GIFReader::ReadExtension()
 217 {
 218     BYTE        cFunction;
 219     BYTE        cSize;
 220     BYTE        cByte;
 221     BOOL        bRet = FALSE;
 222     BOOL        bOverreadDataBlocks = FALSE;
 223
 224     // Extension-Label
 225     rIStm >> cFunction;
 226     if( NO_PENDING( rIStm ) )
 227     {
 228         // Block-Laenge
 229         rIStm >> cSize;
 230
 231         switch( cFunction )
 232         {
 233             // 'Graphic Control Extension'
 234             case( 0xf9 ) :
 235             {
 236                 BYTE cFlags;
 237
 238                 rIStm >> cFlags;
 239                 rIStm >> nTimer;
 240                 rIStm >> nGCTransparentIndex;
 241                 rIStm >> cByte;
 242
 243                 if ( NO_PENDING( rIStm ) )
 244                 {
 245                     nGCDisposalMethod = ( cFlags >> 2) & 7;
 246                     bGCTransparent = ( cFlags & 1 ) ? TRUE : FALSE;
 247                     bStatus = ( cSize == 4 ) && ( cByte == 0 );
 248                     bRet = TRUE;
 249                 }
 250             }
 251             break;
 252
 253             // Application-Extension
 254             case ( 0xff ) :
 255             {
 256                 if ( NO_PENDING( rIStm ) )
 257                 {
 258                     // default diese Extension ueberlesen
 259                     bOverreadDataBlocks = TRUE;
 260
 261                     // Appl.-Extension hat Laenge 11
 262                     if ( cSize == 0x0b )
 263                     {
 264                         ByteString      aAppId;
 265                         ByteString      aAppCode;
 266
 267                         rIStm.Read( aAppId.AllocBuffer( 8 ), 8 );
 268                         rIStm.Read( aAppCode.AllocBuffer( 3 ), 3 );
 269                         rIStm >> cSize;
 270
 271                         // NetScape-Extension
 272                         if( aAppId == "NETSCAPE" && aAppCode == "2.0" && cSize == 3 )
 273                         {
 274                             rIStm >> cByte;
 275
 276                             // Loop-Extension
 277                             if ( cByte == 0x01 )
 278                             {
 279                                 rIStm >> cByte;
 280                                 nLoops = cByte;
 281                                 rIStm >> cByte;
 282                                 nLoops |= ( (USHORT) cByte << 8 );
 283                                 rIStm >> cByte;
 284
 285                                 bStatus = ( cByte == 0 );
 286                                 bRet = NO_PENDING( rIStm );
 287                                 bOverreadDataBlocks = FALSE;
 288
 289                                 // Netscape interpretiert den LoopCount
 290                                 // als reine Anzahl der _Wiederholungen_;
 291                                 // bei uns ist es die Gesamtanzahl der
 292                                 // Durchlaeufe
 293                                 if( nLoops )
 294                                     nLoops++;
 295                             }
 296                             else
 297                                 rIStm.SeekRel( -1 );
 298                         }
 299                         else if ( aAppId == "STARDIV " && aAppCode == "5.0" && cSize == 9 )
 300                         {
 301                             rIStm >> cByte;
 302
 303                             // Loop-Extension
 304                             if ( cByte == 0x01 )
 305                             {
 306                                 rIStm >> nLogWidth100 >> nLogHeight100;
 307                                 rIStm >> cByte;
 308                                 bStatus = ( cByte == 0 );
 309                                 bRet = NO_PENDING( rIStm );
 310                                 bOverreadDataBlocks = FALSE;
 311                             }
 312                             else
 313                                 rIStm.SeekRel( -1 );
 314                         }
 315
 316                     }
 317                 }
 318             }
 319             break;
 320
 321             // alles andere ueberlesen
 322             default:
 323                 bOverreadDataBlocks = TRUE;
 324             break;
 325         }
 326
 327         // Sub-Blocks ueberlesen
 328         if ( bOverreadDataBlocks )
 329         {
 330             bRet = TRUE;
 331             while( cSize && bStatus && !rIStm.IsEof() )
 332             {
 333                 USHORT  nCount = (USHORT) cSize + 1;
 334                 char*   pBuffer = new char[ nCount ];
 335
 336                 bRet = FALSE;
 337                 rIStm.Read( pBuffer, nCount );
 338                 if( NO_PENDING( rIStm ) )
 339                 {
 340                     cSize = (BYTE) pBuffer[ cSize ];
 341                     bRet = TRUE;
 342                 }
 343                 else
 344                     cSize = 0;
 345
 346                 delete[] pBuffer;
 347             }
 348         }
 349     }
 350
 351     return bRet;
 352 }
 353
 354 // ------------------------------------------------------------------------
 355
 356 BOOL GIFReader::ReadLocalHeader()
 357 {
 358     BYTE        pBuf[ 9 ];
 359     BOOL        bRet = FALSE;
 360
 361     rIStm.Read( pBuf, 9 );
 362     if( NO_PENDING( rIStm ) )
 363     {
 364         SvMemoryStream  aMemStm;
 365         BitmapPalette*  pPal;
 366         BYTE                    nFlags;
 367
 368         aMemStm.SetBuffer( (char*) pBuf, 9, FALSE, 9 );
 369         aMemStm >> nImagePosX;
 370         aMemStm >> nImagePosY;
 371         aMemStm >> nImageWidth;
 372         aMemStm >> nImageHeight;
 373         aMemStm >> nFlags;
 374
 375         // Falls Interlaced, ersten Startwert vorgeben
 376         bInterlaced = ( ( nFlags & 0x40 ) == 0x40 );
 377         nLastInterCount = 7;
 378         nLastImageY = 0;
 379
 380         if( nFlags & 0x80 )
 381         {
 382             pPal = &aLPalette;
 383             ReadPaletteEntries( pPal, 1 << ( (nFlags & 7 ) + 1 ) );
 384         }
 385         else
 386             pPal = &aGPalette;
 387
 388         // Falls alles soweit eingelesen werden konnte, kann
 389         // nun das lokale Bild angelegt werden;
 390         // es wird uebergeben, ob der BackgroundColorIndex evtl.
 391         // beruecksichtigt werden soll ( wenn Globale Farbtab. und
 392         // diese auch fuer dieses Bild gilt )
 393         if( NO_PENDING( rIStm ) )
 394         {
 395             CreateBitmaps( nImageWidth, nImageHeight, pPal, bGlobalPalette && ( pPal == &aGPalette ) );
 396             bRet = TRUE;
 397         }
 398     }
 399
 400     return bRet;
 401 }
 402
 403 // ------------------------------------------------------------------------
 404
 405 ULONG GIFReader::ReadNextBlock()
 406 {
 407     ULONG       nRet = 0UL;
 408     ULONG       nRead;
 409     BYTE        cBlockSize;
 410
 411     rIStm >> cBlockSize;
 412
 413     if ( rIStm.IsEof() )
 414         nRet = 4UL;
 415     else if ( NO_PENDING( rIStm ) )
 416     {
 417         if ( cBlockSize == 0 )
 418             nRet = 2UL;
 419         else
 420         {
 421             rIStm.Read( pSrcBuf, cBlockSize );
 422
 423             if( NO_PENDING( rIStm ) )
 424             {
 425                 if( bOverreadBlock )
 426                     nRet = 3UL;
 427                 else
 428                 {
 429                     BOOL        bEOI;
 430                     HPBYTE      pTarget = pDecomp->DecompressBlock( pSrcBuf, cBlockSize, nRead, bEOI );
 431
 432                     nRet = ( bEOI ? 3 : 1 );
 433
 434                     if( nRead && !bOverreadBlock )
 435                         FillImages( pTarget, nRead );
 436
 437                     rtl_freeMemory( pTarget );
 438                 }
 439             }
 440         }
 441     }
 442
 443     return nRet;
 444 }
 445
 446 // ------------------------------------------------------------------------
 447
 448 void GIFReader::FillImages( HPBYTE pBytes, ULONG nCount )
 449 {
 450     for( ULONG i = 0UL; i < nCount; i++ )
 451     {
 452         if( nImageX >= nImageWidth )
 453         {
 454             if( bInterlaced )
 455             {
 456                 long nT1, nT2;
 457
 458                 // falls Interlaced, werden die Zeilen kopiert
 459                 if( nLastInterCount )
 460                 {
 461                     long nMinY = Min( (long) nLastImageY + 1, (long) nImageHeight - 1 );
 462                     long nMaxY = Min( (long) nLastImageY + nLastInterCount, (long) nImageHeight - 1 );
 463
 464                     // letzte gelesene Zeile kopieren, wenn Zeilen
 465                     // nicht zusanmmenfallen ( kommt vorm wenn wir am Ende des Bildes sind )
 466                     if( ( nMinY > nLastImageY ) && ( nLastImageY < ( nImageHeight - 1 ) ) )
 467                     {
 468                         HPBYTE  pScanline8 = pAcc8->GetScanline( nYAcc );
 469                         ULONG   nSize8 = pAcc8->GetScanlineSize();
 470                         HPBYTE  pScanline1 = 0;
 471                         ULONG   nSize1 = 0;
 472
 473                         if( bGCTransparent )
 474                         {
 475                             pScanline1 = pAcc1->GetScanline( nYAcc );
 476                             nSize1 = pAcc1->GetScanlineSize();
 477                         }
 478
 479                         for( long j = nMinY; j <= nMaxY; j++ )
 480                         {
 481                             memcpy( pAcc8->GetScanline( j ), pScanline8, nSize8 );
 482
 483                             if( bGCTransparent )
 484                                 memcpy( pAcc1->GetScanline( j ), pScanline1, nSize1 );
 485                         }
 486                     }
 487                 }
 488
 489                 nT1 = ( ++nImageY ) << 3;
 490                 nLastInterCount = 7;
 491
 492                 if( nT1 >= nImageHeight )
 493                 {
 494                     nT2 = nImageY - ( ( nImageHeight + 7 ) >> 3 );
 495                     nT1 = ( nT2 << 3 ) + 4;
 496                     nLastInterCount = 3;
 497
 498                     if( nT1 >= nImageHeight )
 499                     {
 500                         nT2 -= ( nImageHeight + 3 ) >> 3;
 501                         nT1 = ( nT2 << 2 ) + 2;
 502                         nLastInterCount = 1;
 503
 504                         if( nT1 >= nImageHeight )
 505                         {
 506                             nT2 -= ( nImageHeight + 1 ) >> 2;
 507                             nT1 = ( nT2 << 1 ) + 1;
 508                             nLastInterCount = 0;
 509                         }
 510                     }
 511                 }
 512
 513                 nLastImageY = (USHORT) nT1;
 514                 nYAcc = nT1;
 515             }
 516             else
 517             {
 518                 nLastImageY = ++nImageY;
 519                 nYAcc = nImageY;
 520             }
 521
 522             // Zeile faengt von vorne an
 523             nImageX = 0;
 524         }
 525
 526         if( nImageY < nImageHeight )
 527         {
 528             const BYTE cTmp = pBytes[ i ];
 529
 530             if( bGCTransparent )
 531             {
 532                 if( cTmp == nGCTransparentIndex )
 533                     pAcc1->SetPixel( nYAcc, nImageX++, cTransIndex1 );
 534                 else
 535                 {
 536                     pAcc8->SetPixel( nYAcc, nImageX, cTmp );
 537                     pAcc1->SetPixel( nYAcc, nImageX++, cNonTransIndex1 );
 538                 }
 539             }
 540             else
 541                 pAcc8->SetPixel( nYAcc, nImageX++, cTmp );
 542         }
 543         else
 544         {
 545             bOverreadBlock = TRUE;
 546             break;
 547         }
 548     }
 549 }
 550
 551 // ------------------------------------------------------------------------
 552
 553 void GIFReader::CreateNewBitmaps()
 554 {
 555     AnimationBitmap     aAnimBmp;
 556
 557     aBmp8.ReleaseAccess( pAcc8 );
 558     pAcc8 = NULL;
 559
 560     if( bGCTransparent )
 561     {
 562         aBmp1.ReleaseAccess( pAcc1 );
 563         pAcc1 = NULL;
 564         aAnimBmp.aBmpEx = BitmapEx( aBmp8, aBmp1 );
 565     }
 566     else
 567         aAnimBmp.aBmpEx = BitmapEx( aBmp8 );
 568
 569     aAnimBmp.aPosPix = Point( nImagePosX, nImagePosY );
 570     aAnimBmp.aSizePix = Size( nImageWidth, nImageHeight );
 571     aAnimBmp.nWait = ( nTimer != 65535 ) ? nTimer : ANIMATION_TIMEOUT_ON_CLICK;
 572     aAnimBmp.bUserInput = FALSE;
 573
 574     if( nGCDisposalMethod == 2 )
 575         aAnimBmp.eDisposal = DISPOSE_BACK;
 576     else if( nGCDisposalMethod == 3 )
 577         aAnimBmp.eDisposal = DISPOSE_PREVIOUS;
 578     else
 579         aAnimBmp.eDisposal = DISPOSE_NOT;
 580
 581     aAnimation.Insert( aAnimBmp );
 582
 583     if( aAnimation.Count() == 1 )
 584     {
 585         aAnimation.SetDisplaySizePixel( Size( nGlobalWidth, nGlobalHeight ) );
 586         aAnimation.SetLoopCount( nLoops );
 587     }
 588 }
 589
 590 // ------------------------------------------------------------------------
 591
 592 const Graphic& GIFReader::GetIntermediateGraphic()
 593 {
 594     // Intermediate-Graphic nur erzeugen, wenn schon
 595     // Daten vorliegen, aber die Graphic noch nicht
 596     // vollstaendig eingelesen wurde
 597     if ( bImGraphicReady && !aAnimation.Count() )
 598     {
 599         Bitmap  aBmp;
 600
 601         aBmp8.ReleaseAccess( pAcc8 );
 602
 603         if ( bGCTransparent )
 604         {
 605             aBmp1.ReleaseAccess( pAcc1 );
 606             aImGraphic = BitmapEx( aBmp8, aBmp1 );
 607
 608             pAcc1 = aBmp1.AcquireWriteAccess();
 609             bStatus = bStatus && ( pAcc1 != NULL );
 610         }
 611         else
 612             aImGraphic = aBmp8;
 613
 614         pAcc8 = aBmp8.AcquireWriteAccess();
 615         bStatus = bStatus && ( pAcc8 != NULL );
 616     }
 617
 618     return aImGraphic;
 619 }
 620
 621 // ------------------------------------------------------------------------
 622
 623 BOOL GIFReader::ProcessGIF()
 624 {
 625     BOOL bRead = FALSE;
 626     BOOL bEnd = FALSE;
 627
 628     if ( !bStatus )
 629         eActAction = ABORT_READING;
 630
 631     // Stream an die richtige Stelle bringen
 632     rIStm.Seek( nLastPos );
 633
 634     switch( eActAction )
 635     {
 636         // naechsten Marker lesen
 637         case( MARKER_READING ):
 638         {
 639             BYTE cByte;
 640
 641             rIStm >> cByte;
 642
 643             if( rIStm.IsEof() )
 644                 eActAction = END_READING;
 645             else if( NO_PENDING( rIStm ) )
 646             {
 647                 bRead = TRUE;
 648
 649                 if( cByte == '!' )
 650                     eActAction = EXTENSION_READING;
 651                 else if( cByte == ',' )
 652                     eActAction = LOCAL_HEADER_READING;
 653                 else if( cByte == ';' )
 654                     eActAction = END_READING;
 655                 else
 656                     eActAction = ABORT_READING;
 657             }
 658         }
 659         break;
 660
 661         // ScreenDescriptor lesen
 662         case( GLOBAL_HEADER_READING ):
 663         {
 664             if( ( bRead = ReadGlobalHeader() ) == TRUE )
 665             {
 666                 ClearImageExtensions();
 667                 eActAction = MARKER_READING;
 668             }
 669         }
 670         break;
 671
 672
 673         // Extension lesen
 674         case( EXTENSION_READING ):
 675         {
 676             if( ( bRead = ReadExtension() ) == TRUE )
 677                 eActAction = MARKER_READING;
 678         }
 679         break;
 680
 681
 682         // Image-Descriptor lesen
 683         case( LOCAL_HEADER_READING ):
 684         {
 685             if( ( bRead = ReadLocalHeader() ) == TRUE )
 686             {
 687                 nYAcc = nImageX = nImageY = 0;
 688                 eActAction = FIRST_BLOCK_READING;
 689             }
 690         }
 691         break;
 692
 693
 694         // ersten Datenblock lesen
 695         case( FIRST_BLOCK_READING ):
 696         {
 697             BYTE cDataSize;
 698
 699             rIStm >> cDataSize;
 700
 701             if( rIStm.IsEof() )
 702                 eActAction = ABORT_READING;
 703             else if( cDataSize > 12 )
 704                 bStatus = FALSE;
 705             else if( NO_PENDING( rIStm ) )
 706             {
 707                 bRead = TRUE;
 708                 pDecomp = new GIFLZWDecompressor( cDataSize );
 709                 eActAction = NEXT_BLOCK_READING;
 710                 bOverreadBlock = FALSE;
 711             }
 712             else
 713                 eActAction = FIRST_BLOCK_READING;
 714         }
 715         break;
 716
 717         // naechsten Datenblock lesen
 718         case( NEXT_BLOCK_READING ):
 719         {
 720             USHORT      nLastX = nImageX;
 721             USHORT      nLastY = nImageY;
 722             ULONG       nRet = ReadNextBlock();
 723
 724             // Return: 0:Pending / 1:OK; / 2:OK und letzter Block: / 3:EOI / 4:HardAbort
 725             if( nRet )
 726             {
 727                 bRead = TRUE;
 728
 729                 if ( nRet == 1UL )
 730                 {
 731                     bImGraphicReady = TRUE;
 732                     eActAction = NEXT_BLOCK_READING;
 733                     bOverreadBlock = FALSE;
 734                 }
 735                 else
 736                 {
 737                     if( nRet == 2UL )
 738                     {
 739                         delete pDecomp;
 740                         CreateNewBitmaps();
 741                         eActAction = MARKER_READING;
 742                         ClearImageExtensions();
 743                     }
 744                     else if( nRet == 3UL )
 745                     {
 746                         eActAction = NEXT_BLOCK_READING;
 747                         bOverreadBlock = TRUE;
 748                     }
 749                     else
 750                     {
 751                         delete pDecomp;
 752                         CreateNewBitmaps();
 753                         eActAction = ABORT_READING;
 754                         ClearImageExtensions();
 755                     }
 756                 }
 757             }
 758             else
 759             {
 760                 nImageX = nLastX;
 761                 nImageY = nLastY;
 762             }
 763         }
 764         break;
 765
 766         // ein Fehler trat auf
 767         case( ABORT_READING ):
 768         {
 769             bEnd = TRUE;
 770             eActAction = END_READING;
 771         }
 772         break;
 773
 774         default:
 775         break;
 776     }
 777
 778     // Stream an die richtige Stelle bringen,
 779     // falls Daten gelesen werden konnten
 780     // entweder alte Position oder aktuelle Position
 781     if( bRead || bEnd )
 782         nLastPos = rIStm.Tell();
 783
 784     return bRead;
 785 }
 786
 787 // ------------------------------------------------------------------------
 788
 789 ReadState GIFReader::ReadGIF( Graphic& rGraphic )
 790 {
 791     ReadState eReadState;
 792
 793     bStatus = TRUE;
 794
 795     while( ProcessGIF() && ( eActAction != END_READING ) ) {}
 796
 797     if( !bStatus )
 798         eReadState = GIFREAD_ERROR;
 799     else if( eActAction == END_READING )
 800         eReadState = GIFREAD_OK;
 801     else
 802     {
 803         if ( rIStm.GetError() == ERRCODE_IO_PENDING )
 804             rIStm.ResetError();
 805
 806         eReadState = GIFREAD_NEED_MORE;
 807     }
 808
 809     if( aAnimation.Count() == 1 )
 810     {
 811         rGraphic = aAnimation.Get( 0 ).aBmpEx;
 812
 813         if( nLogWidth100 && nLogHeight100 )
 814         {
 815             rGraphic.SetPrefSize( Size( nLogWidth100, nLogHeight100 ) );
 816             rGraphic.SetPrefMapMode( MAP_100TH_MM );
 817         }
 818     }
 819     else
 820         rGraphic = aAnimation;
 821
 822     return eReadState;
 823 }
 824
 825
 826 // -------------
 827 // - ImportGIF -
 828 // -------------
 829
 830 BOOL ImportGIF( SvStream & rStm, Graphic& rGraphic )
 831 {
 832     GIFReader*  pGIFReader = (GIFReader*) rGraphic.GetContext();
 833     USHORT              nOldFormat = rStm.GetNumberFormatInt();
 834     ReadState   eReadState;
 835     BOOL                bRet = TRUE;
 836
 837     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 838
 839     if( !pGIFReader )
 840         pGIFReader = new GIFReader( rStm );
 841
 842     rGraphic.SetContext( NULL );
 843     eReadState = pGIFReader->ReadGIF( rGraphic );
 844
 845     if( eReadState == GIFREAD_ERROR )
 846     {
 847         bRet = FALSE;
 848         delete pGIFReader;
 849     }
 850     else if( eReadState == GIFREAD_OK )
 851         delete pGIFReader;
 852     else
 853     {
 854         rGraphic = pGIFReader->GetIntermediateGraphic();
 855         rGraphic.SetContext( pGIFReader );
 856     }
 857
 858     rStm.SetNumberFormatInt( nOldFormat );
 859
 860     return bRet;
 861 }