pixel.h

Go to the documentation of this file.

/* This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef _GAN_PIXEL_H
#define _GAN_PIXEL_H

#include <gandalf/common/misc_defs.h>
#include <gandalf/common/bit_array.h>
#include <gandalf/linalg/2vector.h>
#include <gandalf/linalg/2vectorf.h>
#include <gandalf/linalg/3vector.h>
#include <gandalf/linalg/3vectorf.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef enum
{
   GAN_GREY_LEVEL_IMAGE,       
   GAN_GREY_LEVEL_ALPHA_IMAGE, 
   GAN_RGB_COLOUR_IMAGE,       
   GAN_RGB_COLOUR_ALPHA_IMAGE, 
   GAN_VECTOR_FIELD_2D,        
   GAN_VECTOR_FIELD_3D,        
   GAN_RGBX,                   
   GAN_RGBAS,                  
   GAN_YUVX444,                
   GAN_YUVA444,                
   GAN_YUV422,                 
   GAN_UNDEFINED_IMAGE_FORMAT
} Gan_ImageFormat;

typedef struct Gan_GLAPixel_uc
{
   unsigned char I, 
                 A; 
} Gan_GLAPixel_uc;

typedef struct Gan_GLAPixel_s
{
   short I, 
         A; 
} Gan_GLAPixel_s;

typedef struct Gan_GLAPixel_us
{
   unsigned short I, 
                  A; 
} Gan_GLAPixel_us;

typedef struct Gan_GLAPixel_i
{
   int I, 
       A; 
} Gan_GLAPixel_i;

typedef struct Gan_GLAPixel_ui
{
   unsigned int I, 
                A; 
} Gan_GLAPixel_ui;

typedef struct Gan_GLAPixel_f
{
   float I, 
         A; 
} Gan_GLAPixel_f;

typedef struct Gan_GLAPixel_d
{
   double I, 
          A; 
} Gan_GLAPixel_d;

typedef struct Gan_RGBPixel_uc
{
   unsigned char R, 
                 G, 
                 B; 
} Gan_RGBPixel_uc;

typedef struct Gan_RGBPixel_s
{
   short R, 
         G, 
         B; 
} Gan_RGBPixel_s;

typedef struct Gan_RGBPixel_us
{
   unsigned short R, 
                  G, 
                  B; 
} Gan_RGBPixel_us;

typedef struct Gan_RGBPixel_i
{
   int R, 
       G, 
       B; 
} Gan_RGBPixel_i;

typedef struct Gan_RGBPixel_ui
{
   unsigned int R, 
                G, 
                B; 
} Gan_RGBPixel_ui;

typedef struct Gan_RGBPixel_f
{
   float R, 
         G, 
         B; 
} Gan_RGBPixel_f;

typedef struct Gan_RGBPixel_d
{
   double R, 
          G, 
          B; 
} Gan_RGBPixel_d;

typedef struct Gan_RGBAPixel_uc
{
   unsigned char R, 
                 G, 
                 B, 
                 A; 
} Gan_RGBAPixel_uc;

typedef struct Gan_RGBAPixel_s
{
   short R, 
         G, 
         B, 
         A; 
} Gan_RGBAPixel_s;

typedef struct Gan_RGBAPixel_us
{
   unsigned short R, 
                  G, 
                  B, 
                  A; 
} Gan_RGBAPixel_us;

typedef struct Gan_RGBAPixel_i
{
   int R, 
       G, 
       B, 
       A; 
} Gan_RGBAPixel_i;

typedef struct Gan_RGBAPixel_ui
{
   unsigned int R, 
                G, 
                B, 
                A; 
} Gan_RGBAPixel_ui;

typedef struct Gan_RGBAPixel_f
{
   float R, 
         G, 
         B, 
         A; 
} Gan_RGBAPixel_f;

typedef struct Gan_RGBAPixel_d
{
   double R, 
          G, 
          B, 
          A; 
} Gan_RGBAPixel_d;

typedef struct Gan_RGBXPixel_ui8
{
   unsigned int X : 8; 
   unsigned int B : 8; 
   unsigned int G : 8; 
   unsigned int R : 8; 
} Gan_RGBXPixel_ui8;

typedef struct Gan_RGBXPixel_ui10
{
   unsigned int X : 2;  
   unsigned int B : 10; 
   unsigned int G : 10; 
   unsigned int R : 10; 
} Gan_RGBXPixel_ui10;

typedef struct Gan_RGBASPixel_ui10
{
   unsigned int A : 2; 
   unsigned int B : 10; 
   unsigned int G : 10; 
   unsigned int R : 10; 
} Gan_RGBASPixel_ui10;

typedef struct Gan_RGBAPixel_ui12
{
   unsigned int A : 12; 
   unsigned int B : 12; 
   unsigned int G : 12; 
   unsigned int R : 12; 
} Gan_RGBAPixel_ui12;

typedef struct Gan_YUVX444Pixel_ui8
{
   gan_uint8 Y; 
   gan_uint8 U; 
   gan_uint8 V; 
   gan_uint8 X; 
} Gan_YUVX444Pixel_ui8;

typedef struct Gan_YUVA444Pixel_ui8
{
   gan_uint8 Y; 
   gan_uint8 U; 
   gan_uint8 V; 
   gan_uint8 A; 
} Gan_YUVA444Pixel_ui8;

typedef struct Gan_YUV422Pixel_ui8
{
   gan_uint8 UV; 
   gan_uint8 Y;  
} Gan_YUV422Pixel_ui8;

typedef struct Gan_YXPixel_ui10
{
   gan_uint16 X :  6; 
   gan_uint16 Y : 10; 
} Gan_YXPixel_ui10;

typedef struct Gan_YXPixel_ui12
{
   gan_uint16 X :  4; 
   gan_uint16 Y : 12; 
} Gan_YXPixel_ui12;

#if (SIZEOF_CHAR == 1)

typedef struct Gan_GLAPixel_uc Gan_GLAPixel_ui8;

typedef struct Gan_RGBPixel_uc Gan_RGBPixel_ui8;

typedef struct Gan_RGBAPixel_uc Gan_RGBAPixel_ui8;
#else
#error "8-bit type conflict"
#endif /* #if (SIZEOF_CHAR == 1) */

