fad.frame.c

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

      if(tag_id > TAG_ID_MAX) {
        FAD_ERROR("tag id EXCEPTION, id = 0x%x, try skip.\n", tag_id);
        bits_seek_nbytes(&s->bits, s->tag_len);
        s->err = FAD_ERROR_TAG;
        ret = -1;
        break;
      } else {
        if(s->err == FAD_ERROR_TAG)
          s->err = FAD_ERROR_NONE;

        if(frame->sta == FAD_STA_SEEK) {
          if(tag_id!=TAG_PLACEOBJECT2 && tag_id!=TAG_PLACEOBJECT) {
            bits_seek_nbytes(&s->bits, s->tag_len);
            s->err = FAD_ERROR_NONE;
            ret = 0;
            break;
          }
        }
      }

      s->tag_id = tag_id;
      if(g_tag_array[s->tag_id].tag_decode)
        tag_decode_call = g_tag_array[s->tag_id].tag_decode;
      else
        tag_decode_call = _tag_decode_default_method;

      //bits_dump(&s->bits, 4);
      ptr = bits_tell(&s->bits);
      /**call do tag function by tag_id*/
      //FAD_ERROR("+++++%s, len = %d, offset = %x, is_sprite_frame = %x+++++\n", g_tag_array[s->tag_id].tag_string, s->tag_len, ptr-s->bufbeg, FAD_FRAME_CHK_SPRITE(frame->attr));
      ret = tag_decode_call(frame, s);
      offset = bits_tell(&s->bits) - ptr;

      if(ret < 0 || s->tag_len != offset) {
        s->bits.bufptr = ptr;
        bits_seek_nbytes(&s->bits, s->tag_len);
      }
      //FAD_ERROR("-----%s, ret = %d-----\n\n", g_tag_array[s->tag_id].tag_string, ret);
      break;
  }

  if(s->err != FAD_ERROR_NONE) {
    /**print error message even without LIBFAD_DEBUG defined*/
    fprintf(stderr, "***stream.err = %s, frame.sta = %s***\n", fad_stream_errstr(s->err), fad_frame_stastr(frame->sta));
  }
  return ret;
}

u8_t fad_frame_render_graphics(fad_frame_t *frame, dl_node_t *parent) {
  u8_t nbits, beof=FAD_TRUE, i;
  u16_t idx = 0;
  bits_t bits;
  dl_node_t *node = NULL;
  s32_t ret = 0;
  cairo_matrix_t *mx = NULL;

  bits_init(&bits);
  frame->nclip = -1;
  if(parent)
    mx = &parent->mx;
	else
		frame->nbtn = 0;

  for(node = frame->dlhdr.hdr; node; node = node->next) {
    cairo_matrix_t tempMX = {0};
    fad_render_t *dr = NULL;

    if(node == NULL || node->fo == NULL || ((node->flag&0x08) && (node->cx.am+node->cx.aa==0)))
      continue;

#ifdef LIBFAD_DIRTY_AREA
    if(fad_rect_check_over(&frame->dirty_rect, &node->rt) == FAD_FALSE)
      continue;
#endif

    FAD_ERROR("GET displaylist node = %x, depth = %d, count = %d, mx = %x, node->next=%x\n", node, node->depth, frame->dlhdr.count, mx, node->next);
    FAD_ERROR("(*)object (%s) depth = %d, matrix = (%f, %f, %f, %f, %f, %f)\n", fad_object_type_to_string(node->fo->type), node->depth, node->mx.xx, node->mx.xy, node->mx.x0, node->mx.yy, node->mx.yx, node->mx.y0);
    dr = frame->render;

    if(frame->nclip>=0 && frame->clipstack[frame->nclip] && node->depth>frame->clipstack[frame->nclip]) {
      cairo_restore(dr->cr);
      frame->clipstack[frame->nclip] = 0;
      frame->nclip--;
    }

    if(parent) {
      if(parent->flag&0x40)
        node->flag |= 0x40;

      if(FAD_DL_NODE_CHK_MATRIX(node->attr)) {
        if(!FAD_DL_NODE_CHK_MERGE(node->attr)) {
          cairo_matrix_multiply(&tempMX, &node->mx, mx);
          node->mx = tempMX;
          FAD_DL_NODE_SET_MERGE(node->attr);
        }
      } else {
        node->mx = *mx;
      }
    } else if(node->fo->type == FO_TYPE_BUTTON) {
			frame->nbtn++;
		}

    if(node->fo->type != FO_TYPE_SPRITE) {
      cairo_save(dr->cr);
      cairo_set_matrix(dr->cr, &node->mx);
    }
    if(node->fo->do_render) {
      if(node->fo->do_render(node->fo, dr, node) == FAD_FALSE)
        beof = FAD_FALSE;
    }
    if(node->fo->type != FO_TYPE_SPRITE)
      cairo_restore(dr->cr);

    FAD_ERROR("render object (%s,0x%x) done, depth = %d, nframe = %d, beof = %d.\n", fad_object_type_to_string(node->fo->type), node, node->depth, frame->output_frame, beof);

    if(node->ctx == NULL) continue;
    bits_buffer(&bits, node->ctx);

    if(node->flag & 0x20) {
      while(bits_get_u8(&bits) != 0);
    }

    if(node->flag & 0x40) {
      if(frame->nclip < FAD_CLIPSTACK_MAX-1) {
        u16_t clip = bits_get_u16(&bits);

        if((frame->nclip==-1) || (frame->nclip>=0 && clip<frame->clipstack[frame->nclip])) {
          frame->nclip++;
          frame->clipstack[frame->nclip] = clip;
          cairo_save(dr->cr);
          cairo_clip(dr->cr);
          cairo_new_path(dr->cr);
        }
      }
    }
  } /**for(....)*/

  for(i=0; i<=frame->nclip && frame->clipstack[i]; i++) {
    FAD_ERROR("CLEAR DIRTY CLIP STACK!!!\n");
    cairo_restore(frame->render->cr);
    frame->clipstack[i] = 0;
  }

  bits_finish(&bits);

  if(frame->sta != FAD_STA_FINISH && frame->sta != FAD_STA_UPDATEBTN && frame->sta != FAD_STA_END)
    frame->sta = FAD_STA_DOTAG;

  return beof;
}

