fad.morph.c

嵌入式linux环境下的一个FLASH播放器（支持FLASH7.0以下版本）

  msn->type = FAD_SRT_LPT;

  return msn;
}

morph_sr_node_t* morph_sr_node_cpt_new(s32_t sx1, s32_t sy1, s32_t sx0, s32_t sy0, s32_t ex1, s32_t ey1, s32_t ex0, s32_t ey0) {
  morph_sr_node_t *msn = NULL;

  msn = calloc(1, sizeof(morph_sr_node_t));
  msn->sx0 = sx0; msn->sy0 = sy0; msn->sx1 = sx1; msn->sy1 = sy1;
  msn->ox0 = ex0-sx0; msn->oy0 = ey0-sy0; msn->ox1 = ex1-sx1; msn->oy1 = ey1-sy1;
  msn->type = FAD_SRT_CPT;

  return msn;
}

static morph_sr_node_list_t* morph_sr_node_list_new(morph_sr_node_t *msn) {
  morph_sr_node_list_t *mnl = NULL;

  mnl = calloc(1, sizeof(morph_sr_node_list_t));
  mnl->header = mnl->tail = msn;
  mnl->sta = FAD_NLSTA_INIT;
  mnl->next = mnl->prev = NULL;

  return mnl;
}



static void morph_sr_node_list_append(morph_sr_node_list_t *nl, morph_sr_node_t *node) {
  if(nl != NULL) {
    if(nl->header != NULL) {
      nl->tail->next = node;
      nl->tail = node;
    } else {
      nl->header = node;
      nl->tail = node;
    }
  }
}

static void morph_sr_node_list_prepend(morph_sr_node_list_t *nl, morph_sr_node_t *node) {
  if(nl != NULL) {
    if(nl->header != NULL) {
      node->next = nl->header;
      nl->header = node;
    } else {
      nl->header = node;
      nl->tail = node;
    }
  }
}

static void morph_sr_node_list_merge(morph_shape_record_t *msr, morph_sr_node_list_t *nl, u16_t idx) {
  morph_sr_node_list_t *ptr = msr->array[idx], *tail = NULL;
  s8_t match = FAD_FALSE;

  DEBUG_ENTER;
  if(nl->sta == FAD_NLSTA_INIT) {
    if(ptr == NULL) {
      nl->next = nl->prev = nl;
      ptr = msr->array[idx] = nl;
    } else {
      tail = ptr->prev;

      tail->next = nl;
      ptr->prev = nl;
      nl->prev = tail;
      nl->next = ptr;
    }
    nl->sta = FAD_NLSTA_OPEN;
  }

  for(ptr=nl->next; ptr!=nl; ptr=ptr->next) {
    if(ptr->sta == FAD_NLSTA_OPEN) {
      if(ptr->header->sx0==nl->tail->sx0 && ptr->header->sy0==nl->tail->sy0) {
        nl->tail->next = ptr->header->next;
        free(ptr->header);
        nl->tail = ptr->tail;

        ptr->prev->next = ptr->next;
        ptr->next->prev = ptr->prev;
        if(ptr == msr->array[idx]) {
          msr->array[idx] = ptr->next;
        }
        free(ptr);
        ptr = nl;
      } else if(ptr->tail->sx0==nl->header->sx0 && ptr->tail->sy0==nl->header->sy0) {
        ptr->tail->next = nl->header->next;
        free(nl->header);
        ptr->tail = nl->tail;

        nl->prev->next = nl->next;
        nl->next->prev = nl->prev;
        if(nl == msr->array[idx]) {
          msr->array[idx] = nl->next;
        }
        free(nl);
        nl = ptr;
      }
    }
  }

  if((nl->sta==FAD_NLSTA_OPEN) && (nl->header!=nl->tail)) {
    if(nl->header->sx0==nl->tail->sx0 && nl->header->sy0==nl->tail->sy0)
      nl->sta = FAD_NLSTA_CLOSE;
  }
  DEBUG_LEVEL;
}