#if (SIZEOF_SHORT == 2)

typedef struct Gan_GLAPixel_us Gan_GLAPixel_ui16;

typedef struct Gan_RGBPixel_us Gan_RGBPixel_ui16;

typedef struct Gan_RGBAPixel_us Gan_RGBAPixel_ui16;
#else
#error "16-bit type conflict"
#endif /* #if (SIZEOF_SHORT == 2) */

#if (SIZEOF_INT == 4)

typedef struct Gan_GLAPixel_ui Gan_GLAPixel_ui32;

typedef struct Gan_RGBPixel_ui Gan_RGBPixel_ui32;

typedef struct Gan_RGBPixel_i Gan_RGBPixel_i32;

typedef struct Gan_RGBAPixel_ui Gan_RGBAPixel_ui32;

typedef struct Gan_RGBAPixel_i Gan_RGBAPixel_i32;

#else
#error "32-bit type conflict"
#endif /* #if (SIZEOF_INT == 4) */

#if (SIZEOF_FLOAT == 4)

typedef struct Gan_GLAPixel_f Gan_GLAPixel_f32;

typedef struct Gan_RGBPixel_f Gan_RGBPixel_f32;

typedef struct Gan_RGBAPixel_f Gan_RGBAPixel_f32;
#else
#error "32-bit float type conflict"
#endif /* #if (SIZEOF_FLOAT == 4) */

#if (SIZEOF_DOUBLE == 8)

typedef struct Gan_GLAPixel_d Gan_GLAPixel_f64;

typedef struct Gan_RGBPixel_d Gan_RGBPixel_f64;

typedef struct Gan_RGBAPixel_d Gan_RGBAPixel_f64;
#else
#error "64-bit float type conflict"
#endif /* #if (SIZEOF_DOUBLE == 8) */

