ming-streams.c

flash swf file player

  if(ZEND_NUM_ARGS() != 0)
    WRONG_PARAM_COUNT;

  RETURN_DOUBLE(SWFFont_getAscent(getFont(getThis() TSRMLS_CC)));
}

/* }}} */
/* {{{ proto int swffont_getDescent(void)
   Returns the descent of the font, or 0 if not available */

PHP_FUNCTION(swffont_getDescent)
{
  if(ZEND_NUM_ARGS() != 0)
    WRONG_PARAM_COUNT;

  RETURN_DOUBLE(SWFFont_getDescent(getFont(getThis() TSRMLS_CC)));
}

/* }}} */
/* {{{ proto int swffont_getLeading(void)
   Returns the leading of the font, or 0 if not available */

PHP_FUNCTION(swffont_getLeading)
{
  if(ZEND_NUM_ARGS() != 0)
    WRONG_PARAM_COUNT;

  RETURN_DOUBLE(SWFFont_getLeading(getFont(getThis() TSRMLS_CC)));
}

/* }}} */
/* {{{ proto void swffont_addChars(string)
   adds characters to a font required within textfields */
/*
PHP_FUNCTION(swffont_addChars)
{
  zval **zstring;

  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &zstring) == FAILURE)
    WRONG_PARAM_COUNT;

  convert_to_string_ex(zstring);

  SWFFont_addChars(getFont(getThis() TSRMLS_CC), Z_STRVAL_PP(zstring));

}
*/
/* }}} */
/* {{{ proto char *swffont_getShape(code)
   Returns the glyph shape of a char as a text string */

PHP_FUNCTION(swffont_getShape)
{
  zval **zcode;
  char *result;

  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &zcode) == FAILURE)
    WRONG_PARAM_COUNT;

  convert_to_long_ex(zcode);

  result = SWFFont_getShape(getFont(getThis() TSRMLS_CC), Z_LVAL_PP(zcode));
  RETVAL_STRING(result, 1);
  free(result);

}

/* }}} */

/* }}} */
/* {{{ SWFGradient */

static zend_function_entry swfgradient_functions[] = {
  PHP_FALIAS(swfgradient,  swfgradient_init,      NULL)
  PHP_FALIAS(addentry,     swfgradient_addEntry,  NULL)
  { NULL, NULL, NULL }
};

/* {{{ proto class swfgradient_init(void)
   Returns a new SWFGradient object */

PHP_FUNCTION(swfgradient_init)
{
  SWFGradient gradient = newSWFGradient();
  int ret = zend_list_insert(gradient, le_swfgradientp);

  object_init_ex(getThis(), &gradient_class_entry);
  add_property_resource(getThis(), "gradient", ret);
  zend_list_addref(ret);
}


static void destroy_SWFGradient_resource(zend_rsrc_list_entry *resource TSRMLS_DC)
{
  destroySWFGradient((SWFGradient)resource->ptr);
}

/* }}} */
/* {{{ internal function getGradient
   Returns the SWFGradient object contained in zval *id */

static SWFGradient getGradient(zval *id TSRMLS_DC)
{
  void *gradient = SWFgetProperty(id, "gradient", 8, le_swfgradientp TSRMLS_CC);

  if(!gradient)
    php_error(E_ERROR, "called object is not an SWFGradient!");

  return (SWFGradient)gradient;
}

/* }}} */
/* {{{ proto void swfgradient_addEntry(float ratio, string r, string g, string b [, string a]
   Adds given entry to the gradient */

PHP_FUNCTION(swfgradient_addEntry)
{
  zval **ratio, **r, **g, **b;
  byte a = 0xff;

  if(ZEND_NUM_ARGS() == 4)
  {
    if(zend_get_parameters_ex(4, &ratio, &r, &g, &b) == FAILURE)
      WRONG_PARAM_COUNT;
  }
  else if(ZEND_NUM_ARGS() == 5)
  {
    zval **za;

    if(zend_get_parameters_ex(5, &ratio, &r, &g, &b, &za) == FAILURE)
      WRONG_PARAM_COUNT;

    convert_to_long_ex(za);
    a = Z_LVAL_PP(za);
  }
  else
    WRONG_PARAM_COUNT;

  convert_to_double_ex(ratio);
  convert_to_long_ex(r);
  convert_to_long_ex(g);
  convert_to_long_ex(b);

  SWFGradient_addEntry(getGradient(getThis() TSRMLS_CC), Z_DVAL_PP(ratio),
		       Z_LVAL_PP(r), Z_LVAL_PP(g), Z_LVAL_PP(b), a);
}

