fad.shape.c

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

        nl = ptr;
      }
    }
  }

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

static sr_node_list_t *sr_node_list_search_by_point(sr_node_list_t *er, s32_t x, s32_t y, u8_t dir) {
  sr_node_t *node = NULL;
  u8_t match = FAD_FALSE;
  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->x0==x && ptr->header->y0==y) {
          match = FAD_TRUE;
          break;
        }
      } else {
        if(ptr->tail->x0==x && ptr->tail->y0==y) {
          match = FAD_TRUE;
          break;
        }
      }
    }
    ptr = ptr->next;
  } while(ptr != er);

  DEBUG_LEVEL;

  return match==FAD_TRUE ? ptr : NULL;
}

static sr_edgesrecord_t * sr_edgesrecord_new(u16_t fs_num, u16_t ls_num, sr_newstyle_t *ns) {
  sr_edgesrecord_t *er = NULL;

  er = calloc(1, sizeof(sr_edgesrecord_t)+sizeof(sr_node_list_t*)*(fs_num+1+ls_num+1));
  er->fs_num = fs_num;
  er->ls_num = ls_num;
  er->ns = ns;

  return er;
}

static void sr_edgesrecord_set_ns(sr_edgesrecord_t *er, sr_newstyle_t *ns) {
  if(er != NULL)
    er->ns = ns;
  //FAD_ERROR("er = %x, ns = %x, er->ns = %x\n", er, ns, er->ns);
}

static void sr_edgesrecord_destroy(sr_edgesrecord_t *er) {
  u16_t idx;

  for(idx = 0; idx<er->fs_num+er->ls_num; idx++) {
    if(er->array[idx]) {
      sr_node_list_destroy(er->array[idx]);
      free(er->array[idx]);
      er->array[idx] = NULL;
    }
  }
}

static void edgesrecord_add_node_list(sr_edgesrecord_t *er, u16_t idx, sr_node_list_t *nl) {
  sr_node_list_t *ptr = NULL, *tail= NULL;

  ptr = er->array[idx];

  /**edges record node list is a circle list*/
  if(ptr != NULL) {
    tail = ptr->prev;

    tail->next = nl;
    ptr->prev = nl;
    nl->prev = tail;
    nl->next = ptr;
  } else {
    nl->next = nl;
    nl->prev = nl;
    er->array[idx] = nl;
  }
}