typedef struct Gan_Pixel
{
   Gan_ImageFormat format;

   Gan_Type type;

   union
   {
      union
      {
         unsigned char  uc;
         short          s;
         unsigned short us;
         int            i;
         unsigned int   ui;
         double         d;
         float          f;
         Gan_Bool       b;
         void          *p;

         gan_uint8 ui8;
         gan_uint16 ui16;
         gan_uint32 ui32;
         Gan_YXPixel_ui10 ui10;
         Gan_YXPixel_ui12 ui12;
      } gl;

      union
      {
         Gan_GLAPixel_uc uc;
         Gan_GLAPixel_s  s;
         Gan_GLAPixel_us us;
         Gan_GLAPixel_i  i;
         Gan_GLAPixel_ui ui;
         Gan_GLAPixel_d  d;
         Gan_GLAPixel_f  f;

         Gan_GLAPixel_ui8 ui8;
         Gan_GLAPixel_ui16 ui16;
         Gan_GLAPixel_ui32 ui32;
      } gla;

      union
      {
         Gan_RGBPixel_uc uc;
         Gan_RGBPixel_s  s;
         Gan_RGBPixel_us us;
         Gan_RGBPixel_i  i;
         Gan_RGBPixel_ui ui;
         Gan_RGBPixel_d  d;
         Gan_RGBPixel_f  f;

         Gan_RGBPixel_ui8 ui8;
         Gan_RGBPixel_ui16 ui16;
         Gan_RGBPixel_ui32 ui32;
      } rgb;

      union
      {
         Gan_RGBAPixel_uc uc;
         Gan_RGBAPixel_s  s;
         Gan_RGBAPixel_us us;
         Gan_RGBAPixel_i  i;
         Gan_RGBAPixel_ui ui;
         Gan_RGBAPixel_d  d;
         Gan_RGBAPixel_f  f;

         Gan_RGBAPixel_ui8 ui8;
         Gan_RGBAPixel_ui16 ui16;
         Gan_RGBAPixel_ui32 ui32;
         Gan_RGBAPixel_ui12 ui12;
      } rgba;

      union
      {
         Gan_Vector2_f f;
         Gan_Vector2   d;
         Gan_Vector2_s s;
         Gan_Vector2_i i;
      } vfield2D;

      union
      {
         Gan_Vector3_f f;
         Gan_Vector3   d;
         Gan_Vector3_s s;
         Gan_Vector3_i i;
      } vfield3D;

      union
      {
         Gan_RGBXPixel_ui8   ui8;
         Gan_RGBXPixel_ui10 ui10;
      } rgbx;

      union
      {
         Gan_RGBASPixel_ui10 ui10;
      } rgbas;

      union
      {
         Gan_YUVX444Pixel_ui8 ui8;
      } yuvx444;

      union
      {
         Gan_YUVA444Pixel_ui8 ui8;
      } yuva444;

      union
      {
         Gan_YUV422Pixel_ui8 ui8;
      } yuv422;
   } data;
} Gan_Pixel;

 unsigned char  gan_pixel_rgbuc_to_yuc ( const Gan_RGBPixel_uc *rgb );
 unsigned short gan_pixel_rgbuc_to_yus ( const Gan_RGBPixel_uc *rgb );
 unsigned int   gan_pixel_rgbuc_to_yui ( const Gan_RGBPixel_uc *rgb );
 unsigned char  gan_pixel_rgbus_to_yuc ( const Gan_RGBPixel_us *rgb );
 unsigned short gan_pixel_rgbus_to_yus ( const Gan_RGBPixel_us *rgb );
 float          gan_pixel_rgbui_to_yf  ( const Gan_RGBPixel_ui *rgb );
 float          gan_pixel_rgbf_to_yf   ( const Gan_RGBPixel_f  *rgb );
 double         gan_pixel_rgbd_to_yd   ( const Gan_RGBPixel_d  *rgb );
 unsigned char  gan_pixel_rgbauc_to_yuc ( const Gan_RGBAPixel_uc *rgba );
 unsigned short gan_pixel_rgbauc_to_yus ( const Gan_RGBAPixel_uc *rgba );
 unsigned int   gan_pixel_rgbauc_to_yui ( const Gan_RGBAPixel_uc *rgba );
 unsigned char  gan_pixel_rgbaus_to_yuc ( const Gan_RGBAPixel_us *rgba );
 unsigned short gan_pixel_rgbaus_to_yus ( const Gan_RGBAPixel_us *rgba );
 float          gan_pixel_rgbaui_to_yf  ( const Gan_RGBAPixel_ui *rgba );
 float          gan_pixel_rgbaf_to_yf   ( const Gan_RGBAPixel_f  *rgba );
 double         gan_pixel_rgbad_to_yd   ( const Gan_RGBAPixel_d  *rgba );

 Gan_Bool gan_image_convert_pixel ( Gan_Pixel *inpix,
                                   Gan_ImageFormat format, Gan_Type type,
                                   Gan_Pixel *outpix, int *error_code );
 double gan_image_convert_scale ( Gan_Type gtFromType, Gan_Type gtToType );
 Gan_Bool gan_image_offset_pixel_q ( Gan_Pixel *pixel, double offset,
                                    Gan_Pixel *offset_pixel );
 Gan_Bool gan_image_scale_pixel_q ( Gan_Pixel *pixel, double scale,
                                   Gan_Pixel *scaled_pixel );
 Gan_Bool gan_image_divide_pixel_q ( Gan_Pixel *pixel, double scale,
                                    Gan_Pixel *scaled_pixel );
 Gan_Bool gan_image_fill_zero_pixel ( Gan_Pixel *pixel );
 const char *gan_image_format_string ( Gan_ImageFormat format );
 Gan_ImageFormat gan_image_format_with_alpha ( Gan_ImageFormat format );
 Gan_ImageFormat gan_image_format_without_alpha ( Gan_ImageFormat format );

 gan_uint8  gan_pixel_rgbui8_to_yui8 ( const Gan_RGBPixel_ui8 *rgb );

 gan_uint16 gan_pixel_rgbui8_to_yui16 ( const Gan_RGBPixel_ui8 *rgb );

 gan_uint32  gan_pixel_rgbui8_to_yui32   ( const Gan_RGBPixel_ui8 *rgb );

 gan_uint8   gan_pixel_rgbui16_to_yui8   ( const Gan_RGBPixel_ui16 *rgb );

 gan_uint16  gan_pixel_rgbui16_to_yui16  ( const Gan_RGBPixel_ui16 *rgb );

 gan_float32 gan_pixel_rgbui32_to_yf32   ( const Gan_RGBPixel_ui32 *rgb );

 gan_float32 gan_pixel_rgbf32_to_yf32    ( const Gan_RGBPixel_f32  *rgb );

 gan_float64 gan_pixel_rgbf64_to_yf64    ( const Gan_RGBPixel_f64  *rgb );

 gan_uint8   gan_pixel_rgbaui8_to_yui8   ( const Gan_RGBAPixel_ui8 *rgba );

 gan_uint16  gan_pixel_rgbaui8_to_yui16  ( const Gan_RGBAPixel_ui8 *rgba );

 gan_uint32  gan_pixel_rgbaui8_to_yui32  ( const Gan_RGBAPixel_ui8 *rgba );

 gan_uint8   gan_pixel_rgbaui16_to_yui8  ( const Gan_RGBAPixel_ui16 *rgba );

 gan_uint16  gan_pixel_rgbaui16_to_yui16 ( const Gan_RGBAPixel_ui16 *rgba );

 gan_float32 gan_pixel_rgbaui32_to_yf32  ( const Gan_RGBAPixel_ui32 *rgba );

 gan_float32 gan_pixel_rgbaf32_to_yf32   ( const Gan_RGBAPixel_f32  *rgba );

 gan_float64 gan_pixel_rgbaf64_to_yf64   ( const Gan_RGBAPixel_f64  *rgba );

 unsigned char gan_pixel_us_to_uc ( unsigned short x );

 gan_uint8 gan_pixel_ui16_to_ui8 ( gan_uint16 x );

 unsigned char gan_pixel_ui_to_uc ( unsigned x );

 gan_uint8 gan_pixel_ui32_to_ui8 ( gan_uint32 x );

 unsigned char gan_pixel_f_to_uc ( float x );

 gan_uint8 gan_pixel_f32_to_ui8 ( gan_float32 x );

 unsigned char gan_pixel_d_to_uc ( double x );

 gan_uint8 gan_pixel_f64_to_ui8 ( gan_float64 x );

 unsigned short gan_pixel_uc_to_us ( unsigned char x );

 gan_uint16 gan_pixel_ui8_to_ui16 ( gan_uint8 x );

 unsigned short gan_pixel_ui_to_us ( unsigned x );

 gan_uint16 gan_pixel_ui32_to_ui16 ( gan_uint32 x );

 short gan_pixel_i_to_s ( int x );

 gan_int16 gan_pixel_i32_to_i16 ( gan_int32 x );

 unsigned short gan_pixel_f_to_us ( float x );

 gan_int16 gan_pixel_f32_to_ui16 ( gan_float32 x );

 unsigned short gan_pixel_d_to_us ( double x );

 gan_int16 gan_pixel_f64_to_ui16 ( gan_float64 x );

 unsigned int gan_pixel_uc_to_ui ( unsigned char x );

 gan_uint32 gan_pixel_ui8_to_ui32 ( gan_uint8 x );

 unsigned int gan_pixel_us_to_ui ( unsigned short x );

 gan_uint32 gan_pixel_ui16_to_ui32 ( gan_uint16 x );

 int gan_pixel_s_to_i ( short x );

 gan_int32 gan_pixel_i16_to_i32 ( gan_int16 x );

 unsigned int gan_pixel_f_to_ui ( float x );

 gan_uint32 gan_pixel_f32_to_ui32 ( gan_float32 x );

 unsigned int gan_pixel_d_to_ui ( double x );

 gan_uint32 gan_pixel_f64_to_ui32 ( gan_float64 x );

 extern float lookup_table_8bit[];

