PageRenderTime 71ms CodeModel.GetById 29ms RepoModel.GetById 0ms app.codeStats 1ms

/app/vendors/phpvideotoolkit.php5.php

https://github.com/mariuz/firetube
PHP | 3311 lines | 1748 code | 166 blank | 1397 comment | 259 complexity | a33e3bdf4e68c9038f80644b65dd875a MD5 | raw file
Possible License(s): LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2. 

  3. 	/* SVN FILE: $Id$ */
    4. 

  4. 

  5. 	/**
    6. 

  6. 	 * @author Oliver Lillie (aka buggedcom) <publicmail@buggedcom.co.uk>
    7. 

  7. 	 *
    8. 

  8. 	 * @license BSD
    9. 

  9. 	 * @copyright Copyright (c) 2008 Oliver Lillie <http://www.buggedcom.co.uk>
    10. 

  10. 	 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
    11. 

  11. 	 * files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
    12. 

  12. 	 * modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
    13. 

  13. 	 * is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be
    14. 

  14. 	 * included in all copies or substantial portions of the Software.
    15. 

  15. 	 *
    16. 

  16. 	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
    17. 

  17. 	 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
    18. 

  18. 	 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
    19. 

  19. 	 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    20. 

  20. 	 *
    21. 

  21. 	 * @package PHPVideoToolkit (was called ffmpeg)
    22. 

  22. 	 * @version 0.1.5
    23. 

  23. 	 * @changelog SEE CHANGELOG
    24. 

  24. 	 * @abstract This class can be used in conjunction with several server binary libraries to manipulate video and audio
    25. 

  25. 	 * through PHP. It is not intended to solve any particular problems, however you may find it useful. This php class
    26. 

  26. 	 * is in no way associated with the actual FFmpeg releases. Any mistakes contained in this php class are mine and mine
    27. 

  27. 	 * alone.
    28. 

  28. 	 *
    29. 

  29. 	 * Please Note: There are several prerequisites that are required before this class can be used as an aid to manipulate
    30. 

  30. 	 * video and audio. You must at the very least have FFMPEG compiled on your server. If you wish to use this class for FLV
    31. 

  31. 	 * manipulation you must compile FFMPEG with LAME and Ruby's FLVTOOL2. I cannot answer questions regarding the install of
    32. 

  32. 	 * the server binaries needed by this class. I had too learn the hard way and it isn't easy, however it is a good learning
    33. 

  33. 	 * experience. For those of you who do need help read the install.txt file supplied along side this class. It wasn't written
    34. 

  34. 	 * by me however I found it useful when installing ffmpeg for the first time. The original source for the install.txt file
    35. 

  35. 	 * is located http://www.luar.com.hk/blog/?p=669 and the author is Lunar.
    36. 

  36. 	 *
    37. 

  37. 	 * @see install.txt
    38. 

  38. 	 *
    39. 

  39. 	 * @uses ffmpeg http://ffmpeg.sourceforge.net/
    40. 

  40. 	 * @uses lame http://lame.sourceforge.net/
    41. 

  41. 	 * @uses flvtool2 http://www.inlet-media.de/flvtool2 (and ruby http://www.ruby-lang.org/en/)
    42. 

  42. 	 *
    43. 

  43. 	 * @config examples/example-config.php Please edit this files in order for the examples to work.
    44. 

  44. 	 * @example examples/example01.php Converts video to Flash Video (ie FLV).
    45. 

  45. 	 * @example examples/example02.php Screen grabs video frames.
    46. 

  46. 	 * @example examples/example03.php Compile a movie from multiple jpegs
    47. 

  47. 	 * @example examples/example04.php Watermark a video.
    48. 

  48. 	 * @example examples/example05.php Access media metadata without using the ffmpeg-php library.
    49. 

  49. 	 * @example examples/example06.php Extract audio from video.
    50. 

  50. 	 * @example examples/example07.php Join multiple videos together.
    51. 

  51. 	 * @example examples/example08.php Easy video conversion to common formats using the adapters.
    52. 

  52. 	 * @example examples/example09.php Shows you how to access the information about your ffmpeg installation.
    53. 

  53. 	 * @example examples/example10.php Shows you how to extract a specific frame from a movie.
    54. 

  54. 	 * @example examples/example11.php Shows you how to use the ffmpeg-php adapters to provide a pure php emulation of ffmpeg-php.
    55. 

  55. 	 * @example examples/example12.php Shows you how to manipulate/format timecode strings.
    56. 

  56. 	 * @example examples/example13.php This demonstrates how to simply create a FLV stream script.
    57. 

  57. 	 */
    58. 

  58. 

  59. 	/**
    60. 

  60. 	 * Set the ffmpeg binary path
    61. 

  61. 	 */
    62. 

  62. 	if(!defined('PHPVIDEOTOOLKIT_TEMP_DIRECTORY'))
    63. 

  63. 	{
    64. 

  64. 		define('PHPVIDEOTOOLKIT_TEMP_DIRECTORY', '/tmp/');
    65. 

  65. 	}
    66. 

  66. 	/**
    67. 

  67. 	 * Set the ffmpeg binary path
    68. 

  68. 	 */
    69. 

  69. 	if(!defined('PHPVIDEOTOOLKIT_FFMPEG_BINARY'))
    70. 

  70. 	{
    71. 

  71. 		define('PHPVIDEOTOOLKIT_FFMPEG_BINARY', '/usr/local/bin/ffmpeg');
    72. 

  72. 	}
    73. 

  73. 	/**
    74. 

  74. 	 * Set the flvtool2 binary path
    75. 

  75. 	 */
    76. 

  76. 	if(!defined('PHPVIDEOTOOLKIT_FLVTOOLS_BINARY'))
    77. 

  77. 	{
    78. 

  78. 		define('PHPVIDEOTOOLKIT_FLVTOOLS_BINARY', '/usr/bin/flvtool2');
    79. 

  79. 	}
    80. 

  80. 	/**
    81. 

  81. 	 * Set the watermark vhook path
    82. 

  82. 	 */
    83. 

  83. 	if(!defined('PHPVIDEOTOOLKIT_FFMPEG_WATERMARK_VHOOK'))
    84. 

  84. 	{
    85. 

  85. 		define('PHPVIDEOTOOLKIT_FFMPEG_WATERMARK_VHOOK', '/usr/local/lib/vhook/watermark.so');
    86. 

  86. 	}
    87. 

  87. 	/**
    88. 

  88. 	 * Set the memcoder path
    89. 

  89. 	 */
    90. 

  90. 	if(!defined('PHPVIDEOTOOLKIT_MENCODER_BINARY'))
    91. 

  91. 	{
    92. 

  92. 		define('PHPVIDEOTOOLKIT_MENCODER_BINARY', '/usr/local/bin/mencoder');
    93. 

  93. 	}
    94. 

  94. 

  95. 	class PHPVideoToolkit
    96. 

  96. 	{
    97. 

  97. 		
    98. 

  98. 		public $version = '0.1.5';
    99. 

  99. 		
    100. 

  100. 		/**
    101. 

  101. 		 * Error strings
    102. 

  102. 		 */
    103. 

  103. 		private $_messages = array(
    104. 

  104. 			
    105. 

  105. 			'generic_temp_404' 								=> 'The temporary directory does not exist.',
    106. 

  106. 			'generic_temp_writable' 						=> 'The temporary directory is not write-able by the web server.',
    107. 

  107. 			
    108. 

  108. 			'getFileInfo_no_input' 							=> 'Input file does not exist so no information can be retrieved.',
    109. 

  109. 			'streamFLV_no_input' 							=> 'Input file has not been set so the FLV cannot be streamed.',
    110. 

  110. 			'streamFLV_passed_eof' 							=> 'You have tried to stream to a point in the file that does not exit.',
    111. 

  111. 			'setInputFile_file_existence' 					=> 'Input file "#file" does not exist',
    112. 

  112. 			'extractAudio_valid_format' 					=> 'Value "#format" set from $toolkit->extractAudio, is not a valid audio format. Valid values ffmpeg self::FORMAT_AAC, PHPVideoToolkit::FORMAT_AIFF, PHPVideoToolkit::FORMAT_MP2, PHPVideoToolkit::FORMAT_MP3, PHPVideoToolkit::FORMAT_MP4, PHPVideoToolkit::FORMAT_MPEG4, PHPVideoToolkit::FORMAT_M4A or PHPVideoToolkit::FORMAT_WAV. If you wish to specifically try to set another format you should use the advanced function $toolkit->addCommand. Set $command to "-f" and $argument to your required value.',
    113. 

  113. 			'extractFrame_video_frame_rate_404' 			=> 'You have attempted to extract a thumbnail from a video while automagically guessing the framerate of the video, but the framerate could not be accessed. You can remove this error by manually setting the frame rate of the video.',
    114. 

  114. 			'extractFrame_video_info_404' 					=> 'You have attempted to extract a thumbnail from a video and check to see if the thumbnail exists, however it was not possible to access the video information. Please check your temporary directory permissions for read/write access by the webserver.',
    115. 

  115. 			'extractFrame_video_frame_count' 				=> 'You have attempted to extract a thumbnail from a video but the thumbnail you are trying to extract does not exist in the video.',
    116. 

  116. 			'extractFrames_video_begin_frame_count' 		=> 'You have attempted to extract thumbnails from a video but the thumbnail you are trying to start the extraction from does not exist in the video.',
    117. 

  117. 			'extractFrames_video_end_frame_count' 			=> 'You have attempted to extract thumbnails from a video but the thumbnail you are trying to end the extraction at does not exist in the video.',
    118. 

  118. 			'setFormat_valid_format' 						=> 'Value "#format" set from $toolkit->setFormat, is not a valid format. Valid values are PHPVideoToolkit::FORMAT_3GP2, PHPVideoToolkit::FORMAT_3GP, PHPVideoToolkit::FORMAT_AAC, PHPVideoToolkit::FORMAT_AIFF, PHPVideoToolkit::FORMAT_AMR, PHPVideoToolkit::FORMAT_ASF, PHPVideoToolkit::FORMAT_AVI, PHPVideoToolkit::FORMAT_FLV, PHPVideoToolkit::FORMAT_GIF, PHPVideoToolkit::FORMAT_MJ2, PHPVideoToolkit::FORMAT_MP2, PHPVideoToolkit::FORMAT_MP3, PHPVideoToolkit::FORMAT_MP4, PHPVideoToolkit::FORMAT_MPEG4, PHPVideoToolkit::FORMAT_M4A, PHPVideoToolkit::FORMAT_MPEG, PHPVideoToolkit::FORMAT_MPEG1, PHPVideoToolkit::FORMAT_MPEG2, PHPVideoToolkit::FORMAT_MPEGVIDEO, PHPVideoToolkit::FORMAT_PSP, PHPVideoToolkit::FORMAT_RM, PHPVideoToolkit::FORMAT_SWF, PHPVideoToolkit::FORMAT_VOB, PHPVideoToolkit::FORMAT_WAV, PHPVideoToolkit::FORMAT_JPG. If you wish to specifically try to set another format you should use the advanced function $toolkit->addCommand. Set $command to "-f" and $argument to your required value.',
    119. 

  119. 			'setAudioSampleFrequency_valid_frequency' 		=> 'Value "#frequency" set from $toolkit->setAudioSampleFrequency, is not a valid integer. Valid values are 11025, 22050, 44100. If you wish to specifically try to set another frequency you should use the advanced function $toolkit->addCommand. Set $command to "-ar" and $argument to your required value.',
    120. 

  120. 			'setAudioFormat_valid_format' 					=> 'Value "#format" set from $toolkit->setAudioFormat, is not a valid format. Valid values are PHPVideoToolkit::FORMAT_AAC, PHPVideoToolkit::FORMAT_AIFF, PHPVideoToolkit::FORMAT_AMR, PHPVideoToolkit::FORMAT_ASF, PHPVideoToolkit::FORMAT_MP2, PHPVideoToolkit::FORMAT_MP3, PHPVideoToolkit::FORMAT_MP4, PHPVideoToolkit::FORMAT_MPEG2, PHPVideoToolkit::FORMAT_RM, PHPVideoToolkit::FORMAT_WAV. If you wish to specifically try to set another format you should use the advanced function $toolkit->addCommand. Set $command to "-acodec" and $argument to your required value.',
    121. 

  121. 			'setVideoFormat_valid_format' 					=> 'Value "#format" set from $toolkit->setAudioFormat, is not a valid format. Valid values are PHPVideoToolkit::FORMAT_3GP2, PHPVideoToolkit::FORMAT_3GP, PHPVideoToolkit::FORMAT_AVI, PHPVideoToolkit::FORMAT_FLV, PHPVideoToolkit::FORMAT_GIF, PHPVideoToolkit::FORMAT_MJ2, PHPVideoToolkit::FORMAT_MP4, PHPVideoToolkit::FORMAT_MPEG4, PHPVideoToolkit::FORMAT_M4A, PHPVideoToolkit::FORMAT_MPEG, PHPVideoToolkit::FORMAT_MPEG1, PHPVideoToolkit::FORMAT_MPEG2, PHPVideoToolkit::FORMAT_MPEGVIDEO. If you wish to specifically try to set another format you should use the advanced function $toolkit->addCommand. Set $command to "-vcodec" and $argument to your required value.',
    122. 

  122. 			'setAudioBitRate_valid_bitrate' 				=> 'Value "#bitrate" set from $toolkit->setAudioBitRate, is not a valid integer. Valid values are 16, 32, 64, 128. If you wish to specifically try to set another bitrate you should use the advanced function $toolkit->addCommand. Set $command to "-ab" and $argument to your required value.',
    123. 

  123. 			'prepareImagesForConversionToVideo_one_img' 	=> 'When compiling a movie from a series of images, you must include at least one image.',
    124. 

  124. 			'prepareImagesForConversionToVideo_img_404' 	=> '"#img" does not exist.',
    125. 

  125. 			'prepareImagesForConversionToVideo_img_copy' 	=> '"#img" can not be copied to "#tmpfile"',
    126. 

  126. 			'prepareImagesForConversionToVideo_img_type' 	=> 'The images can not be prepared for conversion to video. Please make sure all images are of the same type, ie gif, png, jpeg and then try again.',
    127. 

  127. 			'setVideoOutputDimensions_valid_format' 		=> 'Value "#format" set from $toolkit->setVideoOutputDimensions, is not a valid preset dimension. Valid values are PHPVideoToolkit::SIZE_SQCIF, PHPVideoToolkit::SIZE_SAS, PHPVideoToolkit::SIZE_QCIF, PHPVideoToolkit::SIZE_CIF, PHPVideoToolkit::SIZE_4CIF, PHPVideoToolkit::SIZE_QQVGA, PHPVideoToolkit::SIZE_QVGA, PHPVideoToolkit::SIZE_VGA, PHPVideoToolkit::SIZE_SVGA, PHPVideoToolkit::SIZE_XGA, PHPVideoToolkit::SIZE_UXGA, PHPVideoToolkit::SIZE_QXGA, PHPVideoToolkit::SIZE_SXGA, PHPVideoToolkit::SIZE_QSXGA, PHPVideoToolkit::SIZE_HSXGA, PHPVideoToolkit::SIZE_WVGA, PHPVideoToolkit::SIZE_WXGA, PHPVideoToolkit::SIZE_WSXGA, PHPVideoToolkit::SIZE_WUXGA, PHPVideoToolkit::SIZE_WOXGA, PHPVideoToolkit::SIZE_WQSXGA, PHPVideoToolkit::SIZE_WQUXGA, PHPVideoToolkit::SIZE_WHSXGA, PHPVideoToolkit::SIZE_WHUXGA, PHPVideoToolkit::SIZE_CGA, PHPVideoToolkit::SIZE_EGA, PHPVideoToolkit::SIZE_HD480, PHPVideoToolkit::SIZE_HD720, PHPVideoToolkit::SIZE_HD1080. You can also manually set the width and height.',
    128. 

  128. 			'setVideoOutputDimensions_sas_dim' 				=> 'It was not possible to determine the input video dimensions so it was not possible to continue. If you wish to override this error please change the call to setVideoOutputDimensions and add a true argument to the arguments list... setVideoOutputDimensions(PHPVideoToolkit::SIZE_SAS, true);',
    129. 

  129. 			'setVideoOutputDimensions_valid_integer' 		=> 'You tried to set the video output dimensions to an odd number. FFmpeg requires that the video output dimensions are of event value and divisible by 2. ie 2, 4, 6,... etc',
    130. 

  130. 			'setVideoAspectRatio_valid_ratio' 				=> 'Value "#ratio" set from $toolkit->setVideoOutputDimensions, is not a valid preset dimension. Valid values are PHPVideoToolkit::RATIO_STANDARD, PHPVideoToolkit::RATIO_WIDE, PHPVideoToolkit::RATIO_CINEMATIC. If you wish to specifically try to set another video aspect ratio you should use the advanced function $toolkit->addCommand. Set $command to "-aspect" and $argument to your required value.',
    131. 

  131. 			'addWatermark_img_404' 							=> 'Watermark file "#watermark" does not exist.',
    132. 

  132. 			'addWatermark_vhook_disabled' 					=> 'Vhooking is not enabled in your FFmpeg binary. In order to allow video watermarking you must have FFmpeg compiled with --enable-vhook set. You can however watermark any extracted images using GD. To enable frame watermarking, call $toolkit->addGDWatermark($file) before you execute the extraction.',
    133. 

  133. 			'addVideo_file_404' 							=> 'File "#file" does not exist.',
    134. 

  134. 			'setOutput_output_dir_404' 						=> 'Output directory "#dir" does not exist!',
    135. 

  135. 			'setOutput_output_dir_writable' 				=> 'Output directory "#dir" is not writable!',
    136. 

  136. 			'setOutput_%_missing' 							=> 'The output of this command will be images yet you have not included the "%index" or "%timecode" in the $output_name.',
    137. 

  137. 			'setOutput_%d_depreciated' 						=> 'The use of %d in the output file name is now depreciated. Please use %index. Number padding is still supported. You may also use %timecode instead to add a timecode to the filename.',
    138. 

  138. 			'execute_input_404' 							=> 'Execute error. Input file missing.',
    139. 

  139. 			'execute_output_not_set' 						=> 'Execute error. Output not set.',
    140. 

  140. 			'execute_overwrite_process' 					=> 'Execute error. A file exists in the temp directory and is of the same name as this process file. It will conflict with this conversion. Conversion stopped.',
    141. 

  141. 			'execute_overwrite_fail' 						=> 'Execute error. Output file exists. Process halted. If you wish to automatically overwrite files set the third argument in "PHPVideoToolkit::setOutput();" to "PHPVideoToolkit::OVERWRITE_EXISTING".',
    142. 

  142. 			'execute_partial_error' 						=> 'Execute error. Output for file "#input" encountered a partial error. Files were generated, however one or more of them were empty.',
    143. 

  143. 			'execute_image_error' 							=> 'Execute error. Output for file "#input" was not found. No images were generated.',
    144. 

  144. 			'execute_output_404' 							=> 'Execute error. Output for file "#input" was not found. Please check server write permissions and/or available codecs compiled with FFmpeg. You can check the encode decode availability by inspecting the output array from PHPVideoToolkit::getFFmpegInfo().',
    145. 

  145. 			'execute_output_empty' 							=> 'Execute error. Output for file "#input" was found, but the file contained no data. Please check the available codecs compiled with FFmpeg can support this type of conversion. You can check the encode decode availability by inspecting the output array from PHPVideoToolkit::getFFmpegInfo().',
    146. 

  146. 			'execute_image_file_exists'						=> 'Execute error. There is a file name conflict. The file "#file" already exists in the filesystem. If you wish to automatically overwrite files set the third argument in "PHPVideoToolkit::setOutput();" to "PHPVideoToolkit::OVERWRITE_EXISTING".',
    147. 

  147. 			'execute_result_ok_but_unwritable'				=> 'Process Partially Completed. The process successfully completed however it was not possible to output to "#output". The output was left in the temp directory "#process" for a manual file movement.',
    148. 

  148. 			'execute_result_ok'								=> 'Process Completed. The process successfully completed. Output was generated to "#output".',
    149. 

  149. 			
    150. 

  150. 			'ffmpeg_log_ffmpeg_output'						=> 'OUTPUT',
    151. 

  151. 			'ffmpeg_log_ffmpeg_result'						=> 'RESULT',
    152. 

  152. 			'ffmpeg_log_ffmpeg_command'						=> 'COMMAND',
    153. 

  153. 			'ffmpeg_log_ffmpeg_join_gunk'					=> 'FFMPEG JOIN OUTPUT',
    154. 

  154. 			'ffmpeg_log_ffmpeg_gunk'						=> 'FFMPEG OUTPUT',
    155. 

  155. 			'ffmpeg_log_separator'							=> '-------------------------------'
    156. 

  156. 			
    157. 

  157. 		);
    158. 

  158. 		
    159. 

  159. 		/**
    160. 

  160. 		 * Process Results from PHPVideoToolkit::execute
    161. 

  161. 		 */
    162. 

  162. // 		any return value with this means everything is ok
    163. 

  163. 		const RESULT_OK 				= true;
    164. 

  164. // 		any return value with this means the file has been processed/converted ok however it was 
    165. 

  165. // 		not able to be written to the output address. If this occurs you will need to move the
    166. 

  166. // 		processed file manually from the temp location
    167. 

  167. 		const RESULT_OK_BUT_UNWRITABLE 	= -1;
    168. 

  168. 		
    169. 

  169. 		/**
    170. 

  170. 		 * Codec support constants
    171. 

  171. 		 */
    172. 

  172. 		const ENCODE		   		 	= 'encode';
    173. 

  173. 		const DECODE					= 'decode';
    174. 

  174. 		
    175. 

  175. 		/**
    176. 

  176. 		 * Overwrite constants used in setOutput
    177. 

  177. 		 */
    178. 

  178. 		const OVERWRITE_FAIL			= 'fail';
    179. 

  179. 		const OVERWRITE_PRESERVE		= 'preserve';
    180. 

  180. 		const OVERWRITE_EXISTING		= 'existing';
    181. 

  181. 		const OVERWRITE_UNIQUE			= 'unique';
    182. 

  182. 		
    183. 

  183. 		/**
    184. 

  184. 		 * Formats supported
    185. 

  185. 		 * 3g2             3gp2 format
    186. 

  186. 		 * 3gp             3gp format
    187. 

  187. 		 * aac             ADTS AAC
    188. 

  188. 		 * aiff            Audio IFF
    189. 

  189. 		 * amr             3gpp amr file format
    190. 

  190. 		 * asf             asf format
    191. 

  191. 		 * avi             avi format
    192. 

  192. 		 * flv             flv format
    193. 

  193. 		 * gif             GIF Animation
    194. 

  194. 		 * mov             mov format
    195. 

  195. 		 * mov,mp4,m4a,3gp,3g2,mj2 QuickTime/MPEG4/Motion JPEG 2000 format
    196. 

  196. 		 * mp2             MPEG audio layer 2
    197. 

  197. 		 * mp3             MPEG audio layer 3
    198. 

  198. 		 * mp4             mp4 format
    199. 

  199. 		 * mpeg            MPEG1 System format
    200. 

  200. 		 * mpeg1video      MPEG video
    201. 

  201. 		 * mpeg2video      MPEG2 video
    202. 

  202. 		 * mpegvideo       MPEG video
    203. 

  203. 		 * psp             psp mp4 format
    204. 

  204. 		 * rm              rm format
    205. 

  205. 		 * swf             Flash format
    206. 

  206. 		 * vob             MPEG2 PS format (VOB)
    207. 

  207. 		 * wav             wav format
    208. 

  208. 		 * jpeg            mjpeg format
    209. 

  209. 		 * yuv4mpegpipe    yuv4mpegpipe format
    210. 

  210. 		 */
    211. 

  211. 		const FORMAT_3GP2 			= '3g2';
    212. 

  212. 		const FORMAT_3GP 			= '3gp';
    213. 

  213. 		const FORMAT_AAC			= 'aac';
    214. 

  214. 		const FORMAT_AIFF 			= 'aiff';
    215. 

  215. 		const FORMAT_AMR 			= 'amr';
    216. 

  216. 		const FORMAT_ASF 			= 'asf';
    217. 

  217. 		const FORMAT_AVI			= 'avi';
    218. 

  218. 		const FORMAT_FLV 			= 'flv';
    219. 

  219. 		const FORMAT_GIF 			= 'gif';
    220. 

  220. 		const FORMAT_MJ2 			= 'mj2';
    221. 

  221. 		const FORMAT_MP2 			= 'mp2';
    222. 

  222. 		const FORMAT_MP3 			= 'mp3';
    223. 

  223. 		const FORMAT_MP4 			= 'mp4';
    224. 

  224. 		const FORMAT_MPEG4 			= 'mpeg4';
    225. 

  225. 		const FORMAT_M4A 			= 'm4a';
    226. 

  226. 		const FORMAT_MPEG 			= 'mpeg';
    227. 

  227. 		const FORMAT_MPEG1 			= 'mpeg1video';
    228. 

  228. 		const FORMAT_MPEG2 			= 'mpeg2video';
    229. 

  229. 		const FORMAT_MPEGVIDEO 		= 'mpegvideo';
    230. 

  230. 		const FORMAT_PSP 			= 'psp';
    231. 

  231. 		const FORMAT_RM 			= 'rm';
    232. 

  232. 		const FORMAT_SWF 			= 'swf';
    233. 

  233. 		const FORMAT_VOB 			= 'vob';
    234. 

  234. 		const FORMAT_WAV 			= 'wav';
    235. 

  235. 		const FORMAT_JPG 			= 'mjpeg';
    236. 

  236. 		const FORMAT_Y4MP 			= 'yuv4mpegpipe';
    237. 

  237. 		
    238. 

  238. 		/**
    239. 

  239. 		 * Size Presets
    240. 

  240. 		 */
    241. 

  241. 		const SIZE_SAS	 			= 'SameAsSource';
    242. 

  242. 		const SIZE_SQCIF 			= '128x96';
    243. 

  243. 		const SIZE_QCIF 			= '176x144';
    244. 

  244. 		const SIZE_CIF 				= '352x288';
    245. 

  245. 		const SIZE_4CIF 			= '704x576';
    246. 

  246. 		const SIZE_QQVGA 			= '160x120';
    247. 

  247. 		const SIZE_QVGA 			= '320x240';
    248. 

  248. 		const SIZE_VGA 				= '640x480';
    249. 

  249. 		const SIZE_SVGA 			= '800x600';
    250. 

  250. 		const SIZE_XGA 				= '1024x768';
    251. 

  251. 		const SIZE_UXGA 			= '1600x1200';
    252. 

  252. 		const SIZE_QXGA 			= '2048x1536';
    253. 

  253. 		const SIZE_SXGA 			= '1280x1024';
    254. 

  254. 		const SIZE_QSXGA 			= '2560x2048';
    255. 

  255. 		const SIZE_HSXGA 			= '5120x4096';
    256. 

  256. 		const SIZE_WVGA 			= '852x480';
    257. 

  257. 		const SIZE_WXGA 			= '1366x768';
    258. 

  258. 		const SIZE_WSXGA 			= '1600x1024';
    259. 

  259. 		const SIZE_WUXGA 			= '1920x1200';
    260. 

  260. 		const SIZE_WOXGA 			= '2560x1600';
    261. 

  261. 		const SIZE_WQSXGA 			= '3200x2048';
    262. 

  262. 		const SIZE_WQUXGA 			= '3840x2400';
    263. 

  263. 		const SIZE_WHSXGA 			= '6400x4096';
    264. 

  264. 		const SIZE_WHUXGA 			= '7680x4800';
    265. 

  265. 		const SIZE_CGA 				= '320x200';
    266. 

  266. 		const SIZE_EGA				= '640x350';
    267. 

  267. 		const SIZE_HD480 			= '852x480';
    268. 

  268. 		const SIZE_HD720 			= '1280x720';
    269. 

  269. 		const SIZE_HD1080			= '1920x1080';
    270. 

  270. 		
    271. 

  271. 		/**
    272. 

  272. 		 * Ratio Presets
    273. 

  273. 		 */
    274. 

  274. 		const RATIO_STANDARD		= '4:3';
    275. 

  275. 		const RATIO_WIDE			= '16:9';
    276. 

  276. 		const RATIO_CINEMATIC		= '1.85';
    277. 

  277. 		
    278. 

  278. 		/**
    279. 

  279. 		 * A public var that is to the information available about
    280. 

  280. 		 * the current ffmpeg compiled binary.
    281. 

  281. 		 * @var mixed
    282. 

  282. 		 * @access public
    283. 

  283. 		 */
    284. 

  284. 		public static $ffmpeg_info		= false;
    285. 

  285. 

  286. 		/**
    287. 

  287. 		 * A private var that contains the info of any file that is accessed by PHPVideoToolkit::getFileInfo();
    288. 

  288. 		 * @var array
    289. 

  289. 		 * @access private
    290. 

  290. 		 */
    291. 

  291. 		private static $_file_info		= array();
    292. 

  292. 

  293. 		/**
    294. 

  294. 		 * Determines what happens when an error occurs
    295. 

  295. 		 * @var boolean If true then the script will die, if not false is return by the error
    296. 

  296. 		 * @access public
    297. 

  297. 		 */
    298. 

  298. 		public $on_error_die			= false;
    299. 

  299. 

  300. 		/**
    301. 

  301. 		 * Holds the log file name
    302. 

  302. 		 * @var string
    303. 

  303. 		 * @access private
    304. 

  304. 		 */
    305. 

  305. 		private $_log_file				= null;
    306. 

  306. 

  307. 		/**
    308. 

  308. 		 * Determines if when outputting image frames if the outputted files should have the %d number
    309. 

  309. 		 * replaced with the frames timecode.
    310. 

  310. 		 * @var boolean If true then the files will be renamed.
    311. 

  311. 		 * @access public
    312. 

  312. 		 */
    313. 

  313. 		public $image_output_timecode 	= true;
    314. 

  314. 

  315. 		/**
    316. 

  316. 		 * Holds the timecode separator for when using $image_output_timecode = true
    317. 

  317. 		 * Not all systems allow ':' in filenames.
    318. 

  318. 		 * @var string
    319. 

  319. 		 * @access public
    320. 

  320. 		 */
    321. 

  321. 		public $timecode_seperator_output = '-';
    322. 

  322. 

  323. 		/**
    324. 

  324. 		 * Holds the starting time code when outputting image frames.
    325. 

  325. 		 * @var string The timecode hh(n):mm:ss:ff
    326. 

  326. 		 * @access private
    327. 

  327. 		 */
    328. 

  328. 		private $_image_output_timecode_start = '00:00:00.00';
    329. 

  329. 

  330. 		/**
    331. 

  331. 		 * The format in which the image %timecode placeholder string is outputted.
    332. 

  332. 		 * 	- %hh (hours) representative of hours
    333. 

  333. 		 * 	- %mm (minutes) representative of minutes
    334. 

  334. 		 * 	- %ss (seconds) representative of seconds
    335. 

  335. 		 * 	- %fn (frame number) representative of frames (of the current second, not total frames)
    336. 

  336. 		 * 	- %ms (milliseconds) representative of milliseconds (of the current second, not total milliseconds) (rounded to 3 decimal places)
    337. 

  337. 		 * 	- %ft (frames total) representative of total frames (ie frame number)
    338. 

  338. 		 * 	- %st (seconds total) representative of total seconds (rounded).
    339. 

  339. 		 * 	- %sf (seconds floored) representative of total seconds (floored).
    340. 

  340. 		 * 	- %mt (milliseconds total) representative of total milliseconds. (rounded to 3 decimal places)
    341. 

  341. 		 * NOTE; there are special characters that will be replace by PHPVideoToolkit::$timecode_seperator_output, these characters are
    342. 

  342. 		 * 	- :
    343. 

  343. 		 *  - .
    344. 

  344. 		 * @var string 
    345. 

  345. 		 * @access public
    346. 

  346. 		 */
    347. 

  347. 		private $image_output_timecode_format = '%hh-%mm-%ss-%fn';
    348. 

  348. 

  349. 		/**
    350. 

  350. 		 * Holds the fps of image extracts
    351. 

  351. 		 * @var integer
    352. 

  352. 		 * @access private
    353. 

  353. 		 */
    354. 

  354. 		private $_image_output_timecode_fps = 1;
    355. 

  355. 

  356. 		/**
    357. 

  357. 		 * Holds the current execute commands that will need to be combined
    358. 

  358. 		 * @var array
    359. 

  359. 		 * @access private
    360. 

  360. 		 */
    361. 

  361. 		private $_commands 			= array();
    362. 

  362. 

  363. 		/**
    364. 

  364. 		 * Holds the commands executed
    365. 

  365. 		 * @var array
    366. 

  366. 		 * @access private
    367. 

  367. 		 */
    368. 

  368. 		private $_processed 		= array();
    369. 

  369. 

  370. 		/**
    371. 

  371. 		 * Holds the file references to those that have been processed
    372. 

  372. 		 * @var array
    373. 

  373. 		 * @access private
    374. 

  374. 		 */
    375. 

  375. 		private $_files	 			= array();
    376. 

  376. 

  377. 		/**
    378. 

  378. 		 * Holds the errors encountered
    379. 

  379. 		 * @access private
    380. 

  380. 		 * @var array
    381. 

  381. 		 */
    382. 

  382. 		private $_errors 			= array();
    383. 

  383. 

  384. 		/**
    385. 

  385. 		 * Holds the input file / input file sequence
    386. 

  386. 		 * @access private
    387. 

  387. 		 * @var string
    388. 

  388. 		 */
    389. 

  389. 		private $_input_file 		= null;
    390. 

  390. 

  391. 		/**
    392. 

  392. 		 * Holds the output file / output file sequence
    393. 

  393. 		 * @access private
    394. 

  394. 		 * @var string
    395. 

  395. 		 */
    396. 

  396. 		private $_output_address 	= null;
    397. 

  397. 

  398. 		/**
    399. 

  399. 		 * Holds the process file / process file sequence
    400. 

  400. 		 * @access private
    401. 

  401. 		 * @var string
    402. 

  402. 		 */
    403. 

  403. 		private $_process_address 	= null;
    404. 

  404. 

  405. 		/**
    406. 

  406. 		 * Temporary filename prefix
    407. 

  407. 		 * @access private
    408. 

  408. 		 * @var string
    409. 

  409. 		 */
    410. 

  410. 		private $_tmp_file_prefix	= 'tmp_';
    411. 

  411. 

  412. 		/**
    413. 

  413. 		 * Holds the temporary directory name
    414. 

  414. 		 * @access private
    415. 

  415. 		 * @var string
    416. 

  416. 		 */
    417. 

  417. 		private $_tmp_directory 	= null;
    418. 

  418. 

  419. 		/**
    420. 

  420. 		 * Holds the directory paths that need to be removed by the ___destruct function
    421. 

  421. 		 * @access private
    422. 

  422. 		 * @var array
    423. 

  423. 		 */
    424. 

  424. 		private $_unlink_dirs		= array();
    425. 

  425. 

  426. 		/**
    427. 

  427. 		 * Holds the file paths that need to be deleted by the ___destruct function
    428. 

  428. 		 * @access private
    429. 

  429. 		 * @var array
    430. 

  430. 		 */
    431. 

  431. 		private $_unlink_files		= array();
    432. 

  432. 

  433. 		/**
    434. 

  434. 		 * Holds the timer start micro-float.
    435. 

  435. 		 * @access private
    436. 

  436. 		 * @var integer
    437. 

  437. 		 */
    438. 

  438. 		private $_timer_start		= 0;
    439. 

  439. 		
    440. 

  440. 		/**
    441. 

  441. 		 * Holds the times taken to process each file.
    442. 

  442. 		 * @access private
    443. 

  443. 		 * @var array
    444. 

  444. 		 */
    445. 

  445. 		private $_timers			= array();
    446. 

  446. 

  447. 		/**
    448. 

  448. 		 * Holds the times taken to process each file.
    449. 

  449. 		 * @access private
    450. 

  450. 		 * @var constant
    451. 

  451. 		 */
    452. 

  452. 		private $_overwrite_mode	= null;
    453. 

  453. 

  454. 		/**
    455. 

  455. 		 * Holds a integer value that flags if the image extraction is just a single frame.
    456. 

  456. 		 * @access private
    457. 

  457. 		 * @var integer
    458. 

  458. 		 */
    459. 

  459. 		private $_single_frame_extraction	= null;
    460. 

  460. 

  461. 		/**
    462. 

  462. 		 * Holds the watermark file that is used to watermark any outputted images via GD.
    463. 

  463. 		 * @access private
    464. 

  464. 		 * @var string
    465. 

  465. 		 */
    466. 

  466. 		private $_watermark_url	= null;
    467. 

  467. 

  468. 		/**
    469. 

  469. 		 * Holds the watermark options used to watermark any outputted images via GD.
    470. 

  470. 		 * @access private
    471. 

  471. 		 * @var array
    472. 

  472. 		 */
    473. 

  473. 		private $_watermark_options	= null;
    474. 

  474. 

  475. 		/**
    476. 

  476. 		 * Holds the number of files processed per run.
    477. 

  477. 		 * @access private
    478. 

  478. 		 * @var integer
    479. 

  479. 		 */
    480. 

  480. 		private $_process_file_count = 0;
    481. 

  481. 

  482. 		/**
    483. 

  483. 		 * Holds the times taken to process each file.
    484. 

  484. 		 * @access private
    485. 

  485. 		 * @var array
    486. 

  486. 		 */
    487. 

  487. 		private $_post_processes	= array();
    488. 

  488. 		
    489. 

  489. 		/**
    490. 

  490. 		 * Holds the times taken to process each file.
    491. 

  491. 		 * @access private
    492. 

  492. 		 * @var array
    493. 

  493. 		 */
    494. 

  494. 		private static $_static			= true;
    495. 

  495. 		
    496. 

  496. 		/**
    497. 

  497. 		 * Holds commands should be sent added to the exec before the input file, this is by no means a definitive list
    498. 

  498. 		 * of all the ffmpeg commands, as it only utilizes the ones in use by this class. Also only commands that have 
    499. 

  499. 		 * specific required places are entered in the arrays below. Anything not in these arrays will be treated as an 
    500. 

  500. 		 * after-input item.
    501. 

  501. 		 * @access private
    502. 

  502. 		 * @var array
    503. 

  503. 		 */
    504. 

  504. // 		private $_cmds_before_input		= array();
    505. 

  505. 		private $_cmds_before_input		= array('-inputr');
    506. 

  506. // 		private $_cmds_before_input		= array('-r', '-f');
    507. 

  507. 

  508. 		/**
    509. 

  509. 		 * Constructs the class and sets the temporary directory.
    510. 

  510. 		 *
    511. 

  511. 		 * @access private
    512. 

  512. 		 * @param string $tmp_directory A full absolute path to you temporary directory
    513. 

  513. 		 */
    514. 

  514. 		function __construct($tmp_directory='/tmp/')
    515. 

  515. 		{
    516. 

  516. 			$this->_tmp_directory = $tmp_directory;
    517. 

  517. 			PHPVideoToolkit::$_static = false;
    518. 

  518. 		}
    519. 

  519. 		
    520. 

  520. 		public static function microtimeFloat()
    521. 

  521. 		{
    522. 

  522. 		    list($usec, $sec) = explode(" ", microtime());
    523. 

  523. 		    return ((float) $usec + (float) $sec);
    524. 

  524. 		}
    525. 

  525. 

  526. 		/**
    527. 

  527. 		 * Resets the class
    528. 

  528. 		 *
    529. 

  529. 		 * @access public
    530. 

  530. 		 * @param boolean $keep_input_file Determines whether or not to reset the input file currently set.
    531. 

  531. 		 */
    532. 

  532. 		public function reset($keep_input_file=false, $keep_processes=false)
    533. 

  533. 		{
    534. 

  534. 			if($keep_input_file === false)
    535. 

  535. 			{
    536. 

  536. 				$this->_input_file = null;
    537. 

  537. 			}
    538. 

  538. 			if($keep_processes === false)
    539. 

  539. 			{
    540. 

  540. 				$this->_post_processes = array();
    541. 

  541. 			}
    542. 

  542. 			$this->_single_frame_extraction = null;
    543. 

  543. 			$this->_output_address = null;
    544. 

  544. 			$this->_process_address = null;
    545. 

  545. 			$this->_log_file = null;
    546. 

  546. 			$this->_commands = array();
    547. 

  547. 			$this->_timer_start = 0;
    548. 

  548. 			$this->_process_file_count = 0;
    549. 

  549. 			$this->__destruct();
    550. 

  550. 		}
    551. 

  551. 

  552. 		/**
    553. 

  553. 		 * Returns information about the specified file without having to use ffmpeg-php
    554. 

  554. 		 * as it consults the ffmpeg binary directly. 
    555. 

  555. 		 * 
    556. 

  556. 		 * @access public
    557. 

  557. 		 * @param string $tmp_directory A full absolute path to you temporary directory. Only needed in a static call.
    558. 

  558. 		 * @return mixed false on error encountered, true otherwise
    559. 

  559. 		 **/
    560. 

  560. 		public function getFFmpegInfo($tmp_directory='/tmp/')
    561. 

  561. 		{
    562. 

  562. // 			check to see if the info has already been cached
    563. 

  563. 			if(PHPVideoToolkit::$ffmpeg_info !== false)
    564. 

  564. 			{
    565. 

  565. 				return PHPVideoToolkit::$ffmpeg_info;
    566. 

  566. 			}
    567. 

  567. // 			check to see if this is a static call
    568. 

  568. 			if(PHPVideoToolkit::$_static === true)
    569. 

  569. 			{     
    570. 

  570. 				$toolkit = new PHPVideoToolkit($tmp_directory);
    571. 

  571. 				return $toolkit->getFFmpegInfo();
    572. 

  572. 			}
    573. 

  573. 			$format = '';
    574. 

  574. // 			$info_file = $this->_tmp_directory.$this->unique('ffinfo').'.info';
    575. 

  575. // 			execute the ffmpeg lookup
    576. 

  576. // 			exec(PHPVIDEOTOOLKIT_FFMPEG_BINARY.' -formats &> '.$info_file);
    577. 

  577. 			exec(PHPVIDEOTOOLKIT_FFMPEG_BINARY.' -formats 2>&1', $buffer);
    578. 

  578. 			$buffer = implode("\r\n", $buffer);
    579. 

  579. // 			die($buffer);
    580. 

  580. // 			$data = false;
    581. 

  581. // 			try to open the file
    582. 

  582. // 			$handle = fopen($info_file, 'r');
    583. 

  583. // 			if($handle)
    584. 

  584. // 			{
    585. 

  585. 				$data = array();
    586. 

  586. // 				$buffer = '';
    587. 

  587. // 				loop through the lines of data and collect the buffer
    588. 

  588. // 			    while (!feof($handle))
    589. 

  589. // 				{
    590. 

  590. // 			        $buffer .= fgets($handle, 4096);
    591. 

  591. // 				}
    592. 

  592. // 				echo($buffer);
    593. 

  593. 				$data['compiler'] = array();
    594. 

  594. 				$look_ups = array('configuration'=>'configuration: ', 'formats'=>'File formats:', 'codecs'=>'Codecs:', 'filters'=>'Bitstream filters:', 'protocols'=>'Supported file protocols:', 'abbreviations'=>'Frame size, frame rate abbreviations:', 'Note:');
    595. 

  595. 				$total_lookups = count($look_ups);
    596. 

  596. 				$pregs = array();
    597. 

  597. 				$indexs = array();
    598. 

  598. 				foreach($look_ups as $key=>$reg)
    599. 

  599. 				{
    600. 

  600. 					if(strpos($buffer, $reg) !== false)
    601. 

  601. 					{
    602. 

  602. 						$index = array_push($pregs, $reg);
    603. 

  603. 						$indexs[$key] = $index;
    604. 

  604. 					}
    605. 

  605. 				}
    606. 

  606. 				preg_match('/'.implode('(.*)', $pregs).'/s', $buffer, $matches);
    607. 

  607. 				$configuration = trim($matches[$indexs['configuration']]);
    608. 

  608. // 				grab the ffmpeg configuration flags
    609. 

  609. 				preg_match_all('/--[a-zA-Z0-9\-]+/', $configuration, $config_flags);
    610. 

  610. 				$data['compiler']['configuration'] = $config_flags[0];
    611. 

  611. 				$data['compiler']['vhook-support'] = in_array('--enable-vhook', $config_flags[0]) && !in_array('--disable-vhook', $config_flags[0]);
    612. 

  612. // 				grab the versions
    613. 

  613. 				$data['compiler']['versions'] = array();
    614. 

  614. 				preg_match_all('/([a-zA-Z0-9\-]+) version: ([0-9\.]+)/', $configuration, $versions);
    615. 

  615. 				for($i=0, $a=count($versions[0]); $i<$a; $i++)
    616. 

  616. 				{
    617. 

  617. 					$data['compiler']['versions'][strtolower(trim($versions[1][$i]))] = $versions[2][$i];
    618. 

  618. 				}
    619. 

  619. // 				grab the ffmpeg compile info
    620. 

  620. 				preg_match('/built on (.*), gcc: (.*)/', $configuration, $conf);
    621. 

  621. 				if(count($conf) > 0)
    622. 

  622. 				{
    623. 

  623. 					$data['compiler']['gcc'] = $conf[2];
    624. 

  624. 					$data['compiler']['build_date'] = $conf[1];
    625. 

  625. 					$data['compiler']['build_date_timestamp'] = strtotime($conf[1]);
    626. 

  626. 				}
    627. 

  627. // 				grab the file formats available to ffmpeg
    628. 

  628. 				preg_match_all('/ (DE|D|E) (.*) {1,} (.*)/', trim($matches[$indexs['formats']]), $formats);
    629. 

  629. 				$data['formats'] = array();
    630. 

  630. // 				loop and clean
    631. 

  631. 				for($i=0, $a=count($formats[0]); $i<$a; $i++)
    632. 

  632. 				{
    633. 

  633. 					$data['formats'][strtolower(trim($formats[2][$i]))] = array(
    634. 

  634. 						'encode' 	=> $formats[1][$i] == 'DE' || $formats[1][$i] == 'E',
    635. 

  635. 						'decode' 	=> $formats[1][$i] == 'DE' || $formats[1][$i] == 'D',
    636. 

  636. 						'fullname'	=> $formats[3][$i]
    637. 

  637. 					);
    638. 

  638. 				}
    639. 

  639. // 				grab the bitstream filters available to ffmpeg
    640. 

  640. 				$data['filters'] = array();
    641. 

  641. 				if(isset($indexs['filters']) && isset($matches[$indexs['filters']]))
    642. 

  642. 				{
    643. 

  643. 					$filters = trim($matches[$indexs['filters']]);
    644. 

  644. 					if(empty($filters))
    645. 

  645. 					{
    646. 

  646. 						$data['filters'] = explode(' ', $filters);
    647. 

  647. 					}
    648. 

  648. 				}
    649. 

  649. // 				grab the file prototcols available to ffmpeg
    650. 

  650. 				$data['filters'] = array();
    651. 

  651. 				if(isset($indexs['protocols']) && isset($matches[$indexs['protocols']]))
    652. 

  652. 				{
    653. 

  653. 					$protocols = trim($matches[$indexs['protocols']]);
    654. 

  654. 					if(empty($protocols))
    655. 

  655. 					{
    656. 

  656. 						$data['protocols'] = explode(' ', str_replace(':', '', $protocols));
    657. 

  657. 					}
    658. 

  658. 				}
    659. 

  659. // 				grab the abbreviations available to ffmpeg
    660. 

  660. 				$data['abbreviations'] = array();
    661. 

  661. 				if(isset($indexs['abbreviations']) && isset($matches[$indexs['abbreviations']]))
    662. 

  662. 				{
    663. 

  663. 					$abbreviations = trim($matches[$indexs['abbreviations']]);
    664. 

  664. 					if(empty($abbreviations))
    665. 

  665. 					{
    666. 

  666. 						$data['abbreviations'] = explode(' ', $abbreviations);
    667. 

  667. 					}
    668. 

  668. 				}
    669. 

  669. 				PHPVideoToolkit::$ffmpeg_info = $data;
    670. 

  670. // 			}
    671. 

  671. // 			fclose($handle);
    672. 

  672. // 			if(is_file($info_file))
    673. 

  673. // 			{
    674. 

  674. //	 			if the info file exists remove it
    675. 

  675. // 				unlink($info_file);
    676. 

  676. // 			}
    677. 

  677. 			$data['ffmpeg-php-support'] = $this->hasFFmpegPHPSupport();
    678. 

  678. 			return $data;
    679. 

  679. 		}
    680. 

  680. 		
    681. 

  681. 		/**
    682. 

  682. 		 * Determines if your ffmpeg has particular codec support for encode or decode.
    683. 

  683. 		 * 
    684. 

  684. 		 * @access public
    685. 

  685. 		 * @param string $codec The name of the codec you are checking for. 
    686. 

  686. 		 * @param const $support PHPVideoToolkit::ENCODE or PHPVideoToolkit::DECODE, depending on which functionality is desired.
    687. 

  687. 		 * @return mixed. Boolean false if there is no support, true if there is support.
    688. 

  688. 		 */
    689. 

  689. 		public function hasCodecSupport($codec, $support=PHPVideoToolkit::ENCODE)
    690. 

  690. 		{      
    691. 

  691. 			$codec = strtolower($codec);
    692. 

  692. 			$data = $this->getFFmpegInfo();     
    693. 

  693. 			return isset($data['formats'][$codec]) ? $data['formats'][$codec][$support] : false;
    694. 

  694. 		}
    695. 

  695. 		
    696. 

  696. 		/**
    697. 

  697. 		 * Determines the type of support that exists for the FFmpeg-PHP module.
    698. 

  698. 		 * 
    699. 

  699. 		 * @access public
    700. 

  700. 		 * @return mixed. Boolean false if there is no support, String 'module' if the actuall
    701. 

  701. 		 * 		FFmpeg-PHP module is loaded, or String 'emulated' if the FFmpeg-PHP classes
    702. 

  702. 		 * 		can be emulated through the adapter classes.
    703. 

  703. 		 */
    704. 

  704. 		public function hasFFmpegPHPSupport()
    705. 

  705. 		{
    706. 

  706. 			return extension_loaded('ffmpeg') ? 'module' : (is_file(dirname(__FILE__).DIRECTORY_SEPARATOR.'adapters'.DIRECTORY_SEPARATOR.'ffmpeg-php'.DIRECTORY_SEPARATOR.'ffmpeg_movie.php') && is_file(dirname(__FILE__).DIRECTORY_SEPARATOR.'adapters'.DIRECTORY_SEPARATOR.'ffmpeg-php'.DIRECTORY_SEPARATOR.'ffmpeg_frame.php') && is_file(dirname(__FILE__).DIRECTORY_SEPARATOR.'adapters'.DIRECTORY_SEPARATOR.'ffmpeg-php'.DIRECTORY_SEPARATOR.'ffmpeg_animated_gif.php') ? 'emulated' : false);
    707. 

  707. 		}
    708. 

  708. 		
    709. 

  709. 		/**
    710. 

  710. 		 * Determines if the ffmpeg binary has been compiled with vhook support.
    711. 

  711. 		 * 
    712. 

  712. 		 * @access public
    713. 

  713. 		 * @return mixed. Boolean false if there is no support, true there is support.
    714. 

  714. 		 */
    715. 

  715. 		public function hasVHookSupport()
    716. 

  716. 		{
    717. 

  717. 			$info = $this->getFFmpegInfo();
    718. 

  718. 			return $info['compiler']['vhook-support'];
    719. 

  719. 		}
    720. 

  720. 		
    721. 

  721. 		/**
    722. 

  722. 		 * Returns information about the specified file without having to use ffmpeg-php
    723. 

  723. 		 * as it consults the ffmpeg binary directly. This idea for this function has been borrowed from
    724. 

  724. 		 * a French ffmpeg class located: http://www.phpcs.com/codesource.aspx?ID=45279
    725. 

  725. 		 * 
    726. 

  726. 		 * @access public
    727. 

  727. 		 * @todo Change the search from string explode to a regex based search
    728. 

  728. 		 * @param string $file The absolute path of the file that is required to be manipulated.
    729. 

  729. 		 * @return mixed false on error encountered, true otherwise
    730. 

  730. 		 **/
    731. 

  731. 		public function getFileInfo($file=false, $tmp_directory='/tmp/')
    732. 

  732. 		{
    733. 

  733. // 			check to see if this is a static call
    734. 

  734. 			if($file !== false && PHPVideoToolkit::$_static === true)
    735. 

  735. 			{     
    736. 

  736. 				$toolkit = new PHPVideoToolkit($tmp_directory);
    737. 

  737. 				return $toolkit->getFileInfo($file);
    738. 

  738. 			}
    739. 

  739. // 			if the file has not been specified check to see if an input file has been specified
    740. 

  740. 			if($file === false)
    741. 

  741. 			{
    742. 

  742. 				if(!$this->_input_file)
    743. 

  743. 				{
    744. 

  744. //					input file not valid
    745. 

  745. 					return $this->_raiseError('getFileInfo_no_input');
    746. 

  746. //<-				exits
    747. 

  747. 				}
    748. 

  748. 				$file = $this->_input_file;
    749. 

  749. 			}
    750. 

  750. 			$file = escapeshellarg($file);
    751. 

  751. // 			die($file);
    752. 

  752. // 			create a hash of the filename
    753. 

  753. 			$hash = md5($file);
    754. 

  754. // 			check to see if the info has already been generated
    755. 

  755. 			if(isset(self::$_file_info[$hash]))
    756. 

  756. 			{
    757. 

  757. 				return self::$_file_info[$hash];
    758. 

  758. 			}
    759. 

  759. // 			generate a random filename
    760. 

  760. 			$info_file = $this->_tmp_directory.$this->unique($hash).'.info';
    761. 

  761. 			
    762. 

  762. // 			execute the ffmpeg lookup
    763. 

  763. // 			exec(PHPVIDEOTOOLKIT_FFMPEG_BINARY.' -i '.$file.' &> '.$info_file); 
    764. 

  764. 			exec(PHPVIDEOTOOLKIT_FFMPEG_BINARY.' -i '.$file.' 2>&1', $buffer);
    765. 

  765. 			$buffer = implode("\r\n", $buffer);
    766. 

  766. 			
    767. 

  767. // 			$data = false;
    768. 

  768. // 			try to open the file
    769. 

  769. // 			$handle = fopen($info_file, 'r');
    770. 

  770. // 			if($handle)
    771. 

  771. // 			{
    772. 

  772. 				$data = array();
    773. 

  773. // 				$buffer = '';
    774. 

  774. // 				loop through the lines of data and collect the buffer
    775. 

  775. // 			    while (!feof($handle))
    776. 

  776. // 				{
    777. 

  777. // 			        $buffer .= fgets($handle, 4096);
    778. 

  778. // 				}
    779. 

  779. // die($buffer);
    780. 

  780. // 				grab the duration and bitrate data
    781. 

  781. 				preg_match_all('/Duration: (.*)/', $buffer, $matches);
    782. 

  782. 				if(count($matches) > 0)
    783. 

  783. 				{
    784. 

  784. 					$parts 								= explode(', ', trim($matches[1][0]));
    785. 

  785. 					$data['duration']					= array();
    786. 

  786. 					$timecode					 		= $parts[0];
    787. 

  787. 					$data['duration']['seconds'] 		= $this->timecodeToSeconds($timecode);
    788. 

  788. 					$data['bitrate']  					= intval(ltrim($parts[2], 'bitrate: '));
    789. 

  789. 					$data['duration']['start']  		= ltrim($parts[1], 'start: ');
    790. 

  790. 					$data['duration']['timecode']		= array();
    791. 

  791. 					$data['duration']['timecode']['rounded'] = substr($timecode, 0, 8);
    792. 

  792. 					$data['duration']['timecode']['seconds'] = array();
    793. 

  793. 					$data['duration']['timecode']['seconds']['exact']   = $timecode;
    794. 

  794. 					$data['duration']['timecode']['seconds']['excess']  = intval(substr($timecode, 9));
    795. 

  795. 				}
    796. 

  796. 				
    797. 

  797. // 				match the video stream info
    798. 

  798. 				preg_match('/Stream(.*): Video: (.*)/', $buffer, $matches);
    799. 

  799. 				if(count($matches) > 0)
    800. 

  800. 				{
    801. 

  801. 					$data['video'] 						= array();
    802. 

  802. // 					get the dimension parts
    803. 

  803. // print_r($matches);
    804. 

  804. 					preg_match('/([0-9]{1,5})x([0-9]{1,5})/', $matches[2], $dimensions_matches);
    805. 

  805. // 					print_r($dimensions_matches);
    806. 

  806. 					$dimensions_value = $dimensions_matches[0];
    807. 

  807. 					$data['video']['dimensions'] 	= array(
    808. 

  808. 						'width' 					=> floatval($dimensions_matches[1]),
    809. 

  809. 						'height' 					=> floatval($dimensions_matches[2])
    810. 

  810. 					);
    811. 

  811. // 					get the framerate
    812. 

  812. 					preg_match('/([0-9\.]+) (fps|tb)\(r\)/', $matches[0], $fps_matches);
    813. 

  813. 					$data['video']['frame_rate'] 	= floatval($fps_matches[1]);
    814. 

  814. 					$fps_value = $fps_matches[0];
    815. 

  815. // 					get the ratios
    816. 

  816. 					preg_match('/\[PAR ([0-9\:\.]+) DAR ([0-9\:\.]+)\]/', $matches[0], $ratio_matches);
    817. 

  817. 					if(count($ratio_matches))
    818. 

  818. 					{
    819. 

  819. 						$data['video']['pixel_aspect_ratio'] 	= $ratio_matches[1];
    820. 

  820. 						$data['video']['display_aspect_ratio'] 	= $ratio_matches[2];
    821. 

  821. 					}
    822. 

  822. // 					work out the number of frames
    823. 

  823. 					if(isset($data['duration']) && isset($data['video']))
    824. 

  824. 					{
    825. 

  825. // 						set the total frame count for the video
    826. 

  826. 						$data['video']['frame_count'] 						= ceil($data['duration']['seconds'] * $data['video']['frame_rate']);
    827. 

  827. // 						set the framecode
    828. 

  828. 						$frames												= ceil($data['video']['frame_rate']*($data['duration']['timecode']['seconds']['excess']/10));
    829. 

  829. 						$data['duration']['timecode']['frames'] 			= array();
    830. 

  830. 						$data['duration']['timecode']['frames']['exact']  	= $data['duration']['timecode']['rounded'].'.'.$frames;
    831. 

  831. 						$data['duration']['timecode']['frames']['excess'] 	= $frames;
    832. 

  832. 						$data['duration']['timecode']['frames']['total'] 	= $data['video']['frame_count'];
    833. 

  833. 					}
    834. 

  834. // 					formats should be anything left over, let me know if anything else exists
    835. 

  835. 					$parts 							= explode(',', $matches[2]);
    836. 

  836. 					$other_parts 					= array($dimensions_value, $fps_value);
    837. 

  837. 					$formats = array();
    838. 

  838. 					foreach($parts as $key=>$part)
    839. 

  839. 					{
    840. 

  840. 						$part = trim($part);
    841. 

  841. 						if(!in_array($part, $other_parts))
    842. 

  842. 						{
    843. 

  843. 							array_push($formats, $part);
    844. 

  844. 						}
    845. 

  845. 					}
    846. 

  846. 					$data['video']['pixel_format'] 	= $formats[1];
    847. 

  847. 					$data['video']['codec'] 		= $formats[0];
    848. 

  848. 				}
    849. 

  849. 				
    850. 

  850. // 				match the audio stream info
    851. 

  851. 				preg_match('/Stream(.*): Audio: (.*)/', $buffer, $matches);
    852. 

  852. 				if(count($matches) > 0)
    853. 

  853. 				{
    854. 

  854. // 					setup audio values
    855. 

  855. 					$data['audio'] = array(
    856. 

  856. 						'stereo'		=> -1, 
    857. 

  857. 						'sample_rate'	=> -1, 
    858. 

  858. 						'sample_rate'	=> -1
    859. 

  859. 					);
    860. 

  860. 					$other_parts = array();
    861. 

  861. // 					get the stereo value
    862. 

  862. 					preg_match('/(stereo|mono)/i', $matches[0], $stereo_matches);
    863. 

  863. 					if(count($stereo_matches))
    864. 

  864. 					{
    865. 

  865. 						$data['audio']['stereo'] 		= $stereo_matches[0];
    866. 

  866. 						array_push($other_parts, $stereo_matches[0]);
    867. 

  867. 					}
    868. 

  868. // 					get the sample_rate
    869. 

  869. 					preg_match('/([0-9]{3,6}) Hz/', $matches[0], $sample_matches);
    870. 

  870. 					if(count($sample_matches))
    871. 

  871. 					{
    872. 

  872. 						$data['audio']['sample_rate'] 	= count($sample_matches) ? floatval($sample_matches[1]) : -1;
    873. 

  873. 						array_push($other_parts, $sample_matches[0]);
    874. 

  874. 					}
    875. 

  875. // 					get the bit rate
    876. 

  876. 					preg_match('/([0-9]{1,3}) kb\/s/', $matches[0], $bitrate_matches);
    877. 

  877. 					if(count($bitrate_matches))
    878. 

  878. 					{
    879. 

  879. 						$data['audio']['bitrate'] 		= count($bitrate_matches) ? floatval($bitrate_matches[1]) : -1;
    880. 

  880. 						array_push($other_parts, $bitrate_matches[0]);
    881. 

  881. 					}
    882. 

  882. // 					formats should be anything left over, let me know if anything else exists
    883. 

  883. 					$parts 							= explode(',', $matches[2]);
    884. 

  884. 					$formats = array();
    885. 

  885. 					foreach($parts as $key=>$part)
    886. 

  886. 					{
    887. 

  887. 						$part = trim($part);
    888. 

  888. 						if(!in_array($part, $other_parts))
    889. 

  889. 						{
    890. 

  890. 							array_push($formats, $part);
    891. 

  891. 						}
    892. 

  892. 					}
    893. 

  893. 					$data['audio']['codec'] 		= $formats[0];
    894. 

  894. 				}
    895. 

  895. 

  896. //	 			check that some data has been obtained
    897. 

  897. 				if(!count($data))
    898. 

  898. 				{
    899. 

  899. 					$data = false;
    900. 

  900. 				}
    901. 

  901. 				else
    902. 

  902. 				{
    903. 

  903. 					$data['_raw_info'] = $buffer;
    904. 

  904. 				}
    905. 

  905. 				
    906. 

  906. // 			    fclose($handle);
    907. 

  907. // 			}
    908. 

  908. // 			if(is_file($info_file))
    909. 

  909. // 			{
    910. 

  910. //	 			if the info file exists remove it
    911. 

  911. // 				unlink($info_file);
    912. 

  912. // 			}
    913. 

  913. // 			cache info and return
    914. 

  914. 			return self::$_file_info[$hash] = $data;
    915. 

  915. 		}		
    916. 

  916. 

  917. 		/**
    918. 

  918. 		 * Sets the input file that is going to be manipulated.
    919. 

  919. 		 *
    920. 

  920. 		 * @access public
    921. 

  921. 		 * @param string $file The absolute path of the file that is required to be manipulated.
    922. 

  922. 		 * @param mixed $input_frame_rate If 0 (default) then no input frame rate is set, if false it is automatically retreived, otherwise
    923. 

  923. 		 * 		any other integer will be set as the incoming frame rate.
    924. 

  924. 		 * @return boolean false on error encountered, true otherwise
    925. 

  925. 		 */
    926. 

  926. 		public function setInputFile($file, $input_frame_rate=0)
    927. 

  927. 		{
    928. 

  928. 			$files_length = count($file);
    929. 

  929. // 			if the total number of files entered is 1 then only one file is being processed
    930. 

  930. 			if($files_length == 1)
    931. 

  931. 			{
    932. 

  932. //				check the input file, if there is a %d in there or a similar %03d then the file inputted is a sequence, if neither of those is found
    933. 

  933. //				then qheck to see if the file exists
    934. 

  934. 				if(!preg_match('/\%([0-9]+)d/', $file) && strpos($file, '%d') === false && !is_file($file))
    935. 

  935. 				{
    936. 

  936. //					input file not valid
    937. 

  937. 					return $this->_raiseError('setInputFile_file_existence', array('file'=>$file));
    938. 

  938. //<-				exits
    939. 

  939. 				}
    940. 

  940. 				$escaped_name = $file;
    941. 

  941. // 				$escaped_name = escapeshellarg($files[0]);
    942. 

  942. 				$this->_input_file = $escaped_name;
    943. 

  943. 				$this->_input_file_id = md5($escaped_name);
    944. 

  944. 				
    945. 

  945. // 				the -inputr is a hack for -r to come before the input
    946. 

  946. 				if($input_frame_rate !== 0)
    947. 

  947. 				{
    948. 

  948. 					$info = $this->getFileInfo();
    949. 

  949. 					if(isset($info['video']))
    950. 

  950. 					{
    951. 

  951. 						if($input_frame_rate === false)
    952. 

  952. 						{
    953. 

  953. 							$input_frame_rate = $info['video']['frame_rate'];
    954. 

  954. 						}
    955. 

  955. // 						input frame rate is a command hack
    956. 

  956. 						$this->addCommand('-inputr', $input_frame_rate);
    957. 

  957. 					}
    958. 

  958. 				}
    959. 

  959. 			}
    960. 

  960. 			else
    961. 

  961. 			{
    962. 

  962. // 				more than one video is being added as input so we must join them all
    963. 

  963. 				call_user_func_array(array(&$this, 'addVideo'), array($file, $input_frame_rate));
    964. 

  964. 			}
    965. 

  965. 			return true;
    966. 

  966. 		}
    967. 

  967. 		
    968. 

  968. 		/**
    969. 

  969. 		 * A shortcut for converting video to FLV.
    970. 

  970. 		 *
    971. 

  971. 		 * @access public
    972. 

  972. 		 * @param integer $audio_sample_frequency
    973. 

  973. 		 * @param integer $audio_bitrate
    974. 

  974. 		 */
    975. 

  975. 		public function setFormatToFLV($audio_sample_frequency=44100, $audio_bitrate=64)
    976. 

  976. 		{
    977. 

  977. 			$this->addCommand('-sameq');
    978. 

  978. 			$this->setAudioFormat(self::FORMAT_MP3);
    979. 

  979. //			adjust the audio rates
    980. 

  980. 			$this->setAudioBitRate($audio_bitrate);
    981. 

  981. 			$this->setAudioSampleFrequency($audio_sample_frequency);
    982. 

  982. //			set the video format
    983. 

  983. 			$this->setFormat(self::FORMAT_FLV);
    984. 

  984. //			flag that the flv has to have meta data added after the excecution of this command
    985. 

  985. // 			register the post tidy process
    986. 

  986. 			$this->registerPostProcess('_addMetaToFLV', $this);
    987. 

  987. 		}
    988. 

  988. 		
    989. 

  989. 		/**
    990. 

  990. 		 * When converting video to FLV the meta data has to be added by a ruby program called FLVTools2.
    991. 

  991. 		 * This is a second exec call only after the video has been converted to FLV
    992. 

  992. 		 * http://inlet-media.de/flvtool2
    993. 

  993. 		 *
    994. 

  994. 		 * @access private
    995. 

  995. 		 */
    996. 

  996. 		private function _addMetaToFLV($files)
    997. 

  997. 		{
    998. 

  998. 			$file = array_pop($files);
    999. 

  999. //			prepare the command suitable for exec
    1000. 

  1000. 			$exec_string = $this->_prepareCommand(PHPVIDEOTOOLKIT_FLVTOOLS_BINARY, '-U '.$file);
    1001. 

  1001. //			execute the command
    1002. 

  1002. 			exec($exec_string);
    1003. 

  1003. 			if(is_array($this->_processed[0]))
    1004. 

  1004. 			{
    1005. 

  1005. 				array_push($this->_processed[0], $exec_string);
    1006. 

  1006. 			}
    1007. 

  1007. 			else
    1008. 

  1008. 			{
    1009. 

  1009. 				$this->_processed[0] = array($this->_processed[0], $exec_string);
    1010. 

  1010. 			}
    1011. 

  1011. 			return true;
    1012. 

  1012. 		}
    1013. 

  1013. 		
    1014. 

  1014. 		/**
    1015. 

  1015. 		 * Streams a FLV file from a given point. You can control bandwidth, cache and session options.
    1016. 

  1016. 		 * Inspired by xmoov-php
    1017. 

  1017. 		 * @see xmoov-php, 
    1018. 

  1018. 		 * 		- @link http://xmoov.com/
    1019. 

  1019. 		 * 		- @author Eric Lorenzo Benjamin jr
    1020. 

  1020. 		 * @access public
    1021. 

  1021. 		 * @param integer $seek_pos The position in the file to seek to.
    1022. 

  1022. 		 * @param array|boolean $bandwidth_options If a boolean value, false then no bandwidth limiting will take place. 
    1023. 

  1023. 		 * 		If true then bandwidth limiting will take place with packet_size = 90 and packet_interval = 0.3.
    1024. 

  1024. 		 * 		If an array the following values are default packet_size = 90 and packet_interval = 0.3, you will also 
    1025. 

  1025. 		 * 		have to set active = true, ie array('active'=>true, 'packet_size'=>90, 'packet_interval'=>0.3)
    1026. 

  1026. 		 * @param boolean $allow_cache If true the file will be allowed to cache in the browser, if false then it won't
    1027. 

  1027. 		 * @return boolean
    1028. 

  1028. 		 */
    1029. 

  1029. 		public function flvStreamSeek($seek_pos=0, $bandwidth_options=array(), $allow_cache=true)
    1030. 

  1030. 		{
    1031. 

  1031. // 			check for input file
    1032. 

  1032. 			if(!$this->_input_file)
    1033. 

  1033. 			{
    1034. 

  1034. //				input file not valid
    1035. 

  1035. 				return $this->_raiseError('streamFLV_no_input');
    1036. 

  1036. //<-			exits
    1037. 

  1037. 			}
    1038. 

  1038. // 			make the pos safe
    1039. 

  1039.        		$seek_pos = intval($seek_pos);
    1040. 

  1040. // 			absorb the bandwidth options
    1041. 

  1041. 			$bandwidth_options = is_array($bandwidth_options) ? array_merge(array('active'=>false, 'packet_size'=>90, 'packet_interval'=>0.3), $bandwidth_options) : array('active'=>$bandwidth_options, 'packet_size'=>90, 'packet_interval'=>0.3);
    1042. 

  1042. // 			if this file is not allowed to be cached send cache headers for all browsers.
    1043. 

  1043. 			if(!$allow_cache)
    1044. 

  1044. 			{
    1045. 

  1045. 				session_cache_limiter('nocache');
    1046. 

  1046. 				header('Expires: Thu, 19 Nov 1981 08:52:00 GMT');
    1047. 

  1047. 				header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
    1048. 

  1048. 				header('Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0');
    1049. 

  1049. 				header('Pragma: no-cache');
    1050. 

  1050. 			}
    1051. 

  1051. // 			open file
    1052. 

  1052.             $handle = fopen($this->_input_file, 'rb');
    1053. 

  1053.             $file_size = filesize($this->_input_file) - (($seek_pos > 0) ? $seek_pos  + 1 : 0);
    1054. 

  1054. // 			send the flv headers
    1055. 

  1055. 			header('Content-Type: video/x-flv');
    1056. 

  1056. 			header('Content-Disposition: attachment; filename="'.basename($this->_input_file).'"');
    1057. 

  1057. 			header('Content-Length: '.$file_size);
    1058. 

  1058. // 			flv format header
    1059. 

  1059.             if($seek_pos != 0) 
    1060. 

  1060.             {
    1061. 

  1061.                 print('FLV');
    1062. 

  1062.                 print(pack('C', 1));
    1063. 

  1063.                 print(pack('C', 1));
    1064. 

  1064.                 print(pack('N', 9));
    1065. 

  1065.                 print(pack('N', 9));
    1066. 

  1066.             }
    1067. 

  1067. // 			seek to the required point
    1068. 

  1068.             if(fseek($handle, $seek_pos) === -1)
    1069. 

  1069. 			{
    1070. 

  1070. //				input file not valid
    1071. 

  1071. 				return $this->_raiseError('streamFLV_passed_eof');
    1072. 

  1072. //<-			exits
    1073. 

  1073. 			}
    1074. 

  1074. // 			if bandwidth control is active then workout the options
    1075. 

  1075. 			if($bandwidth_options['active'])
    1076. 

  1076. 			{
    1077. 

  1077.         		$packet_interval = intval($bandwidth_options['packet_interval']);
    1078. 

  1078.         		$packet_size = intval($bandwidth_options['packet_size']) * 1042;
    1079. 

  1079. 			}
    1080. 

  1080. // 			output the file
    1081. 

  1081. 			while(!feof($handle)) 
    1082. 

  1082. 			{
    1083. 

  1083. // 				limit the bandwidth
    1084. 

  1084. 				if($bandwidth_options['active'] && $packet_interval > 0)
    1085. 

  1085. 				{
    1086. 

  1086. // 					output the required packet
    1087. 

  1087. 					$time_start = self::microtimeFloat();
    1088. 

  1088. 					echo fread($handle, $packet_size);
    1089. 

  1089. 					$time_stop = self::microtimeFloat();
    1090. 

  1090. // 					delay the output
    1091. 

  1091. 					$time_difference = $time_stop - $time_start;
    1092. 

  1092. 					if($time_difference < $packet_interval)
    1093. 

  1093. 					{
    1094. 

  1094. 						usleep(($packet_interval * 1000000) - ($time_difference * 1000000));
    1095. 

  1095. 					}
    1096. 

  1096. 				}
    1097. 

  1097. // 				no bandwidth limiting
    1098. 

  1098. 				else
    1099. 

  1099. 				{
    1100. 

  1100. 					echo fread($handle, $file_size); 
    1101. 

  1101. 				}
    1102. 

  1102. 			}
    1103. 

  1103. // 			close the file
    1104. 

  1104.         	fclose($handle);
    1105. 

  1105. 			return true;
    1106. 

  1106. 		}
    1107. 

  1107. 

  1108. 		/**
    1109. 

  1109. 		 * This is an alias for setFormat, but restricts it to audio only formats.
    1110. 

  1110. 		 * 
    1111. 

  1111. 		 * @access public
    1112. 

  1112. 		 * @param integer $format A supported audio format.
    1113. 

  1113. 		 * @param integer $audio_sample_frequency
    1114. 

  1114. 		 * @param integer $audio_bitrate
    1115. 

  1115. 		 **/
    1116. 

  1116. 		public function extractAudio($format=PHPVideoToolkit::FORMAT_MP3, $audio_sample_frequency=44100, $audio_bitrate=64)
    1117. 

  1117. 		{
    1118. 

  1118. // 			check the format is one of the audio formats
    1119. 

  1119. 			if(!in_array($format, array(self::FORMAT_AAC, self::FORMAT_AIFF, self::FORMAT_MP2, self::FORMAT_MP3, self::FORMAT_MP4, self::FORMAT_MPEG4, self::FORMAT_M4A, self::FORMAT_WAV)))
    1120. 

  1120. 			{
    1121. 

  1121. 				return $this->_raiseError('extractAudio_valid_format', array('format'=>$format));
    1122. 

  1122. //<-			exits
    1123. 

  1123. 			}
    1124. 

  1124. 			$this->setFormat($format);
    1125. 

  1125. //			adjust the audio rates
    1126. 

  1126. 			$this->setAudioBitRate($audio_bitrate);
    1127. 

  1127. 			$this->setAudioSampleFrequency($audio_sample_frequency);
    1128. 

  1128. 		}
    1129. 

  1129. 

  1130. 		/**
    1131. 

  1131. 		 * Sets the new video format.
    1132. 

  1132. 		 *
    1133. 

  1133. 		 * @access public
    1134. 

  1134. 		 * @param defined $format The format should use one of the defined variables stated below.
    1135. 

  1135. 		 * 		PHPVideoToolkit::FORMAT_3GP2 - 3g2
    1136. 

  1136. 		 * 		PHPVideoToolkit::FORMAT_3GP - 3gp
    1137. 

  1137. 		 * 		PHPVideoToolkit::FORMAT_AAC - aac
    1138. 

  1138. 		 * 		PHPVideoToolkit::FORMAT_AIFF - aiff
    1139. 

  1139. 		 * 		PHPVideoToolkit::FORMAT_AMR - amr
    1140. 

  1140. 		 * 		PHPVideoToolkit::FORMAT_ASF - asf
    1141. 

  1141. 		 * 		PHPVideoToolkit::FORMAT_AVI - avi
    1142. 

  1142. 		 * 		PHPVideoToolkit::FORMAT_FLV - flv
    1143. 

  1143. 		 * 		PHPVideoToolkit::FORMAT_GIF - gif
    1144. 

  1144. 		 * 		PHPVideoToolkit::FORMAT_MJ2 - mj2
    1145. 

  1145. 		 * 		PHPVideoToolkit::FORMAT_MP2 - mp2
    1146. 

  1146. 		 * 		PHPVideoToolkit::FORMAT_MP3 - mp3
    1147. 

  1147. 		 * 		PHPVideoToolkit::FORMAT_MP4 - mp4
    1148. 

  1148. 		 * 		PHPVideoToolkit::FORMAT_MPEG4 - mpeg4
    1149. 

  1149. 		 * 		PHPVideoToolkit::FORMAT_M4A - m4a
    1150. 

  1150. 		 * 		PHPVideoToolkit::FORMAT_MPEG - mpeg
    1151. 

  1151. 		 * 		PHPVideoToolkit::FORMAT_MPEG1 - mpeg1video
    1152. 

  1152. 		 * 		PHPVideoToolkit::FORMAT_MPEG2 - mpeg2video
    1153. 

  1153. 		 * 		PHPVideoToolkit::FORMAT_MPEGVIDEO - mpegvideo
    1154. 

  1154. 		 * 		PHPVideoToolkit::FORMAT_PSP - psp
    1155. 

  1155. 		 * 		PHPVideoToolkit::FORMAT_RM - rm
    1156. 

  1156. 		 * 		PHPVideoToolkit::FORMAT_SWF - swf
    1157. 

  1157. 		 * 		PHPVideoToolkit::FORMAT_VOB - vob
    1158. 

  1158. 		 * 		PHPVideoToolkit::FORMAT_WAV - wav
    1159. 

  1159.     	 *    	PHPVideoToolkit::FORMAT_JPG - jpg
    1160. 

  1160. 		 * @return boolean false on error encountered, true otherwise
    1161. 

  1161. 		 */
    1162. 

  1162. 		public function setFormat($format)
    1163. 

  1163. 		{
    1164. 

  1164. //			validate input
    1165. 

  1165. 			if(!in_array($format, array(self::FORMAT_3GP2, self::FORMAT_3GP, s…
    1166.

Large files files are truncated, but you can click here to view the full file