dali/internal/text/text-abstraction/cairo-renderer.cpp

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // FILE HEADER
  19 #include <dali/internal/text/text-abstraction/cairo-renderer.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/common/constants.h>
  23 #include <cairo.h>
  24 #include <cairo-ft.h>
  25 #include <cstring>
  26 #include <memory>
  27
  28 #include <ft2build.h>
  29 #include FT_FREETYPE_H
  30 #include FT_GLYPH_H
  31 #include FT_OUTLINE_H
  32 #include FT_STROKER_H
  33
  34 // INTERNAL INCLUDES
  35 #include <dali/devel-api/text-abstraction/font-client.h>
  36 #include <dali/devel-api/text-abstraction/text-renderer-layout-helper.h>
  37 #include <dali/integration-api/debug.h>
  38 #include <dali/internal/imaging/common/image-operations.h>
  39 #include <dali/internal/text/text-abstraction/font-client-impl.h>
  40
  41 namespace
  42 {
  43
  44 const float TO_FLOAT = 1.f / 255.f;
  45 const float TO_UCHAR = 255.f;
  46 const float TWO_PI = 2.f * Dali::Math::PI; ///< 360 degrees in radians
  47
  48 /**
  49  * @brief Run of glyphs that have the same style.
  50  */
  51 struct GlyphRun
  52 {
  53   GlyphRun()
  54   : fontFace{ nullptr },
  55     fontSize{ 0.0 },
  56     glyphIndex{ 0u },
  57     numberOfGlyphs{ 0u },
  58     fontId{ 0u },
  59     colorIndex{ 0u },
  60     isItalicRequired{ false },
  61     isBoldRequired{ false }
  62   {}
  63
  64   FT_Face      fontFace;           ///< The font face used by the glyphs in the run.
  65   double       fontSize;           ///< The font size used by the glyphs in the run. According the Cairo's documentation this is in user space units. It works if I set the size in pixels.
  66   unsigned int glyphIndex;         ///< Index to the first glyph of the run.
  67   unsigned int numberOfGlyphs;     ///< Number of glyphs in the run.
  68   unsigned int fontId;             ///< The id of the font.
  69   unsigned int colorIndex;         ///< The index to the color of the glyphs.
  70   bool         isItalicRequired:1; ///< Whether the italic style is required.
  71   bool         isBoldRequired:1;   ///< Whether the bold style is required.
  72 };
  73
  74 /**
  75  * @brief Helper struct used to destroy a bitmap buffer.
  76  *
  77  * The font client allocates a bitmap's buffer with the new operator.
  78  * However, the PixelBuffer class allocates the buffer with the
  79  * malloc() function and the Rotate() function which is intended
  80  * for the PixelBuffer as well allocates memory with malloc().
  81  *
  82  * This struct keeps the type of allocation and uses the delete[]
  83  * operator or the free() function to deallocate resources.
  84  */
  85 struct GlyphBuffer
  86 {
  87   enum DestructorType
  88   {
  89     FREE,
  90     DELETE
  91   };
  92
  93   GlyphBuffer( Dali::TextAbstraction::FontClient::GlyphBufferData& data, DestructorType type )
  94   : data( data ),
  95     type( type )
  96   {
  97   }
  98
  99   ~GlyphBuffer()
 100   {
 101     switch( type )
 102     {
 103       case FREE:
 104       {
 105         free( data.buffer );
 106         break;
 107       }
 108       case DELETE:
 109       {
 110         delete[] data.buffer;
 111       }
 112     }
 113   }
 114
 115   Dali::TextAbstraction::FontClient::GlyphBufferData& data;
 116   DestructorType type;
 117 };
 118
 119 /**
 120  * @brief Creates a pixel buffer with all pixels set to transparent.
 121  *
 122  * @param[in] parameters Contains the width and height of the pixel buffer.
 123  *
 124  * @return The pixel buffer.
 125  */
 126 Dali::Devel::PixelBuffer CreateVoidPixelBuffer( const Dali::TextAbstraction::TextRenderer::Parameters& parameters )
 127 {
 128   Dali::Pixel::Format pixelFormat = parameters.pixelFormat == Dali::TextAbstraction::TextRenderer::Parameters::A8 ? Dali::Pixel::A8 : Dali::Pixel::RGBA8888;
 129   Dali::Devel::PixelBuffer pixelBuffer = Dali::Devel::PixelBuffer::New( parameters.width,
 130                                                                         parameters.height,
 131                                                                         pixelFormat );
 132
 133   const unsigned int bufferSize = parameters.width * parameters.height * Dali::Pixel::GetBytesPerPixel( pixelFormat );
 134   unsigned char* buffer = pixelBuffer.GetBuffer();
 135   memset( buffer, 0, bufferSize );
 136
 137   return pixelBuffer;
 138 }
 139
 140 /**
 141  * @brief Wraps the vertices of glyphs laid out on a horizontal strainght line on a circular path.
 142  *
 143  * It copies the vertices from the extra cairo context created to lay out the text
 144  * on a horizontal straight line to the cairo context used to render it.
 145  *
 146  * @param[in,out] cr The cairo context used to render the text.
 147  * @param[in] circularCr The extra cairo context created to layout horizontal text.
 148  * @param[in] parameters The parameters of the circular path.
 149  */
 150 void WrapToCircularPath( cairo_t* cr, cairo_t* circularCr, const Dali::TextAbstraction::CircularTextParameters& parameters )
 151 {
 152   bool first = true;
 153
 154   // Copy the path to get a cairo_path_t pointer used to iterate through all its items.
 155   std::unique_ptr<cairo_path_t, void(*)(cairo_path_t*)> path( cairo_copy_path( circularCr ), cairo_path_destroy );
 156
 157   // Iterates through all the path items and transform each vertex to follow the circle.
 158   // Transformed vertices are added to a new path in the 'cr' context (the one used to render the circular text)
 159   for( int i = 0; i < path->num_data; i += path->data[i].header.length )
 160   {
 161     cairo_path_data_t* data = &path->data[i];
 162
 163     switch( data->header.type )
 164     {
 165       case CAIRO_PATH_MOVE_TO:
 166       {
 167         if( first )
 168         {
 169           cairo_new_path( cr );
 170         }
 171
 172         first = false;
 173         double x = data[1].point.x;
 174         double y = data[1].point.y;
 175         Dali::TextAbstraction::TransformToArc( parameters, x, y );
 176         cairo_move_to( cr, x, y );
 177         break;
 178       }
 179       case CAIRO_PATH_LINE_TO:
 180       {
 181         double x = data[1].point.x;
 182         double y = data[1].point.y;
 183         Dali::TextAbstraction::TransformToArc( parameters, x, y );
 184         cairo_line_to( cr, x, y );
 185         break;
 186       }
 187       case CAIRO_PATH_CURVE_TO:
 188       {
 189         double x1 = data[1].point.x;
 190         double y1 = data[1].point.y;
 191         double x2 = data[2].point.x;
 192         double y2 = data[2].point.y;
 193         double x3 = data[3].point.x;
 194         double y3 = data[3].point.y;
 195         Dali::TextAbstraction::TransformToArc( parameters, x1, y1 );
 196         Dali::TextAbstraction::TransformToArc( parameters, x2, y2 );
 197         Dali::TextAbstraction::TransformToArc( parameters, x3, y3 );
 198         cairo_curve_to( cr, x1, y1, x2, y2, x3, y3 );
 199         break;
 200       }
 201       case CAIRO_PATH_CLOSE_PATH:
 202       {
 203         cairo_close_path( cr );
 204         break;
 205       }
 206       default:
 207       {
 208         DALI_LOG_WARNING( "Type of path not handled.\n" );
 209         // Nothing else to do.
 210         break;
 211       }
 212     }
 213   }
 214 }
 215
 216 } // namespace
 217
 218 namespace Dali
 219 {
 220
 221 namespace TextAbstraction
 222 {
 223
 224 namespace Internal
 225 {
 226
 227 Devel::PixelBuffer RenderTextCairo( const TextAbstraction::TextRenderer::Parameters& parameters )
 228 {
 229   const unsigned int numberOfGlyphs = parameters.glyphs.Count();
 230
 231   if( 0u == numberOfGlyphs )
 232   {
 233     // return a pixel buffer with all pixels set to transparent.
 234     return CreateVoidPixelBuffer( parameters );
 235   }
 236
 237   // Convert from DALi glyphs to Cairo glyphs.
 238   std::vector<cairo_glyph_t> cairoGlyphs;
 239   cairoGlyphs.resize( numberOfGlyphs );
 240   cairo_glyph_t* cairoGlyphsBuffer = &cairoGlyphs[0u];
 241
 242   const GlyphInfo* const daliGlyphsBuffer = parameters.glyphs.Begin();
 243   const Vector2* const positionsBuffer = parameters.positions.Begin();
 244   const ColorIndex* const colorIndicesBuffer = ( 0u == parameters.colorIndices.Count() ) ? nullptr : parameters.colorIndices.Begin();
 245
 246   for( unsigned index = 0u; index < numberOfGlyphs; ++index )
 247   {
 248     const GlyphInfo& daliGlyph = *( daliGlyphsBuffer + index );
 249     const Vector2& position = *( positionsBuffer + index );
 250     cairo_glyph_t& cairoGlyph = *( cairoGlyphsBuffer + index );
 251
 252     cairoGlyph.index = daliGlyph.index;
 253     cairoGlyph.x = std::round( position.x );
 254     cairoGlyph.y = std::round( position.y );
 255   }
 256
 257   // Retrieve the FreeType fonts needed by Cairo from the font-client.
 258   Dali::TextAbstraction::FontClient fontClient = Dali::TextAbstraction::FontClient::Get();
 259
 260   FT_Library ftLibrary;
 261   auto error = FT_Init_FreeType( &ftLibrary );
 262   if( error )
 263   {
 264     DALI_LOG_ERROR( "Error initializing FT library\n" );
 265
 266     // return a pixel buffer with all pixels set to transparent.
 267     return CreateVoidPixelBuffer( parameters );
 268   }
 269
 270   // Vector used to store the FreeType font faces, its size and the run of glyphs that use the font.
 271   std::vector<GlyphRun> glyphRuns;
 272   glyphRuns.reserve( 8u );
 273
 274   // The size set in Cairo and FreeType has different units.
 275   // Before the size is set in Cairo it needs to be converted according the formula
 276   // 'pixel_size = point_size * resolution / 72' got from the FreeType doc.
 277   // https://www.freetype.org/freetype2/docs/glyphs/glyphs-2.html
 278
 279   unsigned int horizontalDpi = 0u;
 280   unsigned int verticalDpi = 0u;
 281   fontClient.GetDpi( horizontalDpi, verticalDpi );
 282   const double dVerticalDpi = static_cast<double>( verticalDpi );
 283
 284   const double FROM_26_DOT_6_TO_PIXELS = dVerticalDpi / ( 64.0 * 72.0 );
 285
 286   GlyphRun currentGlyphRun;
 287   currentGlyphRun.fontId = 0u;
 288   currentGlyphRun.colorIndex = 0u;
 289   currentGlyphRun.isItalicRequired = false;
 290   currentGlyphRun.isBoldRequired = false;
 291   for( unsigned index = 0u; index < numberOfGlyphs; ++index )
 292   {
 293     const GlyphInfo& daliGlyph = *( daliGlyphsBuffer + index );
 294     const FontId fontId = daliGlyph.fontId;
 295     const ColorIndex colorIndex = ( nullptr == colorIndicesBuffer ) ? 0u : *( colorIndicesBuffer + index );
 296     const bool isItalicRequired = daliGlyph.isItalicRequired;
 297     const bool isBoldRequired = daliGlyph.isBoldRequired;
 298
 299     if( ( fontId != currentGlyphRun.fontId ) ||
 300         ( ( 0u == fontId ) && ( 0u != daliGlyph.index ) ) ||
 301         ( colorIndex != currentGlyphRun.colorIndex ) ||
 302         ( isItalicRequired != currentGlyphRun.isItalicRequired ) ||
 303         ( isBoldRequired != currentGlyphRun.isBoldRequired ) )
 304     {
 305       // There is a new run. First set the number of glyphs of the previous run and store it.
 306       currentGlyphRun.numberOfGlyphs = index - currentGlyphRun.glyphIndex;
 307       if( 0u != currentGlyphRun.numberOfGlyphs )
 308       {
 309         glyphRuns.push_back( currentGlyphRun );
 310       }
 311
 312       currentGlyphRun.fontFace = nullptr;
 313       currentGlyphRun.fontSize = 0.0;
 314       currentGlyphRun.glyphIndex = index;
 315       currentGlyphRun.numberOfGlyphs = 0u;
 316       currentGlyphRun.fontId = 0u;
 317       currentGlyphRun.colorIndex = 0u;
 318       currentGlyphRun.isItalicRequired = false;
 319       currentGlyphRun.isBoldRequired = false;
 320
 321       if( 0u != fontId )
 322       {
 323         // Get the font's path file name from the font Id.
 324         FontDescription fontDescription;
 325         fontClient.GetDescription( fontId, fontDescription );
 326
 327         switch( fontDescription.type )
 328         {
 329           case FontDescription::FACE_FONT:
 330           {
 331             // Create a FreeType font's face.
 332             auto error = FT_New_Face( ftLibrary, fontDescription.path.c_str(), 0u, &currentGlyphRun.fontFace );
 333             if( error )
 334             {
 335               DALI_LOG_ERROR( "Error in FT while creating a new face\n" );
 336
 337               // return a pixel buffer with all pixels set to transparent.
 338               return CreateVoidPixelBuffer( parameters );
 339             }
 340
 341             // Set the font's size. It needs to be set in the Freetype font and in the Cairo's context.
 342             unsigned int fontSize = fontClient.GetPointSize( fontId );
 343
 344             // Font's size to be set in the Cairo's context.
 345             currentGlyphRun.fontSize = FROM_26_DOT_6_TO_PIXELS * static_cast<double>( fontSize );
 346             break;
 347           }
 348           case FontDescription::BITMAP_FONT:
 349           {
 350             //Nothing to do.
 351             break;
 352           }
 353           default:
 354           {
 355             //Nothing to do.
 356             break;
 357           }
 358         }
 359       }
 360       currentGlyphRun.fontId = fontId;
 361       currentGlyphRun.colorIndex = colorIndex;
 362       currentGlyphRun.isItalicRequired = isItalicRequired;
 363       currentGlyphRun.isBoldRequired = isBoldRequired;
 364     }
 365   }
 366
 367   // Calculate the number of glyphs of the last run and store it.
 368   currentGlyphRun.numberOfGlyphs = numberOfGlyphs - currentGlyphRun.glyphIndex;
 369   if( 0u != currentGlyphRun.numberOfGlyphs )
 370   {
 371     glyphRuns.push_back( currentGlyphRun );
 372   }
 373
 374   // Choose the pixel format to be used.
 375   //
 376   // @note Behdad wrote "Upper 8 bits maps to the fourth byte in a little-endian machine like the intels."
 377   //       https://lists.cairographics.org/archives/cairo/2006-March/006563.html
 378   //
 379   //       Here in practice Cairo's ARGB32 is like DALi's RGBA8888.
 380   //
 381   const bool isDstRgba = TextAbstraction::TextRenderer::Parameters::RGBA8888 == parameters.pixelFormat;
 382   const Pixel::Format pixelFormat = isDstRgba ? Pixel::Format::RGBA8888 : Pixel::Format::A8;
 383   const cairo_format_t cairoFormat = isDstRgba ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_A8;
 384
 385   // This function provides a stride value that will respect all alignment requirements of the
 386   // accelerated image-rendering code within cairo.
 387   const int stride = cairo_format_stride_for_width( cairoFormat,
 388                                                     static_cast<int>( parameters.width ) );
 389   const int strideWidth = stride / Pixel::GetBytesPerPixel( pixelFormat );
 390
 391   // Creates the pixel buffer and retrieves the buffer pointer used to create the Cairo's surface.
 392   Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New( strideWidth, parameters.height, pixelFormat );
 393
 394   unsigned char* buffer = pixelBuffer.GetBuffer();
 395   const unsigned int bufferSize = stride * parameters.height;
 396   memset( buffer, 0, bufferSize );
 397
 398   std::unique_ptr<cairo_surface_t, void(*)(cairo_surface_t*)> surfacePtr( cairo_image_surface_create_for_data( buffer,
 399                                                                                                                cairoFormat,
 400                                                                                                                parameters.width,
 401                                                                                                                parameters.height,
 402                                                                                                                stride ),
 403                                                                           cairo_surface_destroy );
 404   cairo_surface_t* surface = surfacePtr.get();
 405
 406   if( ( nullptr == surface ) || ( CAIRO_STATUS_SUCCESS != cairo_surface_status( surface ) ) )
 407   {
 408     DALI_LOG_ERROR( "Failed to create a cairo's surface\n" );
 409
 410     return CreateVoidPixelBuffer( parameters );
 411   }
 412
 413   // Whether the text is circular.
 414   const bool isCircularText = 0u != parameters.radius;
 415
 416   // Creates a surface for circular text.
 417   //
 418   // The reason to create a surface for circular text is that the strategy
 419   // followed is to layout the text in a straight horizontal line and apply a
 420   // transform to each vertex that forms the geometry of the glyphs to place
 421   // and bend the glyphs accordingly to the circular path.
 422   //
 423   // As the glyphs are laid out first in a straight line they may exceed the
 424   // boundaries of the surface in that case cairo ignores them.
 425   std::unique_ptr<cairo_surface_t, void(*)(cairo_surface_t*)> circularSurfacePtr( nullptr, cairo_surface_destroy );
 426   cairo_surface_t* circularSurface = nullptr;
 427   if( isCircularText )
 428   {
 429     circularSurfacePtr.reset( cairo_surface_create_similar( surface,
 430                                                             CAIRO_CONTENT_ALPHA,
 431                                                             parameters.circularWidth,
 432                                                             parameters.circularHeight ) );
 433     circularSurface = circularSurfacePtr.get();
 434
 435     if( ( nullptr == circularSurface ) || ( CAIRO_STATUS_SUCCESS != cairo_surface_status( circularSurface ) ) )
 436     {
 437       DALI_LOG_ERROR( "Failed to create a cairo's circular surface\n" );
 438
 439       return CreateVoidPixelBuffer( parameters );
 440     }
 441   }
 442
 443   std::unique_ptr<cairo_t, void(*)(cairo_t*)> crPtr( cairo_create( surface ), cairo_destroy );
 444   cairo_t* cr = crPtr.get();
 445
 446   if( CAIRO_STATUS_SUCCESS != cairo_status( cr ) )
 447   {
 448     DALI_LOG_ERROR( "Failed to create a cairo context\n" );
 449
 450     return CreateVoidPixelBuffer( parameters );
 451   }
 452
 453   std::unique_ptr<cairo_t, void(*)(cairo_t*)> circularCrPtr( nullptr, cairo_destroy );
 454   cairo_t* circularCr = nullptr;
 455
 456   if( isCircularText )
 457   {
 458     circularCrPtr.reset( cairo_create( circularSurface ) );
 459     circularCr = circularCrPtr.get();
 460
 461     if( CAIRO_STATUS_SUCCESS != cairo_status( circularCr ) )
 462     {
 463       DALI_LOG_ERROR( "Failed to create a cairo context\n" );
 464
 465       return CreateVoidPixelBuffer( parameters );
 466     }
 467   }
 468
 469   CircularTextParameters circularTextParameters;
 470
 471   // Render the glyphs.
 472   if( isCircularText )
 473   {
 474     // Set the parameters.
 475     circularTextParameters.isClockwise = ( TextAbstraction::TextRenderer::Parameters::CLOCKWISE == parameters.circularLayout );
 476
 477     circularTextParameters.centerX = static_cast<double>( parameters.centerX );
 478     circularTextParameters.centerY = static_cast<double>( parameters.centerY );
 479     circularTextParameters.radius = static_cast<double>( parameters.radius );
 480     circularTextParameters.invRadius = 1.0 / circularTextParameters.radius;
 481     circularTextParameters.beginAngle = -parameters.beginAngle + Dali::Math::PI_2;
 482   }
 483
 484   cairo_move_to( cr, 0.0, 0.0 );
 485
 486   for( const auto& run: glyphRuns )
 487   {
 488     const bool isEmoji = parameters.isEmoji[run.glyphIndex];
 489     if( isEmoji || ( nullptr == run.fontFace ) )
 490     {
 491       // Retrieve the color for the glyph.
 492       const Vector4& color = parameters.colors[run.colorIndex];
 493
 494       const unsigned int lastGlyphIndex = run.glyphIndex + run.numberOfGlyphs;
 495       for( unsigned int index = run.glyphIndex; index < lastGlyphIndex; ++index )
 496       {
 497         // Whether it's a bitmap font.
 498         const bool doBlendWithTextColor = !isEmoji && ( ColorBlendingMode::MULTIPLY == parameters.blendingMode[index] );
 499
 500         // Check if there is an embedded image or a bitmap font image.
 501         const GlyphIndex glyphFontIndex = daliGlyphsBuffer[index].index;
 502         if( 0u != glyphFontIndex )
 503         {
 504           // The embedded image could be A8, RGBA8888 or BGRA8888.
 505           //
 506           // If the embedded image is RGBA8888 or BGRA8888 then the cairo's buffer is ARGB32. It's needed to convert from RGBA or BGRA to ARGB.
 507           // If the embedded image is A8 it's needed to check if the cairo's buffer is A8 or ARGB32 and do the conversion if needed.
 508
 509           const cairo_glyph_t& glyph = *( cairoGlyphsBuffer + index );
 510
 511           // Retrieve the image
 512           TextAbstraction::FontClient::GlyphBufferData data;
 513           std::unique_ptr<GlyphBuffer> glyphBufferPtr( new GlyphBuffer( data, GlyphBuffer::DELETE ) );
 514           if( isEmoji )
 515           {
 516             data.width = parameters.glyphs[run.glyphIndex].width;
 517             data.height = parameters.glyphs[run.glyphIndex].height;
 518           }
 519
 520           fontClient.CreateBitmap( run.fontId, glyphFontIndex, false, false, data, 0u );
 521
 522           if( nullptr == data.buffer )
 523           {
 524             // nothing else to do if there is no image.
 525             continue;
 526           }
 527
 528           // Calculate the position for the circular text.
 529           double glyphX = glyph.x;
 530           double glyphY = glyph.y;
 531
 532           if( isCircularText )
 533           {
 534             // Center of the bitmap.
 535             const double halfWidth = 0.5 * static_cast<double>( data.width );
 536             const double halfHeight = 0.5 * static_cast<double>( data.height );
 537
 538             double centerX = glyph.x + halfWidth;
 539             double centerY = glyph.y - halfHeight;
 540
 541             float radians = circularTextParameters.beginAngle + ( circularTextParameters.isClockwise ? -1.f : 1.f ) * ( Dali::Math::PI_2 + circularTextParameters.invRadius * centerX );
 542             radians = fmod( radians, TWO_PI );
 543             radians += ( radians < 0.f ) ? TWO_PI : 0.f;
 544
 545             TransformToArc( circularTextParameters, centerX, centerY );
 546
 547             uint8_t* pixelsOut = nullptr;
 548             unsigned int widthOut = data.width;
 549             unsigned int heightOut = data.height;
 550             const unsigned int pixelSize = Pixel::GetBytesPerPixel( data.format );
 551
 552             Dali::Internal::Platform::RotateByShear( data.buffer,
 553                                                      data.width,
 554                                                      data.height,
 555                                                      pixelSize,
 556                                                      radians,
 557                                                      pixelsOut,
 558                                                      widthOut,
 559                                                      heightOut );
 560             if( nullptr != pixelsOut )
 561             {
 562               delete[] data.buffer;
 563               data.buffer = pixelsOut;
 564               glyphBufferPtr.get()->type = GlyphBuffer::FREE;
 565               data.width = widthOut;
 566               data.height = heightOut;
 567             }
 568
 569             glyphX = centerX - 0.5 * static_cast<double>( data.width );
 570             glyphY = centerY + 0.5 * static_cast<double>( data.height );
 571           }
 572
 573
 574           if( ( Pixel::A8 != data.format ) &&
 575               ( Pixel::L8 != data.format ) &&
 576               ( Pixel::RGBA8888 != data.format ) &&
 577               ( Pixel::BGRA8888 != data.format ) )
 578           {
 579             DALI_LOG_ERROR( " Cairo Renderer: The valid pixel format for embedded items are A8 or RGBA8888\n" );
 580             continue;
 581           }
 582
 583           // Check if the item is out of the buffer.
 584           if( ( glyphX + static_cast<float>( data.width ) < 0.f ) ||
 585               ( glyphX > static_cast<float>( strideWidth ) ) ||
 586               ( glyphY < 0.f ) ||
 587               ( glyphY - static_cast<float>( data.height ) > static_cast<float>( parameters.height ) ) )
 588           {
 589             // The embedded item is completely out of the buffer.
 590             continue;
 591           }
 592
 593           const bool isSrcA = ( Pixel::A8 == data.format ) || ( Pixel::L8 == data.format );
 594           const bool isSrcRgba = Pixel::RGBA8888 == data.format;
 595           const bool isSrcBgra = Pixel::BGRA8888 == data.format;
 596
 597           // 0 -> image and cairo buffer are A8
 598           // 1 -> image is A8, cairo buffer is ARGB
 599           // 2 -> image is RGBA and cairo buffer is ARGB
 600           // 3 -> image is BGRA and cairo buffer is ARGB
 601           int rgbaCase = 0;
 602           if( isSrcA && isDstRgba )
 603           {
 604             rgbaCase = 1;
 605           }
 606           else if( isSrcRgba && isDstRgba )
 607           {
 608             rgbaCase = 2;
 609           }
 610           else if( isSrcBgra && isDstRgba )
 611           {
 612             rgbaCase = 3;
 613           }
 614           else if( ( isSrcRgba || isSrcBgra ) && !isDstRgba )
 615           {
 616             DALI_LOG_ERROR( "Cairo Renderer: The embedded image is RGBA or BGRA and the Cairo's buffer has been creates with A8 format!\n" );
 617             continue;
 618           }
 619
 620           // Select the cropped source image area to copy into the surface buffer
 621           unsigned int glyphUintX = 0u;
 622           unsigned int glyphUintY = 0u;
 623           unsigned int srcWidth = data.width;
 624           unsigned int srcHeight = data.height;
 625           unsigned int xSrcIndex = 0u;
 626           unsigned int ySrcIndex = 0u;
 627           if( glyphX < 0.f )
 628           {
 629             xSrcIndex = static_cast<unsigned int>( std::abs( glyphX ) );
 630             srcWidth -= xSrcIndex;
 631           }
 632           else
 633           {
 634             glyphUintX = static_cast<unsigned int>( glyphX );
 635           }
 636
 637           if( glyphUintX + srcWidth > static_cast<unsigned int>( strideWidth ) )
 638           {
 639             srcWidth -= ( ( glyphUintX + srcWidth ) - strideWidth );
 640           }
 641
 642           if( glyphY - static_cast<float>( srcHeight ) < 0.f )
 643           {
 644             ySrcIndex = static_cast<unsigned int>( std::abs( glyphY - static_cast<float>( srcHeight ) ) );
 645             srcHeight -= ySrcIndex;
 646           }
 647           else
 648           {
 649             glyphUintY = static_cast<unsigned int>( glyphY - static_cast<float>( srcHeight ) );
 650           }
 651
 652           if( glyphUintY + srcHeight > parameters.height )
 653           {
 654             srcHeight -= ( ( glyphUintY + srcHeight ) - parameters.height );
 655           }
 656
 657           // Calculate the source and destination indices.
 658           const unsigned int srcPixelSize = Pixel::GetBytesPerPixel( data.format );
 659           const unsigned int dstPixelSize = Pixel::GetBytesPerPixel( pixelFormat );
 660
 661           unsigned int srcIndex = srcPixelSize * ( ySrcIndex * srcWidth + xSrcIndex );
 662           unsigned int dstIndex = dstPixelSize * ( glyphUintY * strideWidth + glyphUintX );
 663
 664           const unsigned int srcWidthOffset = srcPixelSize * ( data.width - srcWidth );
 665           const unsigned int dstWidthOffset = dstPixelSize * ( strideWidth - srcWidth );
 666
 667           // Copy the image to the surface
 668           for( unsigned int j = 0; j < srcHeight; ++j )
 669           {
 670             for( unsigned int i = 0; i < srcWidth; ++i )
 671             {
 672               switch( rgbaCase )
 673               {
 674                 case 0: // Both the image's buffer and cairo's buffer are A8
 675                 {
 676                   const unsigned char alpha = *( data.buffer + srcIndex );
 677                   if( alpha != 0u )
 678                   {
 679                     // @todo needs a proper blending!
 680                     *( buffer + dstIndex ) = alpha;
 681                   }
 682                   break;
 683                 }
 684                 case 1: // The image's buffer is A8 and the cairo's buffer is ARGB
 685                 {
 686                   const unsigned char alpha = *( data.buffer + srcIndex );
 687                   if( alpha != 0u )
 688                   {
 689                     // @todo needs a proper blending!
 690                     const float srcAlpha = TO_FLOAT * static_cast<float>( alpha );
 691
 692                     // Write the RGBA modulated with the given default color.
 693                     const float* const colorPtr = color.AsFloat();
 694                     *( buffer + dstIndex + 0u ) = static_cast<unsigned char>( TO_UCHAR * colorPtr[0u] * srcAlpha );
 695                     *( buffer + dstIndex + 1u ) = static_cast<unsigned char>( TO_UCHAR * colorPtr[1u] * srcAlpha );
 696                     *( buffer + dstIndex + 2u ) = static_cast<unsigned char>( TO_UCHAR * colorPtr[2u] * srcAlpha );
 697                     *( buffer + dstIndex + 3u ) = static_cast<unsigned char>( TO_UCHAR * colorPtr[3u] * srcAlpha );
 698                   }
 699                   break;
 700                 }
 701                 case 2: // The image's buffer is RGBA and the cairo's buffer is ARGB
 702                 {
 703                   const unsigned char alpha = *(data.buffer + srcIndex + 3u);
 704                   if( alpha != 0u )
 705                   {
 706                     if( doBlendWithTextColor )
 707                     {
 708                       const float* const colorPtr = color.AsFloat();
 709
 710                       const float srcAlpha = TO_FLOAT * static_cast<float>(alpha) * colorPtr[3u];
 711
 712                       *(buffer + dstIndex + 0u) = static_cast<unsigned char>( static_cast<float>( *(data.buffer + srcIndex + 0u) ) * colorPtr[0u] );
 713                       *(buffer + dstIndex + 1u) = static_cast<unsigned char>( static_cast<float>( *(data.buffer + srcIndex + 1u) ) * colorPtr[1u] );
 714                       *(buffer + dstIndex + 2u) = static_cast<unsigned char>( static_cast<float>( *(data.buffer + srcIndex + 2u) ) * colorPtr[2u] );
 715
 716                       // Write the alpha.
 717                       *(buffer + dstIndex + 3u) = static_cast<unsigned char>( TO_UCHAR * srcAlpha );
 718                     }
 719                     else
 720                     {
 721                       // @todo needs a proper blending!
 722                       // Write the RGB
 723                       *(buffer + dstIndex + 0u) = *(data.buffer + srcIndex + 0u);
 724                       *(buffer + dstIndex + 1u) = *(data.buffer + srcIndex + 1u);
 725                       *(buffer + dstIndex + 2u) = *(data.buffer + srcIndex + 2u);
 726
 727                       // Write the alpha.
 728                       *(buffer + dstIndex + 3u) = *(data.buffer + srcIndex + 3u);
 729                     }
 730                   }
 731                   break;
 732                 }
 733                 case 3: // The image's buffer is BGRA and the cairo's buffer is ARGB
 734                 {
 735                   const unsigned char alpha = *(data.buffer + srcIndex + 3u);
 736                   if( alpha != 0u )
 737                   {
 738                     if( doBlendWithTextColor )
 739                     {
 740                       const float* const colorPtr = color.AsFloat();
 741
 742                       const float srcAlpha = TO_FLOAT * static_cast<float>(alpha) * colorPtr[3u];
 743
 744                       *(buffer + dstIndex + 0u) = static_cast<unsigned char>( static_cast<float>( *(data.buffer + srcIndex + 2u) ) * colorPtr[0u] );
 745                       *(buffer + dstIndex + 1u) = static_cast<unsigned char>( static_cast<float>( *(data.buffer + srcIndex + 1u) ) * colorPtr[1u] );
 746                       *(buffer + dstIndex + 2u) = static_cast<unsigned char>( static_cast<float>( *(data.buffer + srcIndex + 0u) ) * colorPtr[2u] );
 747
 748                       // Write the alpha.
 749                       *(buffer + dstIndex + 3u) = static_cast<unsigned char>( TO_UCHAR * srcAlpha );
 750                     }
 751                     else
 752                     {
 753                       // @todo needs a proper blending!
 754                       // Write the RGBA
 755                       *(buffer + dstIndex + 0u) = *(data.buffer + srcIndex + 2u);
 756                       *(buffer + dstIndex + 1u) = *(data.buffer + srcIndex + 1u);
 757                       *(buffer + dstIndex + 2u) = *(data.buffer + srcIndex + 0u);
 758                       *(buffer + dstIndex + 3u) = *(data.buffer + srcIndex + 3u);
 759                     }
 760                   }
 761                   break;
 762                 }
 763                 default:
 764                 {
 765                   DALI_ASSERT_ALWAYS( !"Cairo Renderer: The accepted values for this switch case are: 0, 1, 2!" );
 766                 }
 767               } // switch
 768               srcIndex += srcPixelSize;
 769               dstIndex += dstPixelSize;
 770             } // for width
 771             srcIndex += srcWidthOffset;
 772             dstIndex += dstWidthOffset;
 773           } // for height
 774         }
 775       }
 776     }
 777     else
 778     {
 779       // Sets the color. The color is actually BGRA
 780       const Vector4& color = parameters.colors[run.colorIndex];
 781
 782       cairo_set_source_rgba( cr,
 783                              static_cast<double>( color.b ),
 784                              static_cast<double>( color.g ),
 785                              static_cast<double>( color.r ),
 786                              static_cast<double>( color.a ) );
 787
 788       // Create the Cairo's font from the FreeType font.
 789       int options = 0;
 790       options = CAIRO_HINT_STYLE_SLIGHT;
 791       std::unique_ptr<cairo_font_face_t, void(*)(cairo_font_face_t*)> fontFacePtr( cairo_ft_font_face_create_for_ft_face( run.fontFace, options ), cairo_font_face_destroy );
 792       cairo_font_face_t* fontFace = fontFacePtr.get();
 793
 794       static const cairo_user_data_key_t key = { 0 };
 795       cairo_status_t status = cairo_font_face_set_user_data( fontFace, &key, run.fontFace, reinterpret_cast<cairo_destroy_func_t>( FT_Done_Face ) );
 796       if( status )
 797       {
 798         cairo_font_face_destroy( fontFace );
 799       }
 800
 801       unsigned int ftSynthesizeFlag = 0u;
 802       if( run.isBoldRequired && !( run.fontFace->style_flags & FT_STYLE_FLAG_BOLD ) )
 803       {
 804         ftSynthesizeFlag |= CAIRO_FT_SYNTHESIZE_BOLD;
 805       }
 806
 807       cairo_ft_font_face_set_synthesize( fontFace, ftSynthesizeFlag );
 808
 809       cairo_font_face_reference( fontFace );
 810
 811       const bool synthesizeItalic = ( run.isItalicRequired && !( run.fontFace->style_flags & FT_STYLE_FLAG_ITALIC ) );
 812
 813       if( CAIRO_STATUS_SUCCESS != cairo_font_face_status( fontFace ) )
 814       {
 815         DALI_LOG_ERROR( "Failed to load the Freetype Font\n" );
 816       }
 817
 818       // Sets the font.
 819       cairo_set_font_face( isCircularText ? circularCr : cr, fontFace );
 820
 821       // Sets the size
 822       cairo_set_font_size( isCircularText ? circularCr : cr, run.fontSize );
 823
 824       // Render the glyphs.
 825       if( isCircularText )
 826       {
 827         circularTextParameters.synthesizeItalic = synthesizeItalic;
 828
 829         const unsigned int glyphJump = circularTextParameters.synthesizeItalic ? 1u : run.numberOfGlyphs;
 830
 831         for( unsigned int index = 0u; index < run.numberOfGlyphs; index += glyphJump )
 832         {
 833           // Clears the current path where the text is laid out on a horizontal straight line.
 834           cairo_new_path( circularCr );
 835           cairo_move_to( circularCr, 0.0, 0.0 );
 836
 837           cairo_glyph_path( circularCr, ( cairoGlyphsBuffer + run.glyphIndex + index ), glyphJump );
 838
 839           WrapToCircularPath( cr, circularCr, circularTextParameters );
 840           cairo_fill( cr );
 841         }
 842       }
 843       else
 844       {
 845         if( synthesizeItalic )
 846         {
 847           // Apply a shear transform to synthesize the italics.
 848           // For a reason Cairo may trim some glyphs if the CAIRO_FT_SYNTHESIZE_OBLIQUE flag is used.
 849
 850           // This is to calculate an offset used to compensate the 'translation' done by the shear transform
 851           // as it's done for the whole render buffer.
 852           double maxY = 0.0;
 853           for( unsigned int index = run.glyphIndex, endIndex = run.glyphIndex + run.numberOfGlyphs; index < endIndex; ++index )
 854           {
 855             maxY = std::max( maxY, (*( cairoGlyphsBuffer + index )).y );
 856           }
 857
 858           cairo_matrix_t matrix;
 859           cairo_matrix_init( &matrix,
 860                                                                                   1.0, 0.0,
 861                                    -TextAbstraction::FontClient::DEFAULT_ITALIC_ANGLE, 1.0,
 862                              maxY * TextAbstraction::FontClient::DEFAULT_ITALIC_ANGLE, 0.0 );
 863
 864           cairo_transform( cr, &matrix );
 865         }
 866
 867         cairo_show_glyphs( cr, ( cairoGlyphsBuffer + run.glyphIndex ), run.numberOfGlyphs );
 868
 869         if( synthesizeItalic )
 870         {
 871           // Restore the transform matrix to the identity.
 872           cairo_matrix_t matrix;
 873           cairo_matrix_init_identity( &matrix );
 874           cairo_set_matrix( cr, &matrix );
 875         }
 876
 877         cairo_fill( cr );
 878       }
 879     }
 880   }
 881
 882   return pixelBuffer;
 883 }
 884
 885 } // namespace Internal
 886
 887 } // namespace TextAbstraction
 888
 889 } // namespace Dali