/*
 * \brief Macro: Convert a pixel field from \c unsigned \c char to \c float type.
 */
 float gan_pixel_uc_to_f ( unsigned char x );

/*
 * \brief Macro: Convert a pixel field from 8-bit unsigned integer to 32-bit float type.
 */
 gan_float32 gan_pixel_ui8_to_f32 ( gan_uint8 x );

 float gan_pixel_us_to_f ( unsigned short x );

 gan_float32 gan_pixel_ui16_to_f32 ( gan_uint16 x );

 float gan_pixel_ui_to_f ( unsigned int x );

 gan_float32 gan_pixel_ui32_to_f32 ( gan_uint32 x );

 double gan_pixel_uc_to_d ( unsigned char x );

 gan_float64 gan_pixel_ui8_to_f64 ( gan_uint8 x );

 double gan_pixel_us_to_d ( unsigned short x );

 gan_float64 gan_pixel_ui16_to_f64 ( gan_uint16 x );

 double gan_pixel_ui_to_d ( unsigned int x );

 gan_float64 gan_pixel_ui32_to_f64 ( gan_uint32 x );
   
 int gan_pixel_f_to_i ( float x );

 gan_int32 gan_pixel_f32_to_i32 ( gan_float32 x );

 int gan_pixel_d_to_i ( double x );

 gan_int32 gan_pixel_f64_to_i32 ( gan_float64 x );

 short gan_pixel_f_to_s ( float x );

 gan_int16 gan_pixel_f32_to_i16 ( gan_float32 x );

 short gan_pixel_d_to_s ( double x );

 gan_int16 gan_pixel_f64_to_i16 ( gan_float64 x );

 float gan_pixel_s_to_f ( short x );

 gan_float32 gan_pixel_i16_to_f32 ( gan_int16 x );

 double gan_pixel_s_to_d ( short x );

 gan_float64 gan_pixel_i16_to_f64 ( gan_int16 x );
   
 float gan_pixel_i_to_f ( int x );

 gan_float32 gan_pixel_i32_to_f32 ( gan_int32 x );

 double gan_pixel_i_to_d ( int x );

 gan_float64 gan_pixel_i32_to_f64 ( gan_int32 x );