static morph_sr_node_list_t *morph_sr_node_list_search_by_point(morph_sr_node_list_t *er, s32_t x, s32_t y, u8_t dir) {
  morph_sr_node_t *node = NULL;
  u8_t match = FAD_FALSE;
  morph_sr_node_list_t *ptr = er;

  if(ptr == NULL)
    return NULL;

  DEBUG_ENTER;
  FAD_ERROR("search edgesrecord hdr = %x\n", er);
  do {
    if(ptr->sta == FAD_NLSTA_OPEN) {
      if(dir == FAD_DIRT_FALSE) {
        if(ptr->header->sx0==x && ptr->header->sy0==y) {
          match = FAD_TRUE;
          break;
        }
      } else {
        if(ptr->tail->sx0==x && ptr->tail->sy0==y) {
          match = FAD_TRUE;
          break;
        }
      }
    }
    ptr = ptr->next;
  } while(ptr != er);

  DEBUG_LEVEL;

  return match==FAD_TRUE ? ptr : NULL;
}

static s32_t _morph_shape_parse(bits_t *sbits, morph_shape_record_t *msr, u32_t offset) {
  bits_t *ebits, mybits;
  u16_t fs0_idx, fs1_idx, ls_idx, fs0 = 0, fs1 = 0, ls = 0;
  u8_t sflag, snbits, eflag, enbits, fs_nbits, ls_nbits, type = FAD_SRT_XXX;
  s32_t sx=0, sy=0, ex=0, ey=0;
  morph_sr_node_list_t *fs0_nl = NULL, *fs1_nl = NULL, *ls_nl = NULL;

  ebits = &mybits;

  bits_init(ebits);
  /**offset+1: seek one byte in ebits, fs_nbits, ls_nbits unused in ebits*/
  bits_buffer(ebits, bits_tell(sbits)+offset+1);

  fs_nbits = bits_get_u8(sbits);
  ls_nbits = fs_nbits&0x0f;
  fs_nbits = fs_nbits>>4;

#define MSN_LPT_NEW morph_sr_node_lpt_new(sx, sy, ex, ey)
#define MSN_CPT_NEW morph_sr_node_cpt_new(sctlx, sctly, sx, sy, ectlx, ectly, ex, ey)

  FAD_ERROR("fs_nbits = %d, ls_nbits = %d\n", fs_nbits, ls_nbits);
  while(sflag=bits_get_ubits(sbits, 6)) {
    if(sflag&0x20) {
      /**edge record*/
      morph_sr_node_t *msn = NULL;

      eflag = bits_get_ubits(ebits, 6);
      snbits = (sflag&0x0f)+2;
      enbits = (eflag&0x0f)+2;

      if((sflag&0x10)&&(eflag&0x10)) {
        /**straight edge record*/

        bits_get_xy(sbits, snbits, &sx, &sy);
        bits_get_xy(ebits, enbits, &ex, &ey);

        //FAD_ERROR("LPT_NEW: fs1 = %d, fs0 = %d, fs1_nl = %x, fs0_nl = %x, ls = %d, ls_nl = %d\n", fs1, fs0, fs1_nl, fs0_nl,ls, ls_nl);
        //FAD_ERROR("LINE_TO:sx = %f, sy = %f, ex = %f, ey = %f\n", sx/20.00, sy/20.00, ex/20.00, ey/20.00);
        if(fs1 != fs0) {
          if(fs0_nl) {
            morph_sr_node_list_append(fs0_nl, MSN_LPT_NEW);
          } else if(fs0 > 0) {
            fs0_nl = morph_sr_node_list_new(MSN_LPT_NEW);
          }
          if(fs1_nl) {
            morph_sr_node_list_prepend(fs1_nl, MSN_LPT_NEW);
          } else if(fs1 > 0) {
            fs1_nl = morph_sr_node_list_new(MSN_LPT_NEW);
          }
        }
        if(ls_nl) {
          morph_sr_node_list_append(ls_nl, MSN_LPT_NEW);
        } else if(ls>0 && ls<=msr->ls_num) {
          ls_nl = morph_sr_node_list_new(MSN_LPT_NEW);
        }
      } else {
        /**curved edge record*/
        s32_t sctlx = sx, sctly = sy, ectlx = ex, ectly = ey;

        FAD_ERROR("CPT_NEW: fs1 = %d, fs0 = %d, fs1_nl = %x, fs0_nl = %x, ls = %d, ls_nl = %d\n", fs1, fs0, fs1_nl, fs0_nl,ls, ls_nl);
        /**get start-shape curved shape record*/
        if(sflag&0x10) {
          bits_get_xy(sbits, snbits, &sx, &sy);
          sctlx = sx; sctly = sy;
        } else {
          sx += bits_get_sbits(sbits, snbits);
          sy += bits_get_sbits(sbits, snbits);
          sctlx = sx; sctly = sy;
          sx += bits_get_sbits(sbits, snbits);
          sy += bits_get_sbits(sbits, snbits);
        }

        /**get end-shape curved shape record*/
        if(eflag&0x10) {
          bits_get_xy(ebits, enbits, &ex, &ey);
          ectlx = ex; ectly = ey;
        } else {
          ex += bits_get_sbits(ebits, enbits);
          ey += bits_get_sbits(ebits, enbits);
          ectlx = ex; ectly = ey;
          ex += bits_get_sbits(ebits, enbits);
          ey += bits_get_sbits(ebits, enbits);
        }

        if(fs1 != fs0) {
          if(fs0_nl) {
            morph_sr_node_list_append(fs0_nl, MSN_CPT_NEW);
          } else if(fs0 > 0) {
            fs0_nl = morph_sr_node_list_new(MSN_CPT_NEW);
          }
          if(fs1_nl) {
            morph_sr_node_list_prepend(fs1_nl, MSN_CPT_NEW);
          } else if(fs1 > 0) {
            fs1_nl = morph_sr_node_list_new(MSN_CPT_NEW);
          }
        }
        if(ls_nl) {
          morph_sr_node_list_append(ls_nl, MSN_CPT_NEW);
        } else if(ls>0 && ls<=msr->ls_num) {
          ls_nl = morph_sr_node_list_new(MSN_CPT_NEW);
        }
      }/**curved edge record [END]*/
    } else { /**style change record*/
      u8_t fs_change = FAD_FALSE;

      if(fs0_nl && ((sflag&0x01)||(sflag&0x02))) {
        morph_sr_node_list_merge(msr, fs0_nl, fs0);
        fs0_nl = NULL;
      }
      if(fs1_nl && ((sflag&0x01)||(sflag&0x04))) {
        morph_sr_node_list_merge(msr, fs1_nl, fs1);
        fs1_nl = NULL;
      }
      if(ls_nl && ((sflag&0x01)||(sflag&0x08))) {
        morph_sr_node_list_merge(msr, ls_nl, msr->fs_num+ls);
        ls_nl = NULL;
      }

      if(sflag&0x01) {
        bits_get_ubits(ebits, 6);

        snbits = bits_get_ubits(sbits, 5);
        sx = bits_get_sbits(sbits, snbits);
        sy = bits_get_sbits(sbits, snbits);

        enbits = bits_get_ubits(ebits, 5);
        ex = bits_get_sbits(ebits, enbits);
        ey = bits_get_sbits(ebits, enbits);
        FAD_ERROR("MOVE_TO:sx = %f, sy = %f, ex = %f, ey = %f\n", sx/20.00, sy/20.00, ex/20.00, ey/20.00);
      }

      if(fs0 == fs1)
        fs_change = FAD_TRUE;

      if(sflag&0x02) {
        fs0 = bits_get_ubits(sbits, fs_nbits);
        if(fs0 <= 0) {
          fs0_nl = NULL;
        }
      }
      if(sflag&0x04) {
        fs1 = bits_get_ubits(sbits, fs_nbits);
        if(fs1 <= 0) {
          fs1_nl = NULL;
        }
      }
      if(sflag&0x08) {
        ls = bits_get_ubits(sbits, ls_nbits);
        if(ls <= 0) {
          ls_nl = NULL;
        }
      }

      /**merge move_to record*/
      if(fs0 != fs1) {
        if(fs0 > 0) {
          if(fs_change || (sflag&0x01) || ((sflag&0x02)&&(type!=FAD_SRT_XXX))) {
            fs0_nl = morph_sr_node_list_search_by_point(msr->array[fs0], sx, sy, FAD_DIRT_TRUE);
            if(fs0_nl == NULL)
              fs0_nl = morph_sr_node_list_new(MSN_LPT_NEW);
          }
        }
        if(fs1 > 0) {
          if(fs_change || (sflag&0x01) || ((sflag&0x04)&&(type!=FAD_SRT_XXX))) {
            fs1_nl = morph_sr_node_list_search_by_point(msr->array[fs1], sx, sy, FAD_DIRT_FALSE);
            if(fs1_nl==NULL)
              fs1_nl = morph_sr_node_list_new(MSN_LPT_NEW);
          }
        }
      } else {
        if(fs0_nl) {
          morph_sr_node_list_merge(msr, fs0_nl, fs0);
          fs0_nl = NULL;
        }
        if(fs1_nl) {
          morph_sr_node_list_merge(msr, fs1_nl, fs1);
          fs1_nl = NULL;
        }
      }

      if(ls>0 && ls<=msr->ls_num) {
        if((sflag&0x01) || ((sflag&0x08)&&(type!=FAD_SRT_XXX))){
          ls_nl = morph_sr_node_list_search_by_point(msr->array[msr->fs_num+ls], sx, sy, FAD_DIRT_TRUE);
          if(ls_nl==NULL)
            ls_nl = morph_sr_node_list_new(MSN_LPT_NEW);
        }
      }
    }
  }

  if(fs0_nl) {
    morph_sr_node_list_merge(msr, fs0_nl, fs0);
  }
  if(fs1_nl) {
    morph_sr_node_list_merge(msr, fs1_nl, fs1);
  }
  if(ls_nl) {
    morph_sr_node_list_merge(msr, ls_nl, msr->fs_num+ls);
  }
  bits_finish(ebits);

  return 0;
}