/* }}} */

/* }}} */
/* {{{ SWFMorph */

static zend_function_entry swfmorph_functions[] = {
  PHP_FALIAS(swfmorph,              swfmorph_init,            NULL)
  PHP_FALIAS(getshape1,             swfmorph_getShape1,       NULL)
  PHP_FALIAS(getshape2,             swfmorph_getShape2,       NULL)
  { NULL, NULL, NULL }
};

/* {{{ proto object swfmorph_init(void)
   Returns a new SWFMorph object */

PHP_FUNCTION(swfmorph_init)
{
  SWFMorph morph = newSWFMorphShape();
  int ret = zend_list_insert(morph, le_swfmorphp);

  object_init_ex(getThis(), &morph_class_entry);
  add_property_resource(getThis(), "morph", ret);
  zend_list_addref(ret);
}


static void destroy_SWFMorph_resource(zend_rsrc_list_entry *resource TSRMLS_DC)
{
  destroySWFMorph((SWFMorph)resource->ptr);
}

/* }}} */
/* {{{ internal function getMorph
   Returns the SWFMorph object contained in zval *id */

static SWFMorph getMorph(zval *id TSRMLS_DC)
{
  void *morph = SWFgetProperty(id, "morph", 5, le_swfmorphp TSRMLS_CC);

  if(!morph)
    php_error(E_ERROR, "called object is not an SWFMorph!");

  return (SWFMorph)morph;
}

/* }}} */
/* {{{ proto SWFShape swfmorph_getShape1(void)
   Return's this SWFMorph's start shape */

PHP_FUNCTION(swfmorph_getShape1)
{
  SWFMorph morph = getMorph(getThis() TSRMLS_CC);
  SWFShape shape = SWFMorph_getShape1(morph);
  int ret = zend_list_insert(shape, le_swfshapep);

  object_init_ex(return_value, &shape_class_entry);
  add_property_resource(return_value, "shape", ret);
  zend_list_addref(ret);
}

/* }}} */
/* {{{ proto SWFShape swfmorph_getShape2(void)
   Return's this SWFMorph's start shape */

PHP_FUNCTION(swfmorph_getShape2)
{
  SWFMorph morph = getMorph(getThis() TSRMLS_CC);
  SWFShape shape = SWFMorph_getShape2(morph);
  int ret = zend_list_insert(shape, le_swfshapep);

  object_init_ex(return_value, &shape_class_entry);
  add_property_resource(return_value, "shape", ret);
  zend_list_addref(ret);
}

/* }}} */

/* }}} */
/* {{{ SWFMovie */

static zend_function_entry swfmovie_functions[] = {
  PHP_FALIAS(swfmovie,          swfmovie_init,              NULL)
  PHP_FALIAS(nextframe,         swfmovie_nextFrame,         NULL)
  PHP_FALIAS(labelframe,        swfmovie_labelFrame,        NULL)
  PHP_FALIAS(add,               swfmovie_add,               NULL)
  PHP_FALIAS(remove,            swfmovie_remove,            NULL)
  PHP_FALIAS(output,            swfmovie_output,            NULL)
  PHP_FALIAS(save,              swfmovie_save,              NULL)
  PHP_FALIAS(savetofile,        swfmovie_saveToFile,        NULL)
  PHP_FALIAS(setbackground,     swfmovie_setBackground,     NULL)
	PHP_FALIAS(protect,           swfmovie_Protect,           NULL)
  PHP_FALIAS(setrate,           swfmovie_setRate,           NULL)
  PHP_FALIAS(setdimension,      swfmovie_setDimension,      NULL)
  PHP_FALIAS(setframes,         swfmovie_setFrames,         NULL)
  PHP_FALIAS(streammp3,         swfmovie_streamMp3,         NULL)
  PHP_FALIAS(addexport,         swfmovie_addExport,         NULL)
  PHP_FALIAS(writeexports,      swfmovie_writeExports,      NULL)
  { NULL, NULL, NULL }
};

