skl_cmap.cpp

mpeg4编解码器

/********************************************************
 * Some code. Copyright (C) 2003 by Pascal Massimino.   *
 * All Rights Reserved.      (http://skal.planet-d.net) *
 * For Educational/Academic use ONLY. See 'LICENSE.TXT'.*
 ********************************************************/
/*
 * skl_cmap.cpp
 *
 *  color maps
 ********************************************************/

#include "skl.h"
#include "skl_syst/skl_bits.h"
#include "skl_2d/skl_cmap.h"

//////////////////////////////////////////////////////////
// SKL_CMAP_X
//////////////////////////////////////////////////////////

SKL_CMAP_X::SKL_CMAP_X(const SKL_CMAP &In)
 :  _Nb(In.Get_Nb_Colors())
{
  const SKL_UINT32 *In_Cols = In.Get_Colors();
  SKL_FORMAT_SHIFT shft( In.Get_Format() );
  for( int i=0; i<_Nb; ++i )
    _Map[i] = shft.Unpack(In_Cols[i]);
}

SKL_CMAP_X::SKL_CMAP_X(const SKL_CMAP_X &In)
 :  _Nb(In.Get_Nb_Colors())
{
  for(int i=0; i<_Nb; ++i) _Map[i] = In[i];
}

//////////////////////////////////////////////////////////

void SKL_CMAP_X::Ramp(SKL_COLOR c1, SKL_COLOR c2, 
                      int Start, int End)
{
  SKL_ASSERT(Start>=0); 
  SKL_ASSERT(Start<End);
  SKL_ASSERT(End<=256);
  if (_Nb<End) _Nb=End;
  int N = End-Start;
  if (N<=1) {
    _Map[Start] = c1.Mix(c2, 0.5f);  // !!
    return;
  }
  float Scale = 1.0f/(N-1);
  for( int i=0; i<N; ++i )
    _Map[Start+i] = c1.Mix(c2, Scale*i);
}

void SKL_CMAP_X::RGB_Cube( SKL_FORMAT Fmt )
{
  int r_max = (1<<Fmt.Bits(2))-1;
  int g_max = (1<<Fmt.Bits(1))-1;
  int b_max = (1<<Fmt.Bits(0))-1;

  SKL_ASSERT( (r_max+1)*(g_max+1)*(b_max+1)<=256 );

  int i = 0;
  for( int r=0; r<=r_max; ++r )
    for( int g=0; g<=g_max; ++g )
      for( int b=0; b<=b_max; ++b )
        _Map[i++] = SKL_COLOR( r*255/r_max, g*255/g_max, b*255/b_max );
}   

//////////////////////////////////////////////////////////
// SKL_CMAP
//////////////////////////////////////////////////////////

SKL_CMAP::SKL_CMAP(const SKL_CMAP_X &In, SKL_FORMAT fmt )
 : _Nb(In.Get_Nb_Colors())
 , _Format(fmt) 
{
  SKL_FORMAT_SHIFT shft( fmt );
  const SKL_COLOR *In_Cols = In.Get_Colors();
  for( int i=0; i<_Nb; ++i )
    _Map[i] = shft.Pack(In_Cols[i]);
}

SKL_CMAP::SKL_CMAP(const SKL_CMAP &In, SKL_FORMAT fmt)
{
  _Nb = In.Get_Nb_Colors();
  Set_Format( In.Get_Format() );
  if (fmt==0 || fmt==In.Get_Format() ) {
    SKL_MEMCPY( _Map, In.Get_Colors(), _Nb*sizeof(_Map[0]) );
  }
  else {
    SKL_FORMAT_SHIFT in( In.Get_Format() );
    SKL_FORMAT_SHIFT out( fmt );
    for(int i=0; i<_Nb; ++i) {
      SKL_COLOR C = in.Unpack( In[i] );
      _Map[i] = out.Pack(C);
    }
  }
}

SKL_CMAP::SKL_CMAP(const SKL_FORMAT fmt, int Nb)
  : _Nb(Nb), _Format(fmt)
{
  SKL_ASSERT(Nb>=0); SKL_ASSERT(Nb<=256);
  SKL_BZERO(_Map, _Nb*sizeof(_Map[0]) );
}     

