bitmap.c

关于rcp2c_v3.rar协议在LINUX下的实现程序

  // configure the palmOS bitmap settings
  switch (bitmaptype)
  {
    case rwBitmap:
      cbitsPel = 1;
      dstPaletteSize = 2;
      for (i = 0; i < dstPaletteSize; i++)
      {
        dstPalette[i][0] = PalmPalette1bpp[i][0];
        dstPalette[i][1] = PalmPalette1bpp[i][1];
        dstPalette[i][2] = PalmPalette1bpp[i][2];
      }
      break;

    case rwBitmapGrey:
      cbitsPel = 2;
      dstPaletteSize = 4;
      for (i = 0; i < dstPaletteSize; i++)
      {
        dstPalette[i][0] = PalmPalette2bpp[i][0];
        dstPalette[i][1] = PalmPalette2bpp[i][1];
        dstPalette[i][2] = PalmPalette2bpp[i][2];
      }
      break;

    case rwBitmapGrey16:
      cbitsPel = 4;
      dstPaletteSize = 16;
      for (i = 0; i < dstPaletteSize; i++)
      {
        dstPalette[i][0] = PalmPalette4bpp[i][0];
        dstPalette[i][1] = PalmPalette4bpp[i][1];
        dstPalette[i][2] = PalmPalette4bpp[i][2];
      }
      break;

    case rwBitmapColor16:
      cbitsPel = 4;
      dstPaletteSize = 16;
      for (i = 0; i < dstPaletteSize; i++)
      {
        dstPalette[i][0] = PalmPalette4bppColor[i][0];
        dstPalette[i][1] = PalmPalette4bppColor[i][1];
        dstPalette[i][2] = PalmPalette4bppColor[i][2];
      }
      break;

    case rwBitmapColor256:
      cbitsPel = 8;
      dstPaletteSize = 256;
      for (i = 0; i < dstPaletteSize; i++)
      {
        dstPalette[i][0] = PalmPalette8bpp[i][0];
        dstPalette[i][1] = PalmPalette8bpp[i][1];
        dstPalette[i][2] = PalmPalette8bpp[i][2];
      }
      if (colortable)
        colorDat = COLOR_TABLE_SIZE;
      break;

    case rwBitmapColor16k:
      cbitsPel = 16;
      colortable = fFalse;
      colorDat = 8;                              // direct color structure
      break;

    case rwBitmapColor24k:
      cbitsPel = 24;
      colortable = fFalse;
      colorDat = 8;                              // direct color structure
      break;

    case rwBitmapColor32k:
      cbitsPel = 32;
      colortable = fFalse;
      colorDat = 8;                              // direct color structure
      break;

    default:
      Assert(fFalse);
      break;
  }

  // allocate memory for image data (word aligned)
  cbRow = ((dx * cbitsPel + 15) & ~15) >> 3;
  rcbmp->cbDst = (cbRow * dy) + colorDat;
  rcbmp->pbBits = (unsigned char *)malloc(rcbmp->cbDst);
  memset(rcbmp->pbBits, 0, rcbmp->cbDst);

  // configure the bitmap header
  switch (bitmaptype)
  {
    case rwBitmap:
    case rwBitmapGrey:
    case rwBitmapGrey16:
    case rwBitmapColor16:
      rcbmp->pixelsize = cbitsPel;
      rcbmp->version = 1;
      break;

    case rwBitmapColor256:
      rcbmp->pixelsize = cbitsPel;
      rcbmp->version = 2;

      // do we need to store a color table?
      if (colortable)
      {

        PILRC_BYTE *tmpPtr;
        int i;

        // rcbmp->ff |= 0x4000; 
        rcbmp->flags.hasColorTable = fTrue;

        tmpPtr = rcbmp->pbBits;
        *tmpPtr++ = 0x01;
        *tmpPtr++ = 0x00;

        // extract the color table (the number we have)
        for (i = 0; i < numClrs; i++)
        {
          *tmpPtr++ = i;
          *tmpPtr++ = pbmi->bmiColors[i].rgbRed;
          *tmpPtr++ = pbmi->bmiColors[i].rgbGreen;
          *tmpPtr++ = pbmi->bmiColors[i].rgbBlue;
        }

        // fill in remaining colors with black
        for (; i < 256; i++)
        {
          *tmpPtr++ = i;
          *tmpPtr++ = 0;
          *tmpPtr++ = 0;
          *tmpPtr++ = 0;
        }
      }
      // do we need to consider transparency?
      switch (transparencyData[0])
      {
        case rwTransparency:
          // rcbmp->ff |= 0x2000;
          rcbmp->flags.hasTransparency = fTrue;

          rcbmp->transparentIndex =
            BMP_RGBToColorIndex(transparencyData[1],
                                transparencyData[2],
                                transparencyData[3],
                                dstPalette, dstPaletteSize);
          break;

        case rwTransparencyIndex:
          // rcbmp->ff |= 0x2000;
          rcbmp->flags.hasTransparency = fTrue;

          rcbmp->transparentIndex = transparencyData[1];
          break;

        default:
          break;
      }
      break;

    case rwBitmapColor16k:
      rcbmp->pixelsize = cbitsPel;
      rcbmp->version = 2;

      // rcbmp->ff |= 0x0400; 
      rcbmp->flags.directColor = fTrue;
      {
        PILRC_BYTE *tmpPtr;

        tmpPtr = rcbmp->pbBits;
        *tmpPtr++ = 5;                           // 5 red bits
        *tmpPtr++ = 6;                           // 6 green bits
        *tmpPtr++ = 5;                           // 5 blue bits
        tmpPtr++;                                // skip over reserved

        // do we need to consider transparency?
        switch (transparencyData[0])
        {
          case rwTransparency:
            // rcbmp->ff |= 0x2000;
            rcbmp->flags.hasTransparency = fTrue;

            tmpPtr++;
            *tmpPtr++ = transparencyData[1];
            *tmpPtr++ = transparencyData[2];
            *tmpPtr++ = transparencyData[3];     // set the
            // transparent
            // color

            break;

          default:
            break;
        }
      }
      break;

    case rwBitmapColor24k:
    case rwBitmapColor32k:

      rcbmp->pixelsize = cbitsPel;
      rcbmp->version = 2;
      // rcbmp->ff |= 0x0400; 

      rcbmp->flags.directColor = fTrue;
      {
        PILRC_BYTE *tmpPtr;

        tmpPtr = rcbmp->pbBits;
        *tmpPtr++ = 8;                           // 8 red bits
        *tmpPtr++ = 8;                           // 8 green bits
        *tmpPtr++ = 8;                           // 8 blue bits
        tmpPtr++;                                // skip over reserved

        // do we need to consider transparency?
        switch (transparencyData[0])
        {
          case rwTransparency:
            // rcbmp->ff |= 0x2000;
            rcbmp->flags.hasTransparency = fTrue;

            tmpPtr++;
            *tmpPtr++ = transparencyData[1];
            *tmpPtr++ = transparencyData[2];
            *tmpPtr++ = transparencyData[3];     // set the
            // transparent
            // color

            break;

          default:
            break;
        }
      }
      break;

    default:
      break;
  }

  // convert from .bmp to binary format
  for (y = 0; y < dy; y++)
  {
    for (x = 0; x < dx; x++)
    {

      int yT = (dy > 0) ? dy - y - 1 : y;
      int w, a, r, g, b;

      // whats the (r,g,b) tupile at the index?
      w = getBits(pbmi, dx, pbSrc, x, yT, 32, &a, &r, &g, &b);

      // what type of bitmap are we dealing with?
      switch (bitmaptype)
      {
        case rwBitmap:
          {
            int v = BMP_RGBToColorIndex(r, g, b,
                                        dstPalette,
                                        dstPaletteSize);

            // if needed, set the bit
            if (v == 1)
              BMP_SetBits1bpp(dx, rcbmp->pbBits, x, y, 16);
          }
          break;

        case rwBitmapGrey:
          {
            int v = BMP_RGBToColorIndex(r, g, b,
                                        dstPalette,
                                        dstPaletteSize);

            BMP_SetBits2bpp(dx, rcbmp->pbBits, x, y, v, 16);
          }
          break;

        case rwBitmapGrey16:
        case rwBitmapColor16:
          {
            int v = BMP_RGBToColorIndex(r, g, b,
                                        dstPalette,
                                        dstPaletteSize);

            BMP_SetBits4bpp(dx, rcbmp->pbBits, x, y, v, 16);
          }
          break;

        case rwBitmapColor256:
          {
            int v = BMP_RGBToColorIndex(r, g, b,
                                        dstPalette,
                                        dstPaletteSize);

            // if we need a color table, use original bitmap data
            if (colortable)
              BMP_SetBits8bpp(dx, (rcbmp->pbBits + colorDat), x, y, w, 16);

            // no color table? use mapping
            else
              BMP_SetBits8bpp(dx, (rcbmp->pbBits + colorDat), x, y, v, 16);
          }
          break;

        case rwBitmapColor16k:
          {
            int pixel = ((((int)r & 0xF8) << 8) |       // 1111100000000000 
                         // 
                         (((int)g & 0xFC) << 3) |       // 0000011111100000
                         (((int)b & 0xF8) >> 3));       // 0000000000011111

            BMP_SetBits16bpp(dx, (rcbmp->pbBits + colorDat), x, y, pixel, 16);
          }
          break;

        case rwBitmapColor24k:
          {
            int pixel = ((r << 16) | (g << 8) | b);

            BMP_SetBits24bpp(dx, (rcbmp->pbBits + colorDat), x, y, pixel, 16);
          }
          break;

        case rwBitmapColor32k:
          {
            int pixel = ((a << 24) | (r << 16) | (g << 8) | b);

            BMP_SetBits32bpp(dx, (rcbmp->pbBits + colorDat), x, y, pixel, 16);
          }
          break;

        default:
          break;
      }
    }
  }

  // store width/height information in bitmap
  rcbmp->cx = (int)dx;
  rcbmp->cy = (int)dy;
  rcbmp->cbRow = (int)cbRow;
}