s32_t shape_record_parse(bits_t* bits, shape_record_t* sr) {
  sr_newstyle_t *ns = NULL;
  u8_t flag, nbits, fs_nbits, ls_nbits, type = FAD_SRT_XXX;
  u16_t fs0_idx, fs1_idx, ls_idx, fs0 = 0, fs1 = 0, ls = 0;
  s32_t x = 0, y = 0;
  sr_edgesrecord_t *er = NULL;
  u16_t fs_num = 1, ls_num = 0;
  sr_node_list_t *fs0_nl = NULL, *fs1_nl = NULL, *ls_nl = NULL;
  static s32_t node_count = 0;

  if(sr->srv == FAD_SRV_SHAPE1 || sr->srv == FAD_SRV_SHAPE2 || sr->srv == FAD_SRV_SHAPE3) {
    ns = calloc(1, sizeof(sr_newstyle_t));
    if(ns == NULL)
      return SHAPE_RECORD_PARSE_FALSE;

    fs_num = _fill_style_array_decode(&ns->fs_array, bits, sr->srv);
    ls_num = _line_style_array_decode(&ns->ls_array, bits, sr->srv);
  }

  er = sr_edgesrecord_new(fs_num, ls_num, ns);
  if(sr->header == NULL) {
    sr->header = sr->tail = er;
  }

  fs_nbits = bits_get_u8(bits);
  ls_nbits = fs_nbits&0x0f;
  fs_nbits = fs_nbits>>4;
  //FAD_ERROR("fs_nbits = %d, ls_nbits = %d\n", fs_nbits, ls_nbits);

  while(flag = bits_get_ubits(bits, 6)) {
    if(flag&0x20) {
      nbits = (flag&0x0f)+2;
      if(flag&0x10) {
        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);
        }
        type = FAD_SRT_LPT;

        if(fs1 != fs0) {
          if(fs0_nl) {
            sr_node_list_append(fs0_nl, sr_node_new(x, y, 0, 0, type));
          } else if(fs0 > 0) {
            fs0_nl = sr_node_list_new(sr_node_new(x, y, 0, 0, type));
          }
          if(fs1_nl) {
            sr_node_list_prepend(fs1_nl, sr_node_new(x, y, 0, 0, type));
          } else if(fs1 > 0) {
            fs1_nl = sr_node_list_new(sr_node_new(x, y, 0, 0, type));
          }
        }

        if(ls_nl) {
          sr_node_list_append(ls_nl, sr_node_new(x, y, 0, 0, type));
        } else if(ls>0 && ls<=ls_num) {
          ls_nl = sr_node_list_new(sr_node_new(x, y, 0, 0, type));
        }

        FAD_ERROR("append line to(%f, %f) to shape record, fs0_nl=%x, fs1_nl = %x, ls_nl = %x, node.count = %d.\n", x/20.00, y/20.00, fs0_nl, fs1_nl, ls_nl, node_count++);
      } else {
        s32_t ctlx, ctly;

        x += bits_get_sbits(bits, nbits);
        y += bits_get_sbits(bits, nbits);
        ctlx = x;
        ctly = y;
        x += bits_get_sbits(bits, nbits);
        y += bits_get_sbits(bits, nbits);
        type = FAD_SRT_CPT;

        if(fs1 != fs0) {
          if(fs0_nl) {
            sr_node_list_append(fs0_nl, sr_node_new(x, y, ctlx, ctly, type));
          } else if(fs0 > 0) {
            fs0_nl = sr_node_list_new(sr_node_new(x, y, ctlx, ctly, type));
          }
          if(fs1_nl) {
            sr_node_list_prepend(fs1_nl, sr_node_new(x, y, ctlx, ctly, type));
            sr_node_list_rebuild(fs1_nl);
          } else if(fs1 > 0) {
            fs1_nl = sr_node_list_new(sr_node_new(x, y, ctlx, ctly, type));
          }
        }
        if(ls_nl) {
          sr_node_list_append(ls_nl, sr_node_new(x, y, ctlx, ctly, type));
        } else if(ls>0 && ls<=ls_num) {
          ls_nl = sr_node_list_new(sr_node_new(x, y, ctlx, ctly, type));
        }

        FAD_ERROR("append curve to(%f, %f, %f, %f) to shape record, fs0_nl = %x, fs1_nl = %x, ls_nl = %x, node.count=%d.\n", ctlx/20.00, ctly/20.00, x/20.00, y/20.00, fs0_nl, fs1_nl, ls_nl, node_count++);
      }
    } else {
      u8_t fs_change = FAD_FALSE;

      if(fs0_nl && ((flag&0x01)||(flag&0x02))) {
        sr_node_list_merge(er, fs0_nl, fs0);
        fs0_nl = NULL;
      }
      if(fs1_nl && ((flag&0x01)||(flag&0x04))) {
        sr_node_list_merge(er, fs1_nl, fs1);
        fs1_nl = NULL;
      }
      if(ls_nl && ((flag&0x01)||(flag&0x08))) {
        sr_node_list_merge(er, ls_nl, fs_num+ls);
        ls_nl = NULL;
      }

      if(flag&0x01) {
        nbits = bits_get_ubits(bits, 5);
        x = bits_get_sbits(bits, nbits);
        y = bits_get_sbits(bits, nbits);
        type = FAD_SRT_LPT;
      }

      /**just hack the flag value, when fs0 == fs1*/
      if(fs0 == fs1)
        fs_change = FAD_TRUE;

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

      if(fs0 != fs1) {
        if(fs0 > 0) {
          if(fs_change || (flag&0x01) || ((flag&0x02)&&(type!=FAD_SRT_XXX))) {
            fs0_nl = sr_node_list_search_by_point(er->array[fs0], x, y, FAD_DIRT_TRUE);
            if(fs0_nl == NULL)
              fs0_nl = sr_node_list_new(sr_node_new(x, y, 0, 0, FAD_SRT_LPT));
          }
        }
        if(fs1 > 0) {
          if(fs_change || (flag&0x01) || ((flag&0x04)&&(type!=FAD_SRT_XXX))) {
            fs1_nl = sr_node_list_search_by_point(er->array[fs1], x, y, FAD_DIRT_FALSE);
            if(fs1_nl==NULL)
              fs1_nl = sr_node_list_new(sr_node_new(x, y, 0, 0, FAD_SRT_LPT));
          }
        }
      } else {
        if(fs0_nl) {
          sr_node_list_merge(er, fs0_nl, fs0);
          fs0_nl = NULL;
        }
        if(fs1_nl) {
          sr_node_list_merge(er, fs1_nl, fs1);
          fs1_nl = NULL;
        }
      }

      if(ls>0 && ls<=ls_num) {
        if((flag&0x01) || ((flag&0x08)&&(type!=FAD_SRT_XXX))){
          ls_nl = sr_node_list_search_by_point(er->array[fs_num+ls], x, y, FAD_DIRT_TRUE);
          if(ls_nl==NULL)
            ls_nl = sr_node_list_new(sr_node_new(x, y, 0, 0, FAD_SRT_LPT));
        }
      }

      if(flag&0x01)
        FAD_ERROR("append move to(%f, %f) to shape record, fs0_nl = %x, fs1_nl = %x, ls_nl = %x, node_count = %d.\n", x/20.00, y/20.00, fs0_nl, fs1_nl, ls_nl, node_count++);

      if(flag&0x10) {
        ns = calloc(1, sizeof(sr_newstyle_t));
        fs_num = _fill_style_array_decode(&ns->fs_array, bits, sr->srv);
        ls_num = _line_style_array_decode(&ns->ls_array, bits, sr->srv);
        fs0 = fs1 = ls = 0;
        fs0_nl = fs1_nl = ls_nl = NULL;
        type = FAD_SRT_XXX;

        er = sr_edgesrecord_new(fs_num, ls_num, ns);

        if(sr->tail == NULL)
          sr->header = er;
        else
          sr->tail->next = er;
        sr->tail = er;

        fs_nbits = bits_get_u8(bits);
        ls_nbits = fs_nbits&0x0f;
        fs_nbits = fs_nbits>>4;
        FAD_ERROR("append new style to shape record, er = %x, ns = %x, fs_num = %d, ls_num = %d\n", er, ns, fs_num, ls_num);
      }
    }
  }

  if(fs0_nl) {
    sr_node_list_merge(er, fs0_nl, fs0);
  }
  if(fs1_nl) {
    sr_node_list_merge(er, fs1_nl, fs1);
  }
  if(ls_nl) {
    sr_node_list_merge(er, ls_nl, fs_num+ls);
  }

  return SHAPE_RECORD_PARSE_TRUE;
}

