freetype-commit
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Git][freetype/freetype][gsoc-anurag-2022] SIMD with Fixed-Point


From: Anurag Thakur (@AdbhutDev)
Subject: [Git][freetype/freetype][gsoc-anurag-2022] SIMD with Fixed-Point
Date: Sun, 16 Oct 2022 20:28:40 +0000

Anurag Thakur pushed to branch gsoc-anurag-2022 at FreeType / FreeType

Commits:

  • 17d14a6c
    by Anurag Thakur at 2022-10-17T01:58:17+05:30
    SIMD with Fixed-Point
    

2 changed files:

Changes:

  • src/dense/ftdense.c
    ... ... @@ -11,7 +11,7 @@
    11 11
     #include "ftdense.h"
    
    12 12
     
    
    13 13
     #include <math.h>
    
    14
    -#include <tmmintrin.h>
    
    14
    +#include <immintrin.h>
    
    15 15
     #include "ftdenseerrs.h"
    
    16 16
     
    
    17 17
     #define PIXEL_BITS 8
    
    ... ... @@ -419,41 +419,66 @@ dense_render_glyph( dense_worker* worker, const FT_Bitmap* target )
    419 419
       unsigned char* dest     = target->buffer;
    
    420 420
       unsigned char* dest_end = target->buffer + worker->m_w * worker->m_h;
    
    421 421
     
    
    422
    -  // __m128 offset = _mm_setzero_ps();
    
    423
    -  // __m128i mask = _mm_set1_epi32(0x0c080400);
    
    424
    -  // __m128 sign_mask = _mm_set1_ps(-0.f);
    
    425
    -  // for (int i = 0; i < worker->m_h*worker->m_w; i += 4) {
    
    426
    -  //   __m128 x = _mm_load_ps(&source[i]);
    
    427
    -  //   x = _mm_add_ps(x, _mm_castsi128_ps(_mm_slli_si128(_mm_castps_si128(x), 4)));
    
    428
    -  //   x = _mm_add_ps(x, _mm_shuffle_ps(_mm_setzero_ps(), x, 0x40));
    
    429
    -  //   x = _mm_add_ps(x, offset);
    
    430
    -  //   __m128 y = _mm_andnot_ps(sign_mask, x);  // fabs(x)
    
    431
    -  //   y = _mm_min_ps(y, _mm_set1_ps(1.0f));
    
    432
    -  //   y = _mm_mul_ps(y, _mm_set1_ps(255.0f));
    
    433
    -  //   __m128i z = _mm_cvtps_epi32(y);
    
    434
    -  //   z = _mm_shuffle_epi8(z, mask);
    
    435
    -  //   _mm_store_ss((float *)&dest[i], (__m128)z);
    
    436
    -  //   offset = _mm_shuffle_ps(x, x, _MM_SHUFFLE(3, 3, 3, 3));
    
    437
    -  // }
    
    438
    -
    
    439
    -  FT20D12 valnew = 0;
    
    440
    -  //float          value    = 0.0f;
    
    441
    -  while ( dest < dest_end )
    
    422
    +   __m128i offset = _mm_setzero_si128();
    
    423
    +  __m128i mask   = _mm_set1_epi32( 0x0c080400 );
    
    424
    +
    
    425
    +  for (int i = 0; i < worker->m_h*worker->m_w; i += 4)
    
    442 426
       {
    
    443
    -    valnew += *source++;
    
    427
    +    // load 4 floats from source
    
    444 428
     
    
    445
    -   // printf("%d\n", *source);
    
    429
    +    __m128i x = _mm_load_si128( (__m128i*)&source[i] );
    
    446 430
     
    
    447
    -    if(valnew > 0){
    
    448
    -      int nnew = valnew >>4;
    
    431
    +    // bkc
    
    432
    +    x = _mm_add_epi32( x, _mm_slli_si128( x, 4 ) );
    
    449 433
     
    
    450
    -      if(nnew>255)nnew=255;
    
    451
    -      *dest = (unsigned char)nnew;
    
    452
    -    }else{
    
    453
    -      *dest = 0;
    
    454
    -    }
    
    455
    -    dest++;
    
    434
    +    // more bkc
    
    435
    +    x = _mm_add_epi32(
    
    436
    +        x, _mm_castps_si128( _mm_shuffle_ps( _mm_setzero_ps(),
    
    437
    +                                             _mm_castsi128_ps( x ), 0x40 ) ) );
    
    438
    +
    
    439
    +    // add the prefsum of previous 4 floats to all current floats
    
    440
    +    x = _mm_add_epi32( x, offset );
    
    441
    +
    
    442
    +    // take absolute value
    
    443
    +    __m128i y = _mm_abs_epi32( x );  // fabs(x)
    
    444
    +
    
    445
    +    // cap max value to 1
    
    446
    +    y = _mm_min_epi32( y, _mm_set1_epi32( 4080 ) );
    
    447
    +
    
    448
    +    // reduce to 255
    
    449
    +    y = _mm_srli_epi32( y, 4 );
    
    450
    +
    
    451
    +    // black magic
    
    452
    +    y = _mm_shuffle_epi8( y, mask );
    
    453
    +
    
    454
    +    // for some reason, storing float in an unsigned char array works fine lol
    
    455
    +    _mm_store_ss( (float*)&dest[i], (__m128)y );
    
    456
    +
    
    457
    +    // store the current prefix sum in offset
    
    458
    +    offset = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps( x ),
    
    459
    +                                               _mm_castsi128_ps( x ),
    
    460
    +                                               _MM_SHUFFLE( 3, 3, 3, 3 ) ) );
    
    456 461
       }
    
    462
    +  
    
    463
    +
    
    464
    +    // FT20D12 valnew = 0;
    
    465
    +    // //float          value    = 0.0f;
    
    466
    +    // while ( dest < dest_end )
    
    467
    +    // {
    
    468
    +    //   valnew += *source++;
    
    469
    +
    
    470
    +    //  // printf("%d\n", *source);
    
    471
    +
    
    472
    +    //   if(valnew > 0){
    
    473
    +    //     int nnew = valnew >>4;
    
    474
    +
    
    475
    +    //     if(nnew>255)nnew=255;
    
    476
    +    //     *dest = (unsigned char)nnew;
    
    477
    +    //   }else{
    
    478
    +    //     *dest = 0;
    
    479
    +    //   }
    
    480
    +    //   dest++;
    
    481
    +    // }
    
    457 482
     
    
    458 483
       free(worker->m_a);
    
    459 484
       return error;
    

  • src/dense/ftdense.h
    ... ... @@ -41,8 +41,8 @@ extern "C"
    41 41
     #endif
    
    42 42
     
    
    43 43
       typedef signed long TPos;
    
    44
    -  typedef signed long long FT26D6;
    
    45
    -  typedef signed long long FT20D12;
    
    44
    +  typedef signed long FT26D6;
    
    45
    +  typedef signed int FT20D12;
    
    46 46
     
    
    47 47
       typedef struct
    
    48 48
       {
    


  • reply via email to

    [Prev in Thread] Current Thread [Next in Thread]