/*
 * Skip a newline 
 */
static int
BMP_SkipNewLine(PILRC_BYTE * data,
                int size,
                int i)
{
  while (i < size && (data[i] != '\n' && data[i] != '\r'))
  {
    ++i;
  }
  if (i + 1 < size && data[i] == '\r' && data[i + 1] == '\n')
  {
    i += 2;
  }
  else if (i < size)
  {
    ++i;
  }
  return i;
}

/**
 * Convert a .pbitm file to Palm Computing resource data.
 *
 * @param rcbmp      a reference to the Palm Computing resource data.
 * @param data       a reference to the bitmap resource. 
 * @param size       the size the bitmap resource.
 */
static void
BMP_ConvertTextBitmap(RCBITMAP * rcbmp,
                      PILRC_BYTE * data,
                      int size)
{
  int i, x, y;

  // determine the width and height of the image
  rcbmp->cx = 0;
  rcbmp->cy = 0;
  for (i = 0; i < size; i = BMP_SkipNewLine(data, size, i))
  {
    int j = i;

    while ((j < size) && (data[j] != '\n') && (data[j] != '\r'))
      j++;
    if (rcbmp->cx < (j - i))
      rcbmp->cx = j - i;
    ++rcbmp->cy;
  }

  // allocate image buffer
  rcbmp->cbRow = ((rcbmp->cx + 15) & ~15) / 8;
  rcbmp->cbDst = rcbmp->cbRow * rcbmp->cy;
  rcbmp->pbBits = malloc(rcbmp->cbDst);
  memset(rcbmp->pbBits, 0, rcbmp->cbDst);

  // convert the image
  x = 0;
  y = 0;
  for (i = 0; i < size;)
  {
    if ((data[i] == '\n') || (data[i] == '\r'))
    {
      x = 0;
      y++;
      i = BMP_SkipNewLine(data, size, i);
    }
    else
    {
      if ((data[i] != ' ') && (data[i] != '-'))
        rcbmp->pbBits[(y * rcbmp->cbRow) + (x >> 3)] |= (1 << (7 - (x & 7)));

      x++;
      i++;
    }
  }
}

/**
 * Convert a .xbm file to Palm Computing resource data.
 *
 * @param rcbmp      a reference to the Palm Computing resource data.
 * @param data       a reference to the bitmap resource. 
 * @param size       the size the bitmap resource.
 */
static void
BMP_ConvertX11Bitmap(RCBITMAP * rcbmp,
                     PILRC_BYTE * data,
                     int size)
{
  static PILRC_BYTE rev[] =
    { 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 };

  char name_and_type[80], *type;
  int i, value, pos;

  // read X11 bitmap header
  for (i = 0; i < size; i = BMP_SkipNewLine(data, size, i))
  {

    int result[2];