s32_t morph_shape_decode(fad_frame_t* frame, fad_stream_t* s) {
  morph_shape_t* ms = NULL;
  u16_t id;
  u32_t offset;
  u8_t  *ptr = NULL;

  ms = calloc(1, sizeof(morph_shape_t));
  if(ms == NULL) {
    s->err = FAD_ERROR_MEM;
    return -1;
  }

  ms->base.do_render = _morph_shape_do_render;
  ms->base.do_free = _morph_shape_do_free;
  ms->base.type = FO_TYPE_MORPHSHAPE;

  id = bits_get_u16(&s->bits);

  bits_get_rect(&s->bits, &ms->start_bound);
  bits_get_rect(&s->bits, &ms->end_bound);

  offset = bits_get_u32(&s->bits);
  ptr = bits_tell(&s->bits);

  _morph_fill_style_array_decode(&ms->mfsa, &s->bits);
  _morph_line_style_array_decode(&ms->mlsa, &s->bits);
  if(_morph_shape_record_init(&ms->msr, ms->mfsa.count, ms->mlsa.count) < 0)
    return -1;

  offset -= bits_tell(&s->bits)-ptr;
  if(_morph_shape_parse(&s->bits, &ms->msr, offset) < 0) {
    FAD_ERROR("***morph shape parse failure.***\n");
    return -1;
  }

  s->dict->put(s->dict, ms, id);
  FAD_ERROR("append morphing shape to dictionary, id = %d, offset = %d\n", id, offset);

  return 0;
}