fad.bits.c

libFAD is a Flash Animation Decode library

/**
 * libFAD - Flash Animation Decode library
 * Copyright (C) 2005-2006 VGSystem Technologies, Inc.
 *
 * libFAD is the legal property of its developers, whose names are too numerous
 * to list here.  Please refer to the COPYRIGHT file distributed with this
 * source distribution.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: fad.bits.c,v 1.16 2006/02/26 11:38:39 wrxzzj Exp $
 */
#include "fad.bits.h"

#define BITS_SYNC(bits) \
  if(bits->npad > 0) { \
    bits->npad = 0; \
    bits->bufptr++; \
  }

void bits_init(bits_t* bits) {
  bits->bufptr = NULL;
  bits->npad = 0;
}

void bits_finish(bits_t* bits) {
  /**do nothing*/
}

void bits_sync(bits_t* bits) {
  BITS_SYNC(bits);
}

u8_t* bits_tell(bits_t* bits) {
  BITS_SYNC(bits);
  return bits->bufptr;
}

void bits_buffer(bits_t* bits, u8_t* buffer) {
  bits->bufptr = buffer;
  bits->npad = 0;
}

u8_t bits_get_u8(bits_t* bits) {
  BITS_SYNC(bits);
  return *bits->bufptr++;
}

s8_t bits_get_s8(bits_t* bits) {
  BITS_SYNC(bits);
  return *bits->bufptr++;
}

u16_t bits_get_u16(bits_t* bits) {
  u16_t val;

  BITS_SYNC(bits);
#ifdef BYTE_BIGIAN
  val = *bits->bufptr|*(bits->bufptr+1)<<8;
#else
  val = *(u16_t* )bits->bufptr;
#endif
  bits->bufptr += 2;

  return val;
}

void bits_dump(bits_t* bits, u16_t num_line, FILE* fp) {
  u16_t i = 0;
  u8_t* ptr = bits->bufptr;
  fprintf(fp, "bits->nbits = %d\n", bits->npad);

  while(i++ < num_line) {
    fprintf(fp, "%x %x %x %x %x %x %x %x\n", *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4), *(ptr+5), *(ptr+6), *(ptr+7));
    ptr += 8;
  }
}

s16_t bits_get_s16(bits_t* bits) {
  s16_t val;

  BITS_SYNC(bits);
#ifdef BYTE_BIGIAN
  val = *bits->bufptr|*(bits->bufptr+1)<<8;
#else
  val = *(s16_t* )bits->bufptr;
#endif
  bits->bufptr += 2;

  return val;
}

u32_t bits_get_u32(bits_t* bits) {
  u32_t val;

  BITS_SYNC(bits);
#ifdef BYTE_BIGIAN
  val = *bits->bufptr|*(bits->bufptr+1)<<8|*(bits->bufptr+2)<<16|*(bits->bufptr+3)<<24;
#else
  val = *(u32_t* )bits->bufptr;
#endif
  bits->bufptr += 4;

  return val;
}

s32_t bits_get_s32(bits_t* bits) {
  s32_t val;

  BITS_SYNC(bits);
#ifdef BYTE_BIGIAN
  val = *bits->bufptr|*(bits->bufptr+1)<<8|*(bits->bufptr+2)<<16|*(bits->bufptr+3)<<24;
#else
  val = *(s32_t* )bits->bufptr;
#endif
  bits->bufptr += 4;

  return val;
}

sbit_t bits_get_sbits(bits_t* bits, u32_t nbits) {
  sbit_t val = 0;
  u8_t i, j;

  if(nbits == 0 || bits == NULL)
    return 0;

  i = bits->npad; j = 24;
  bits->npad += nbits;
  while(bits->npad > 7) {
    val = val|*(bits->bufptr++)<<(i+j);
    j -= 8;
    bits->npad -= 8;
  }
  if(bits->npad > 0)
    val = val|*(bits->bufptr)<<(i+j);

  val = val>>(32-nbits);

  return val;
}

ubit_t bits_get_ubits(bits_t* bits, u32_t nbits) {
  ubit_t val = 0;
  u8_t i, j;

  if(nbits == 0 || bits == NULL)
    return 0;

  i = bits->npad; j = 24;
  bits->npad += nbits;
  while(bits->npad > 7) {
    val = val|*(bits->bufptr++)<<(i+j);
    j -= 8;
    bits->npad -= 8;
  }
  if(bits->npad > 0)
    val = val|*(bits->bufptr)<<(i+j);

  val = val>>1;
  if(val&0x80000000)
    val = val&0x7fffffff;

  val = val>>(31-nbits);

  return val;
}

fbit_t bits_get_fbits(bits_t* bits, u32_t nbits) {
  return bits_get_sbits(bits, nbits);
}

s8_t bits_seek_nbits(bits_t* bits, u32_t nbits) {
  u8_t b;

  bits->npad += nbits;

  while(bits->npad > 7) {
    bits->bufptr++;
    bits->npad -= 8;
  }

  return 0;
}