//////////////////////////////////////////////////////////

void SKL_CMAP::Ramp(SKL_COLOR c1, SKL_COLOR c2,
                    int Start, int End)
{
  SKL_CMAP_X tmp; 
  tmp.Ramp(c1,c2,Start,End);
  *this = SKL_CMAP(tmp,_Format);
}

//////////////////////////////////////////////////////////
// Formatting shifts and masks
//////////////////////////////////////////////////////////

SKL_FORMAT::SKL_FORMAT(SKL_ARGB R_msk, SKL_ARGB G_msk, 
                       SKL_ARGB B_msk, SKL_ARGB A_msk,
                       int Depth)
{
   int Pos[4] = { 0 };
   int Size[4] = { 0 };
   int Msk[4] = { B_msk, G_msk, R_msk, A_msk };

   for( int i=0; i<4; ++i ) {
     SKL_UINT32 Tmp = Msk[i];
     if (Tmp) for( ; !(Tmp&1); Tmp>>=1 ) Pos[i]++;
     for( ;(Tmp&1); Tmp>>=1 ) Size[i]++;
   }

  _Bits = (Size[3]<<12) | (Size[2]<<8) | (Size[1]<<4) | (Size[0]<<0);

  if (G_msk>R_msk) _Bits |= BGR_ORDER;

  if (Depth<=0) Depth = Compute_Depth();
  _Bits |= Depth<<16;

//  printf( "Mask RGBA: 0x%.8x 0x%.8x 0x%.8x 0x%.8x  => 0x%.8x\n", Msk[0], Msk[1], Msk[2], Msk[3], _Bits );
}
          
int SKL_FORMAT::Compute_Depth() const {
    // we assume packed pixels
  int d = Bits(0) + Bits(1) + Bits(2) + Bits(3);
  return ( (d+7) & ~7 ) / 8;    // size in byte
}

int SKL_FORMAT::Depth() const {
  int d = Raw_Depth();
  if ( !d ) return Compute_Depth();
  else return d;
}

//////////////////////////////////////////////////////////
// SKL_FORMAT_SHIFT
//////////////////////////////////////////////////////////

void SKL_FORMAT_SHIFT::Store_Mask_And_Shift(const SKL_FORMAT f)
{
         // we assume packed pixels
  int i, t;
  for(i=0, t=0; i<4; ++i) {
    _Mask[i] = SKL_BMASKS::And[f.Bits(i)]<<t;
    t += f.Bits(i);
    _Shift[i] = 32-t;
  }
  if (f.Is_BGR()) {
    SKL_INT32 S = _Shift[0]; _Shift[0] = _Shift[2]; _Shift[2] = S;
    SKL_UINT32 M = _Mask[0]; _Mask[0] = _Mask[2]; _Mask[2] = M;
  }
//  Print_Infos();
}

//////////////////////////////////////////////////////////
// -- debug
//////////////////////////////////////////////////////////

void SKL_FORMAT::Print_Infos() const {
  printf("Format:0x%.5x  (depth:%d/%d)\n",
    _Bits, Compute_Depth(), Depth() );
}

void SKL_FORMAT_SHIFT::Print_Infos() const {
  printf("Shifts: R:%d   G:%d   B:%d (A:%d) \n",
    _Shift[2], _Shift[1], _Shift[0], _Shift[3]);
  printf("Masks:  R:0x%.8x   G:0x%.8x   B:0x%.8x   (A:0x%.8x)\n",
    _Mask[2], _Mask[1], _Mask[0], _Mask[3]);
}

void SKL_FORMAT_SHIFT::Print_Col(SKL_UINT32 c) const {
  SKL_COLOR C = UnpackA(c);
  printf("C=0x%.8x -> r=0x%x  g=0x%x  b=0x%x  (a=0x%x)\n",
    c, C.R(), C.G(), C.B(), C.A() );
}

//////////////////////////////////////////////////////////