void fad_frame_render_movie(fad_frame_t* frame) {

  if(fad_frame_render_graphics(frame, NULL) && frame->output_frame>=frame->total_frame) {
    fprintf(stderr, "*****THE END*****\n");
    frame->sta = FAD_STA_END;
  }
}

void fad_frame_render_audio(fad_frame_t *frame, fad_stream_t *s) {
  event_sound_t *es = NULL;
	frame_priv_t *priv = NULL;

  if(FAD_FRAME_CHK_EVENTSOUND(frame->attr)) {
    es = (event_sound_t *)s->dict->get(s->dict, frame->es_id);

    if(default_render_open_snddev(frame->render, es->attr) < 0)
      FAD_ERROR("event.sound: open /dev/dsp failure.\n");

    switch(es->attr&0xf0) {
      case 0x10: /**ADPCM audio decode*/
        fad_sound_render_adpcm(frame->render, es->data, es->attr, es->nsize/*4096<<(es->attr&0x01)*/);
        break;

      case 0x20: /**MPEG3 audio decode*/
        fad_sound_render_mpeg3(frame->render, es->data, es->attr, es->nsize, NULL, NULL, NULL);
        break;

      case 0x00:
      case 0x30: /**RAW audio decode*/
        FAD_ERROR("render raw sound data in event sound.\n");
        fad_sound_render_raw(frame->render, es->data, es->attr, es->nsize);
        break;

      case 0x60: /**Nellymoser audio decode*/
        FAD_ERROR("Nellymoser audio render is N/A.\n");
        break;
    }
  }

  if(FAD_FRAME_CHK_STREAMSOUND(frame->attr)) {
		priv = (frame_priv_t *)frame->priv;

    switch(frame->ss_attr&0xf0) {
      case 0x10: /**ADPCM audio decode*/
        fad_sound_render_adpcm(frame->render, frame->ss_buff, frame->ss_attr, frame->ss_nsize);
        break;

      case 0x20: /**MPEG3 audio decode*/
        fad_sound_render_mpeg3(frame->render, frame->ss_buff, frame->ss_attr, frame->ss_nsize, &priv->mad_frame, &priv->mad_synth, &priv->mad_stream);
        break;

      case 0x00:
      case 0x30: /**RAW audio decode*/
        FAD_ERROR("render raw sound data in stream sound.\n");
        fad_sound_render_raw(frame->render, frame->ss_buff, frame->ss_attr, frame->ss_nsize);
        break;

      case 0x60: /**Nellymoser audio decode*/
        FAD_ERROR("Nellymoser audio render is N/A.\n");
        break;
    }
  }

  FAD_FRAME_CLR_EVENTSOUND(frame->attr);
  FAD_FRAME_CLR_STREAMSOUND(frame->attr);
}

void fad_frame_render_actionscript(fad_frame_t* frame, fad_stream_t *stream) {
#ifdef LIBFAD_AS2
  fad_actions_context_t fac;

  if(frame->asr) {
    fad_actions_context_init(&fac, frame, stream);
    action_script_exec(&fac, frame->asr);
    fad_actions_context_finish(&fac);
  }
#endif
}

void fad_frame_set_update_callback(fad_frame_t *frame, void (* update)(void *, s32_t, s32_t, s32_t ,s32_t), void *surface) {
  if(frame) {
    frame->update = update;
    frame->priv_surface = surface;
  }
}

static s32_t _fad_frame_proc_mbevt(fad_frame_t *frame, u8_t evt, s32_t x, s32_t y) {
  dl_node_t *node = NULL;
	s32_t ret = 0, count = 0;

	x *= 20; y *= 20;
  for(node = frame->dlhdr.hdr; node && count<frame->nbtn; node = node->next) {
    if(node == NULL || node->fo == NULL || node->fo->type != FO_TYPE_BUTTON)
      continue;

		ret = node->fo->proc_mbevt(node->fo, evt, x, y);
		count++;

    if(ret>0 && (frame->sta==FAD_STA_END || frame->sta==FAD_STA_STOP))
      frame->sta = FAD_STA_UPDATEBTN;
//    printf("evt = %x, x = %d, y = %d, ret = %x\n", evt, x, y, ret);
  }

	return FAD_TRUE;
}

const char * fad_tag_id_to_string(u16_t tag_id) {
  if(tag_id < TAG_ID_MAX)
    return g_tag_array[tag_id].tag_string;

  return "TAG_UNDEFINE(val=???)";
}