static void shape_record_render_node_list(sr_node_list_t *nl, fad_render_t *render, dl_node_t *node) {
  sr_node_list_t *ptr = nl;
  sr_node_t *hdr = NULL;
  s32_t x, y;

  FAD_ERROR("render node list = %x\n", ptr);
  hdr = ptr->header;
#ifdef LIBFAD_DO_RENDER
  cairo_move_to(render->cr, hdr->x0/20.00, hdr->y0/20.00);
#endif
  x = hdr->x0; y = hdr->y0;
  FAD_ERROR("move to (%f, %f)\n", hdr->x0/20.00, hdr->y0/20.00);
  hdr = hdr->next;
  
  while (hdr != NULL) {
    if(hdr->type == FAD_SRT_LPT) {
#ifdef LIBFAD_DO_RENDER
      cairo_line_to(render->cr, hdr->x0/20.00, hdr->y0/20.00);
#endif
      x = hdr->x0; y = hdr->y0;
      FAD_ERROR("line to (%f, %f)\n", hdr->x0/20.00, hdr->y0/20.00);
    } else {
      double x0, y0, x1, y1;
#ifdef LIBFAD_DO_RENDER
      x0 = x/20.00+(hdr->x1-x)/30.00; y0 = y/20.00+(hdr->y1-y)/30.00;
      x1 = hdr->x1/20.00+(hdr->x0-hdr->x1)/60.00; y1 = hdr->y1/20.00+(hdr->y0-hdr->y1)/60.00;
      cairo_curve_to(render->cr, x0, y0, x1, y1, hdr->x0/20.00, hdr->y0/20.00);
#endif
      x = hdr->x0; y = hdr->y0;
      FAD_ERROR("curve to (%f, %f, %f, %f)\n", hdr->x1/20.00, hdr->y1/20.00, hdr->x0/20.00, hdr->y0/20.00);
    }

    hdr = hdr->next;
  }
}

