%%	options

copyright owner	=	Dirk Krause
copyright year	=	2011-2013
license		=	bsd



%%	header

#ifdef __cplusplus
extern "C" {
#endif

/**	Set up resampling structure.
	This function must be called before you start
	any conversion using dk3pixre_convert().
	@param	pp	Resampling structure.
	@param	inw	Input number of bits per component.
	@param	outw	Output number of bits per component.
*/
void
dk3pixre_set(dk3_pixel_resample_t *pp, size_t inw, size_t outw);

/**	Resample pixel. The dk3_pixel_resample_t structure must
	already be set up using dk3pixre_set().
	@param	pp	Resampling structure.
	@param	inval	Value to resample.
	@return	Pixel component resampled.
*/
dk3_bif_pixel_t
dk3pixre_convert(dk3_pixel_resample_t *pp, dk3_bif_pixel_t inval);

/**	Get mask for maximum output value.
	@param	pp	Resampling structure.
	@return	Maximum value for given number of output bits.
*/
dk3_bif_pixel_t
dk3pixre_get_max_value(dk3_pixel_resample_t *pp);

/**	Get one pixel component value from packed bytes.
	@param	row	Pixel data.
	@param	vi	Value index.
	@param	bpc	Number of bits per component.
	@return	Pixel component value.
*/
dk3_bif_pixel_t
dk3pixre_get_value_from_packed_bytes(
  unsigned char const	*row,
  dk3_bif_coord_t	 vi,
  size_t		 bpc
);

#ifdef __cplusplus
}
#endif

%%	module

#include "dk3all.h"
#include "dk3pixre.h"



$!trace-include



void
dk3pixre_set(dk3_pixel_resample_t *pp, size_t inw, size_t outw)
{
  size_t	i;
  if((pp) && (inw) && (outw)) {
    pp->insize = inw;
    pp->outsize = outw;
    pp->andmask = (dk3_bif_pixel_t)0;
    pp->ormask = (dk3_bif_pixel_t)0;
    pp->shiftw = 0;
    pp->direction = 0;
    if(outw > inw) {
      pp->direction = 1;
      pp->shiftw = outw - inw;
      for(i = 0; i < pp->shiftw; i++) {
        pp->ormask |= dk3bits_get(i);
      }
      for(i = inw; i < outw; i++) {
        pp->andmask |= dk3bits_get(i);
      }
    } else {
      if(outw < inw) {
        pp->direction = -1;
	pp->shiftw = inw - outw;
	for(i = 0; i < outw; i++) {
	  pp->andmask |= dk3bits_get(i);
	}
      }
    }
    pp->maxval = (dk3_bif_pixel_t)0U;
    for(i = 0; i < outw; i++) {
      pp->maxval |= dk3bits_get(i);
    }
  }
}



dk3_bif_pixel_t
dk3pixre_convert(dk3_pixel_resample_t *pp, dk3_bif_pixel_t inval)
{
  dk3_bif_pixel_t	back;
  $? "+ dk3pixre_convert %u", (unsigned)inval
  back = inval;
  if(pp) {
    switch(pp->direction) {
      case 1: {
        back = (back << (pp->shiftw));
	if(inval & 1) {
	  back |= (pp->ormask);
	} else {
	  back &= (pp->andmask);
	}
      } break;
      case -1: {	$? ". shift right %d", (int)(pp->shiftw)
        back = (back >> (pp->shiftw));	$? ". andmask=%d", (int)(pp->andmask)
	back &= (pp->andmask);
      } break;
    }
  } $? "- dk3pixre_convert %u", (unsigned)back
  return back;
}



dk3_bif_pixel_t
dk3pixre_get_value_from_packed_bytes(
  unsigned char const	*row,
  dk3_bif_coord_t	 vi,
  size_t		 bpc
)
{
  unsigned short const	*us;
  unsigned char		 uc;
  dk3_bif_coord_t	 byteindex;
  dk3_bif_coord_t	 inbyte;

  dk3_bif_pixel_t	back = (dk3_bif_pixel_t)0;
  switch(bpc) {
    case 16: {
      us = (unsigned short const *)row;
      back = us[vi];
    } break;
    case 8: {
      back =  (dk3_bif_pixel_t)(row[vi]);
      back &= 0x00FFU;
    } break;
    case 4: {
      byteindex = vi / 2L;
      inbyte    = vi % 2L;
      uc = row[byteindex];
      switch((int)inbyte) {
        case 0: {
	  uc = uc >> 4;
	} break;
      }
      back = (dk3_bif_pixel_t)uc;
      back &= 0x000FU;
    } break;
    case 2: {
      byteindex = vi / 4L;
      inbyte    = vi % 4L;
      uc = row[byteindex];
      switch((int)inbyte) {
        case 0: {
	  uc = uc >> 6;
	} break;
	case 1: {
	  uc = uc >> 4;
	} break;
	case 2: {
	  uc = uc >> 2;
	} break;
      }
      back = (dk3_bif_pixel_t)uc;
      back &= 0x0003U;
    } break;
    case 1: {
      byteindex = vi / 8L;
      inbyte    = vi % 8L;
      uc = row[byteindex];
      switch((int)inbyte) {
        case 0: { uc = uc >> 7; } break;
	case 1: { uc = uc >> 6; } break;
	case 2: { uc = uc >> 5; } break;
	case 3: { uc = uc >> 4; } break;
	case 4: { uc = uc >> 3; } break;
	case 5: { uc = uc >> 2; } break;
	case 6: { uc = uc >> 1; } break;
      }
      back = (dk3_bif_pixel_t)uc;
      back &= 0x0001U;
    } break;
  }
  return back;
}



dk3_bif_pixel_t
dk3pixre_get_max_value(dk3_pixel_resample_t *pp)
{
  dk3_bif_pixel_t back = (dk3_bif_pixel_t)0U;
  if(pp) {
    back = pp->maxval;
  }
  return back;
}