fad.dl.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 General Library 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.dl.c,v 1.36 2006/03/08 10:21:30 wrxzzj Exp $
 */
#include "fad.dl.h"
#include "fad.bits.h"

static void _dl_put(dl_header_t* dlhdr, dl_node_t* node) {
  if(node && dlhdr) {
    dl_node_t *ptr = dlhdr->hdr, *prev = NULL;

    for(; ptr && node->depth > ptr->depth; ) {
      prev = ptr;
      ptr = ptr->next;
    }

    if(prev == NULL) {
      if(ptr)
        node->next = ptr;

      dlhdr->hdr = node;
    } else {
      prev->next = node;
      node->next = ptr;
    }

    dlhdr->count++;
		FAD_ERROR("add node = %x,%d (%x, %x)\n", node, node->depth, prev, ptr);
  }
}

static dl_node_t* _dl_get(dl_header_t* dlhdr, u16_t depth) {
  dl_node_t *ptr = NULL;

  if(dlhdr) {
    ptr = dlhdr->hdr;

    for(; ptr; ptr = ptr->next)
      if(ptr->depth == depth)
        break;
  }

  return ptr;
}

static dl_node_t* _dl_rmv(dl_header_t* dlhdr, u16_t depth) {
  dl_node_t *ptr = NULL, *prev = NULL;

  if(dlhdr) {
    ptr = dlhdr->hdr;

    while(ptr && ptr->depth < depth) {
      prev = ptr;
      ptr = ptr->next;
    }

    if(ptr && ptr->depth == depth) {
      if(prev)
        prev->next = ptr->next;
      else
        dlhdr->hdr = ptr->next;

      dlhdr->count--;

      if(ptr->fo->do_copy)
        free(ptr->fo);
			ptr->fo = NULL;
    } else
      ptr = NULL;
  }

  return ptr;
}

void dl_header_init(dl_header_t* dlhdr) {
  if(dlhdr != NULL) {
    dlhdr->count = 0;
    dlhdr->hdr = NULL;

    dlhdr->put = _dl_put;
    dlhdr->get = _dl_get;
    dlhdr->rmv = _dl_rmv;
  }
}

void dl_header_finish(dl_header_t* dlhdr) {
  dl_node_t *node = dlhdr->hdr, *ptr = NULL;

  if(dlhdr != NULL) {
    while(node != NULL) {
      ptr = node;
      node = node->next;
      if(ptr->fo->do_copy)
        free(ptr->fo);

      free(ptr);
    }
    dlhdr->count = 0;
    dlhdr->hdr = NULL;
  }
}

s32_t place_object_decode(fad_frame_t* frame, fad_stream_t* s) {
  dl_node_t* node= NULL;
  u16_t id, depth;
  u8_t *ptr, *ctx;
  rect_t temp;
  fad_object_t *new = NULL;

  ptr = bits_tell(&s->bits);
  id = bits_get_u16(&s->bits);
  depth = bits_get_u16(&s->bits);

  new = s->dict->get(s->dict, id);
  if(new == NULL)
    return -1;

  node = calloc(1, sizeof(dl_node_t));
	node->depth = depth;
  frame->dlhdr.put(&frame->dlhdr, node);

  node->flag = 0x04;

  if(new->do_copy)
    node->fo = new->do_copy(new);
  else
    node->fo = new;

  bits_get_matrix(&s->bits, &node->mx);
#ifdef LIBFAD_DIRTY_AREA
  if(node->fo->get_rect) {
    (* node->fo->get_rect)(node->fo, &node->rt);
    fad_rect_do_matrix(&node->rt, &node->mx);
  }
#endif

  if(ctx-ptr < s->tag_len) {
    node->flag |= 0x08;
    bits_get_rgbxform(&s->bits, (rgbxform_t* )&node->cx);
    node->cx.am = 0xff;
    node->cx.aa = 0x00;
  }
  node->ctx = NULL;

  //FAD_ERROR("PLACE OBJECT (%s) to display list, id=%d ==> depth=%d, flag = %x, node = %x\n", fad_object_type_to_string(node->fo->type), id, node->depth, node->flag, node);
  //FAD_ERROR("PLACE OBJECT matrix = (%f, %f, %f, %f, %f, %f)\n", node->mx.xx, node->mx.xy, node->mx.x0, node->mx.yy, node->mx.yx, node->mx.y0);

  node->attr = 0;
  FAD_DL_NODE_SET_BTNMX(node->attr);
  FAD_DL_NODE_SET_MATRIX(node->attr);
  FAD_DL_NODE_SET_VER(node->attr, 1);
  FAD_FRAME_SET_MODIFY(frame->attr);

  return 0;
}