s8_t bits_seek_nbytes(bits_t* bits, u32_t nbytes) {
  BITS_SYNC(bits);
  bits->bufptr += nbytes;

  return 0;
}

void bits_get_rect(bits_t* bits, rect_t* rt) {
  u8_t nbits;

  BITS_SYNC(bits);
  nbits = (*bits->bufptr>>3)&0x1f;
  bits->npad = 5;
  if(rt) {
    rt->x0 = bits_get_sbits(bits, nbits);
    rt->x1 = bits_get_sbits(bits, nbits);
    rt->y0 = bits_get_sbits(bits, nbits);
    rt->y1 = bits_get_sbits(bits, nbits);
  } else
    bits_seek_nbits(bits, nbits<<2);
}

void bits_get_matrix(bits_t* bits, cairo_matrix_t* mx) {
  u8_t nbits;

  BITS_SYNC(bits);
  if(mx) {
    mx->xx = mx->yy = 1.00;
    mx->yx = mx->xy = 0.00;
    mx->x0 = mx->y0 = 0.00;
  }

  if(bits_get_ubits(bits, 1)) {
    nbits = bits_get_ubits(bits, 5);
    if(mx) {
      mx->xx = (double)bits_get_sbits(bits, nbits)/0xffff;
      mx->yy = (double)bits_get_sbits(bits, nbits)/0xffff;
    } else
      bits_seek_nbits(bits, nbits<<1);
  }

  if(bits_get_ubits(bits, 1)) {
    nbits = bits_get_ubits(bits, 5);
    if(mx) {
      mx->yx = (double)bits_get_sbits(bits, nbits)/0xffff;
      mx->xy = (double)bits_get_sbits(bits, nbits)/0xffff;
    } else 
      bits_seek_nbits(bits, nbits<<1);
  }

  nbits = bits_get_ubits(bits, 5);
  if(mx) {
    mx->x0 = (double)bits_get_sbits(bits, nbits)/20.000;
    mx->y0 = (double)bits_get_sbits(bits, nbits)/20.000;
  } else
    bits_seek_nbits(bits, nbits<<1);
}

/**used by shape record parse*/
void bits_get_xy(bits_t *bits, u8_t nbits, s32_t *x, s32_t *y) {
  if(bits_get_ubits(bits, 1)) {
    *x += bits_get_sbits(bits, nbits);
    *y += bits_get_sbits(bits, nbits);
  } else {
    if(bits_get_ubits(bits, 1))
      *y += bits_get_sbits(bits, nbits);
    else
      *x += bits_get_sbits(bits, nbits);
  }
}

void bits_get_rgbxform(bits_t* bits, rgbxform_t* cx) {
  u8_t nbits, b;

  BITS_SYNC(bits);
  b = (*bits->bufptr>>2)&0x3f;
  bits->npad = 6;

  if(cx) {
    cx->rm = cx->gm = cx->bm = 0xff;
    cx->ra = cx->ga = cx->ba = 0x00;
  }

  nbits = b&0x0f;
  if(b&0x10) {
    if(cx) {
      cx->rm = bits_get_sbits(bits, nbits);
      cx->gm = bits_get_sbits(bits, nbits);
      cx->bm = bits_get_sbits(bits, nbits);
    } else
      bits_seek_nbits(bits, nbits*3);
  }

  if(b&0x20) {
    if(cx) {
      cx->ra = bits_get_sbits(bits, nbits);
      cx->ga = bits_get_sbits(bits, nbits);
      cx->ba = bits_get_sbits(bits, nbits);
    } else
      bits_seek_nbits(bits, nbits*3);
  }
}

void bits_get_rgbaxform(bits_t* bits, rgbaxform_t* cx) {
  u8_t nbits, b;

  BITS_SYNC(bits);
  b = (*bits->bufptr>>2)&0x3f;
  bits->npad = 6;

  if(cx) {
    cx->base.rm = cx->base.gm = cx->base.bm = cx->am = 0xff;
    cx->base.ra = cx->base.ga = cx->base.ba = cx->aa = 0x00;
  }

  nbits = b&0x0f;
  if(b&0x10) {
    if(cx) {
      cx->base.rm = bits_get_sbits(bits, nbits);
      cx->base.gm = bits_get_sbits(bits, nbits);
      cx->base.bm = bits_get_sbits(bits, nbits);
      cx->am = bits_get_sbits(bits, nbits);
    } else
      bits_seek_nbits(bits, nbits<<2);
  }

  if(b&0x20) {
    if(cx) {
      cx->base.ra = bits_get_sbits(bits, nbits);
      cx->base.ga = bits_get_sbits(bits, nbits);
      cx->base.ba = bits_get_sbits(bits, nbits);
      cx->aa = bits_get_sbits(bits, nbits);
    } else
      bits_seek_nbits(bits, nbits<<2);
  }
}