static void shape_record_render_edgesrecord(sr_edgesrecord_t *er, fad_render_t *render, shape_record_t *sr, dl_node_t *node) {
  u16_t idx = 0, count;
  u16_t total = er->fs_num+1+er->ls_num+1;

  for(; idx<total; idx++) {
  FAD_ERROR("total = %d, er = %x, array[%d] = %x\n", total, er, idx, er->array[idx]);
    if(er->array[idx]) {
      sr_node_list_t *nlptr = er->array[idx];
#ifdef LIBFAD_DEBUG
      count = 0;
#endif
      do {
        FAD_ERROR("render: node list = %x, nl->sta = %x\n", nlptr, nlptr->sta);
        shape_record_render_node_list(nlptr, render, node);

        nlptr = nlptr->next;
#ifdef  LIBFAD_DEBUG
        count++;
#endif
      } while(nlptr != er->array[idx]);

      if(node->flag&0x40)
        break;

      if(er->ns!=NULL) {
        if(idx <= er->fs_num) {
#ifdef  LIBFAD_DO_RENDER
          _fill_style_do_render(render, &(er->ns->fs_array), idx-1, sr->srv, sr->dict, node);
          cairo_fill(render->cr);
#endif
        } else {
#ifdef  LIBFAD_DO_RENDER
          _line_style_do_render(render, &(er->ns->ls_array), idx-er->fs_num-1, sr->srv, node);
          cairo_stroke(render->cr);
#endif
        }
      }
      FAD_ERROR("summary: node list count = %d\n", count);
    }
  }
}

static void shape_record_core_render(shape_record_t *sr, fad_render_t *render, dl_node_t *node) {
  sr_edgesrecord_t *ptr = sr->header;

  while(ptr != NULL) {
    if(sr->ns != NULL && ptr->ns == NULL)
      ptr->ns = sr->ns;

    FAD_ERROR("edgesrecord do render, er = %x, ns = %x\n", ptr, ptr->ns);
    shape_record_render_edgesrecord(ptr, render, sr, node);
    ptr = ptr->next;
  }
}

u8_t shape_record_do_render(shape_record_t* sr, fad_render_t* render, dl_node_t *node) {
  shape_record_core_render(sr, render, node);
  return FAD_TRUE;
}

void shape_record_free(shape_record_t* sr) {
  sr_edgesrecord_t *hdr = NULL, *ptr = NULL;

  for(hdr=sr->header; hdr!=NULL;) {
    ptr = hdr->next;
    sr_edgesrecord_destroy(hdr);
    free(hdr);
    hdr = ptr;
  }

  if(sr->ns)
    free(sr->ns);
}

static void _style_shape_do_free(fad_object_t* fo) {
  style_shape_t* ss = (style_shape_t* )fo;

  FAD_ERROR("style shape doing free, object = %x, sr = %x\n", fo, &ss->sr);
  shape_record_free(&ss->sr);
}

static u8_t _style_shape_do_render(fad_object_t* fo, fad_render_t* render, dl_node_t *node) {
  style_shape_t* ss = (style_shape_t* )fo;

  return shape_record_do_render(&ss->sr, render, node);
}

static void  _style_shape_get_rect(fad_object_t* fo, rect_t *rt) {
  style_shape_t* ss = (style_shape_t* )fo;

  *rt = ss->bound;
}