/* {{{ swfmovie_init */

PHP_FUNCTION(swfmovie_init)
{
  zval **version;
  SWFMovie movie;
  int ret;
//fprintf(stderr, "SWFMovie_output %x %d\n", SWFMovie_output, getpid()); sleep(30);
  if(ZEND_NUM_ARGS() == 1)
  {
    if(zend_get_parameters_ex(1, &version) == FAILURE)
      WRONG_PARAM_COUNT;

    convert_to_long_ex(version);

    movie = newSWFMovie(Z_LVAL_PP(version));
  }
  else
    movie = newSWFMovie(4); /* default version 4 */

  ret = zend_list_insert(movie, le_swfmoviep);

  object_init_ex(getThis(), &movie_class_entry);
  add_property_resource(getThis(), "movie", ret);
  zend_list_addref(ret);
}


static void destroy_SWFMovie_resource(zend_rsrc_list_entry *resource TSRMLS_DC)
{
  destroySWFMovie((SWFMovie)resource->ptr);
}

/* }}} */
/* {{{ getMovie */

SWFMovie getMovie(zval *id TSRMLS_DC)
{
  void *movie = SWFgetProperty(id, "movie", 5, le_swfmoviep TSRMLS_CC);

  if(!movie)
    php_error(E_ERROR, "called object is not an SWFMovie!");

  return (SWFMovie)movie;
}

/* }}} */
/* {{{ swfmovie_nextframe */

PHP_FUNCTION(swfmovie_nextFrame)
{
  SWFMovie_nextFrame(getMovie(getThis() TSRMLS_CC));
}

/* }}} */
/* {{{ swfmovie_labelframe */

PHP_FUNCTION(swfmovie_labelFrame)
{
  zval **label;

  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &label) == FAILURE)
    WRONG_PARAM_COUNT;

  convert_to_string_ex(label);

  SWFMovie_labelFrame(getMovie(getThis() TSRMLS_CC), Z_STRVAL_PP(label));
}

/* }}} */
/* {{{ swfmovie_add */

PHP_FUNCTION(swfmovie_add)
{
  zval **zchar;
  int ret;
  SWFBlock block;
  SWFDisplayItem item;
  SWFMovie movie = getMovie(getThis() TSRMLS_CC);

  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &zchar) == FAILURE)
    WRONG_PARAM_COUNT;

  convert_to_object_ex(zchar);

  /* XXX - SWFMovie_add deals w/ all block types.  Probably will need to add that.. */
  if(Z_OBJCE_PP(zchar) == &action_class_entry)
    block = (SWFBlock)getAction(*zchar TSRMLS_CC);
  else
    block = (SWFBlock)getCharacter(*zchar TSRMLS_CC);

  item = SWFMovie_add(movie, block);

  if(item != NULL)
  {
    /* try and create a displayitem object */
    ret = zend_list_insert(item, le_swfdisplayitemp);
    object_init_ex(return_value, &displayitem_class_entry);
    add_property_resource(return_value, "displayitem", ret);
  }
}

/* }}} */
/* {{{ swfmovie_remove */

PHP_FUNCTION(swfmovie_remove)
{
  zval **zchar;
  SWFDisplayItem item;
  SWFMovie movie = getMovie(getThis() TSRMLS_CC);

  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &zchar) == FAILURE)
    WRONG_PARAM_COUNT;

  convert_to_object_ex(zchar);
  item = getDisplayItem(*zchar TSRMLS_CC);

  SWFMovie_remove(movie, item);
}


/* }}} */
/* {{{ swfmovie_output */

void phpByteOutputMethod(byte b, void *data)
{
  TSRMLS_FETCH();

  php_write(&b, 1 TSRMLS_CC);
}

