pHash.xml

<?xml version="1.0"?>

<extension name="pHash" version="1.1.2">
<summary>pHash</summary>
  <license>PHP</license>

 <maintainers>
  <maintainer>        
   <name>Evan Klinger</name>
   <email>eklinger@phash.org</email>
   <role>lead</role>
  </maintainer>
 </maintainers>

 <release>
  <version>0.9.2</version>
  <date>2013-05-14</date>

<state>beta</state>
 </release>

<deps language="cpp" platform="all">
<with defaults='/usr:/usr/local' testfile='include/pHash.h'>
	<header name="pHash.h"/>
	<header name="audiophash.h"/>

<lib name="pHash" platform="all" function="ph_texthash"/>

</with>
 </deps>

<code role="code" position="top">
struct ph_mh_image_hash
{
	uint8_t *hash;
	int len;
};
struct ph_audio_hash
{
	uint32_t *hash;
	int len;
};
struct ph_video_hash
{
	ulong64 *hash;
	int len;
};
struct ph_text_hash
{
	TxtHashPoint *p;
	int count;
};
</code>

<resource name="ph_video_hash" payload="ph_video_hash" alloc="no">
 <description>
  A ulong64 resource
 </description>
 <destruct>
	if(resource)
	{
		free(resource->hash);
		free(resource);
	}
 </destruct>
</resource>
<resource name="ph_image_hash" payload="ulong64" alloc="no">
 <description>
  A ulong64 resource
 </description>
 <destruct>
	if(resource)
		free(resource);
 </destruct>
</resource>
<resource name="ph_audio_hash" payload="ph_audio_hash" alloc="no">
 <description>
  A uint32_t resource
 </description>
 <destruct>
	if(resource)
	{
		free(resource->hash);
		free(resource);
	}
 </destruct>
</resource>
<resource name="ph_mh_image_hash" payload="ph_mh_image_hash" alloc="no">
 <description>
  A uint8_t resource
 </description>
 <destruct>
	if(resource)
	{
		free(resource->hash);
		free(resource);
	}
 </destruct>
</resource>
<resource name="ph_txt_hash" payload="ph_text_hash" alloc="no">
 <description>
  A TxtHashPoint resource
 </description>
 <destruct>
	if(resource)
	{
		free(resource->p);
		free(resource);
	}
 </destruct>
</resource>

<function name="ph_dct_videohash" if="HAVE_VIDEO_HASH">
   <proto>resource ph_video_hash ph_dct_videohash(string file)</proto>
   <summary>pHash DCT video hash</summary>
   <description>
	Perceptual video hash based on DCT.
   </description>
   <code>
<![CDATA[
	int len;
	ulong64 *video_hash = ph_dct_videohash(file, len);
	if(video_hash)
	{
		ph_video_hash *p = (ph_video_hash *)malloc(sizeof(ph_video_hash));
		p->hash = video_hash;
		p->len = len;
		return_res = p;
	
	}
	else
		RETURN_FALSE;
]]>   
</code>
  </function>


<function name="ph_dct_imagehash" if="HAVE_IMAGE_HASH">
   <proto>resource ph_image_hash ph_dct_imagehash(string file)</proto>
   <summary>pHash DCT image hash</summary>
   <description>
	Perceptual image hash based on DCT.
   </description>
   <code>
<![CDATA[
	ulong64 *hash = (ulong64 *)malloc(sizeof(ulong64));
	int ret = ph_dct_imagehash(file, *hash);
	if(ret != 0)
	{
		free(hash);
		RETURN_FALSE;
	}
	else
		return_res = hash;
]]>   
    </code>
</function>

<function name="ph_mh_imagehash" if="HAVE_IMAGE_HASH">
   <proto>resource ph_mh_image_hash ph_mh_imagehash(string file, float alpha=2.0, float level=1.0)</proto>
   <summary>Fixed Length MH image hash</summary>
   <description>
	Marr-Hildreth wavelet based image hash.
   </description>
   <code>
<![CDATA[
	int num = 0;
	uint8_t *hash = ph_mh_imagehash(file, num, alpha, level);
	if (hash)
	{
		ph_mh_image_hash *h = (ph_mh_image_hash *)malloc(sizeof(ph_mh_image_hash));
		h->hash = hash;
		h->len = num;
		return_res = h;
	}
	else
		RETURN_FALSE;
]]>
    </code>
</function>

<function name="ph_texthash">
   <proto>resource ph_txt_hash ph_texthash(string file)</proto>
   <summary>pHash cyclic text hash</summary>
   <description>
	Perceptual text hash based on cyclic polynomials.
   </description>
   <code>
<![CDATA[
	int num;
	TxtHashPoint *txtHash = ph_texthash(file, &num);
	if(txtHash)
	{
		ph_text_hash *h = (ph_text_hash *)malloc(sizeof(ph_text_hash));
		h->p = txtHash;
		h->count = num;
		return_res = h;
	}
	else
		RETURN_FALSE;
]]>   
</code>
  </function>

<function name="ph_audiohash" if="HAVE_AUDIO_HASH">
   <proto>resource ph_audio_hash ph_audiohash(string file, int sample_rate=5512, int channels=1)</proto>
   <summary>pHash audio hash</summary>
   <description>
	Perceptual audio hash based on bark scale.
   </description>
   <code>
<![CDATA[
	int n;
	float *audiobuf = ph_readaudio(file, sample_rate, channels, NULL, n);
	if(audiobuf)
	{
		int nb_frames;
		uint32_t *hash = ph_audiohash(audiobuf, n, sample_rate, nb_frames);
		free(audiobuf);

		if(hash)
		{
			ph_audio_hash *h = (ph_audio_hash *)malloc(sizeof(ph_audio_hash));
			h->hash = hash;
			h->len = nb_frames;

			return_res = h;
		}
		else
			RETURN_FALSE;
	}
	else
		RETURN_FALSE;
]]>   
</code>
</function>

<function name="ph_image_dist" if="HAVE_IMAGE_HASH">
   <proto>float ph_image_dist(resource ph_image_hash h1,resource ph_image_hash h2)</proto>
   <summary>pHash image distance.</summary>
   <description>
	Calculate distance between two images.
   </description>
   <code>
<![CDATA[
	if(h1 && h2)
	{
		int dist = ph_hamming_distance(*h1, *h2);
		RETURN_DOUBLE(dist);
	}
	else
		RETURN_DOUBLE(-1);
]]>   
</code>
  </function>

<function name="ph_dct_imagehash_to_array" if="HAVE_IMAGE_HASH">
   <proto>array ph_dct_imagehash_to_array(resource ph_image_hash h)</proto>
   <summary>Conversion of DCT pHash image hash to 8-bytes array.</summary>
   <description>
	Returns DCT pHash image hash represented as array of 8 bytes.
   </description>
   <code>
<![CDATA[
	if (h)
	{
		array_init(return_value);
		uint8_t *p = (uint8_t*) h;
		for (int i = 0; i < sizeof(ulong64) / sizeof(uint8_t); i++)
		{
			add_next_index_long(return_value, *(p + i));
		}
	}
	else
	{
		RETURN_FALSE;
	}
]]>
   </code>
</function>

<function name="ph_mh_imagehash_to_array" if="HAVE_IMAGE_HASH">
   <proto>array ph_mh_imagehash_to_array(resource ph_mh_image_hash h)</proto>
   <summary>Conversion of fixed Length MH image hash to 72-bytes array.</summary>
   <description>
	Returns fixed Length MH image hash represented as array of 72 bytes.
   </description>
   <code>
<![CDATA[
	if (h)
	{
		array_init(return_value);
		for (int i = 0; i < h->len; i++)
		{
			add_next_index_long(return_value, *(h->hash + i));
		}
	}
	else
	{
		RETURN_FALSE;
	}
]]>
   </code>
</function>

<function name="ph_video_dist" if="HAVE_VIDEO_HASH">
   <proto>float ph_video_dist(resource ph_video_hash h1,resource ph_video_hash h2, int thresh=21)</proto>
   <summary>pHash video distance.</summary>
   <description>
	Calculate distance between two videos.
   </description>
   <code>
<![CDATA[
	if(h1 && h2)
	{
		double sim = ph_dct_videohash_dist(h1->hash, h1->len, h2->hash, h2->len, thresh);
		RETURN_DOUBLE(sim);
	}
	else
		RETURN_DOUBLE(-1);
]]>   
</code>
  </function>

<function name="ph_audio_dist" if="HAVE_AUDIO_HASH">
   <proto>float ph_audio_dist(resource ph_audio_hash h1,resource ph_audio_hash h2, 
		int block_size=256, float thresh=0.30)</proto>
   <summary>pHash audio distance.</summary>
   <description>
	Calculate distance between two audio files.
   </description>
   <code>
<![CDATA[
	if(h1 && h2)
	{
		int Nc;
		double *cs = ph_audio_distance_ber(h1->hash, h1->len, h2->hash, h2->len, 
				thresh, block_size, Nc);
		if(cs)
		{
			double max_cs = 0.0;
			for (int i = 0; i < Nc; ++i)
			{
				if (cs[i] > max_cs)
				{
					max_cs = cs[i];
				}
			}
			free(cs);
			RETURN_DOUBLE(max_cs);
		}
		else
			RETURN_DOUBLE(-1);
	}
	else
		RETURN_DOUBLE(-1);
]]>   
</code>
  </function>

<function name="ph_compare_text_hashes">
   <proto>array ph_compare_text_hashes(resource ph_txt_hash h1,resource ph_txt_hash h2)</proto>
   <summary>pHash text distance.</summary>
   <description>
	Calculate distance between two text hashes.
   </description>
   <code>
<![CDATA[
	if(h1 && h2)
	{
		int count = 0;
		TxtMatch *m = ph_compare_text_hashes(h1->p, h1->count, h2->p, h2->count, &count);
		if(m)
		{
			for(int i = 0; i < count; ++i)
			{
				zval *array;
				MAKE_STD_ZVAL(array);
				array_init(array);
				add_assoc_long(array, "begin", m[i].first_index);
				add_assoc_long(array, "end", m[i].second_index);
				add_assoc_long(array, "length", m[i].length);
				add_next_index_zval(return_value, array);
			}
			free(m);
		}
		else
			RETURN_FALSE;

	}
	else
		RETURN_FALSE;
]]>   
</code>
  </function>


</extension>