s32_t place_object2_decode(fad_frame_t* frame, fad_stream_t* s) {
  u8_t place_flag, has_move = 0, has_character = 0;
  dl_node_t* node = NULL;
  u16_t depth, id = -1;
  fad_object_t *new = NULL;

  place_flag = bits_get_u8(&s->bits);
  depth = bits_get_u16(&s->bits);

  has_move = place_flag&0x01;
  has_character = place_flag&0x02;

  if(has_character) {
    fad_object_t* fo = NULL;

    id = bits_get_u16(&s->bits);
    new = s->dict->get(s->dict, id);
    if(new == NULL) {
      FAD_ERROR("cann't found any fad.object in dictionary.\n");
      return -1;
    }
    if(new->do_copy)
      fo = new->do_copy(new);
    else
      fo = new;

    /**place new character to displaylist*/
    node = (dl_node_t* )frame->dlhdr.get(&frame->dlhdr, depth);
    if(node == NULL) {
      node = (dl_node_t* )calloc(1, sizeof(dl_node_t));
      node->depth = depth;
      frame->dlhdr.put(&frame->dlhdr, node);

      node->mx.xx = node->mx.yy = 1.00;
      node->mx.xy = node->mx.yx = 0.00;
      node->mx.x0 = node->mx.y0 = 0.00;
    }

    //memset(node, 0, sizeof(dl_node_t));
    node->fo = fo;

    FAD_ERROR("PLACE OBJECT2 (%s) to display list, id=%d ==> depth=%d, flag = %x, node = %x, has_move = %d\n", fad_object_type_to_string(node->fo->type), id, depth, place_flag, node, has_move);
  } else {
    /**modify character's attribute at depth in displaylist*/ 
    node = (dl_node_t* )frame->dlhdr.get(&frame->dlhdr, depth);
    if(node == NULL)
      return -1;
    FAD_ERROR("MODIFY OBJECT2 (%s) attribute in display list, depth=%d, flag = %x, node = %x, node->flag = %x\n", fad_object_type_to_string(node->fo->type), depth, place_flag, node, node->flag);
  }


  node->flag |= place_flag;
  if(place_flag & 0x04) {
    bits_get_matrix(&s->bits, &node->mx);
    node->attr = 0;
    FAD_DL_NODE_SET_BTNMX(node->attr);
    FAD_DL_NODE_SET_MATRIX(node->attr);
  }
  FAD_ERROR("PLACE OBJECT2 matrix = (%f, %f, %f, %f, %f, %f), node->flag = %x\n", node->mx.xx, node->mx.xy, node->mx.x0, node->mx.yy, node->mx.yx, node->mx.y0, node->flag);

#ifdef LIBFAD_DIRTY_AREA
  if(node->fo->get_rect) {
    (* node->fo->get_rect)(node->fo, &node->rt);
    if(place_flag & 0x04)
      fad_rect_do_matrix(&node->rt, &node->mx);

    fad_rect_do_merge(&frame->dirty_rect, &node->rt);
  }
#endif

  if(place_flag & 0x08) {
    bits_get_rgbaxform(&s->bits, &node->cx);
    FAD_ERROR("(rm = %d, ra = %d, gm = %d, ga = %d, bm = %d, ba = %d, am = %d, aa = %d.\n", 
        node->cx.base.rm, node->cx.base.ra, node->cx.base.gm, node->cx.base.ga,
        node->cx.base.bm, node->cx.base.ba, node->cx.am, node->cx.aa);
  }

  if(place_flag & 0x10)
    node->ratio = bits_get_u16(&s->bits);

  if(place_flag & 0x40)
    node->ctx = bits_tell(&s->bits);

  FAD_DL_NODE_SET_VER(node->attr, 2);

  FAD_FRAME_SET_MODIFY(frame->attr);

  return 0;
}