filter/source/flash/swfwriter2.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "swfwriter.hxx"
  21 #include <vcl/virdev.hxx>
  22 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  23
  24 #include <math.h>
  25
  26 using namespace ::swf;
  27 using namespace ::std;
  28 using namespace ::com::sun::star::uno;
  29 using namespace ::com::sun::star::io;
  30
  31 // -----------------------------------------------------------------------------
  32
  33 sal_uInt16 getMaxBitsUnsigned( sal_uInt32 nValue )
  34 {
  35     sal_uInt16 nBits = 0;
  36
  37     while( nValue )
  38     {
  39         nBits++;
  40         nValue >>= 1;
  41     }
  42
  43     return nBits;
  44 }
  45
  46 // -----------------------------------------------------------------------------
  47
  48 sal_uInt16 getMaxBitsSigned( sal_Int32 nValue )
  49 {
  50     if( nValue < 0 )
  51         nValue *= -1;
  52
  53     return getMaxBitsUnsigned( static_cast< sal_uInt32 >(nValue) ) + 1;
  54 }
  55
  56 // -----------------------------------------------------------------------------
  57
  58 BitStream::BitStream()
  59 {
  60     mnBitPos = 8;
  61     mnCurrentByte = 0;
  62 }
  63
  64 // -----------------------------------------------------------------------------
  65
  66 void BitStream::writeUB( sal_uInt32 nValue, sal_uInt16 nBits )
  67 {
  68     while( nBits != 0 )
  69     {
  70         mnCurrentByte |= nValue << (32 - nBits) >> (32 - mnBitPos);
  71
  72         if ( nBits > mnBitPos )
  73         {
  74             nBits = nBits - mnBitPos;
  75             mnBitPos = 0;
  76         }
  77         else
  78         {
  79             mnBitPos = sal::static_int_cast<sal_uInt8>( mnBitPos - nBits );
  80             nBits = 0;
  81         }
  82
  83         if( 0 == mnBitPos )
  84             pad();
  85     }
  86 }
  87
  88 // -----------------------------------------------------------------------------
  89
  90 void BitStream::writeSB( sal_Int32 nValue, sal_uInt16 nBits )
  91 {
  92     writeUB( static_cast< sal_uInt32 >(nValue), nBits );
  93 }
  94
  95 // -----------------------------------------------------------------------------
  96
  97 void BitStream::writeFB( sal_uInt32 nValue, sal_uInt16 nBits )
  98 {
  99     writeUB( nValue, nBits );
 100 }
 101
 102 // -----------------------------------------------------------------------------
 103
 104 void BitStream::pad()
 105 {
 106     if( 8 != mnBitPos )
 107     {
 108         maData.push_back( mnCurrentByte );
 109         mnCurrentByte = 0;
 110         mnBitPos = 8;
 111     }
 112 }
 113
 114 // -----------------------------------------------------------------------------
 115
 116 void BitStream::writeTo( SvStream& out )
 117 {
 118     pad();
 119
 120     vector< sal_uInt8 >::iterator aIter( maData.begin() );
 121     const vector< sal_uInt8>::iterator aEnd( maData.end() );
 122     while(aIter != aEnd)
 123     {
 124         out << (*aIter++);
 125     }
 126 }
 127
 128 // -----------------------------------------------------------------------------
 129
 130 sal_uInt32 BitStream::getOffset() const
 131 {
 132     return maData.size();
 133 }
 134
 135 ////////////////////////////////////////////////////////////////////////////////
 136
 137 Tag::Tag( sal_uInt8 nTagId )
 138 {
 139     mnTagId = nTagId;
 140 }
 141
 142 // -----------------------------------------------------------------------------
 143
 144 void Tag::write( SvStream &out )
 145 {
 146     Seek( STREAM_SEEK_TO_END );
 147     sal_uInt32 nSz = Tell();
 148     Seek( STREAM_SEEK_TO_BEGIN );
 149
 150     if( mnTagId != 0xff )
 151     {
 152         bool bLarge = nSz > 62;
 153
 154         sal_uInt16 nCode = ( mnTagId << 6 ) | ( bLarge ? 0x3f : _uInt16(nSz) );
 155
 156         out << (sal_uInt8)nCode;
 157         out << (sal_uInt8)(nCode >> 8);
 158
 159         if( bLarge )
 160         {
 161             sal_uInt32 nTmp = nSz;
 162
 163             out << (sal_uInt8)nTmp;
 164             nTmp >>= 8;
 165             out << (sal_uInt8)nTmp;
 166             nTmp >>= 8;
 167             out << (sal_uInt8)nTmp;
 168             nTmp >>= 8;
 169             out << (sal_uInt8)nTmp;
 170         }
 171     }
 172
 173     out.Write( GetData(), nSz );
 174 }
 175 #if 0
 176 // -----------------------------------------------------------------------------
 177
 178 void Tag::addI32( sal_Int32 nValue )
 179 {
 180     addUI32( static_cast<sal_uInt32>( nValue ) );
 181 }
 182 #endif
 183 // -----------------------------------------------------------------------------
 184
 185 void Tag::addUI32( sal_uInt32 nValue )
 186 {
 187     *this << nValue;
 188 }
 189 #if 0
 190 // -----------------------------------------------------------------------------
 191
 192 void Tag::addI16( sal_Int16 nValue )
 193 {
 194     addUI16( static_cast<sal_uInt16>( nValue ) );
 195 }
 196 #endif
 197 // -----------------------------------------------------------------------------
 198
 199 void Tag::addUI16( sal_uInt16 nValue )
 200 {
 201     *this << (sal_uInt8)nValue;
 202     *this << (sal_uInt8)(nValue >> 8);
 203 }
 204
 205 // -----------------------------------------------------------------------------
 206
 207 void Tag::addUI8( sal_uInt8 nValue )
 208 {
 209     *this << (sal_uInt8)nValue;
 210 }
 211
 212 // -----------------------------------------------------------------------------
 213
 214 void Tag::addBits( BitStream& rIn )
 215 {
 216     rIn.writeTo( *this );
 217 }
 218
 219 // -----------------------------------------------------------------------------
 220
 221 void Tag::addRGBA( const Color& rColor )
 222 {
 223     addUI8( rColor.GetRed() );
 224     addUI8( rColor.GetGreen() );
 225     addUI8( rColor.GetBlue() );
 226     addUI8( 0xff - rColor.GetTransparency() );
 227 }
 228
 229 // -----------------------------------------------------------------------------
 230
 231 void Tag::addRGB( const Color& rColor )
 232 {
 233     addUI8( rColor.GetRed() );
 234     addUI8( rColor.GetGreen() );
 235     addUI8( rColor.GetBlue() );
 236 }
 237
 238 // -----------------------------------------------------------------------------
 239
 240 void Tag::addRect( const Rectangle& rRect )
 241 {
 242     writeRect( *this, rRect );
 243 }
 244
 245 // -----------------------------------------------------------------------------
 246
 247 void Tag::writeRect( SvStream& rOut, const Rectangle& rRect )
 248 {
 249     BitStream aBits;
 250
 251     sal_Int32 minX, minY, maxX, maxY;
 252
 253     if( rRect.Left() < rRect.Right() )
 254     {
 255         minX = rRect.Left();
 256         maxX = rRect.Right();
 257     }
 258     else
 259     {
 260         maxX = rRect.Left();
 261         minX = rRect.Right();
 262     }
 263
 264
 265     if( rRect.Top() < rRect.Bottom() )
 266     {
 267         minY = rRect.Top();
 268         maxY = rRect.Bottom();
 269     }
 270     else
 271     {
 272         maxY = rRect.Top();
 273         minY = rRect.Bottom();
 274     }
 275
 276     // AS: Figure out the maximum nubmer of bits required to represent any of the
 277     //  rectangle coordinates.  Since minX or minY could be negative, they could
 278     //  actually require more bits than maxX or maxY.
 279     // AS: Christian, can they be negative, or is that a wasted check?
 280     // CL: I think so, f.e. for shapes that have the top and/or left edge outside
 281     //         the page origin
 282     sal_uInt8 nBits1 = sal::static_int_cast<sal_uInt8>( max( getMaxBitsSigned( minX ), getMaxBitsSigned( minY ) ) );
 283     sal_uInt8 nBits2 = sal::static_int_cast<sal_uInt8>( max( getMaxBitsSigned( maxX ), getMaxBitsSigned( maxY ) ) );
 284     sal_uInt8 nBitsMax = max( nBits1, nBits2 );
 285
 286     aBits.writeUB( nBitsMax, 5 );
 287     aBits.writeSB( minX, nBitsMax );
 288     aBits.writeSB( maxX, nBitsMax );
 289     aBits.writeSB( minY, nBitsMax );
 290     aBits.writeSB( maxY, nBitsMax );
 291
 292     aBits.writeTo( rOut );
 293 }
 294
 295 // -----------------------------------------------------------------------------
 296
 297 void Tag::addMatrix( const ::basegfx::B2DHomMatrix& rMatrix ) // #i73264#
 298 {
 299     writeMatrix( *this, rMatrix );
 300 }
 301
 302 // -----------------------------------------------------------------------------
 303
 304 void Tag::writeMatrix( SvStream& rOut, const ::basegfx::B2DHomMatrix& rMatrix ) // #i73264#
 305 {
 306
 307     BitStream aBits;
 308
 309     const sal_uInt8 bHasScale = rMatrix.get(0, 0) != 1.0 || rMatrix.get(1, 1) != 1.0;
 310
 311     aBits.writeUB( bHasScale, 1 );
 312
 313     if( bHasScale )
 314     {
 315         sal_uInt8 nScaleBits = 31;
 316
 317         aBits.writeUB( nScaleBits, 5 );
 318         aBits.writeFB( getFixed( rMatrix.get(0, 0) ), nScaleBits ); // Scale X
 319         aBits.writeFB( getFixed( rMatrix.get(1, 1) ), nScaleBits ); // Scale Y
 320     }
 321
 322     const sal_uInt8 bHasRotate = rMatrix.get(0, 1) != 0.0 || rMatrix.get(1, 0) != 0.0;
 323
 324     aBits.writeUB( bHasRotate, 1 );
 325
 326     if( bHasRotate )
 327     {
 328         sal_uInt8 nRotateBits = 31;
 329
 330         aBits.writeUB( nRotateBits, 5 );
 331         aBits.writeFB( getFixed( rMatrix.get(0, 1) ), nRotateBits );    // RotateSkew0
 332         aBits.writeFB( getFixed( rMatrix.get(1, 0) ), nRotateBits );    // RotateSkew1
 333     }
 334
 335     sal_uInt8 nTranslateBits = 16;
 336
 337     aBits.writeUB( nTranslateBits, 5 );
 338     aBits.writeSB( (sal_Int16)rMatrix.get(0, 2), nTranslateBits );      // Translate X
 339     aBits.writeSB( (sal_Int16)rMatrix.get(1, 2), nTranslateBits );      // Translate Y
 340
 341     aBits.writeTo( rOut );
 342 }
 343
 344 // -----------------------------------------------------------------------------
 345
 346 void Tag::addString( const char* pString )
 347 {
 348     if( pString )
 349     {
 350         while( *pString )
 351             addUI8( *pString++ );
 352     }
 353
 354     addUI8( 0 );
 355 }
 356
 357 // -----------------------------------------------------------------------------
 358
 359 void Tag::addStream( SvStream& rIn )
 360 {
 361     *this << rIn;
 362 }
 363
 364 ////////////////////////////////////////////////////////////////////////////////
 365
 366 Sprite::Sprite( sal_uInt16 nId )
 367 : mnId( nId ), mnFrames(0)
 368 {
 369 }
 370
 371 // -----------------------------------------------------------------------------
 372
 373 Sprite::~Sprite()
 374 {
 375     for(vector< Tag* >::iterator i = maTags.begin(); i != maTags.end(); ++i)
 376         delete *i;
 377 }
 378
 379 // -----------------------------------------------------------------------------
 380
 381 void Sprite::write( SvStream& out )
 382 {
 383     SvMemoryStream aTmp;
 384     for(vector< Tag* >::iterator i = maTags.begin(); i != maTags.end(); ++i)
 385         (*i)->write( aTmp );
 386
 387     if( !mnFrames )
 388         mnFrames = 1;
 389
 390     aTmp.Seek(0);
 391
 392     Tag aTag( TAG_DEFINESPRITE );
 393     aTag.addUI16( mnId );
 394     aTag.addUI16( _uInt16( mnFrames ) );
 395     aTag.addStream( aTmp );
 396     aTag.write( out );
 397 }
 398
 399 // -----------------------------------------------------------------------------
 400
 401 void Sprite::addTag( Tag* pNewTag )
 402 {
 403     if( pNewTag )
 404     {
 405         if( pNewTag->getTagId() == TAG_SHOWFRAME )
 406             mnFrames++;
 407
 408         maTags.push_back( pNewTag );
 409     }
 410 }
 411
 412 /////////////////////////////////////////////////////////////////////////////////
 413
 414 sal_uInt32 swf::getFixed( double fValue )
 415 {
 416     sal_Int16 nUpper = (sal_Int16)floor(fValue);
 417     sal_uInt16 nLower = (sal_uInt16)((fValue - floor(fValue))*0x10000);
 418
 419     sal_uInt32 temp = ((sal_Int32)nUpper)<<16;
 420     temp |= nLower;
 421
 422     return temp;
 423 }
 424
 425 /////////////////////////////////////////////////////////////////////////////////
 426
 427 /** constructs a new flash font for the given VCL Font */
 428 FlashFont::FlashFont( const Font& rFont, sal_uInt16 nId )
 429 : maFont( rFont ), mnNextIndex(0), mnId( nId )
 430 {
 431 }
 432
 433 // -----------------------------------------------------------------------------
 434
 435 FlashFont::~FlashFont()
 436 {
 437 }
 438
 439 // -----------------------------------------------------------------------------
 440
 441 /** gets the glyph id for the given character. The glyphs are created on demand */
 442 sal_uInt16 FlashFont::getGlyph( sal_uInt16 nChar, VirtualDevice* pVDev )
 443 {
 444     // see if we already created a glyph for this character
 445     std::map<sal_uInt16, sal_uInt16, ltuint16>::iterator aIter( maGlyphIndex.find(nChar) );
 446     if( aIter != maGlyphIndex.end() )
 447     {
 448         return aIter->second;
 449     }
 450
 451     // if not, we create one now
 452
 453     maGlyphIndex[nChar] = mnNextIndex;
 454
 455     Font aOldFont( pVDev->GetFont() );
 456     Font aNewFont( aOldFont );
 457     aNewFont.SetAlign( ALIGN_BASELINE );
 458     pVDev->SetFont( aNewFont );
 459     aOldFont.SetOrientation(0);
 460
 461     // let the virtual device convert the character to polygons
 462     PolyPolygon aPolyPoly;
 463     pVDev->GetTextOutline( aPolyPoly, OUString(nChar) );
 464
 465     maGlyphOffsets.push_back( _uInt16( maGlyphData.getOffset() ) );
 466
 467     // Number of fill and line index bits set to 1
 468     maGlyphData.writeUB( 0x11, 8 );
 469
 470     const sal_uInt16 nCount = aPolyPoly.Count();
 471     sal_uInt16 i,n;
 472     for( i = 0; i < nCount; i++ )
 473     {
 474         Polygon& rPoly = aPolyPoly[ i ];
 475
 476         const sal_uInt16 nSize = rPoly.GetSize();
 477         if( nSize )
 478         {
 479             // convert polygon to flash EM_SQUARE (1024x1024)
 480             for( n = 0; n < nSize; n++ )
 481             {
 482                 Point aPoint( rPoly[n] );
 483                 aPoint.X() = static_cast<long>((double(aPoint.X()) * 1024.0 ) / double(aOldFont.GetHeight()));
 484                 aPoint.Y() = static_cast<long>((double(aPoint.Y()) * 1024.0 ) / double(aOldFont.GetHeight()));
 485                 rPoly[n] = aPoint;
 486             }
 487             Writer::Impl_addPolygon( maGlyphData, rPoly, true );
 488         }
 489     }
 490     Writer::Impl_addEndShapeRecord( maGlyphData );
 491
 492     maGlyphData.pad();
 493
 494     pVDev->SetFont( aOldFont );
 495
 496     return mnNextIndex++;
 497 }
 498
 499 // -----------------------------------------------------------------------------
 500
 501 void FlashFont::write( SvStream& out )
 502 {
 503     Tag aTag( TAG_DEFINEFONT );
 504
 505     aTag.addUI16( mnId );
 506
 507     sal_uInt16 nGlyphs = _uInt16( maGlyphOffsets.size() );
 508     sal_uInt16 nOffset = nGlyphs * sizeof( sal_uInt16 );
 509
 510     for(vector< sal_uInt16 >::iterator i = maGlyphOffsets.begin(); i != maGlyphOffsets.end(); ++i)
 511         aTag.addUI16( nOffset + (*i) );
 512
 513     aTag.addBits( maGlyphData );
 514
 515     aTag.write( out );
 516 }
 517
 518 ////////////////////////////////////////////////////////////////////////////////
 519
 520 /** this c'tor creates a solid fill style */
 521 FillStyle::FillStyle( const Color& rSolidColor )
 522 :   meType( solid ),
 523     maColor( rSolidColor )
 524 {
 525 }
 526
 527 // -----------------------------------------------------------------------------
 528
 529 /** this c'tor creates a tiled or clipped bitmap fill style */
 530 FillStyle::FillStyle( sal_uInt16 nBitmapId, bool bClipped, const ::basegfx::B2DHomMatrix& rMatrix ) // #i73264#
 531 :   meType( bClipped ? clipped_bitmap : tiled_bitmap ),
 532     maMatrix( rMatrix ),
 533     mnBitmapId( nBitmapId )
 534 {
 535 }
 536
 537 // -----------------------------------------------------------------------------
 538
 539 FillStyle::FillStyleType Impl_getFillStyleType( const Gradient& rGradient )
 540 {
 541     switch( rGradient.GetStyle() )
 542     {
 543     case GradientStyle_ELLIPTICAL:
 544     case GradientStyle_RADIAL:
 545         return FillStyle::radial_gradient;
 546 //  case GradientStyle_AXIAL:
 547 //  case GradientStyle_SQUARE:
 548 //  case GradientStyle_RECT:
 549 //  case GradientStyle_LINEAR:
 550     default:
 551         return FillStyle::linear_gradient;
 552     }
 553 }
 554
 555 // -----------------------------------------------------------------------------
 556
 557 /** this c'tor creates a linear or radial gradient fill style */
 558 FillStyle::FillStyle( const Rectangle& rBoundRect, const Gradient& rGradient )
 559 :   meType( Impl_getFillStyleType( rGradient ) ),
 560     maGradient( rGradient ),
 561     maBoundRect( rBoundRect )
 562 {
 563 }
 564
 565 // -----------------------------------------------------------------------------
 566
 567 void FillStyle::addTo( Tag* pTag ) const
 568 {
 569     pTag->addUI8( sal::static_int_cast<sal_uInt8>( meType ) );
 570     switch( meType )
 571     {
 572     case solid:
 573         pTag->addRGBA( maColor );
 574         break;
 575     case linear_gradient:
 576     case radial_gradient:
 577         Impl_addGradient( pTag );
 578         break;
 579     case tiled_bitmap:
 580     case clipped_bitmap:
 581         pTag->addUI16( mnBitmapId );
 582         pTag->addMatrix( maMatrix );
 583         break;
 584     }
 585 }
 586
 587 // -----------------------------------------------------------------------------
 588
 589 struct GradRecord
 590 {
 591     sal_uInt8   mnRatio;
 592     Color       maColor;
 593
 594     GradRecord( sal_uInt8 nRatio, const Color& rColor ) : mnRatio( nRatio ), maColor( rColor ) {}
 595 };
 596
 597 // TODO: better emulation of our gradients
 598 void FillStyle::Impl_addGradient( Tag* pTag ) const
 599 {
 600     vector< struct GradRecord > aGradientRecords;
 601     basegfx::B2DHomMatrix m(basegfx::tools::createRotateB2DHomMatrix((maGradient.GetAngle() - 900) * F_PI1800));
 602
 603     switch( maGradient.GetStyle() )
 604     {
 605     case GradientStyle_ELLIPTICAL:
 606     case GradientStyle_RADIAL:
 607         {
 608             aGradientRecords.push_back( GradRecord( 0x00, maGradient.GetEndColor() ) );
 609             aGradientRecords.push_back( GradRecord( 0xff, maGradient.GetStartColor() ) );
 610
 611             double tx = ( maGradient.GetOfsX() * 32768.0 ) / 100.0;
 612             double ty = ( maGradient.GetOfsY() * 32768.0 ) / 100.0;
 613             double scalex = (double)maBoundRect.GetWidth() / 32768.0;
 614             double scaley = (double)maBoundRect.GetHeight() / 32768.0;
 615
 616             m.scale( 1.2, 1.2 );
 617
 618             if( scalex > scaley )
 619             {
 620                 double scale_move = scaley / scalex;
 621
 622                 m.translate( tx, scale_move * ty );
 623
 624
 625                 m.scale( scalex, scalex );
 626             }
 627             else
 628             {
 629                 double scale_move = scalex / scaley;
 630
 631                 m.translate( scale_move * tx, ty );
 632
 633
 634                 m.scale( scaley, scaley );
 635             }
 636
 637         }
 638         break;
 639     case GradientStyle_AXIAL:
 640         {
 641             aGradientRecords.push_back( GradRecord( 0x00, maGradient.GetEndColor() ) );
 642             aGradientRecords.push_back( GradRecord( 0x80, maGradient.GetStartColor() ) );
 643             aGradientRecords.push_back( GradRecord( 0xff, maGradient.GetEndColor() ) );
 644             double tx = ( 32768.0 / 2.0 );
 645             double ty = ( 32768.0 / 2.0 );
 646             double scalex = (double)maBoundRect.GetWidth() / 32768.0;
 647             double scaley = (double)maBoundRect.GetHeight() / 32768.0;
 648
 649             m.translate( tx, ty );
 650             m.scale( scalex, scaley );
 651         }
 652         break;
 653     case GradientStyle_SQUARE:
 654     case GradientStyle_RECT:
 655     case GradientStyle_LINEAR:
 656         {
 657             aGradientRecords.push_back( GradRecord( 0x00, maGradient.GetStartColor() ) );
 658             aGradientRecords.push_back( GradRecord( 0xff, maGradient.GetEndColor() ) );
 659             double scalex = (double)maBoundRect.GetWidth() / 32768.0;
 660             double scaley = (double)maBoundRect.GetHeight() / 32768.0;
 661
 662             m.scale( scalex, scaley );
 663
 664             m.translate( maBoundRect.GetWidth() / 2.0, maBoundRect.GetHeight() / 2.0 );
 665         }
 666         break;
 667     case  GradientStyle_FORCE_EQUAL_SIZE: break;
 668     }
 669
 670     m.translate( maBoundRect.Left(), maBoundRect.Top() );
 671
 672     pTag->addMatrix( m );
 673
 674     DBG_ASSERT( aGradientRecords.size() < 8, "Illegal FlashGradient!" );
 675
 676     pTag->addUI8( static_cast<sal_uInt8>( aGradientRecords.size() ) );
 677
 678     for(std::vector< GradRecord >::iterator i = aGradientRecords.begin(); i != aGradientRecords.end(); ++i)
 679     {
 680         pTag->addUI8( (*i).mnRatio );
 681         pTag->addRGBA( (*i).maColor );
 682     }
 683 }
 684
 685 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */