PageRenderTime 60ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/sites/all/modules/video/libraries/phpvideotoolkit/phpvideotoolkit.php4.php

https://bitbucket.org/becomplete/enrollment123
PHP | 3599 lines | 1939 code | 185 blank | 1475 comment | 308 complexity | 4c6e845bbcc0b7211b8420958005a721 MD5 | raw file
Possible License(s): AGPL-1.0

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.8
    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. 	if(!defined('DS'))
    60. 

  60. 	{
    61. 

  61. 		define('DS', DIRECTORY_SEPARATOR);
    62. 

  62. 	}
    63. 

  63. 	
    64. 

  64. 	/**
    65. 

  65. 	 * Set the ffmpeg binary path
    66. 

  66. 	 */
    67. 

  67. 	if(!defined('PHPVIDEOTOOLKIT_FFMPEG_BINARY'))
    68. 

  68. 	{
    69. 

  69. 		define('PHPVIDEOTOOLKIT_FFMPEG_BINARY', '/usr/local/bin/ffmpeg');
    70. 

  70. 	}
    71. 

  71. 	/**
    72. 

  72. 	 * Set the flvtool2 binary path
    73. 

  73. 	 */
    74. 

  74. 	if(!defined('PHPVIDEOTOOLKIT_FLVTOOLS_BINARY'))
    75. 

  75. 	{
    76. 

  76. 		define('PHPVIDEOTOOLKIT_FLVTOOLS_BINARY', '/usr/bin/flvtool2');
    77. 

  77. 	}
    78. 

  78. 	/**
    79. 

  79. 	 * Set the watermark vhook path
    80. 

  80. 	 */
    81. 

  81. 	if(!defined('PHPVIDEOTOOLKIT_FFMPEG_WATERMARK_VHOOK'))
    82. 

  82. 	{
    83. 

  83. 		define('PHPVIDEOTOOLKIT_FFMPEG_WATERMARK_VHOOK', '/usr/local/lib/vhook/watermark.so');
    84. 

  84. 	}
    85. 

  85. 	/**
    86. 

  86. 	 * Set the memcoder path
    87. 

  87. 	 */
    88. 

  88. 	if(!defined('PHPVIDEOTOOLKIT_MENCODER_BINARY'))
    89. 

  89. 	{
    90. 

  90. 		define('PHPVIDEOTOOLKIT_MENCODER_BINARY', '/usr/local/bin/mencoder');
    91. 

  91. 	}
    92. 

  92. 	
    93. 

  93. 	/**
    94. 

  94. 	* Codec support constants
    95. 

  95. 	*/
    96. 

  96.    define('PHPVIDEOTOOLKIT_ENCODE', 'encode');
    97. 

  97.    define('PHPVIDEOTOOLKIT_DECODE', 'decode'); 
    98. 

  98. 		
    99. 

  99. 	/**
    100. 

  100. 	 * Process Results from PHPVideoToolkit::execute
    101. 

  101. 	 */
    102. 

  102. // 	any return value with this means everything is ok
    103. 

  103. 	define('PHPVIDEOTOOLKIT_RESULT_OK', true);
    104. 

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

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

  106. // 	processed file manually from the temp location
    107. 

  107. 	define('PHPVIDEOTOOLKIT_RESULT_OK_BUT_UNWRITABLE', -1);
    108. 

  108. 	
    109. 

  109. 	/**
    110. 

  110. 	 * Overwrite constants used in setOutput
    111. 

  111. 	 */
    112. 

  112. 	define('PHPVIDEOTOOLKIT_OVERWRITE_FAIL', 'fail');
    113. 

  113. 	define('PHPVIDEOTOOLKIT_OVERWRITE_PRESERVE', 'preserve');
    114. 

  114. 	define('PHPVIDEOTOOLKIT_OVERWRITE_EXISTING', 'existing');
    115. 

  115. 	define('PHPVIDEOTOOLKIT_OVERWRITE_UNIQUE', 'unique');
    116. 

  116. 	
    117. 

  117. 	/**
    118. 

  118. 	 * Formats supported
    119. 

  119. 	 * 3g2             3gp2 format
    120. 

  120. 	 * 3gp             3gp format
    121. 

  121. 	 * aac             ADTS AAC
    122. 

  122. 	 * aiff            Audio IFF
    123. 

  123. 	 * amr             3gpp amr file format
    124. 

  124. 	 * asf             asf format
    125. 

  125. 	 * avi             avi format
    126. 

  126. 	 * flv             flv format
    127. 

  127. 	 * gif             GIF Animation
    128. 

  128. 	 * mov             mov format
    129. 

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

  130. 	 * mp2             MPEG audio layer 2
    131. 

  131. 	 * mp3             MPEG audio layer 3
    132. 

  132. 	 * mp4             mp4 format
    133. 

  133. 	 * mpeg            MPEG1 System format
    134. 

  134. 	 * mpeg1video      MPEG video
    135. 

  135. 	 * mpeg2video      MPEG2 video
    136. 

  136. 	 * mpegvideo       MPEG video
    137. 

  137. 	 * psp             psp mp4 format
    138. 

  138. 	 * rm              rm format
    139. 

  139. 	 * swf             Flash format
    140. 

  140. 	 * vob             MPEG2 PS format (VOB)
    141. 

  141. 	 * wav             wav format
    142. 

  142. 	 * jpeg            mjpeg format
    143. 

  143. 	 * yuv4mpegpipe    yuv4mpegpipe format
    144. 

  144. 	 */
    145. 

  145. 	define('PHPVIDEOTOOLKIT_FORMAT_3GP2', '3g2');
    146. 

  146. 	define('PHPVIDEOTOOLKIT_FORMAT_3GP', '3gp');
    147. 

  147. 	define('PHPVIDEOTOOLKIT_FORMAT_AAC', 'aac');
    148. 

  148. 	define('PHPVIDEOTOOLKIT_FORMAT_AIFF', 'aiff');
    149. 

  149. 	define('PHPVIDEOTOOLKIT_FORMAT_AMR', 'amr');
    150. 

  150. 	define('PHPVIDEOTOOLKIT_FORMAT_ASF', 'asf');
    151. 

  151. 	define('PHPVIDEOTOOLKIT_FORMAT_AVI', 'avi');
    152. 

  152. 	define('PHPVIDEOTOOLKIT_FORMAT_FLV', 'flv');
    153. 

  153. 	define('PHPVIDEOTOOLKIT_FORMAT_GIF', 'gif');
    154. 

  154. 	define('PHPVIDEOTOOLKIT_FORMAT_MJ2', 'mj2');
    155. 

  155. 	define('PHPVIDEOTOOLKIT_FORMAT_MP2', 'mp2');
    156. 

  156. 	define('PHPVIDEOTOOLKIT_FORMAT_MP3', 'mp3');
    157. 

  157. 	define('PHPVIDEOTOOLKIT_FORMAT_MP4', 'mp4');
    158. 

  158. 	define('PHPVIDEOTOOLKIT_FORMAT_MPEG4', 'mpeg4');
    159. 

  159. 	define('PHPVIDEOTOOLKIT_FORMAT_M4A', 'm4a');
    160. 

  160. 	define('PHPVIDEOTOOLKIT_FORMAT_MPEG', 'mpeg');
    161. 

  161. 	define('PHPVIDEOTOOLKIT_FORMAT_MPEG1', 'mpeg1video');
    162. 

  162. 	define('PHPVIDEOTOOLKIT_FORMAT_MPEG2', 'mpeg2video');
    163. 

  163. 	define('PHPVIDEOTOOLKIT_FORMAT_MPEGVIDEO', 'mpegvideo');
    164. 

  164. 	define('PHPVIDEOTOOLKIT_FORMAT_PSP', 'psp');
    165. 

  165. 	define('PHPVIDEOTOOLKIT_FORMAT_RM', 'rm');
    166. 

  166. 	define('PHPVIDEOTOOLKIT_FORMAT_SWF', 'swf');
    167. 

  167. 	define('PHPVIDEOTOOLKIT_FORMAT_VOB', 'vob');
    168. 

  168. 	define('PHPVIDEOTOOLKIT_FORMAT_WAV', 'wav');
    169. 

  169. 	define('PHPVIDEOTOOLKIT_FORMAT_JPG', 'mjpeg');
    170. 

  170. 	define('PHPVIDEOTOOLKIT_FORMAT_Y4MP', 'yuv4mpegpipe');
    171. 

  171. 	
    172. 

  172. 	/**
    173. 

  173. 	 * Size Presets
    174. 

  174. 	 */
    175. 

  175. 	define('PHPVIDEOTOOLKIT_SIZE_SAS', 'SameAsSource');
    176. 

  176. 	define('PHPVIDEOTOOLKIT_SIZE_SQCIF', '128x96');
    177. 

  177. 	define('PHPVIDEOTOOLKIT_SIZE_QCIF', '176x144');
    178. 

  178. 	define('PHPVIDEOTOOLKIT_SIZE_CIF', '352x288');
    179. 

  179. 	define('PHPVIDEOTOOLKIT_SIZE_4CIF', '704x576');
    180. 

  180. 	define('PHPVIDEOTOOLKIT_SIZE_QQVGA', '160x120');
    181. 

  181. 	define('PHPVIDEOTOOLKIT_SIZE_QVGA', '320x240');
    182. 

  182. 	define('PHPVIDEOTOOLKIT_SIZE_VGA', '640x480');
    183. 

  183. 	define('PHPVIDEOTOOLKIT_SIZE_SVGA', '800x600');
    184. 

  184. 	define('PHPVIDEOTOOLKIT_SIZE_XGA', '1024x768');
    185. 

  185. 	define('PHPVIDEOTOOLKIT_SIZE_UXGA', '1600x1200');
    186. 

  186. 	define('PHPVIDEOTOOLKIT_SIZE_QXGA', '2048x1536');
    187. 

  187. 	define('PHPVIDEOTOOLKIT_SIZE_SXGA', '1280x1024');
    188. 

  188. 	define('PHPVIDEOTOOLKIT_SIZE_QSXGA', '2560x2048');
    189. 

  189. 	define('PHPVIDEOTOOLKIT_SIZE_HSXGA', '5120x4096');
    190. 

  190. 	define('PHPVIDEOTOOLKIT_SIZE_WVGA', '852x480');
    191. 

  191. 	define('PHPVIDEOTOOLKIT_SIZE_WXGA', '1366x768');
    192. 

  192. 	define('PHPVIDEOTOOLKIT_SIZE_WSXGA', '1600x1024');
    193. 

  193. 	define('PHPVIDEOTOOLKIT_SIZE_WUXGA', '1920x1200');
    194. 

  194. 	define('PHPVIDEOTOOLKIT_SIZE_WOXGA', '2560x1600');
    195. 

  195. 	define('PHPVIDEOTOOLKIT_SIZE_WQSXGA', '3200x2048');
    196. 

  196. 	define('PHPVIDEOTOOLKIT_SIZE_WQUXGA', '3840x2400');
    197. 

  197. 	define('PHPVIDEOTOOLKIT_SIZE_WHSXGA', '6400x4096');
    198. 

  198. 	define('PHPVIDEOTOOLKIT_SIZE_WHUXGA', '7680x4800');
    199. 

  199. 	define('PHPVIDEOTOOLKIT_SIZE_CGA', '320x200');
    200. 

  200. 	define('PHPVIDEOTOOLKIT_SIZE_EGA', '640x350');
    201. 

  201. 	define('PHPVIDEOTOOLKIT_SIZE_HD480', '852x480');
    202. 

  202. 	define('PHPVIDEOTOOLKIT_SIZE_HD720', '1280x720');
    203. 

  203. 	define('PHPVIDEOTOOLKIT_SIZE_HD1080', '1920x1080');
    204. 

  204. 	
    205. 

  205. 	/**
    206. 

  206. 	 * Ratio Presets
    207. 

  207. 	 */
    208. 

  208. 	define('PHPVIDEOTOOLKIT_RATIO_STANDARD', '4:3');
    209. 

  209. 	define('PHPVIDEOTOOLKIT_RATIO_WIDE', '16:9');
    210. 

  210. 	define('PHPVIDEOTOOLKIT_RATIO_CINEMATIC', '1.85');
    211. 

  211. 	
    212. 

  212. 		
    213. 

  213. 	/**
    214. 

  214. 	 * Audio Channel Presets
    215. 

  215. 	 */
    216. 

  216. 	define('PHPVIDEOTOOLKIT_AUDIO_STEREO', 2);
    217. 

  217. 	define('PHPVIDEOTOOLKIT_AUDIO_MONO', 1);
    218. 

  218. 

  219. 	/**
    220. 

  220. 	 * @author Oliver Lillie (aka buggedcom) <publicmail@buggedcom.co.uk>
    221. 

  221. 	 * @license BSD
    222. 

  222. 	 * @package PHPVideoToolkit (was called ffmpeg)
    223. 

  223. 	 */
    224. 

  224. 	class PHPVideoToolkit
    225. 

  225. 	{
    226. 

  226. 		
    227. 

  227. 		var $version = '0.1.8';
    228. 

  228. 		
    229. 

  229. 		/**
    230. 

  230. 		 * Error strings
    231. 

  231. 		 */
    232. 

  232. 		var $_messages = array(
    233. 

  233. 			
    234. 

  234. 			'generic_temp_404' 								=> 'The temporary directory does not exist.',
    235. 

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

  236. 			
    237. 

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

  238. 			'inputFileHasVideo_no_input' 					=> 'Input file does not exist so no information can be retrieved.',
    239. 

  239. 			'inputFileHasAudio_no_input' 					=> 'Input file does not exist so no information can be retrieved.',
    240. 

  240. 			'setInputFile_file_existence' 					=> 'Input file "#file" does not exist',
    241. 

  241. 			'extractAudio_valid_format' 					=> 'Value "#format" set from $toolkit->extractAudio, is not a valid audio format. Valid values ffmpeg PHPVIDEOTOOLKIT_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.',
    242. 

  242. 			'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.',
    243. 

  243. 			'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.',
    244. 

  244. 			'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.',
    245. 

  245. 			'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.',
    246. 

  246. 			'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.',
    247. 

  247. 			'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.',
    248. 

  248. 			'setAudioChannels_valid_channels' 				=> 'Value "#channels" set from $toolkit->setAudioChannels, is not a valid integer. Valid values are 1, or 2. If you wish to specifically try to set another channels value you should use the advanced function $toolkit->addCommand. Set $command to "-ac" and $argument to your required value.',
    249. 

  249. 			'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.',
    250. 

  250. 			'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.',
    251. 

  251. 			'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.',
    252. 

  252. 			'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.',
    253. 

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

  254. 			'prepareImagesForConversionToVideo_img_404' 	=> '"#img" does not exist.',
    255. 

  255. 			'prepareImagesForConversionToVideo_img_copy' 	=> '"#img" can not be copied to "#tmpfile"',
    256. 

  256. 			'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.',
    257. 

  257. 			'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.',
    258. 

  258. 			'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);',
    259. 

  259. 			'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',
    260. 

  260. 			'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.',
    261. 

  261. 			'addWatermark_img_404' 							=> 'Watermark file "#watermark" does not exist.',
    262. 

  262. 			'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.',
    263. 

  263. 			'addVideo_file_404' 							=> 'File "#file" does not exist.',
    264. 

  264. 			'setOutput_output_dir_404' 						=> 'Output directory "#dir" does not exist!',
    265. 

  265. 			'setOutput_output_dir_writable' 				=> 'Output directory "#dir" is not writable!',
    266. 

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

  267. 			'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.',
    268. 

  268. 			'execute_input_404' 							=> 'Execute error. Input file missing.',
    269. 

  269. 			'execute_output_not_set' 						=> 'Execute error. Output not set.',
    270. 

  270. 			'execute_temp_unwritable'		   				=> 'Execute error. The tmp directory supplied is not writable.',
    271. 

  271. 			'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.',
    272. 

  272. 			'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".',
    273. 

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

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

  275. 			'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().',
    276. 

  276. 			'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().',
    277. 

  277. 			'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".',
    278. 

  278. 			'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.',
    279. 

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

  280. 			
    281. 

  281. 			'ffmpeg_log_ffmpeg_output'						=> 'OUTPUT',
    282. 

  282. 			'ffmpeg_log_ffmpeg_result'						=> 'RESULT',
    283. 

  283. 			'ffmpeg_log_ffmpeg_command'						=> 'COMMAND',
    284. 

  284. 			'ffmpeg_log_ffmpeg_join_gunk'					=> 'FFMPEG JOIN OUTPUT',
    285. 

  285. 			'ffmpeg_log_ffmpeg_gunk'						=> 'FFMPEG OUTPUT',
    286. 

  286. 			'ffmpeg_log_separator'							=> '-------------------------------'
    287. 

  287. 			
    288. 

  288. 		);
    289. 

  289. 		
    290. 

  290. 		/**
    291. 

  291. 		 * A public var that is to the information available about
    292. 

  292. 		 * the current ffmpeg compiled binary.
    293. 

  293. 		 * @var mixed
    294. 

  294. 		 * @access public
    295. 

  295. 		 */
    296. 

  296. 		var $ffmpeg_info		= false;
    297. 

  297. 

  298. 		/**
    299. 

  299. 		 * A public var that determines if the ffmpeg binary has been found. The default value
    300. 

  300. 		 * is null unless getFFmpegInfo is called whereby depending on the results it is set to
    301. 

  301. 		 * true or false
    302. 

  302. 		 * @var mixed
    303. 

  303. 		 * @access public
    304. 

  304. 		 */
    305. 

  305. 		var $ffmpeg_found		= null;
    306. 

  306. 

  307. 		/**
    308. 

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

  309. 		 * @var array
    310. 

  310. 		 * @access private
    311. 

  311. 		 */
    312. 

  312. 		var $_file_info		= array();
    313. 

  313. 

  314. 		/**
    315. 

  315. 		 * Determines what happens when an error occurs
    316. 

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

  317. 		 * @access public
    318. 

  318. 		 */
    319. 

  319. 		var $on_error_die			= false;
    320. 

  320. 

  321. 		/**
    322. 

  322. 		 * Holds the log file name
    323. 

  323. 		 * @var string
    324. 

  324. 		 * @access private
    325. 

  325. 		 */
    326. 

  326. 		var $_log_file				= null;
    327. 

  327. 

  328. 		/**
    329. 

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

  330. 		 * replaced with the frames timecode.
    331. 

  331. 		 * @var boolean If true then the files will be renamed.
    332. 

  332. 		 * @access public
    333. 

  333. 		 */
    334. 

  334. 		var $image_output_timecode 	= true;
    335. 

  335. 

  336. 		/**
    337. 

  337. 		 * Holds the timecode separator for when using $image_output_timecode = true
    338. 

  338. 		 * Not all systems allow ':' in filenames.
    339. 

  339. 		 * @var string
    340. 

  340. 		 * @access public
    341. 

  341. 		 */
    342. 

  342. 		var $timecode_seperator_output = '-';
    343. 

  343. 

  344. 		/**
    345. 

  345. 		 * Holds the starting time code when outputting image frames.
    346. 

  346. 		 * @var string The timecode hh(n):mm:ss:ff
    347. 

  347. 		 * @access private
    348. 

  348. 		 */
    349. 

  349. 		var $_image_output_timecode_start = '00:00:00.00';
    350. 

  350. 

  351. 		/**
    352. 

  352. 		 * The format in which the image %timecode placeholder string is outputted.
    353. 

  353. 		 * 	- %hh (hours) representative of hours
    354. 

  354. 		 * 	- %mm (minutes) representative of minutes
    355. 

  355. 		 * 	- %ss (seconds) representative of seconds
    356. 

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

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

  358. 		 * 	- %ft (frames total) representative of total frames (ie frame number)
    359. 

  359. 		 * 	- %st (seconds total) representative of total seconds (rounded).
    360. 

  360. 		 * 	- %sf (seconds floored) representative of total seconds (floored).
    361. 

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

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

  363. 		 * 	- :
    364. 

  364. 		 *  - .
    365. 

  365. 		 * @var string 
    366. 

  366. 		 * @access public
    367. 

  367. 		 */
    368. 

  368. 		var $image_output_timecode_format = '%hh-%mm-%ss-%fn';
    369. 

  369. 

  370. 		/**
    371. 

  371. 		 * Holds the fps of image extracts
    372. 

  372. 		 * @var integer
    373. 

  373. 		 * @access private
    374. 

  374. 		 */
    375. 

  375. 		var $_image_output_timecode_fps = 1;
    376. 

  376. 

  377. 		/**
    378. 

  378. 		 * Holds the current execute commands that will need to be combined
    379. 

  379. 		 * @var array
    380. 

  380. 		 * @access private
    381. 

  381. 		 */
    382. 

  382. 		var $_commands 			= array();
    383. 

  383. 

  384. 		/**
    385. 

  385. 		 * Holds the commands executed
    386. 

  386. 		 * @var array
    387. 

  387. 		 * @access private
    388. 

  388. 		 */
    389. 

  389. 		var $_processed 		= array();
    390. 

  390. 

  391. 		/**
    392. 

  392. 		 * Holds the file references to those that have been processed
    393. 

  393. 		 * @var array
    394. 

  394. 		 * @access private
    395. 

  395. 		 */
    396. 

  396. 		var $_files	 			= array();
    397. 

  397. 

  398. 		/**
    399. 

  399. 		 * Holds the errors encountered
    400. 

  400. 		 * @access private
    401. 

  401. 		 * @var array
    402. 

  402. 		 */
    403. 

  403. 		var $_errors 			= array();
    404. 

  404. 

  405. 		/**
    406. 

  406. 		 * Holds the input file / input file sequence
    407. 

  407. 		 * @access private
    408. 

  408. 		 * @var string
    409. 

  409. 		 */
    410. 

  410. 		var $_input_file 		= null;
    411. 

  411. 

  412. 		/**
    413. 

  413. 		 * Holds the output file / output file sequence
    414. 

  414. 		 * @access private
    415. 

  415. 		 * @var string
    416. 

  416. 		 */
    417. 

  417. 		var $_output_address 	= null;
    418. 

  418. 

  419. 		/**
    420. 

  420. 		 * Holds the process file / process file sequence
    421. 

  421. 		 * @access private
    422. 

  422. 		 * @var string
    423. 

  423. 		 */
    424. 

  424. 		var $_process_address 	= null;
    425. 

  425. 

  426. 		/**
    427. 

  427. 		 * Temporary filename prefix
    428. 

  428. 		 * @access private
    429. 

  429. 		 * @var string
    430. 

  430. 		 */
    431. 

  431. 		var $_tmp_file_prefix	= 'tmp_';
    432. 

  432. 

  433. 		/**
    434. 

  434. 		 * Holds the temporary directory name
    435. 

  435. 		 * @access private
    436. 

  436. 		 * @var string
    437. 

  437. 		 */
    438. 

  438. 		var $_tmp_directory 	= null;
    439. 

  439. 

  440. 		/**
    441. 

  441. 		 * Holds the directory paths that need to be removed by the ___destruct function
    442. 

  442. 		 * @access private
    443. 

  443. 		 * @var array
    444. 

  444. 		 */
    445. 

  445. 		var $_unlink_dirs		= array();
    446. 

  446. 

  447. 		/**
    448. 

  448. 		 * Holds the file paths that need to be deleted by the ___destruct function
    449. 

  449. 		 * @access private
    450. 

  450. 		 * @var array
    451. 

  451. 		 */
    452. 

  452. 		var $_unlink_files		= array();
    453. 

  453. 

  454. 		/**
    455. 

  455. 		 * Holds the timer start micro-float.
    456. 

  456. 		 * @access private
    457. 

  457. 		 * @var integer
    458. 

  458. 		 */
    459. 

  459. 		var $_timer_start		= 0;
    460. 

  460. 		
    461. 

  461. 		/**
    462. 

  462. 		 * Holds the times taken to process each file.
    463. 

  463. 		 * @access private
    464. 

  464. 		 * @var array
    465. 

  465. 		 */
    466. 

  466. 		var $_timers			= array();
    467. 

  467. 

  468. 		/**
    469. 

  469. 		 * Holds the times taken to process each file.
    470. 

  470. 		 * @access private
    471. 

  471. 		 * @var constant
    472. 

  472. 		 */
    473. 

  473. 		var $_overwrite_mode	= null;
    474. 

  474. 

  475. 		/**
    476. 

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

  477. 		 * @access private
    478. 

  478. 		 * @var integer
    479. 

  479. 		 */
    480. 

  480. 		var $_single_frame_extraction	= null;
    481. 

  481. 

  482. 		/**
    483. 

  483. 		 * Holds the watermark file that is used to watermark any outputted images via GD.
    484. 

  484. 		 * @access private
    485. 

  485. 		 * @var string
    486. 

  486. 		 */
    487. 

  487. 		var $_watermark_url	= null;
    488. 

  488. 

  489. 		/**
    490. 

  490. 		 * Holds the watermark options used to watermark any outputted images via GD.
    491. 

  491. 		 * @access private
    492. 

  492. 		 * @var array
    493. 

  493. 		 */
    494. 

  494. 		var $_watermark_options	= null;
    495. 

  495. 

  496. 		/**
    497. 

  497. 		 * Holds the number of files processed per run.
    498. 

  498. 		 * @access private
    499. 

  499. 		 * @var integer
    500. 

  500. 		 */
    501. 

  501. 		var $_process_file_count = 0;
    502. 

  502. 

  503. 		/**
    504. 

  504. 		 * Holds the times taken to process each file.
    505. 

  505. 		 * @access private
    506. 

  506. 		 * @var array
    507. 

  507. 		 */
    508. 

  508. 		var $_post_processes	= array();
    509. 

  509. 		
    510. 

  510. 		/**
    511. 

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

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

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

  514. 		 * after-input item.
    515. 

  515. 		 * @access private
    516. 

  516. 		 * @var array
    517. 

  517. 		 */
    518. 

  518. // 		var $_cmds_before_input		= array();
    519. 

  519. 		var $_cmds_before_input		= array('-inputr');
    520. 

  520. // 		var $_cmds_before_input		= array('-r', '-f');
    521. 

  521. 

  522. 		/**
    523. 

  523. 		 * Constructs the class and sets the temporary directory.
    524. 

  524. 		 *
    525. 

  525. 		 * @access private
    526. 

  526. 		 * @param string $tmp_directory A full absolute path to you temporary directory
    527. 

  527. 		 */
    528. 

  528. 		function PHPVideoToolkit($tmp_directory='/tmp/')
    529. 

  529. 		{
    530. 

  530. 			$this->_tmp_directory = $tmp_directory;
    531. 

  531. // 			emulate php5 destructors
    532. 

  532.     		register_shutdown_function(array(&$this, '__destruct'));
    533. 

  533. 		}
    534. 

  534. 		
    535. 

  535. 		function microtimeFloat()
    536. 

  536. 		{
    537. 

  537. 		    list($usec, $sec) = explode(" ", microtime());
    538. 

  538. 		    return ((float) $usec + (float) $sec);
    539. 

  539. 		}
    540. 

  540. 

  541. 		/**
    542. 

  542. 		 * Resets the class
    543. 

  543. 		 *
    544. 

  544. 		 * @access public
    545. 

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

  546. 		 */
    547. 

  547. 		function reset($keep_input_file=false, $keep_processes=false)
    548. 

  548. 		{
    549. 

  549. 			if($keep_input_file === false)
    550. 

  550. 			{
    551. 

  551. 				$this->_input_file = null;
    552. 

  552. 			}
    553. 

  553. 			if($keep_processes === false)
    554. 

  554. 			{
    555. 

  555. 				$this->_post_processes = array();
    556. 

  556. 			}
    557. 

  557. 			$this->_single_frame_extraction = null;
    558. 

  558. 			$this->_output_address = null;
    559. 

  559. 			$this->_process_address = null;
    560. 

  560. 			$this->_log_file = null;
    561. 

  561. 			$this->_commands = array();
    562. 

  562. 			$this->_timer_start = 0;
    563. 

  563. 			$this->_process_file_count = 0;
    564. 

  564. 			$this->__destruct();
    565. 

  565. 		}
    566. 

  566. 

  567. 		/**
    568. 

  568. 		 * Returns information about the specified file without having to use ffmpeg-php
    569. 

  569. 		 * as it consults the ffmpeg binary directly. 
    570. 

  570. 		 * 
    571. 

  571. 		 * @access public
    572. 

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

  573. 		 * @return mixed false on error encountered, true otherwise
    574. 

  574. 		 **/
    575. 

  575. 		function getFFmpegInfo()
    576. 

  576. 		{
    577. 

  577. // 			check to see if this is a static call
    578. 

  578. 			if(!$this)
    579. 

  579. 			{     
    580. 

  580. 				$toolkit = new PHPVideoToolkit($tmp_directory);
    581. 

  581. 				return $toolkit->getFFmpegInfo();
    582. 

  582. 			}
    583. 

  583. // 			check to see if the info has already been cached
    584. 

  584. 			if($this->ffmpeg_info !== false)
    585. 

  585. 			{
    586. 

  586. 				return $this->ffmpeg_info;
    587. 

  587. 			}
    588. 

  588. // 			check to see if this is a static call
    589. 

  589. 			$format = '';
    590. 

  590. 			$data = array();
    591. 

  591. // 			execute the ffmpeg lookup
    592. 

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

  593. 			
    594. 

  594. 			$this->ffmpeg_found = $data['ffmpeg-found']  = !(strpos($buffer[0], 'command not found') !== false || strpos($buffer[0], 'No such file or directory') !== false);
    595. 

  595. 			$data['binary'] 	= array();
    596. 

  596. 			$data['compiler'] 	= array();
    597. 

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

  598. 			$data['raw'] 		= implode("\r\n", $buffer);
    599. 

  599. 			
    600. 

  600. 			if(!$this->ffmpeg_found)
    601. 

  601. 			{
    602. 

  602. 				$this->ffmpeg_info = $data;
    603. 

  603. 				return $data;
    604. 

  604. 			} 
    605. 

  605. 			
    606. 

  606. 			$buffer = $data['raw'];
    607. 

  607. 			
    608. 

  608. // 			start building the info array
    609. 

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

  610. 			$total_lookups = count($look_ups);
    611. 

  611. 			$pregs = array();
    612. 

  612. 			$indexs = array();
    613. 

  613. 			foreach($look_ups as $key=>$reg)
    614. 

  614. 			{
    615. 

  615. 				if(strpos($buffer, $reg) !== false)
    616. 

  616. 				{
    617. 

  617. 					$index = array_push($pregs, $reg);
    618. 

  618. 					$indexs[$key] = $index;
    619. 

  619. 				}
    620. 

  620. 			}
    621. 

  621. 			preg_match('/'.implode('(.*)', $pregs).'(.*)/s', $buffer, $matches);
    622. 

  622. 			$configuration = trim($matches[$indexs['configuration']]);
    623. 

  623. // 			grab the ffmpeg configuration flags
    624. 

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

  625. 			$data['binary']['configuration'] = $config_flags[0];
    626. 

  626. 			$data['binary']['vhook-support'] = in_array('--enable-vhook', $config_flags[0]) || !in_array('--disable-vhook', $config_flags[0]);
    627. 

  627. // 			grab the versions
    628. 

  628. 			$data['binary']['versions'] = array();
    629. 

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

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

  631. 			{
    632. 

  632. 				$data['binary']['versions'][strtolower(trim($versions[1][$i]))] = $versions[2][$i];
    633. 

  633. 			}
    634. 

  634. // 			grab the ffmpeg compile info
    635. 

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

  636. 			if(count($conf) > 0)
    637. 

  637. 			{
    638. 

  638. 				$data['compiler']['gcc'] = $conf[2];
    639. 

  639. 				$data['compiler']['build_date'] = $conf[1];
    640. 

  640. 				$data['compiler']['build_date_timestamp'] = strtotime($conf[1]);
    641. 

  641. 			}
    642. 

  642. // 			grab the file formats available to ffmpeg
    643. 

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

  644. 			$data['formats'] = array();
    645. 

  645. // 			loop and clean
    646. 

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

  647. 			{
    648. 

  648. 				$data['formats'][strtolower(trim($formats[2][$i]))] = array(
    649. 

  649. 					'encode' 	=> $formats[1][$i] == 'DE' || $formats[1][$i] == 'E',
    650. 

  650. 					'decode' 	=> $formats[1][$i] == 'DE' || $formats[1][$i] == 'D',
    651. 

  651. 					'fullname'	=> $formats[3][$i]
    652. 

  652. 				);
    653. 

  653. 			}
    654. 

  654. // 			grab the bitstream filters available to ffmpeg
    655. 

  655. 			$data['filters'] = array();
    656. 

  656. 			if(isset($indexs['filters']) && isset($matches[$indexs['filters']]))
    657. 

  657. 			{
    658. 

  658. 				$filters = trim($matches[$indexs['filters']]);
    659. 

  659. 				if(empty($filters) === false)
    660. 

  660. 				{
    661. 

  661. 					$data['filters'] = explode(' ', $filters);
    662. 

  662. 				}
    663. 

  663. 			}
    664. 

  664. // 		    grab the file prototcols available to ffmpeg
    665. 

  665. 			$data['filters'] = array();
    666. 

  666. 			if(isset($indexs['protocols']) && isset($matches[$indexs['protocols']]))
    667. 

  667. 			{
    668. 

  668. 				$protocols = trim($matches[$indexs['protocols']]);
    669. 

  669. 				if(empty($protocols) === false)
    670. 

  670. 				{
    671. 

  671. 					$data['protocols'] = explode(' ', str_replace(':', '', $protocols));
    672. 

  672. 				}
    673. 

  673. 			}
    674. 

  674. // 			grab the abbreviations available to ffmpeg
    675. 

  675. 			$data['abbreviations'] = array();
    676. 

  676. 			if(isset($indexs['abbreviations']) && isset($matches[$indexs['abbreviations']]))
    677. 

  677. 			{
    678. 

  678. 				$abbreviations = trim($matches[$indexs['abbreviations']]);
    679. 

  679. 				if(empty($abbreviations) === false)
    680. 

  680. 				{
    681. 

  681. 					$data['abbreviations'] = explode(' ', $abbreviations);
    682. 

  682. 				}
    683. 

  683. 			}
    684. 

  684. 			$this->ffmpeg_info = $data;
    685. 

  685. 			return $data;
    686. 

  686. 			
    687. 

  687. 		}
    688. 

  688. 		
    689. 

  689. 		/**
    690. 

  690. 		 * Determines the type of support that exists for the FFmpeg-PHP module.
    691. 

  691. 		 * 
    692. 

  692. 		 * @access public
    693. 

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

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

  695. 		 * 		can be emulated through the adapter classes.
    696. 

  696. 		 */
    697. 

  697. 		function hasFFmpegPHPSupport()
    698. 

  698. 		{
    699. 

  699. 			return $this->ffmpeg_found === false ? false : (extension_loaded('ffmpeg') ? 'module' : (is_file(dirname(__FILE__).DS.'adapters'.DS.'ffmpeg-php'.DS.'ffmpeg_movie.php') && is_file(dirname(__FILE__).DS.'adapters'.DS.'ffmpeg-php'.DS.'ffmpeg_frame.php') && is_file(dirname(__FILE__).DS.'adapters'.DS.'ffmpeg-php'.DS.'ffmpeg_animated_gif.php') ? 'emulated' : false));
    700. 

  700. 		}
    701. 

  701. 		
    702. 

  702. 		/**
    703. 

  703. 		 * Determines if the ffmpeg binary has been compiled with vhook support.
    704. 

  704. 		 * 
    705. 

  705. 		 * @access public
    706. 

  706. 		 * @return mixed. Boolean false if there is no support, true there is support.
    707. 

  707. 		 */
    708. 

  708. 		function hasVHookSupport()
    709. 

  709. 		{
    710. 

  710. 			$info = $this->getFFmpegInfo();
    711. 

  711. 			return $info['binary']['vhook-support'];
    712. 

  712. 		}
    713. 

  713. 		
    714. 

  714. 		/**
    715. 

  715. 		 * Returns information about the specified file without having to use ffmpeg-php
    716. 

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

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

  718. 		 * 
    719. 

  719. 		 * @access public
    720. 

  720. 		 * @todo Change the search from string explode to a regex based search
    721. 

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

  722. 		 * @return mixed false on error encountered, true otherwise
    723. 

  723. 		 **/
    724. 

  724. 		function getFileInfo($file=false, $tmp_directory='/tmp/')
    725. 

  725. 		{
    726. 

  726. // 			check to see if this is a static call
    727. 

  727. 			if($file !== false && !$this)
    728. 

  728. 			{     
    729. 

  729. 				$toolkit = new PHPVideoToolkit($tmp_directory);
    730. 

  730. 				return $toolkit->getFileInfo($file);
    731. 

  731. 			}
    732. 

  732. // 			if the file has not been specified check to see if an input file has been specified
    733. 

  733. 			if($file === false)
    734. 

  734. 			{
    735. 

  735. 				if(!$this->_input_file)
    736. 

  736. 				{
    737. 

  737. //					input file not valid
    738. 

  738. 					return $this->_raiseError('getFileInfo_no_input');
    739. 

  739. //<-				exits
    740. 

  740. 				}
    741. 

  741. 				$file = $this->_input_file;
    742. 

  742. 			}
    743. 

  743. 			$file = escapeshellarg($file);
    744. 

  744. // 			create a hash of the filename
    745. 

  745. 			$hash = md5($file);
    746. 

  746. // 			check to see if the info has already been generated
    747. 

  747. 			if(isset($this->_file_info[$hash]))
    748. 

  748. 			{
    749. 

  749. 				return $this->_file_info[$hash];
    750. 

  750. 			}
    751. 

  751. // 			execute the ffmpeg lookup
    752. 

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

  753. 			$buffer = implode("\r\n", $buffer);
    754. 

  754. 			$data = array();
    755. 

  755. // 			grab the duration and bitrate data
    756. 

  756. 			preg_match_all('/Duration: (.*)/', $buffer, $matches);
    757. 

  757. 			if(count($matches) > 0)
    758. 

  758. 			{
    759. 

  759. 				$line = trim($matches[0][0]);
    760. 

  760. // 				capture any data
    761. 

  761. 				preg_match_all('/(Duration|start|bitrate): ([^,]*)/', $line, $matches);
    762. 

  762. // 				setup the default data
    763. 

  763. 				$data['duration'] = array(
    764. 

  764. 					'timecode' => array(
    765. 

  765. 						'seconds' => array(
    766. 

  766. 							'exact' => -1,
    767. 

  767. 							'excess' => -1
    768. 

  768. 						),
    769. 

  769. 						'rounded' => -1,
    770. 

  770. 					)
    771. 

  771. 				);
    772. 

  772. // 				get the data
    773. 

  773. 				foreach ($matches[1] as $key => $detail)
    774. 

  774. 				{
    775. 

  775. 					$value = $matches[2][$key];
    776. 

  776. 					switch(strtolower($detail))
    777. 

  777. 					{
    778. 

  778. 						case 'duration' :
    779. 

  779. // 						print_r($value);
    780. 

  780. 							$data['duration']['timecode']['rounded'] = substr($value, 0, 8);
    781. 

  781. 							$data['duration']['timecode']['frames'] = array();
    782. 

  782. 							$data['duration']['timecode']['frames']['exact'] = $value;
    783. 

  783. 							$data['duration']['timecode']['frames']['excess'] = intval(substr($value, 9));
    784. 

  784. 							break;
    785. 

  785. 						case 'bitrate' :
    786. 

  786. 							$data['bitrate'] = strtoupper($value) === 'N/A' ? -1 : intval($value);
    787. 

  787. 							break;
    788. 

  788. 						case 'start' :
    789. 

  789. 							$data['duration']['start'] = $value;
    790. 

  790. 							break;
    791. 

  791. 					}
    792. 

  792. 				}
    793. 

  793. 			}
    794. 

  794. 			
    795. 

  795. // 			match the video stream info
    796. 

  796. 			preg_match('/Stream(.*): Video: (.*)/', $buffer, $matches);
    797. 

  797. 			if(count($matches) > 0)
    798. 

  798. 			{
    799. 

  799. 				$data['video'] 						= array();
    800. 

  800. // 				get the dimension parts
    801. 

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

  802. // 				print_r($dimensions_matches);
    803. 

  803. 				$dimensions_value = $dimensions_matches[0];
    804. 

  804. 				$data['video']['dimensions'] 	= array(
    805. 

  805. 					'width' 					=> floatval($dimensions_matches[1]),
    806. 

  806. 					'height' 					=> floatval($dimensions_matches[2])
    807. 

  807. 				);
    808. 

  808. // 				get the framerate
    809. 

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

  810. 				$data['duration']['timecode']['frames']['frame_rate'] = $data['video']['frame_rate'] 	= floatval($fps_matches[1]);
    811. 

  811. 				$data['duration']['timecode']['seconds']['total'] = $data['duration']['seconds'] = $this->formatTimecode($data['duration']['timecode']['frames']['exact'], '%hh:%mm:%ss.%fn', '%st.%ms', $data['video']['frame_rate']);
    812. 

  812. 				$fps_value = $fps_matches[0];
    813. 

  813. // 				get the ratios
    814. 

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

  815. 				if(count($ratio_matches))
    816. 

  816. 				{
    817. 

  817. 					$data['video']['pixel_aspect_ratio'] 	= $ratio_matches[1];
    818. 

  818. 					$data['video']['display_aspect_ratio'] 	= $ratio_matches[2];
    819. 

  819. 				}
    820. 

  820. // 				work out the number of frames
    821. 

  821. 				if(isset($data['duration']) && isset($data['video']))
    822. 

  822. 				{
    823. 

  823. // 					set the total frame count for the video
    824. 

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

  825. // 					set the framecode
    826. 

  826. 					$data['duration']['timecode']['seconds']['excess'] 	= floatval($data['duration']['seconds']) - floor($data['duration']['seconds']);
    827. 

  827. 					$data['duration']['timecode']['seconds']['exact'] 	= $this->formatSeconds($data['duration']['seconds'], '%hh:%mm:%ss.%ms');
    828. 

  828. 					$data['duration']['timecode']['frames']['total'] 	= $data['video']['frame_count'];
    829. 

  829. 				}
    830. 

  830. // 				formats should be anything left over, let me know if anything else exists
    831. 

  831. 				$parts 							= explode(',', $matches[2]);
    832. 

  832. 				$other_parts 					= array($dimensions_value, $fps_value);
    833. 

  833. 				$formats = array();
    834. 

  834. 				foreach($parts as $key=>$part)
    835. 

  835. 				{
    836. 

  836. 					$part = trim($part);
    837. 

  837. 					if(!in_array($part, $other_parts))
    838. 

  838. 					{
    839. 

  839. 						array_push($formats, $part);
    840. 

  840. 					}
    841. 

  841. 				}
    842. 

  842. 				$data['video']['pixel_format'] 	= $formats[1];
    843. 

  843. 				$data['video']['codec'] 		= $formats[0];
    844. 

  844. 			}
    845. 

  845. 			
    846. 

  846. // 			match the audio stream info
    847. 

  847. 			preg_match('/Stream(.*): Audio: (.*)/', $buffer, $matches);
    848. 

  848. 			if(count($matches) > 0)
    849. 

  849. 			{
    850. 

  850. // 				setup audio values
    851. 

  851. 				$data['audio'] = array(
    852. 

  852. 					'stereo'		=> -1, 
    853. 

  853. 					'sample_rate'	=> -1, 
    854. 

  854. 					'sample_rate'	=> -1
    855. 

  855. 				);
    856. 

  856. 				$other_parts = array();
    857. 

  857. // 				get the stereo value
    858. 

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

  859. 				if(count($stereo_matches))
    860. 

  860. 				{
    861. 

  861. 					$data['audio']['stereo'] 		= $stereo_matches[0];
    862. 

  862. 					array_push($other_parts, $stereo_matches[0]);
    863. 

  863. 				}
    864. 

  864. // 				get the sample_rate
    865. 

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

  866. 				if(count($sample_matches))
    867. 

  867. 				{
    868. 

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

  869. 					array_push($other_parts, $sample_matches[0]);
    870. 

  870. 				}
    871. 

  871. // 				get the bit rate
    872. 

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

  873. 				if(count($bitrate_matches))
    874. 

  874. 				{
    875. 

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

  876. 					array_push($other_parts, $bitrate_matches[0]);
    877. 

  877. 				}
    878. 

  878. // 				formats should be anything left over, let me know if anything else exists
    879. 

  879. 				$parts 							= explode(',', $matches[2]);
    880. 

  880. 				$formats = array();
    881. 

  881. 				foreach($parts as $key=>$part)
    882. 

  882. 				{
    883. 

  883. 					$part = trim($part);
    884. 

  884. 					if(!in_array($part, $other_parts))
    885. 

  885. 					{
    886. 

  886. 						array_push($formats, $part);
    887. 

  887. 					}
    888. 

  888. 				}
    889. 

  889. 				$data['audio']['codec'] 		= $formats[0];
    890. 

  890. // 				if no video is set then no audio frame rate is set 
    891. 

  891. 				if($data['duration']['timecode']['seconds']['exact'] === -1)
    892. 

  892. 				{
    893. 

  893. 					$exact_timecode = $this->formatTimecode($data['duration']['timecode']['frames']['exact'], '%hh:%mm:%ss.%fn', '%hh:%mm:%ss.%ms', 1000);
    894. 

  894. 					$data['duration']['timecode']['seconds'] = array(
    895. 

  895. 						'exact'  => $exact_timecode,
    896. 

  896. 						'excess' => intval(substr($exact_timecode, 8)),
    897. 

  897. 						'total' => $this->formatTimecode($data['duration']['timecode']['frames']['exact'], '%hh:%mm:%ss.%fn', '%ss.%ms', 1000)
    898. 

  898. 					);
    899. 

  899. 					$data['duration']['timecode']['frames']['frame_rate'] = 1000;
    900. 

  900. 					$data['duration']['seconds'] = $data['duration']['timecode']['seconds']['total'];
    901. 

  901. 					//$this->formatTimecode($data['duration']['timecode']['frames']['exact'], '%hh:%mm:%ss.%fn', '%st.%ms', $data['video']['frame_rate']);					
    902. 

  902. 				}
    903. 

  903. 			}
    904. 

  904. 

  905. // 			check that some data has been obtained
    906. 

  906. 			if(!count($data))
    907. 

  907. 			{
    908. 

  908. 				$data = false;
    909. 

  909. 			}
    910. 

  910. 			else
    911. 

  911. 			{
    912. 

  912. 				$data['_raw_info'] = $buffer;
    913. 

  913. 			}
    914. 

  914. 			return $this->_file_info[$hash] = $data;
    915. 

  915. 		}		
    916. 

  916. 

  917. 		/**
    918. 

  918. 		 * Determines if the input media has a video stream.
    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. 		 * @return bool
    923. 

  923. 		 **/
    924. 

  924. 		function fileHasVideo($file=false)
    925. 

  925. 		{
    926. 

  926. // 			check to see if this is a static call
    927. 

  927. 			if($file !== false && !isset($this))
    928. 

  928. 			{     
    929. 

  929. 				$toolkit = new PHPVideoToolkit();
    930. 

  930. 				$data = $toolkit->getFileInfo($file);
    931. 

  931. 			}
    932. 

  932. // 			if the file has not been specified check to see if an input file has been specified
    933. 

  933. 			else if($file === false)
    934. 

  934. 			{
    935. 

  935. 				if(!$this->_input_file)
    936. 

  936. 				{
    937. 

  937. //					input file not valid
    938. 

  938. 					return $this->_raiseError('inputFileHasVideo_no_input');
    939. 

  939. //<-				exits
    940. 

  940. 				}
    941. 

  941. 				$file = $this->_input_file;
    942. 

  942. 				$data = $this->getFileInfo($file);
    943. 

  943. 			}
    944. 

  944. 			return isset($data['video']);
    945. 

  945. 		}		
    946. 

  946. 

  947. 		/**
    948. 

  948. 		 * Determines if the input media has an audio stream.
    949. 

  949. 		 * 
    950. 

  950. 		 * @access public
    951. 

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

  952. 		 * @return bool
    953. 

  953. 		 **/
    954. 

  954. 		function fileHasAudio($file=false)
    955. 

  955. 		{
    956. 

  956. // 			check to see if this is a static call
    957. 

  957. 			if($file !== false && !isset($this))
    958. 

  958. 			{     
    959. 

  959. 				$toolkit = new PHPVideoToolkit();
    960. 

  960. 				$data = $toolkit->getFileInfo($file);
    961. 

  961. 			}
    962. 

  962. // 			if the file has not been specified check to see if an input file has been specified
    963. 

  963. 			else if($file === false)
    964. 

  964. 			{
    965. 

  965. 				if(!$this->_input_file)
    966. 

  966. 				{
    967. 

  967. //					input file not valid
    968. 

  968. 					return $this->_raiseError('inputFileHasAudio_no_input');
    969. 

  969. //<-				exits
    970. 

  970. 				}
    971. 

  971. 				$file = $this->_input_file;
    972. 

  972. 				$data = $this->getFileInfo($file);
    973. 

  973. 			}
    974. 

  974. 			return isset($data['audio']);
    975. 

  975. 		}		
    976. 

  976. 

  977. 		/**
    978. 

  978. 		 * Determines if your ffmpeg has particular codec support for encode or decode.
    979. 

  979. 		 * 
    980. 

  980. 		 * @access public
    981. 

  981. 		 * @param string $codec The name of the codec you are checking for. 
    982. 

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

  983. 		 * @return mixed. Boolean false if there is no support, true if there is support.
    984. 

  984. 		 */
    985. 

  985.    		function hasCodecSupport($codec, $support=PHPVIDEOTOOLKIT_ENCODE)
    986. 

  986. 		{      
    987. 

  987. 			$codec = strtolower($codec);
    988. 

  988. 			$data = $this->getFFmpegInfo();     
    989. 

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

  990. 		}
    991. 

  991. 

  992. 		/**
    993. 

  993. 		 * Sets the input file that is going to be manipulated.
    994. 

  994. 		 *
    995. 

  995. 		 * @access public
    996. 

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

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

  998. 		 * 		any other integer will be set as the incoming frame rate.
    999. 

  999. 		 * @return boolean false on error encountered, true otherwise
    1000. 

  1000. 		 */
    1001. 

  1001. 		function setInputFile($file, $input_frame_rate=0)
    1002. 

  1002. 		{
    1003. 

  1003. 			$files_length = count($file);
    1004. 

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

  1005. 			if($files_length == 1)
    1006. 

  1006. 			{
    1007. 

  1007. //				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
    1008. 

  1008. //				then qheck to see if the file exists
    1009. 

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

  1010. 				{
    1011. 

  1011. //					input file not valid
    1012. 

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

  1013. //<-				exits
    1014. 

  1014. 				}
    1015. 

  1015. 				$escaped_name = $file;
    1016. 

  1016. // 				$escaped_name = escapeshellarg($files[0]);
    1017. 

  1017. 				$this->_input_file = $escaped_name;
    1018. 

  1018. 				$this->_input_file_id = md5($escaped_name);
    1019. 

  1019. 				
    1020. 

  1020. // 				the -inputr is a hack for -r to come before the input
    1021. 

  1021. 				if($input_frame_rate !== 0)
    1022. 

  1022. 				{
    1023. 

  1023. 					$info = $this->getFileInfo();
    1024. 

  1024. 					if(isset($info['video']))
    1025. 

  1025. 					{
    1026. 

  1026. 						if($input_frame_rate === false)
    1027. 

  1027. 						{
    1028. 

  1028. 							$input_frame_rate = $info['video']['frame_rate'];
    1029. 

  1029. 						}
    1030. 

  1030. // 						input frame rate is a command hack
    1031. 

  1031. 						$this->addCommand('-inputr', $input_frame_rate);
    1032. 

  1032. 					}
    1033. 

  1033. 				}
    1034. 

  1034. 			}
    1035. 

  1035. 			else
    1036. 

  1036. 			{
    1037. 

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

  1038. 				call_user_func_array(array(&$this, 'addVideo'), array($file, $input_frame_rate));
    1039. 

  1039. 			}
    1040. 

  1040. 			return true;
    1041. 

  1041. 		}
    1042. 

  1042. 		
    1043. 

  1043. 		/**
    1044. 

  1044. 		 * A shortcut for converting video to FLV.
    1045. 

  1045. 		 *
    1046. 

  1046. 		 * @access public
    1047. 

  1047. 		 * @param integer $audio_sample_frequency
    1048. 

  1048. 		 * @param integer $audio_bitrate
    1049. 

  1049. 		 */
    1050. 

  1050. 		function setFormatToFLV($audio_sample_frequency=44100, $audio_bitrate=64)
    1051. 

  1051. 		{
    1052. 

  1052. 			$this->addCommand('-sameq');
    1053. 

  1053. 			$this->setAudioFormat(PHPVIDEOTOOLKIT_FORMAT_MP3);
    1054. 

  1054. //			adjust the audio rates
    1055. 

  1055. 			$this->setAudioBitRate($audio_bitrate);
    1056. 

  1056. 			$this->setAudioSampleFrequency($audio_sample_frequency);
    1057. 

  1057. //			set the video format
    1058. 

  1058. 			$this->setFormat(PHPVIDEOTOOLKIT_FORMAT_FLV);
    1059. 

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

  1060. // 			register the post tidy process
    1061. 

  1061. 			$this->registerPostProcess('_addMetaToFLV', $this);
    1062. 

  1062. 		}
    1063. 

  1063. 		
    1064. 

  1064. 		/**
    1065. 

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

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

  1067. 		 * http://inlet-media.de/flvtool2
    1068. 

  1068. 		 *
    1069. 

  1069. 		 * @access private
    1070. 

  1070. 		 */
    1071. 

  1071. 		function _addMetaToFLV($files)
    1072. 

  1072. 		{
    1073. 

  1073. 			$file = array_pop($files);
    1074. 

  1074. //			prepare the command suitable for exec
    1075. 

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

  1076. //			execute the command
    1077. 

  1077. 			exec($exec_string);
    1078. 

  1078. 			if(is_array($this->_processed[0]))
    1079. 

  1079. 			{
    1080. 

  1080. 				array_push($this->_processed[0], $exec_string);
    1081. 

  1081. 			}
    1082. 

  1082. 			else
    1083. 

  1083. 			{
    1084. 

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

  1085. 			}
    1086. 

  1086. 			return true;
    1087. 

  1087. 		}
    1088. 

  1088. 

  1089. 		/**
    1090. 

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

  1091. 		 * Inspired by xmoov-php
    1092. 

  1092. 		 * @see xmoov-php, 
    1093. 

  1093. 		 * 		- @link http://xmoov.com/
    1094. 

  1094. 		 * 		- @author Eric Lorenzo Benjamin jr
    1095. 

  1095. 		 * @access public
    1096. 

  1096. 		 * @param integer $seek_pos The position in the file to seek to.
    1097. 

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

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

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

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

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

  1102. 		 * @return boolean
    1103. 

  1103. 		 */
    1104. 

  1104. 		function flvStreamSeek($seek_pos=0, $bandwidth_options=array(), $allow_cache=true)
    1105. 

  1105. 		{
    1106. 

  1106. // 			check for input file
    1107. 

  1107. 			if(!$this->_input_file)
    1108. 

  1108. 			{
    1109. 

  1109. //				input file not valid
    1110. 

  1110. 				return $this->_raiseError('streamFLV_no_input');
    1111. 

  1111. //<-			exits
    1112. 

  1112. 			}
    1113. 

  1113. // 			make the pos safe
    1114. 

  1114.        		$seek_pos = intval($seek_pos);
    1115. 

  1115. // 			absorb the bandwidth options
    1116. 

  1116. 			$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);
    1117. 

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

  1118. 			if(!$allow_cache)
    1119. 

  1119. 			{
    1120. 

  1120. 				session_cache_limiter('nocache');
    1121. 

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

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

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

  1124. 				header('Pragma: no-cache');
    1125. 

  1125. 			}
    1126. 

  1126. // 			open file
    1127. 

  1127.             $handle = fopen($this->_input_file, 'rb');
    1128. 

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

  1129. // 			send the flv headers
    1130. 

  1130. 			header('Content-Type: video/x-flv');
    1131. 

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

  1132. 			header('Content-Length: '.$file_size);
    1133. 

  1133. // 			flv format header
    1134. 

  1134.             if($seek_pos != 0) 
    1135. 

  1135.             {
    1136. 

  1136.                 print('FLV');
    1137. 

  1137.                 print(pack('C', 1));
    1138. 

  1138.                 print(pack('C', 1));
    1139. 

  1139.                 print(pack('N', 9));
    1140. 

  1140.                 print(pack('N', 9));
    1141. 

  1141.             }
    1142. 

  1142. // 			seek to the required point
    1143. 

  1143.             if(fseek($handle, $seek_pos) === -1)
    1144. 

  1144. 			{
    1145. 

  1145. //				input file not valid
    1146. 

  1146. 				return $this->_raiseError('streamFLV_passed_eof');
    1147. 

  1147. //<-			exits
    1148. 

  1148. 			}
    1149. 

  1149. // 			if bandwidth control is active then workout the options
    1150. 

  1150. 			if($bandwid…
    1151.

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