// other hard-wired 8 bit conversions
#if (SIZEOF_CHAR == 1)

 int gan_pixel_f_to_ui8 ( float x );

 int gan_pixel_d_to_ui8 ( double x );

 float gan_pixel_ui8_to_f ( gan_uint8 x );

 double gan_pixel_ui8_to_d ( gan_uint8 x );

#endif /* (SIZEOF_CHAR == 1) */

// other hard-wired 16 bit conversions
#if (SIZEOF_SHORT == 2)

 int gan_pixel_f_to_ui16 ( float x );

 int gan_pixel_d_to_ui16 ( double x );

 float gan_pixel_ui16_to_f ( gan_uint16 x );

 double gan_pixel_ui16_to_d ( gan_uint16 x );

#endif /* (SIZEOF_SHORT == 2) */

// hard-wired 32 bit conversions
#if (SIZEOF_INT == 4)

 int gan_pixel_f_to_ui32 ( float x );

 int gan_pixel_d_to_ui32 ( double x );

 float gan_pixel_ui32_to_f ( gan_uint32 x );

 double gan_pixel_ui32_to_d ( gan_uint32 x );

#endif /* (SIZEOF_INT == 4) */

 Gan_Bool gan_image_convert_pixel_q ( Gan_Pixel *inpix,
                                     Gan_ImageFormat format, Gan_Type type,
                                     Gan_Pixel *outpix );

 Gan_Bool gan_image_convert_pixel_i ( Gan_Pixel *pix,
                                     Gan_ImageFormat format, Gan_Type type );

 Gan_Bool gan_image_offset_pixel_i ( Gan_Pixel *pixel, double offset );

 Gan_Bool gan_image_scale_pixel_i ( Gan_Pixel *pixel, double scale );

 Gan_Bool gan_image_divide_pixel_i ( Gan_Pixel *pixel, double scale );

#ifdef __cplusplus
}
#endif

#endif /* #ifndef _GAN_PIXEL_H */

---