PHP_FUNCTION(swfmovie_output)
{
  zval **zlimit = NULL;
  int limit = -1;
  SWFMovie movie = getMovie(getThis() TSRMLS_CC);

  switch (ZEND_NUM_ARGS()) {
  case 1:
    if (zend_get_parameters_ex(1, &zlimit) == FAILURE)
	  WRONG_PARAM_COUNT;
    convert_to_long_ex(zlimit);
    limit = Z_LVAL_PP(zlimit);
    if((limit<0)||(limit>9)) {
      php_error(E_WARNING,"compression level must be within 0..9");
      RETURN_FALSE;
    }
			
	break;
  }
  RETURN_LONG(SWFMovie_output(movie, &phpByteOutputMethod, NULL, limit));
}


/* }}} */
/* {{{ swfmovie_saveToFile */

void phpStreamOutputMethod(byte b, void *data)
{
	TSRMLS_FETCH();
	php_stream_write((php_stream*)data, &b, 1);
}

PHP_FUNCTION(swfmovie_saveToFile)
{
  zval **x, **zlimit = NULL;
  int limit = -1;
  void *what;

  switch (ZEND_NUM_ARGS()) {
  case 1:
  	if(zend_get_parameters_ex(1, &x) == FAILURE)
		WRONG_PARAM_COUNT;
	break;
  case 2:
	if(zend_get_parameters_ex(2, &x, &zlimit) == FAILURE)
		 WRONG_PARAM_COUNT;
	convert_to_long_ex(zlimit);
    limit = Z_LVAL_PP(zlimit);
    if((limit<0)||(limit>9)) {
    	php_error(E_WARNING,"compression level must be within 0..9");
    	RETURN_FALSE;
    }
	break;
  default:
		WRONG_PARAM_COUNT;
	}
	ZEND_FETCH_RESOURCE(what, php_stream *, x, -1,"File-Handle",php_file_le_stream());
	RETURN_LONG(SWFMovie_output(getMovie(getThis()), &phpStreamOutputMethod, what, limit));
}


/* }}} */
/* {{{ swfmovie_save */

PHP_FUNCTION(swfmovie_save)
{
  zval **x, **zlimit = NULL;
  int limit = -1;
  void *stream;
  long retval;

  switch (ZEND_NUM_ARGS()) {
  case 1:
    if (zend_get_parameters_ex(1, &x) == FAILURE)
	  WRONG_PARAM_COUNT;
    break;
  case 2:
    if (zend_get_parameters_ex(2, &x, &zlimit) == FAILURE)
      WRONG_PARAM_COUNT;
    convert_to_long_ex(zlimit);
    limit = Z_LVAL_PP(zlimit);
    if((limit<0)||(limit>9)) {
      php_error(E_WARNING,"compression level must be within 0..9");
      RETURN_FALSE;
    }
    break;
  default:
    WRONG_PARAM_COUNT;
  }
	if (Z_TYPE_PP(x) == IS_RESOURCE) {
			ZEND_FETCH_RESOURCE(stream, php_stream *, x, -1,"File-Handle",php_file_le_stream());
			RETURN_LONG(SWFMovie_output(getMovie(getThis() TSRMLS_CC), &phpStreamOutputMethod, stream, limit));
		}

	convert_to_string_ex(x);
	stream = php_stream_open_wrapper(Z_STRVAL_PP(x), "wb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);

	if (stream == NULL) {
			RETURN_FALSE;
		}

	retval = SWFMovie_output(getMovie(getThis() TSRMLS_CC), &phpStreamOutputMethod, (void *)stream, limit);
	php_stream_close(stream);
	RETURN_LONG(retval);
}


/* }}} */
/* {{{ swfmovie_setbackground */

PHP_FUNCTION(swfmovie_setBackground)
{
  zval **r, **g, **b;
  SWFMovie movie = getMovie(getThis() TSRMLS_CC);

  if((ZEND_NUM_ARGS() != 3) || zend_get_parameters_ex(3, &r, &g, &b) == FAILURE)
    WRONG_PARAM_COUNT;

  convert_to_long_ex(r);
  convert_to_long_ex(g);
  convert_to_long_ex(b);

  SWFMovie_setBackground(movie, Z_LVAL_PP(r), Z_LVAL_PP(g), Z_LVAL_PP(b));
}