tahoma2d/toonz/sources/common/trop/optimize_for_lp64.h

#pragma once

#ifndef OPTIMIZE_FOR_LP64_INCLUDED
#define OPTIMIZE_FOR_LP64_INCLUDED

/* ========================================================================= */

/*

  *****************************************************************************
  *  OSSERVAZIONI                                                             *
  *****************************************************************************

  ____________OSS 1:___________________________________________________________


  se devo fare DUE MOLTIPLICAZIONI 13 bit * 8 bit posso farle in un
  colpo solo, ad esempio:

  siano X = xxxxxxxxxxxxx
  S = ssssssss
  Y = yyyyyyyyyyyyy
  T = tttttttt

  e devo calcolare
  U = X * S
  V = Y * T
  posso farlo in un colpo solo impacchettando i bit cosi':

  A = X       0 00000000 Y       = xxxxxxxxxxxxx 0 00000000 yyyyyyyyyyyyy
  B = 00000 S 0 00000000 00000 T = 00000ssssssss 0 00000000 00000tttttttt

  ora se faccio C = A * B si ha

  C = U ?????????????????????? V =
  = uuuuuuuuuuuuuuuuuuuuu ?????????????????????? vvvvvvvvvvvvvvvvvvvvv

  dove C e' di 64 bit; cioe' i primi 21 bit sono X * S = U
  e gli ultimi 21 sono Y * T = V

  ____________OSS 2:___________________________________________________________


  se devo fare DUE MOLTIPLICAZIONI 16 bit * 16 bit del tipo
  X * S = U
  Y * S = V

  con

  #X = 16,
  #Y = 16,
  #S = 16

  (dove l'operatore '#' da' come risultato il numero di bit di cui e' composto
  un numero intero)

  posso farle tutte e due in un solo colpo impacchettando i bit cosi':

  O = 0000000000000000,   #O = 16
  A = X O Y           ,   #A = 48
  B = S               ,   #B = 16
  C = A * B           ,   #C = 64

  dove i primi 32 bit sono X * S e i secondi 32 bit sono Y * S

  ____________OSS 3:___________________________________________________________


  se devo fare QUATTRO MOLTIPLICAZIONI 8 bit * 8 bit del tipo
  X * S = I           #X = 8, #S = 8, #I = 16
  Y * S = J           #Y = 8, #S = 8, #J = 16
  Z * S = K           #Z = 8, #S = 8, #K = 16
  W * S = L           #W = 8, #S = 8, #L = 16


  posso farle tutte e due in un solo colpo impacchettando i bit cosi':

  O = 00000000             #O = 8
  C = XOYOZOW * OOOOOOS    #C = 64

  dove
  I sono i primi 16 bit,
  J sono i secondi 16 bit,
  K sono i terzi 16 bit,
  L i quarti 16 bit
  _____________________________________________________________________________

  *****************************************************************************
  */

/* ========================================================================= */

#define OPTIMIZE_FOR_LP64

/* ========================================================================= */

#define MASK_FIRST_OF_3_X_16BIT 0x7FFFC00000000
#define MASK_SECOND_OF_3_X_16BIT 0x3FFFE0000
#define MASK_THIRD_OF_3_X_16BIT 0x1FFFF

#define FIRST_OF_3_X_16BIT(x) (x) >> 34
#define SECOND_OF_3_X_16BIT(x) ((x)&MASK_SECOND_OF_3_X_16BIT) >> 17;
#define THIRD_OF_3_X_16BIT(x) (x) & MASK_THIRD_OF_3_X_16BIT;

/* ========================================================================= */

#define MASK_FIRST_OF_2_X_24BIT 0x3FFFFFE000000
#define MASK_SECOND_OF_2_X_24BIT 0x1FFFFFF

#define FIRST_OF_2_X_24BIT(x) (x) >> 25
#define SECOND_OF_2_X_24BIT(x) (x) & MASK_SECOND_OF_2_X_24BIT

/* ========================================================================= */

#define MASK_FIRST_OF_2_X_32BIT 0xFFFFFFFF00000000
#define MASK_SECOND_OF_2_X_32BIT 0xFFFFFFFF

#define FIRST_OF_2_X_32BIT(x) (x) >> 32
#define SECOND_OF_2_X_32BIT(x) (x) & MASK_SECOND_OF_2_X_32BIT

/* ========================================================================= */

typedef unsigned char UINT8;
typedef unsigned short UINT16;
typedef unsigned int UINT24;
typedef unsigned int UINT32;
typedef unsigned long UINT50;
typedef unsigned long UINT51;
typedef unsigned long UINT64;

/* ========================================================================= */

#if 0

/* esegue a1+b1, a2+c2, a3+c3 in un'unica operazione */
UINT64  add_3_x_16bit ( UINT16 a1, UINT16 a2, UINT16 a3,
			UINT16 b1, UINT16 b2, UINT16 b3 );

/* esegue a1+b1, a2+b2 in un'unica operazione */
UINT50 add_2_x_24bit ( UINT24 a1, UINT24 a2,
		       UINT24 b1, UINT24 b2 );

/* esegue a1*b, a2*b in un'unica operazione */
UINT64 mult_2_x_16bit ( UINT16 a1, UINT16 a2,
			UINT16 b );
#endif

/* ========================================================================= */

/* ------------------------------------------------------------------------- */

#define ADD_3_X_16BIT(a1, a2, a3, b1, b2, b3)                                  \
  (0L | (UINT64)(a1) << 34 | (UINT64)(a2) << 17 | (a3)) +                      \
      (0L | (UINT64)(b1) << 34 | (UINT64)(b2) << 17 | (b3))

inline UINT64 add_3_x_16bit(UINT16 a1, UINT16 a2, UINT16 a3, UINT16 b1,
                            UINT16 b2, UINT16 b3) {
  return (0L | (UINT64)a1 << 34 | (UINT64)a2 << 17 | a3) +
         (0L | (UINT64)b1 << 34 | (UINT64)b2 << 17 | b3);
}

/* ------------------------------------------------------------------------- */

#define ADD_2_X_24BIT(a1, a2, b1, b2)                                          \
  (0L | (UINT64)(a1) << 25 | (a2)) + (0L | (UINT64)(b1) << 25 | (b2))

inline UINT50 add_2_x_24bit(UINT24 a1, UINT24 a2, UINT24 b1, UINT24 b2) {
  return (0L | (UINT64)a1 << 25 | a2) + (0L | (UINT64)b1 << 25 | b2);
}

/* ------------------------------------------------------------------------- */

#define MULT_2_X_16BIT(a1, a2, b)                                              \
  ((UINT64)b) * (((UINT64)(a1) << 32) | (UINT64)a2)

inline UINT64 mult_2_x_16bit(UINT16 a1, UINT16 a2, UINT16 b) {
  return (0L | (UINT64)a1 << 32 | a2) * b;
}

#endif