PageRenderTime 69ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 1ms

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

https://bitbucket.org/priyadarshan_salkar/thinkshaddi
PHP | 3585 lines | 1847 code | 226 blank | 1512 comment | 363 complexity | 4eb049d3aced0707eddc3f2d885b42de MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, AGPL-1.0 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * @file
    4. 

  4.  * Libary to access FFmpeg
    5. 

  5.  */
    6. 

  6. 

  7. /**
    8. 

  8.  * @author Oliver Lillie (aka buggedcom) <publicmail@buggedcom.co.uk>
    9. 

  9.  *
    10. 

  10.  * @license GPL 2.0
    11. 

  11.  *
    12. 

  12.  * @package FFMPEG (was called PHPVideoToolkit)
    13. 

  13.  * @version 0.1.9
    14. 

  14.  *
    15. 

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

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

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

  18.  * alone.
    19. 

  19.  *
    20. 

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

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

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

  23.  * 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
    24. 

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

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

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

  27.  *
    28. 

  28.  * @uses ffmpeg http://ffmpeg.org
    29. 

  29.  */
    30. 

  30. if (!defined('DS')) {
    31. 

  31.   define('DS', DIRECTORY_SEPARATOR);
    32. 

  32. }
    33. 

  33. 

  34. /**
    35. 

  35.  * Set the flvtool2 binary path
    36. 

  36.  */
    37. 

  37. if (!defined('PHPVIDEOTOOLKIT_FLVTOOLS_BINARY')) {
    38. 

  38.   define('PHPVIDEOTOOLKIT_FLVTOOLS_BINARY', '/usr/bin/flvtool2');
    39. 

  39. }
    40. 

  40. /**
    41. 

  41.  * Set the watermark vhook path
    42. 

  42.  */
    43. 

  43. if (!defined('PHPVIDEOTOOLKIT_FFMPEG_WATERMARK_VHOOK')) {
    44. 

  44.   define('PHPVIDEOTOOLKIT_FFMPEG_WATERMARK_VHOOK', '/usr/local/lib/vhook/watermark.so');
    45. 

  45. }
    46. 

  46. /**
    47. 

  47.  * Set the memcoder path
    48. 

  48.  */
    49. 

  49. if (!defined('PHPVIDEOTOOLKIT_MENCODER_BINARY')) {
    50. 

  50.   define('PHPVIDEOTOOLKIT_MENCODER_BINARY', '/usr/local/bin/mencoder');
    51. 

  51. }
    52. 

  52. 

  53. class PHPVideoToolkit {
    54. 

  54.   public $version = '0.1.9';
    55. 

  55. 

  56.   /**
    57. 

  57.    * Error strings
    58. 

  58.    */
    59. 

  59.   protected $_messages = array(
    60. 

  60.     'generic_temp_404' => 'The temporary directory does not exist.',
    61. 

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

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

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

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

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

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

  67.     'setInputFile_file_existence' => 'Input file "#file" does not exist',
    68. 

  68.     '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.',
    69. 

  69.     '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.',
    70. 

  70.     '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.',
    71. 

  71.     '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.',
    72. 

  72.     '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.',
    73. 

  73.     '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.',
    74. 

  74.     '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.',
    75. 

  75.     '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.',
    76. 

  76.     '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.',
    77. 

  77.     'setAudioFormat_valid_format' => 'Value "#format" set from $toolkit->setAudioCodec, 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.',
    78. 

  78.     'setAudioFormat_cannnot_encode' => 'Value "#codec" set from $toolkit->setAudioCodec, can not be used to encode the output as the version of FFmpeg that you are using does not have the capability to encode audio with this codec.',
    79. 

  79.     'setVideoFormat_valid_format' => 'Value "#format" set from $toolkit->setVideoCodec, 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.',
    80. 

  80.     'setVideoFormat_cannnot_encode' => 'Value "#codec" set from $toolkit->setVideoCodec, can not be used to encode the output as the version of FFmpeg that you are using does not have the capability to encode video with this codec.',
    81. 

  81.     '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.',
    82. 

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

  83.     'prepareImagesForConversionToVideo_img_404' => '"#img" does not exist.',
    84. 

  84.     'prepareImagesForConversionToVideo_img_copy' => '"#img" can not be copied to "#tmpfile"',
    85. 

  85.     '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.',
    86. 

  86.     '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.',
    87. 

  87.     '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);',
    88. 

  88.     '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',
    89. 

  89.     '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.',
    90. 

  90.     'addWatermark_img_404' => 'Watermark file "#watermark" does not exist.',
    91. 

  91.     '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.',
    92. 

  92.     'addVideo_file_404' => 'File "#file" does not exist.',
    93. 

  93.     'setOutput_output_dir_404' => 'Output directory "#dir" does not exist!',
    94. 

  94.     'setOutput_output_dir_writable' => 'Output directory "#dir" is not writable!',
    95. 

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

  96.     '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.',
    97. 

  97.     'execute_input_404' => 'Execute error. Input file missing.',
    98. 

  98.     'execute_output_not_set' => 'Execute error. Output not set.',
    99. 

  99.     'execute_temp_unwritable' => 'Execute error. The tmp directory supplied is not writable.',
    100. 

  100.     '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.',
    101. 

  101.     '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".',
    102. 

  102.     'execute_ffmpeg_return_error' => 'Execute error. It was not possible to encode "#input" as FFmpeg returned an error. The error #stream of the input file. FFmpeg reports the error to be "#message".',
    103. 

  103.     'execute_ffmpeg_return_error_multipass' => 'Execute error. It was not possible to encode "#input" as FFmpeg returned an error. Note, however the error was encountered on the second pass of the encoding process and the first pass appear to go fine. The error #stream of the input file. FFmpeg reports the error to be "#message".',
    104. 

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

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

  106.     '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().',
    107. 

  107.     '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().',
    108. 

  108.     '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".',
    109. 

  109.     '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.',
    110. 

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

  111.     'ffmpeg_log_ffmpeg_output' => 'OUTPUT',
    112. 

  112.     'ffmpeg_log_ffmpeg_result' => 'RESULT',
    113. 

  113.     'ffmpeg_log_ffmpeg_command' => 'COMMAND',
    114. 

  114.     'ffmpeg_log_ffmpeg_join_gunk' => 'FFMPEG JOIN OUTPUT',
    115. 

  115.     'ffmpeg_log_ffmpeg_gunk' => 'FFMPEG OUTPUT',
    116. 

  116.     'ffmpeg_log_separator' => '-------------------------------'
    117. 

  117.   );
    118. 

  118. 

  119.   /**
    120. 

  120.    * Process Results from PHPVideoToolkit::execute
    121. 

  121.    */
    122. 

  122. // 		any return value with this means everything is ok
    123. 

  123.   const RESULT_OK = TRUE;
    124. 

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

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

  126. // 		processed file manually from the temp location
    127. 

  127.   const RESULT_OK_BUT_UNWRITABLE = -1;
    128. 

  128. 

  129.   /**
    130. 

  130.    * Codec support constants
    131. 

  131.    */
    132. 

  132.   const ENCODE = 'encode';
    133. 

  133.   const DECODE = 'decode';
    134. 

  134. 

  135.   /**
    136. 

  136.    * Overwrite constants used in setOutput
    137. 

  137.    */
    138. 

  138.   const OVERWRITE_FAIL = 'fail';
    139. 

  139.   const OVERWRITE_PRESERVE = 'preserve';
    140. 

  140.   const OVERWRITE_EXISTING = 'existing';
    141. 

  141.   const OVERWRITE_UNIQUE = 'unique';
    142. 

  142. 

  143.   /**
    144. 

  144.    * Formats supported
    145. 

  145.    * 3g2             3gp2 format
    146. 

  146.    * 3gp             3gp format
    147. 

  147.    * aac             ADTS AAC
    148. 

  148.    * aiff            Audio IFF
    149. 

  149.    * amr             3gpp amr file format
    150. 

  150.    * asf             asf format
    151. 

  151.    * avi             avi format
    152. 

  152.    * flv             flv format
    153. 

  153.    * gif             GIF Animation
    154. 

  154.    * mov             mov format
    155. 

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

  156.    * mp2             MPEG audio layer 2
    157. 

  157.    * mp3             MPEG audio layer 3
    158. 

  158.    * mp4             mp4 format
    159. 

  159.    * mpeg            MPEG1 System format
    160. 

  160.    * mpeg1video      MPEG video
    161. 

  161.    * mpeg2video      MPEG2 video
    162. 

  162.    * mpegvideo       MPEG video
    163. 

  163.    * psp             psp mp4 format
    164. 

  164.    * rm              rm format
    165. 

  165.    * swf             Flash format
    166. 

  166.    * vob             MPEG2 PS format (VOB)
    167. 

  167.    * wav             wav format
    168. 

  168.    * jpeg            mjpeg format
    169. 

  169.    * yuv4mpegpipe    yuv4mpegpipe format
    170. 

  170.    */
    171. 

  171.   const FORMAT_3GP2 = '3g2';
    172. 

  172.   const FORMAT_3GP = '3gp';
    173. 

  173.   const FORMAT_AAC = 'aac';
    174. 

  174.   const FORMAT_AIFF = 'aiff';
    175. 

  175.   const FORMAT_AMR = 'amr';
    176. 

  176.   const FORMAT_ASF = 'asf';
    177. 

  177.   const FORMAT_AVI = 'avi';
    178. 

  178.   const FORMAT_FLV = 'flv';
    179. 

  179.   const FORMAT_GIF = 'gif';
    180. 

  180.   const FORMAT_MJ2 = 'mj2';
    181. 

  181.   const FORMAT_MP2 = 'mp2';
    182. 

  182.   const FORMAT_MP3 = 'mp3';
    183. 

  183.   const FORMAT_MP4 = 'mp4';
    184. 

  184.   const FORMAT_MPEG4 = 'mpeg4';
    185. 

  185.   const FORMAT_M4A = 'm4a';
    186. 

  186.   const FORMAT_MPEG = 'mpeg';
    187. 

  187.   const FORMAT_MPEG1 = 'mpeg1video';
    188. 

  188.   const FORMAT_MPEG2 = 'mpeg2video';
    189. 

  189.   const FORMAT_MPEGVIDEO = 'mpegvideo';
    190. 

  190.   const FORMAT_PSP = 'psp';
    191. 

  191.   const FORMAT_RM = 'rm';
    192. 

  192.   const FORMAT_SWF = 'swf';
    193. 

  193.   const FORMAT_VOB = 'vob';
    194. 

  194.   const FORMAT_WAV = 'wav';
    195. 

  195.   const FORMAT_JPG = 'mjpeg';
    196. 

  196.   const FORMAT_Y4MP = 'yuv4mpegpipe';
    197. 

  197. 

  198.   /**
    199. 

  199.    * Size Presets
    200. 

  200.    */
    201. 

  201.   const SIZE_SAS = 'SameAsSource';
    202. 

  202.   const SIZE_SQCIF = '128x96';
    203. 

  203.   const SIZE_QCIF = '176x144';
    204. 

  204.   const SIZE_CIF = '352x288';
    205. 

  205.   const SIZE_4CIF = '704x576';
    206. 

  206.   const SIZE_QQVGA = '160x120';
    207. 

  207.   const SIZE_QVGA = '320x240';
    208. 

  208.   const SIZE_VGA = '640x480';
    209. 

  209.   const SIZE_SVGA = '800x600';
    210. 

  210.   const SIZE_XGA = '1024x768';
    211. 

  211.   const SIZE_UXGA = '1600x1200';
    212. 

  212.   const SIZE_QXGA = '2048x1536';
    213. 

  213.   const SIZE_SXGA = '1280x1024';
    214. 

  214.   const SIZE_QSXGA = '2560x2048';
    215. 

  215.   const SIZE_HSXGA = '5120x4096';
    216. 

  216.   const SIZE_WVGA = '852x480';
    217. 

  217.   const SIZE_WXGA = '1366x768';
    218. 

  218.   const SIZE_WSXGA = '1600x1024';
    219. 

  219.   const SIZE_WUXGA = '1920x1200';
    220. 

  220.   const SIZE_WOXGA = '2560x1600';
    221. 

  221.   const SIZE_WQSXGA = '3200x2048';
    222. 

  222.   const SIZE_WQUXGA = '3840x2400';
    223. 

  223.   const SIZE_WHSXGA = '6400x4096';
    224. 

  224.   const SIZE_WHUXGA = '7680x4800';
    225. 

  225.   const SIZE_CGA = '320x200';
    226. 

  226.   const SIZE_EGA = '640x350';
    227. 

  227.   const SIZE_HD480 = '852x480';
    228. 

  228.   const SIZE_HD720 = '1280x720';
    229. 

  229.   const SIZE_HD1080 = '1920x1080';
    230. 

  230. 

  231.   /**
    232. 

  232.    * Ratio Presets
    233. 

  233.    */
    234. 

  234.   const RATIO_STANDARD = '4:3';
    235. 

  235.   const RATIO_WIDE = '16:9';
    236. 

  236.   const RATIO_CINEMATIC = '1.85';
    237. 

  237. 

  238.   /**
    239. 

  239.    * Audio Channel Presets
    240. 

  240.    */
    241. 

  241.   const AUDIO_STEREO = 2;
    242. 

  242.   const AUDIO_MONO = 1;
    243. 

  243. 

  244.   /**
    245. 

  245.    * A public var that is to the information available about
    246. 

  246.    * the current ffmpeg compiled binary.
    247. 

  247.    * @var mixed
    248. 

  248.    * @access public
    249. 

  249.    */
    250. 

  250.   public static $ffmpeg_info = FALSE;
    251. 

  251. 

  252.   /**
    253. 

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

  254.    * is NULL unless getFFmpegInfo is called whereby depending on the results it is set to
    255. 

  255.    * TRUE or FALSE
    256. 

  256.    * @var mixed
    257. 

  257.    * @access public
    258. 

  258.    */
    259. 

  259.   public static $ffmpeg_found = NULL;
    260. 

  260. 

  261.   /**
    262. 

  262.    * A protected var that contains the info of any file that is accessed by PHPVideoToolkit::getFileInfo();
    263. 

  263.    * @var array
    264. 

  264.    * @access protected
    265. 

  265.    */
    266. 

  266.   protected static $_file_info = array();
    267. 

  267. 

  268.   /**
    269. 

  269.    * Determines what happens when an error occurs
    270. 

  270.    * @var boolean If TRUE then the script will die, if not FALSE is return by the error
    271. 

  271.    * @access public
    272. 

  272.    */
    273. 

  273.   public $on_error_die = FALSE;
    274. 

  274. 

  275.   /**
    276. 

  276.    * Holds the log file name
    277. 

  277.    * @var string
    278. 

  278.    * @access protected
    279. 

  279.    */
    280. 

  280.   protected $_log_file = NULL;
    281. 

  281. 

  282.   /**
    283. 

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

  284.    * replaced with the frames timecode.
    285. 

  285.    * @var boolean If TRUE then the files will be renamed.
    286. 

  286.    * @access public
    287. 

  287.    */
    288. 

  288.   public $image_output_timecode = TRUE;
    289. 

  289. 

  290.   /**
    291. 

  291.    * Holds the timecode separator for when using $image_output_timecode = TRUE
    292. 

  292.    * Not all systems allow ':' in filenames.
    293. 

  293.    * @var string
    294. 

  294.    * @access public
    295. 

  295.    */
    296. 

  296.   public $timecode_seperator_output = '-';
    297. 

  297. 

  298.   /**
    299. 

  299.    * Holds the starting time code when outputting image frames.
    300. 

  300.    * @var string The timecode hh(n):mm:ss:ff
    301. 

  301.    * @access protected
    302. 

  302.    */
    303. 

  303.   protected $_image_output_timecode_start = '00:00:00.00';
    304. 

  304. 

  305.   /**
    306. 

  306.    * The format in which the image %timecode placeholder string is outputted.
    307. 

  307.    * 	- %hh (hours) representative of hours
    308. 

  308.    * 	- %mm (minutes) representative of minutes
    309. 

  309.    * 	- %ss (seconds) representative of seconds
    310. 

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

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

  312.    * 	- %ft (frames total) representative of total frames (ie frame number)
    313. 

  313.    * 	- %st (seconds total) representative of total seconds (rounded).
    314. 

  314.    * 	- %sf (seconds floored) representative of total seconds (floored).
    315. 

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

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

  317.    * 	- :
    318. 

  318.    *  - .
    319. 

  319.    * @var string
    320. 

  320.    * @access public
    321. 

  321.    */
    322. 

  322.   protected $image_output_timecode_format = '%hh-%mm-%ss-%fn';
    323. 

  323. 

  324.   /**
    325. 

  325.    * Holds the fps of image extracts
    326. 

  326.    * @var integer
    327. 

  327.    * @access protected
    328. 

  328.    */
    329. 

  329.   protected $_image_output_timecode_fps = 1;
    330. 

  330. 

  331.   /**
    332. 

  332.    * Holds the current execute commands that will need to be combined
    333. 

  333.    * @var array
    334. 

  334.    * @access protected
    335. 

  335.    */
    336. 

  336.   protected $_commands = array();
    337. 

  337. 

  338.   /**
    339. 

  339.    * Holds the commands executed
    340. 

  340.    * @var array
    341. 

  341.    * @access protected
    342. 

  342.    */
    343. 

  343.   protected $_processed = array();
    344. 

  344. 

  345.   /**
    346. 

  346.    * Holds the file references to those that have been processed
    347. 

  347.    * @var array
    348. 

  348.    * @access protected
    349. 

  349.    */
    350. 

  350.   protected $_files = array();
    351. 

  351. 

  352.   /**
    353. 

  353.    * Holds the errors encountered
    354. 

  354.    * @access protected
    355. 

  355.    * @var array
    356. 

  356.    */
    357. 

  357.   protected $_errors = array();
    358. 

  358. 

  359.   /**
    360. 

  360.    * Holds the input file / input file sequence
    361. 

  361.    * @access protected
    362. 

  362.    * @var string
    363. 

  363.    */
    364. 

  364.   protected $_input_file = NULL;
    365. 

  365. 

  366.   /**
    367. 

  367.    * Holds the output file / output file sequence
    368. 

  368.    * @access protected
    369. 

  369.    * @var string
    370. 

  370.    */
    371. 

  371.   protected $_output_address = NULL;
    372. 

  372. 

  373.   /**
    374. 

  374.    * Holds the process file / process file sequence
    375. 

  375.    * @access protected
    376. 

  376.    * @var string
    377. 

  377.    */
    378. 

  378.   protected $_process_address = NULL;
    379. 

  379. 

  380.   /**
    381. 

  381.    * Temporary filename prefix
    382. 

  382.    * @access protected
    383. 

  383.    * @var string
    384. 

  384.    */
    385. 

  385.   protected $_tmp_file_prefix = 'tmp_';
    386. 

  386. 

  387.   /**
    388. 

  388.    * Holds the temporary directory name
    389. 

  389.    * @access protected
    390. 

  390.    * @var string
    391. 

  391.    */
    392. 

  392.   protected $_tmp_directory = NULL;
    393. 

  393. 

  394.   /**
    395. 

  395.    * Holds the directory paths that need to be removed by the ___destruct function
    396. 

  396.    * @access protected
    397. 

  397.    * @var array
    398. 

  398.    */
    399. 

  399.   protected $_unlink_dirs = array();
    400. 

  400. 

  401.   /**
    402. 

  402.    * Holds the file paths that need to be deleted by the ___destruct function
    403. 

  403.    * @access protected
    404. 

  404.    * @var array
    405. 

  405.    */
    406. 

  406.   protected $_unlink_files = array();
    407. 

  407. 

  408.   /**
    409. 

  409.    * Holds the timer start micro-float.
    410. 

  410.    * @access protected
    411. 

  411.    * @var integer
    412. 

  412.    */
    413. 

  413.   protected $_timer_start = 0;
    414. 

  414. 

  415.   /**
    416. 

  416.    * Holds the times taken to process each file.
    417. 

  417.    * @access protected
    418. 

  418.    * @var array
    419. 

  419.    */
    420. 

  420.   protected $_timers = array();
    421. 

  421. 

  422.   /**
    423. 

  423.    * Holds the times taken to process each file.
    424. 

  424.    * @access protected
    425. 

  425.    * @var constant
    426. 

  426.    */
    427. 

  427.   protected $_overwrite_mode = NULL;
    428. 

  428. 

  429.   /**
    430. 

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

  431.    * @access protected
    432. 

  432.    * @var integer
    433. 

  433.    */
    434. 

  434.   protected $_single_frame_extraction = NULL;
    435. 

  435. 

  436.   /**
    437. 

  437.    * Holds the watermark file that is used to watermark any outputted images via GD.
    438. 

  438.    * @access protected
    439. 

  439.    * @var string
    440. 

  440.    */
    441. 

  441.   protected $_watermark_url = NULL;
    442. 

  442. 

  443.   /**
    444. 

  444.    * Holds the watermark options used to watermark any outputted images via GD.
    445. 

  445.    * @access protected
    446. 

  446.    * @var array
    447. 

  447.    */
    448. 

  448.   protected $_watermark_options = NULL;
    449. 

  449. 

  450.   /**
    451. 

  451.    * Holds the number of files processed per run.
    452. 

  452.    * @access protected
    453. 

  453.    * @var integer
    454. 

  454.    */
    455. 

  455.   protected $_process_file_count = 0;
    456. 

  456. 

  457.   /**
    458. 

  458.    * Holds the times taken to process each file.
    459. 

  459.    * @access protected
    460. 

  460.    * @var array
    461. 

  461.    */
    462. 

  462.   protected $_post_processes = array();
    463. 

  463. 

  464.   /**
    465. 

  465.    * Stores command output
    466. 

  466.    * @var array
    467. 

  467.    */
    468. 

  468.   protected $_command_output = array();
    469. 

  469. 

  470.   // Stores the FFMPEG Binary Path
    471. 

  471.   protected $_ffmpeg_binary;
    472. 

  472. 

  473.   /**
    474. 

  474.    * Constructs the class and sets the temporary directory.
    475. 

  475.    *
    476. 

  476.    * @access protected
    477. 

  477.    * @param string $tmp_directory A full absolute path to you temporary directory
    478. 

  478.    */
    479. 

  479.   function __construct($ffmpeg_binary = '/usr/bin/ffmpeg', $tmp_dir='/tmp/') {
    480. 

  480. // 			print_r(array(debug_backtrace(), $tmp_dir));
    481. 

  481.     $this->_ffmpeg_binary = $ffmpeg_binary;
    482. 

  482.     $this->_tmp_directory = $tmp_dir;
    483. 

  483.   }
    484. 

  484. 

  485.   public static function microtimeFloat() {
    486. 

  486.     list($usec, $sec) = explode(" ", microtime());
    487. 

  487.     return ((float) $usec + (float) $sec);
    488. 

  488.   }
    489. 

  489. 

  490.   /**
    491. 

  491.    * Resets the class
    492. 

  492.    *
    493. 

  493.    * @access public
    494. 

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

  495.    */
    496. 

  496.   public function reset($keep_input_file=FALSE, $keep_processes=FALSE) {
    497. 

  497.     if ($keep_input_file === FALSE) {
    498. 

  498.       $this->_input_file = NULL;
    499. 

  499.     }
    500. 

  500.     if ($keep_processes === FALSE) {
    501. 

  501.       $this->_post_processes = array();
    502. 

  502.     }
    503. 

  503.     $this->_single_frame_extraction = NULL;
    504. 

  504.     $this->_output_address = NULL;
    505. 

  505.     $this->_process_address = NULL;
    506. 

  506.     $this->_log_file = NULL;
    507. 

  507.     $this->_commands = array();
    508. 

  508.     $this->_command_output = array();
    509. 

  509.     $this->_timer_start = 0;
    510. 

  510.     $this->_process_file_count = 0;
    511. 

  511.     $this->__destruct();
    512. 

  512.   }
    513. 

  513. 

  514.   private function _captureExecBufferFallback() {
    515. 

  515.     $commands = func_get_args();
    516. 

  516. 

  517.     foreach ($commands as $command) {
    518. 

  518.       $buffer = array();
    519. 

  519.       $err = 0;
    520. 

  520.       exec($command . ' 2>&1', $buffer, $err);
    521. 

  521.       if ($err === 0) {
    522. 

  522.         return $buffer;
    523. 

  523.       }
    524. 

  524.     }
    525. 

  525. 

  526.     return array();
    527. 

  527.   }
    528. 

  528. 

  529.   private function _captureExecBuffer($command) {
    530. 

  530.     $buffer = array();
    531. 

  531.     $err = 0;
    532. 

  532.     exec($command . ' 2>&1', $buffer, $err);
    533. 

  533. 

  534.     if ($err !== 127) {
    535. 

  535.       if (isset($buffer[0]) === FALSE) {
    536. 

  536.         $tmp_file = $this->_tmp_directory . '_temp_' . uniqid(time() . '-') . '.txt';
    537. 

  537.         exec($command . ' &>' . $tmp_file, $buffer, $err);
    538. 

  538.         if ($handle = fopen($tmp_file, 'r')) {
    539. 

  539.           $buffer = array();
    540. 

  540.           while (!feof($handle)) {
    541. 

  541.             array_push($buffer, fgets($handle, 4096));
    542. 

  542.           }
    543. 

  543.           fclose($handle);
    544. 

  544.         }
    545. 

  545.         @unlink($tmp_file);
    546. 

  546.       }
    547. 

  547.     }
    548. 

  548. 

  549.     $this->_command_output[] = array(
    550. 

  550.       'command' => $command,
    551. 

  551.       'output' => implode("\n", $buffer),
    552. 

  552.     );
    553. 

  553. 

  554.     return $buffer;
    555. 

  555.   }
    556. 

  556. 

  557.   /**
    558. 

  558.    * Returns information about the specified file without having to use ffmpeg-php
    559. 

  559.    * as it consults the ffmpeg binary directly.
    560. 

  560.    * NOTE: calling this statically for caching to work you must set the temp directory.
    561. 

  561.    *
    562. 

  562.    * @access public
    563. 

  563.    * @return mixed FALSE on error encountered, TRUE otherwise
    564. 

  564.    * */
    565. 

  565.   public function getFFmpegInfo($read_from_cache = TRUE) {
    566. 

  566.     // check to see if the info has already been cached
    567. 

  567.     if ($read_from_cache && PHPVideoToolkit::$ffmpeg_info !== FALSE) {
    568. 

  568.       return PHPVideoToolkit::$ffmpeg_info;
    569. 

  569.     }
    570. 

  570. 

  571.     $data = array();
    572. 

  572. 

  573.     $formats = $this->_captureExecBuffer($this->_ffmpeg_binary . ' -formats');
    574. 

  574.     $codecs = $this->_captureExecBuffer($this->_ffmpeg_binary . ' -codecs');
    575. 

  575.     $filters = $this->_captureExecBuffer($this->_ffmpeg_binary . ' -bsfs');
    576. 

  576.     $protocols = $this->_captureExecBuffer($this->_ffmpeg_binary . ' -protocols');
    577. 

  577.     $pixformats = $this->_captureExecBufferFallback($this->_ffmpeg_binary . ' -pix_fmts', $this->_ffmpeg_binary . ' -pix_fmt list');
    578. 

  578.     $help = $this->_captureExecBuffer($this->_ffmpeg_binary . ' -h');
    579. 

  579. 

  580.     self::$ffmpeg_found = $data['ffmpeg-found'] = !empty($formats) && strpos($formats[0], 'not found') === FALSE && strpos($formats[0], 'No such file or directory') === FALSE;
    581. 

  581. 

  582.     $data['compiler'] = array();
    583. 

  583.     $data['binary'] = array();
    584. 

  584.     $data['ffmpeg-php-support'] = self::hasFFmpegPHPSupport();
    585. 

  585. 

  586.     // FFmpeg 0.5 and lower don't support -codecs, -bsfs or -protocols, but the info is in -formats
    587. 

  587.     if (strpos(end($codecs), 'missing argument for option')) {
    588. 

  588.       $formats = implode("\n", $formats);
    589. 

  589.       $codecs = $formats;
    590. 

  590.       $filters = $formats;
    591. 

  591.       $protocols = $formats;
    592. 

  592.       $pixformats = implode("\n", $pixformats);
    593. 

  593.       $help = implode("\n", $help);
    594. 

  594.       $data['raw'] = $formats . $pixformats;
    595. 

  595.     }
    596. 

  596.     else {
    597. 

  597.       $formats = implode("\n", $formats);
    598. 

  598.       $codecs = implode("\n", $codecs);
    599. 

  599.       $filters = implode("\n", $filters);
    600. 

  600.       $protocols = implode("\n", $protocols);
    601. 

  601.       $pixformats = implode("\n", $pixformats);
    602. 

  602.       $help = implode("\n", $help);
    603. 

  603.       $data['raw'] = $formats . "\n" . $codecs . "\n" . $filters . "\n" . $protocols . "\n" . $pixformats;
    604. 

  604.     }
    605. 

  605. 

  606.     if (!self::$ffmpeg_found) {
    607. 

  607.       self::$ffmpeg_info = $data;
    608. 

  608.       return $data;
    609. 

  609.     }
    610. 

  610. 

  611.     // grab the versions
    612. 

  612.     $data['binary']['versions'] = self::getVersion($data['raw']);
    613. 

  613. 

  614.     // grab the ffmpeg configuration flags
    615. 

  615.     $config_flags = array();
    616. 

  616.     if (preg_match_all('/--[a-zA-Z0-9\-]+/', $formats, $config_flags)) {
    617. 

  617.       $data['binary']['configuration'] = $config_flags[0];
    618. 

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

  619. 

  620.       // grab the ffmpeg compile info
    621. 

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

  622.       if (count($conf) > 0) {
    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.     }
    628. 

  628. 

  629.     // grab the file formats available to ffmpeg
    630. 

  630.     $formatmatches = array();
    631. 

  631.     $data['formats'] = array();
    632. 

  632.     if (preg_match_all('/ (DE|D|E) (.*) {1,} (.*)/', $formats, $formatmatches)) {
    633. 

  633. // 			loop and clean
    634. 

  634. // Formats:
    635. 

  635. //  D. = Demuxing supported
    636. 

  636. //  .E = Muxing supported
    637. 

  637.       for ($i = 0, $a = count($formatmatches[0]); $i < $a; $i++) {
    638. 

  638.         $data['formats'][strtolower(trim($formatmatches[2][$i]))] = array(
    639. 

  639.           'mux' => $formatmatches[1][$i] == 'DE' || $formatmatches[1][$i] == 'E',
    640. 

  640.           'demux' => $formatmatches[1][$i] == 'DE' || $formatmatches[1][$i] == 'D',
    641. 

  641.           'fullname' => $formatmatches[3][$i]
    642. 

  642.         );
    643. 

  643.       }
    644. 

  644.     }
    645. 

  645. 

  646.     // grab the codecs available
    647. 

  647.     $codecsmatches = array();
    648. 

  648.     $data['codecs'] = array('video' => array(), 'audio' => array(), 'subtitle' => array());
    649. 

  649.     if (preg_match_all('/ ((?:[DEVAST ]{6})|(?:[DEVASTFB ]{8})|(?:[DEVASIL\.]{6})) ([A-Za-z0-9\_]+) (.+)/', $codecs, $codecsmatches)) {
    650. 

  650. 

  651. // FFmpeg 0.12+
    652. 

  652. //  D..... = Decoding supported
    653. 

  653. //  .E.... = Encoding supported
    654. 

  654. //  ..V... = Video codec
    655. 

  655. //  ..A... = Audio codec
    656. 

  656. //  ..S... = Subtitle codec
    657. 

  657. //  ...I.. = Intra frame-only codec
    658. 

  658. //  ....L. = Lossy compression
    659. 

  659. //  .....S = Lossless compression
    660. 

  660. 

  661. // FFmpeg other
    662. 

  662. //  D..... = Decoding supported
    663. 

  663. //  .E.... = Encoding supported
    664. 

  664. //  ..V... = Video codec
    665. 

  665. //  ..A... = Audio codec
    666. 

  666. //  ..S... = Subtitle codec
    667. 

  667. //  ...S.. = Supports draw_horiz_band
    668. 

  668. //  ....D. = Supports direct rendering method 1
    669. 

  669. //  .....T = Supports weird frame truncation
    670. 

  670. 

  671.       for ($i = 0, $a = count($codecsmatches[0]); $i < $a; $i++) {
    672. 

  672.         $options = preg_split('//', $codecsmatches[1][$i], -1, PREG_SPLIT_NO_EMPTY);
    673. 

  673.         if ($options) {
    674. 

  674.           $id = trim($codecsmatches[2][$i]);
    675. 

  675.           $type = $options[2] === 'V' ? 'video' : ($options[2] === 'A' ? 'audio' : 'subtitle');
    676. 

  676.           switch ($options[2]) {
    677. 

  677.           // 					video
    678. 

  678.             case 'V' :
    679. 

  679.               $data['codecs'][$type][$id] = array(
    680. 

  680.                 'encode' => isset($options[1]) === TRUE && $options[1] === 'E',
    681. 

  681.                 'decode' => isset($options[0]) === TRUE && $options[0] === 'D',
    682. 

  682.                 'draw_horizontal_band' => isset($options[3]) === TRUE && $options[3] === 'S',
    683. 

  683.                 'direct_rendering_method_1' => isset($options[4]) === TRUE && $options[4] === 'D',
    684. 

  684.                 'weird_frame_truncation' => isset($options[5]) === TRUE && $options[5] === 'T',
    685. 

  685.                 'fullname' => trim($codecsmatches[3][$i])
    686. 

  686.               );
    687. 

  687.               break;
    688. 

  688.           // 					audio
    689. 

  689.             case 'A' :
    690. 

  690.           // 					subtitle
    691. 

  691.             case 'S' :
    692. 

  692.               $data['codecs'][$type][$id] = array(
    693. 

  693.                 'encode' => isset($options[1]) === TRUE && $options[1] === 'E',
    694. 

  694.                 'decode' => isset($options[0]) === TRUE && $options[0] === 'D',
    695. 

  695.                 'fullname' => trim($codecsmatches[3][$i])
    696. 

  696.               );
    697. 

  697.               break;
    698. 

  698.           }
    699. 

  699.         }
    700. 

  700.       }
    701. 

  701.     }
    702. 

  702. 

  703.     // grab the bitstream filters available to ffmpeg
    704. 

  704.     $data['filters'] = array();
    705. 

  705.     $locate = 'Bitstream filters:';
    706. 

  706.     if (!empty($filters) && ($pos = strpos($filters, $locate)) !== FALSE) {
    707. 

  707.       $filters = trim(substr($filters, $pos + strlen($locate)));
    708. 

  708.       $data['filters'] = explode("\n", $filters);
    709. 

  709.     }
    710. 

  710. 

  711.     // grab the file protocols available to ffmpeg
    712. 

  712.     $data['protocols'] = array();
    713. 

  713.     $locate = 'Supported file protocols:';
    714. 

  714.     if (!empty($protocols) && ($pos = strpos($protocols, $locate)) !== FALSE) {
    715. 

  715.       $protocols = trim(substr($filters, $pos + strlen($locate)));
    716. 

  716.       $data['protocols'] = explode("\n", $protocols);
    717. 

  717.     }
    718. 

  718. 

  719.     // grab the pixel formats available to ffmpeg
    720. 

  720.     $data['pixelformats'] = array();
    721. 

  721.     // Separate code for FFmpeg 0.5
    722. 

  722.     if (strpos($pixformats, 'Pixel formats') === FALSE) {
    723. 

  723.       // Format:
    724. 

  724.       // name       nb_channels depth is_alpha
    725. 

  725.       // yuv420p         3         8      n
    726. 

  726.       // yuyv422         1         8      n
    727. 

  727.       $matches = array();
    728. 

  728.       preg_match_all('#(\w+)\s+(\d+)\s+(\d+)\s+(y|n)#', $pixformats, $matches, PREG_SET_ORDER);
    729. 

  729.       foreach ($matches as $match) {
    730. 

  730.         $data['pixelformats'][$match[1]] = array(
    731. 

  731.           'encode' => TRUE, // Assume true
    732. 

  732.           'decode' => TRUE, // Assume true
    733. 

  733.           'components' => intval($match[2]),
    734. 

  734.           'bpp' => intval($match[3]),
    735. 

  735.         );
    736. 

  736.       }
    737. 

  737.     }
    738. 

  738.     else {
    739. 

  739.       // Format:
    740. 

  740.       // Pixel formats:
    741. 

  741.       // I.... = Supported Input  format for conversion
    742. 

  742.       // .O... = Supported Output format for conversion
    743. 

  743.       // ..H.. = Hardware accelerated format
    744. 

  744.       // ...P. = Paletted format
    745. 

  745.       // ....B = Bitstream format
    746. 

  746.       // FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL
    747. 

  747.       // -----
    748. 

  748.       // IO... yuv420p                3            12
    749. 

  749.       $matches = array();
    750. 

  750.       preg_match_all('#(I|\.)(O|\.)(H|\.)(P|\.)(B|\.)\s+(\w+)\s+(\d+)\s+(\d+)#', $pixformats, $matches, PREG_SET_ORDER);
    751. 

  751.       foreach ($matches as $match) {
    752. 

  752.         $data['pixelformats'][$match[6]] = array(
    753. 

  753.           'encode' => $match[1] == 'I',
    754. 

  754.           'decode' => $match[2] == 'O',
    755. 

  755.           'components' => intval($match[7]),
    756. 

  756.           'bpp' => intval($match[8]),
    757. 

  757.         );
    758. 

  758.       }
    759. 

  759.     }
    760. 

  760. 

  761.     // grab the command line options available to ffmpeg
    762. 

  762.     $data['commandoptions'] = array();
    763. 

  763.     $matches = array();
    764. 

  764.     preg_match_all('#\n-(\w+)(?:\s+<(int|string|binary|flags|int64|float|rational)>)?#', $help, $matches, PREG_SET_ORDER);
    765. 

  765.     foreach ($matches as $match) {
    766. 

  766.       $data['commandoptions'][$match[1]] = array(
    767. 

  767.         'datatype' => isset($match[2]) ? $match[2] : NULL,
    768. 

  768.       );
    769. 

  769.     }
    770. 

  770. 

  771.     PHPVideoToolkit::$ffmpeg_info = $data;
    772. 

  772. 

  773.     return $data;
    774. 

  774.   }
    775. 

  775. 

  776.   /**
    777. 

  777.    * Returns the installed version of FFmpeg
    778. 

  778.    * @param $format
    779. 

  779.    *   one of raw, version
    780. 

  780.    * @return $version
    781. 

  781.    *   String, FFmpeg version
    782. 

  782.    */
    783. 

  783.   protected function getVersion($output) {
    784. 

  784.     // Search for SVN string
    785. 

  785.     // FFmpeg version SVN-r20438, Copyright (c) 2000-2009 Fabrice Bellard, et al.
    786. 

  786.     $pattern = "/(?:ffmpeg|avconv) version SVN-r([0-9.]*)/i";
    787. 

  787.     if (preg_match($pattern, $output, $matches)) {
    788. 

  788.       return $matches[1];
    789. 

  789.     }
    790. 

  790. 

  791.     // Some OSX versions are built from a very early CVS
    792. 

  792.     // I do not know what to do with this version- using 1 for now
    793. 

  793.     $pattern = "/(?:ffmpeg|avconv) version.*CVS.*Mac OSX universal/msUi";
    794. 

  794.     if (preg_match($pattern, $output, $matches)) {
    795. 

  795.       return 0;
    796. 

  796.     }
    797. 

  797. 

  798.     // Search for git string
    799. 

  799.     // FFmpeg version git-N-29240-gefb5fa7, Copyright (c) 2000-2011 the FFmpeg developers.
    800. 

  800.     // ffmpeg version N-31145-g59bd0fe, Copyright (c) 2000-2011 the FFmpeg developers
    801. 

  801.     $pattern = "/(?:ffmpeg|avconv) version.*N-([0-9.]*)/i";
    802. 

  802.     if (preg_match($pattern, $output, $matches)) {
    803. 

  803.       // Versions above this seem to be ok
    804. 

  804.       if ($matches[1] >= 29240) {
    805. 

  805.         return array(
    806. 

  806.           'svn' => (int) $matches[1],
    807. 

  807.           'version' => NULL, // Return NULL as there appears to be no version number.
    808. 

  808.         );
    809. 

  809.       }
    810. 

  810.     }
    811. 

  811. 

  812.     // Do we have a release?
    813. 

  813.     // ffmpeg version 0.4.9-pre1, build 4736, Copyright (c) 2000-2004 Fabrice Bellard
    814. 

  814.     $pattern = "/(?:ffmpeg|avconv) version ([0-9.]*)/i";
    815. 

  815.     if (preg_match($pattern, $output, $matches)) {
    816. 

  816.       return $matches[1];
    817. 

  817.     }
    818. 

  818. 

  819.     // Do we have a build version?
    820. 

  820.     // ffmpeg version 0.4.9-pre1, build 4736, Copyright (c) 2000-2004 Fabrice Bellard
    821. 

  821.     $pattern = "/(?:ffmpeg|avconv) version.*, build ([0-9]*)/i";
    822. 

  822.     if (preg_match($pattern, $output, $matches)) {
    823. 

  823.       return $matches[1];
    824. 

  824.     }
    825. 

  825. 

  826.     return FALSE;
    827. 

  827.   }
    828. 

  828. 

  829.   /**
    830. 

  830.    * Determines if your ffmpeg has particular codec support for encode or decode.
    831. 

  831.    *
    832. 

  832.    * @access public
    833. 

  833.    * @param $codec
    834. 

  834.    *   The name of the codec you are checking for.
    835. 

  835.    * @param $support
    836. 

  836.    *   PHPVideoToolkit::ENCODE or PHPVideoToolkit::DECODE, depending on which functionality is desired.
    837. 

  837.    * @return
    838. 

  838.    *   Boolean FALSE if there is no support, TRUE if there is support.
    839. 

  839.    */
    840. 

  840.   public function hasCodecSupport($codec, $support=PHPVideoToolkit::ENCODE) {
    841. 

  841.     $codec = strtolower($codec);
    842. 

  842.     $data = $this->getFFmpegInfo();
    843. 

  843.     return isset($data['formats'][$codec]) === TRUE ? $data['formats'][$codec][$support] : FALSE;
    844. 

  844.   }
    845. 

  845. 

  846.   /**
    847. 

  847.    * Determines the type of support that exists for the FFmpeg-PHP module.
    848. 

  848.    *
    849. 

  849.    * @access public
    850. 

  850.    * @return mixed. Boolean FALSE if there is no support, String 'module' if the actuall
    851. 

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

  852.    * 		can be emulated through the adapter classes.
    853. 

  853.    */
    854. 

  854.   public function hasFFmpegPHPSupport() {
    855. 

  855.     return self::$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));
    856. 

  856.   }
    857. 

  857. 

  858.   /**
    859. 

  859.    * Determines if the ffmpeg binary has been compiled with vhook support.
    860. 

  860.    *
    861. 

  861.    * @access public
    862. 

  862.    * @return mixed. Boolean FALSE if there is no support, TRUE there is support.
    863. 

  863.    */
    864. 

  864.   public function hasVHookSupport() {
    865. 

  865.     $info = $this->getFFmpegInfo();
    866. 

  866.     return $info['binary']['vhook-support'];
    867. 

  867.   }
    868. 

  868. 

  869.   /**
    870. 

  870.    * Returns information about the specified file without having to use ffmpeg-php
    871. 

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

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

  873.    *
    874. 

  874.    * @param $file
    875. 

  875.    *   The absolute path of the file that is required to be manipulated.
    876. 

  876.    * @return
    877. 

  877.    *   FALSE on error encountered, TRUE otherwise
    878. 

  878.    */
    879. 

  879.   public function getFileInfo($file = FALSE) {
    880. 

  880.     // if the file has not been specified check to see if an input file has been specified
    881. 

  881.     if ($file === FALSE) {
    882. 

  882.       if (!$this->_input_file) {
    883. 

  883.         return $this->_raiseError('getFileInfo_no_input');
    884. 

  884.       }
    885. 

  885.       $file = $this->_input_file;
    886. 

  886.     }
    887. 

  887.     $file = escapeshellarg($file);
    888. 

  888.     // create a hash of the filename
    889. 

  889.     $hash = md5($file);
    890. 

  890.     // check to see if the info has already been generated
    891. 

  891.     if (isset(self::$_file_info[$hash]) === TRUE) {
    892. 

  892.       return self::$_file_info[$hash];
    893. 

  893.     }
    894. 

  894. 

  895.     // execute the ffmpeg lookup
    896. 

  896.     $buffer = $this->_captureExecBuffer($this->_ffmpeg_binary . ' -i ' . $file);
    897. 

  897.     $buffer = implode("\r\n", $buffer);
    898. 

  898. 

  899.     $data = $this->parseFileInfo($buffer);
    900. 

  900. 

  901.     // check that some data has been obtained
    902. 

  902.     if (empty($data)) {
    903. 

  903.       $data = FALSE;
    904. 

  904.     }
    905. 

  905.     else {
    906. 

  906.       $data['_raw_info'] = $buffer;
    907. 

  907.     }
    908. 

  908. 

  909.     // cache info and return
    910. 

  910.     return self::$_file_info[$hash] = $data;
    911. 

  911.   }
    912. 

  912. 

  913.   /**
    914. 

  914.    * Parses file information returned by ffmpeg -i
    915. 

  915.    *
    916. 

  916.    * @param $raw
    917. 

  917.    *   Return text of ffmpeg -i
    918. 

  918.    * @return
    919. 

  919.    *   Array containing various data about the file
    920. 

  920.    */
    921. 

  921.   public function parseFileInfo($raw) {
    922. 

  922.     $data = array();
    923. 

  923.     $matches = array();
    924. 

  924. 

  925.     // grab the duration and bitrate data
    926. 

  926.     preg_match_all('/Duration: (.*)/', $raw, $matches);
    927. 

  927. 

  928.     if (!empty($matches)) {
    929. 

  929.       $line = trim($matches[0][0]);
    930. 

  930.       // capture any data
    931. 

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

  932.       // setup the default data
    933. 

  933.       $data['duration'] = array(
    934. 

  934.         'timecode' => array(
    935. 

  935.           'seconds' => array(
    936. 

  936.             'exact' => -1,
    937. 

  937.             'excess' => -1
    938. 

  938.           ),
    939. 

  939.           'rounded' => -1,
    940. 

  940.         )
    941. 

  941.       );
    942. 

  942.       // get the data
    943. 

  943.       foreach ($matches[1] as $key => $detail) {
    944. 

  944.         $value = $matches[2][$key];
    945. 

  945.         switch (strtolower($detail)) {
    946. 

  946.           case 'duration' :
    947. 

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

  948.             $data['duration']['timecode']['frames'] = array();
    949. 

  949.             $data['duration']['timecode']['frames']['exact'] = $value;
    950. 

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

  951.             break;
    952. 

  952.           case 'bitrate' :
    953. 

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

  954.             break;
    955. 

  955.           case 'start' :
    956. 

  956.             $data['duration']['start'] = $value;
    957. 

  957.             break;
    958. 

  958.         }
    959. 

  959.       }
    960. 

  960.     }
    961. 

  961. 

  962.     // match the video stream info
    963. 

  963.     preg_match('/Stream(.*): Video: (.*)/', $raw, $matches);
    964. 

  964.     if (count($matches) > 0) {
    965. 

  965.       $data['video'] = array();
    966. 

  966.       // get the dimension parts
    967. 

  967.       preg_match('/([1-9][0-9]*)x([1-9][0-9]*)/', $matches[2], $dimensions_matches);
    968. 

  968. 

  969.       $dimensions_value = $dimensions_matches[0];
    970. 

  970.       $data['video']['dimensions'] = array(
    971. 

  971.         'width' => floatval($dimensions_matches[1]),
    972. 

  972.         'height' => floatval($dimensions_matches[2])
    973. 

  973.       );
    974. 

  974.       // get the timebases
    975. 

  975.       $data['video']['time_bases'] = array();
    976. 

  976.       preg_match_all('/([0-9\.k]+) (fps|tbr|tbc|tbn)/', $matches[0], $fps_matches);
    977. 

  977.       if (count($fps_matches[0]) > 0) {
    978. 

  978.         foreach ($fps_matches[2] as $key => $abrv) {
    979. 

  979.           $data['video']['time_bases'][$abrv] = $fps_matches[1][$key];
    980. 

  980.         }
    981. 

  981.       }
    982. 

  982. 

  983.       // get the video frames per second
    984. 

  984.       $data['duration']['timecode']['seconds']['total'] = $data['duration']['seconds'] = (float)$this->formatTimecode($data['duration']['timecode']['frames']['exact'], '%hh:%mm:%ss.%ms', '%ss.%ms');
    985. 

  985.       $fps = isset($data['video']['time_bases']['fps']) === TRUE ? $data['video']['time_bases']['fps'] : (isset($data['video']['time_bases']['tbr']) === TRUE ? $data['video']['time_bases']['tbr'] : FALSE);
    986. 

  986.       if ($fps !== FALSE) {
    987. 

  987.         $fps = floatval($fps);
    988. 

  988.         $data['duration']['timecode']['frames']['frame_rate'] = $data['video']['frame_rate'] = $fps;
    989. 

  989.         // set the total frame count for the video
    990. 

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

  991.         $data['duration']['timecode']['frames']['exact'] = $this->formatTimecode($data['video']['frame_count'], '%ft', '%hh:%mm:%ss.%fn', $fps);
    992. 

  992.         $data['duration']['timecode']['frames']['total'] = $data['video']['frame_count'];
    993. 

  993.       }
    994. 

  994. 

  995.       $fps_value = $fps_matches[0];
    996. 

  996.       // get the ratios
    997. 

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

  998.       if (count($ratio_matches)) {
    999. 

  999.         $data['video']['pixel_aspect_ratio'] = $ratio_matches[1];
    1000. 

  1000.         $data['video']['display_aspect_ratio'] = $ratio_matches[2];
    1001. 

  1001.       }
    1002. 

  1002.       // work out the number of frames
    1003. 

  1003.       if (isset($data['duration']) === TRUE && isset($data['video']) === TRUE) {
    1004. 

  1004.         // set the framecode
    1005. 

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

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

  1007.       }
    1008. 

  1008.       // formats should be anything left over, let me know if anything else exists
    1009. 

  1009.       $parts = explode(',', $matches[2]);
    1010. 

  1010.       $other_parts = array($dimensions_value, $fps_value);
    1011. 

  1011.       $formats = array();
    1012. 

  1012.       foreach ($parts as $key => $part) {
    1013. 

  1013.         $part = trim($part);
    1014. 

  1014.         if (!in_array($part, $other_parts)) {
    1015. 

  1015.           array_push($formats, $part);
    1016. 

  1016.         }
    1017. 

  1017.       }
    1018. 

  1018.       $data['video']['pixel_format'] = $formats[1];
    1019. 

  1019.       $data['video']['codec'] = $formats[0];
    1020. 

  1020.     }
    1021. 

  1021. 

  1022.     // match the audio stream info
    1023. 

  1023.     preg_match('/Stream(.*): Audio: (.*)/', $raw, $matches);
    1024. 

  1024.     if (count($matches) > 0) {
    1025. 

  1025.       // setup audio values
    1026. 

  1026.       $data['audio'] = array(
    1027. 

  1027.         'stereo' => -1,
    1028. 

  1028.         'sample_rate' => -1,
    1029. 

  1029.         'sample_rate' => -1
    1030. 

  1030.       );
    1031. 

  1031.       $other_parts = array();
    1032. 

  1032.       // get the stereo value
    1033. 

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

  1034.       if (count($stereo_matches)) {
    1035. 

  1035.         $data['audio']['stereo'] = $stereo_matches[0];
    1036. 

  1036.         array_push($other_parts, $stereo_matches[0]);
    1037. 

  1037.       }
    1038. 

  1038.       // get the sample_rate
    1039. 

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

  1040.       if (count($sample_matches)) {
    1041. 

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

  1042.         array_push($other_parts, $sample_matches[0]);
    1043. 

  1043.       }
    1044. 

  1044.       // get the bit rate
    1045. 

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

  1046.       if (count($bitrate_matches)) {
    1047. 

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

  1048.         array_push($other_parts, $bitrate_matches[0]);
    1049. 

  1049.       }
    1050. 

  1050.       // formats should be anything left over, let me know if anything else exists
    1051. 

  1051.       $parts = explode(',', $matches[2]);
    1052. 

  1052.       $formats = array();
    1053. 

  1053.       foreach ($parts as $key => $part) {
    1054. 

  1054.         $part = trim($part);
    1055. 

  1055.         if (!in_array($part, $other_parts)) {
    1056. 

  1056.           array_push($formats, $part);
    1057. 

  1057.         }
    1058. 

  1058.       }
    1059. 

  1059.       $data['audio']['codec'] = $formats[0];
    1060. 

  1060.       // if no video is set then no audio frame rate is set
    1061. 

  1061.       if ($data['duration']['timecode']['seconds']['exact'] === -1) {
    1062. 

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

  1063.         $data['duration']['timecode']['seconds'] = array(
    1064. 

  1064.           'exact' => $exact_timecode,
    1065. 

  1065.           'excess' => intval(substr($exact_timecode, 8)),
    1066. 

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

  1067.         );
    1068. 

  1068.         $data['duration']['timecode']['frames']['frame_rate'] = 1000;
    1069. 

  1069.         $data['duration']['seconds'] = $data['duration']['timecode']['seconds']['total'];
    1070. 

  1070.       }
    1071. 

  1071.     }
    1072. 

  1072. 

  1073.     return $data;
    1074. 

  1074.   }
    1075. 

  1075. 

  1076.   /**
    1077. 

  1077.    * Determines if the input media has a video stream.
    1078. 

  1078.    *
    1079. 

  1079.    * @access public
    1080. 

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

  1081.    * @return bool
    1082. 

  1082.    * */
    1083. 

  1083.   public function fileHasVideo($file=FALSE) {
    1084. 

  1084. // 			check to see if this is a static call
    1085. 

  1085.     if ($file !== FALSE && isset($this) === FALSE) {
    1086. 

  1086.       $toolkit = new PHPVideoToolkit();
    1087. 

  1087.       $data = $toolkit->getFileInfo($file);
    1088. 

  1088.     }
    1089. 

  1089. // 			if the file has not been specified check to see if an input file has been specified
    1090. 

  1090.     elseif ($file === FALSE) {
    1091. 

  1091.       if (!$this->_input_file) {
    1092. 

  1092. //					input file not valid
    1093. 

  1093.         return $this->_raiseError('inputFileHasVideo_no_input');
    1094. 

  1094. // <-				exits
    1095. 

  1095.       }
    1096. 

  1096.       $file = $this->_input_file;
    1097. 

  1097.       $data = $this->getFileInfo($file);
    1098. 

  1098.     }
    1099. 

  1099.     return isset($data['video']);
    1100. 

  1100.   }
    1101. 

  1101. 

  1102.   /**
    1103. 

  1103.    * Determines if the input media has an audio stream.
    1104. 

  1104.    *
    1105. 

  1105.    * @access public
    1106. 

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

  1107.    * @return bool
    1108. 

  1108.    * */
    1109. 

  1109.   public function fileHasAudio($file=FALSE) {
    1110. 

  1110. // 			check to see if this is a static call
    1111. 

  1111.     if ($file !== FALSE && isset($this) === FALSE) {
    1112. 

  1112.       $toolkit = new PHPVideoToolkit();
    1113. 

  1113.       $data = $toolkit->getFileInfo($file);
    1114. 

  1114.     }
    1115. 

  1115. // 			if the file has not been specified check to see if an input file has been specified
    1116. 

  1116.     elseif ($file === FALSE) {
    1117. 

  1117.       if (!$this->_input_file) {
    1118. 

  1118. //					input file not valid
    1119. 

  1119.         return $this->_raiseError('inputFileHasAudio_no_input');
    1120. 

  1120. // <-				exits
    1121. 

  1121.       }
    1122. 

  1122.       $file = $this->_input_file;
    1123. 

  1123.       $data = $this->getFileInfo($file);
    1124. 

  1124.     }
    1125. 

  1125.     return isset($data['audio']);
    1126. 

  1126.   }
    1127. 

  1127. 

  1128.   /**
    1129. 

  1129.    * Sets the input file that is going to be manipulated.
    1130. 

  1130.    *
    1131. 

  1131.    * @access public
    1132. 

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

  1133.    * @param mixed $input_frame_rate If 0 (default) then no input frame rate is set, if FALSE it is automatically retrieved, otherwise
    1134. 

  1134.    * 		any other integer will be set as the incoming frame rate.
    1135. 

  1135.    * @return boolean FALSE on error encountered, TRUE otherwise
    1136. 

  1136.    */
    1137. 

  1137.   public function setInputFile($file, $input_frame_rate=0, $validate_decode_codecs=TRUE) {
    1138. 

  1138.     $files_length = count($file);
    1139. 

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

  1140.     if ($files_length == 1) {
    1141. 

  1141. //				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
    1142. 

  1142. //				then qheck to see if the file exists
    1143. 

  1143.       if (!preg_match('/\%([0-9]+)d/', $file) && strpos($file, '%d') === FALSE && !is_file($file)) {
    1144. 

  1144. //					input file not valid
    1145. 

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

  1146. // <-				exits
    1147. 

  1147.       }
    1148. 

  1148.       $escaped_name = $file;
    1149. 

  1149. // 				$escaped_name = escapeshellarg($files[0]);
    1150. 

  1150.       $this->_input_file = $escaped_name;
    1151. 

  1151.       $this->_input_file_id = md5($escaped_name);
    1152. 

  1152. 

  1153.       if ($input_frame_rate !== 0) {
    1154. 

  1154.         $info = $this->getFileInfo();
    1155. 

  1155.         if (isset($info['video']) === TRUE) {
    1156. 

  1156.           if ($input_frame_rate === FALSE) {
    1157. 

  1157.             $input_frame_rate = $info['video']['frame_rate'];
    1158. 

  1158.           }
    1159. 

  1159. // 						input frame rate is a command hack
    1160. 

  1160.           $this->addCommand('-r', $input_frame_rate, TRUE);
    1161. 

  1161.         }
    1162. 

  1162.       }
    1163. 

  1163.     }
    1164. 

  1164.     else {
    1165. 

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

  1166.       call_user_func_array(array(&$this, 'addVideo'), array($file, $input_frame_rate));
    1167. 

  1167.     }
    1168. 

  1168.     return TRUE;
    1169. 

  1169.   }
    1170. 

  1170. 

  1171.   /**
    1172. 

  1172.    * A shortcut for converting video to FLV.
    1173. 

  1173.    *
    1174. 

  1174.    * @access public
    1175. 

  1175.    * @param integer $audio_sample_frequency
    1176. 

  1176.    * @param integer $audio_bitrate
    1177. 

  1177.    * @param boolean $validate_codecs
    1178. 

  1178.    * @return mixed
    1179. 

  1179.    */
    1180. 

  1180.   public function setFormatToFLV($audio_sample_frequency=44100, $audio_bitrate=64, $validate_codecs=TRUE) {
    1181. 

  1181.     $this->addCommand('-sameq');
    1182. 

  1182.     $audio_able = $this->setAudioFormat(self::FORMAT_MP3, $validate_codecs);
    1183. 

  1183. //			adjust the audio rates
    1184. 

  1184.     $this->setAudioBitRate($audio_bitrate);
    1185. 

  1185.     $this->setAudioSampleFrequency($audio_sample_frequency);
    1186. 

  1186. //			set the video format
    1187. 

  1187.     $flv_able = $this->setFormat(self::FORMAT_FLV, $validate_codecs);
    1188. 

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

  1189. // 			register the post tidy process
    1190. 

  1190.     $this->registerPostProcess('_addMetaToFLV', $this);
    1191. 

  1191.     return $audio_able !== FALSE && $flv_able !== FALSE;
    1192. 

  1192.   }
    1193. 

  1193. 

  1194.   /**
    1195. 

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

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

  1197.    * http://inlet-media.de/flvtool2
    1198. 

  1198.    *
    1199. 

  1199.    * @access protected
    1200. 

  1200.    */
    1201. 

  1201.   protected function _addMetaToFLV($files) {
    1202. 

  1202.     $file = array_pop($files);
    1203. 

  1203. //			prepare the command suitable for exec
    1204. 

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

  1205. //			execute the command
    1206. 

  1206.     exec($exec_string);
    1207. 

  1207.     if (is_array($this->_processed[0])) {
    1208. 

  1208.       array_push($this->_processed[0], $exec_string);
    1209. 

  1209.     }
    1210. 

  1210.     else {
    1211. 

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

  1212.     }
    1213. 

  1213.     return TRUE;
    1214. 

  1214.   }
    1215. 

  1215. 

  1216.   /**
    1217. 

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

  1218.    * Inspired by xmoov-php
    1219. 

  1219.    * @see http://xmoov.com/
    1220. 

  1220.    * @access public
    1221. 

  1221.    * @param integer $seek_pos The position in the file to seek to.
    1222. 

  1222.    * @param array|boolean $bandwidth_options If a boolean value, FALSE then no bandwidth limiting will take place.
    1223. 

  1223.    * 		If TRUE then bandwidth limiting will take place with packet_size = 90 and packet_interval = 0.3.
    1224. 

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

  1225.    * 		have to set active = TRUE, ie array('active'=>true, 'packet_size'=>90, 'packet_interval'=>0.3)
    1226. 

  1226.    * @param boolean $allow_cache If TRUE the file will be allowed to cache in the browser, if FALSE then it won't
    1227. 

  1227.    * @return boolean
    1228. 

  1228.    */
    1229. 

  1229.   public function flvStreamSeek($seek_pos=0, $bandwidth_options=array(), $allow_cache=TRUE) {
    1230. 

  1230. // 			check for input file
    1231. 

  1231.     if (!$this->_input_file) {
    1232. 

  1232. //				input file not valid
    1233. 

  1233.       return $this->_raiseError('streamFLV_no_input');
    1234. 

  1234. // <-			exits
    1235. 

  1235.     }
    1236. 

  1236. // 			make the pos safe
    1237. 

  1237.     $seek_pos = intval($seek_pos);
    1238. 

  1238. // 			absorb the bandwidth options
    1239. 

  1239.     $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);
    1240. 

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

  1241.     if (!$allow_cache) {
    1242. 

  1242.       session_cache_limiter('nocache');
    1243. 

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

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

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

  1246.       header('Pragma: no-cache');
    1247. 

  1247.     }
    1248. 

  1248. // 			open file
    1249. 

  1249.     $handle = fopen($this->_input_file, 'rb');
    1250. 

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

  1251. // 			send the flv headers
    1252. 

  1252.     header('Content-Type: video/x-flv');
    1253. 

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

  1254.     header('Content-Length: ' . $file_size);
    1255. 

  1255. // 			flv format header
    1256. 

  1256.     if ($seek_pos != 0) {
    1257. 

  1257.       print('FLV');
    1258. 

  1258.       print(pack('C', 1));
    1259. 

  1259.       print(pack('C', 1));
    1260. 

  1260.       print(pack('N', 9));
    1261. 

  1261.       print(pack('N', 9));
    1262. 

  1262.     }
    1263. 

  1263. // 			seek to the required point
    1264. 

  1264.     if (fseek($handle, $seek_pos) === -1) {
    1265. 

  1265. //				input file not valid
    1266. 

  1266.       return $this->_raiseError('streamFLV_passed_eof');
    1267. 

  1267. // <-			exits
    1268. 

  1268.     }
    1269. 

  1269. // 			if bandwidth control is active then workout the options
    1270. 

  1270.     if ($bandwidth_options['active']) {
    1271. 

  1271.       $packet_interval = intval($bandwidth_options['packet_interval']);
    1272. 

  1272.       $packet_size = intval($bandwidth_options['packet_size']) * 1042;
    1273. 

  1273.     }
    1274. 

  1274. // 			output the file
    1275. 

  1275.     while (!feof($handle)) {
    1276. 

  1276. // 				limit the bandwidth
    1277. 

  1277.       if ($bandwidth_options['active'] && $packet_interval > 0) {
    1278. 

  1278. // 					output the required packet
    1279. 

  1279.         $time_start = self::microtimeFloat();
    1280. 

  1280.         echo fread($handle, $packet_size);
    1281. 

  1281.         $time_stop = self::microtimeFloat();
    1282. 

  1282. // 					delay the output
    1283. 

  1283.         $time_difference = $time_stop - $time_start;
    1284. 

  1284.         if ($time_difference < $packet_interval) {
    1285. 

  1285.           usleep(($packet_interval * 1000000) - ($time_difference * 1000000));
    1286. 

  1286.         }
    1287. 

  1287.       }
    1288. 

  1288. // 				no bandwidth limiting
    1289. 

  1289.       else {
    1290. 

  1290.         echo fread($handle, $file_size);
    1291. 

  1291.       }
    1292. 

  1292.     }
    1293. 

  1293. // 			close the file
    1294. 

  1294.     fclose($handle);
    1295. 

  1295.     return TRUE;
    1296. 

  1296.   }
    1297. 

  1297. 

  1298.   /**
    1299. 

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

  1300.    *
    1301. 

  1301.    * @access public
    1302. 

  1302.    * @param integer $format A supported audio format.
    1303. 

  1303.    * @param integer $audio_sample_frequency
    1304. 

  1304.    * @param integer $audio_bitrate
    1305. 

  1305.    * */
    1306. 

  1306.   public function extractAudio($format=PHPVideoToolkit::FORMAT_MP3, $audio_sample_frequency=44100, $audio_bitrate=64) {
    1307. 

  1307. // 			check the format is one of the audio formats
    1308. 

  1308.     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))) {
    1309. 

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

  1310. // <-			exits
    1311. 

  1311.     }
    1312. 

  1312.     $this->setFormat($format);
    1313. 

  1313. //			adjust the audio rates
    1314. 

  1314.     $this->setAudioBitRate($audio_bitrate);
    1315. 

  1315.     $this->setAudioSampleFrequency($audio_sample_frequency);
    1316. 

  1316.   }
    1317. 

  1317. 

  1318.   /**
    1319. 

  1319.    * Sets the new video format.
    1320. 

  1320.    *
    1321. 

  1321.    * @access public
    1322. 

  1322.    * @param $format
    1323. 

  1323.    *   The format should use one of the defined variables stated below.
    1324. 

  1324.    * 		PHPVideoToolkit::FORMAT_3GP2 - 3g2
    1325. 

  1325.    * 		PHPVideoToolkit::FORMAT_3GP - 3gp
    1326. 

  1326.    * 		PHPVideoToolkit::FORMAT_AAC - aac
    1327. 

  1327.    * 		PHPVideoToolkit::FORMAT_AIFF - aiff
    1328. 

  1328.    * 		PHPVideoToolkit::FORMAT_AMR - amr
    1329. 

  1329.    * 		PHPVideoToolkit::FORMAT_ASF - asf
    1330. 

  1330.    * 		PHPVideoToolkit::FORMAT_AVI - avi
    1331. 

  1331.    * 		PHPVideoToolkit::FORMAT_FLV - flv
    1332. 

  1332.    * 		PHPVideoToolkit::FORMAT_GIF - gif
    1333. 

  1333.    * 		PHPVideoToolkit::FORMAT_MJ2 - mj2
    1334. 

  1334.    * 		PHPVideoToolkit::FORMAT_MP2 - mp2
    1335. 

  1335.    * 		PHPVideoToolkit::FORMAT_MP3 - mp3
    1336. 

  1336.    * 		PHPVideoToolkit::FORMAT_MP4 - mp4
    1337. 

  1337.    * 		PHPVideoToolkit::FORMAT_MPEG4 - mpeg4
    1338. 

  1338.    * 		PHPVideoToolkit::FORMAT_M4A - m4a
    1339. 

  1339.    * 		PHPVideoToolkit::FORMAT_MPEG - mpeg
    1340. 

  1340.    * 		PHPVideoToolkit::FORMAT_MPEG1 - mpeg1video
    1341. 

  1341.    * 		PHPVideoToolkit::FORMAT_MPEG2 - mpeg2video
    1342. 

  1342.    * 		PHPVideoToolkit::FORMAT_MPEGVIDEO - mpegvideo
    1343. 

  1343.    * 		PHPVideoToolkit::FORMAT_PSP - psp
    1344. 

  1344.    * 		PHPVideoToolkit::FORMAT_RM - rm
    1345. 

  1345.    * 		PHPVideoToolkit::FORMAT_SWF - swf
    1346. 

  1346.    * 		PHPVideoToolkit::FORMAT_VOB - vob
    1347. 

  1347.    * 		PHPVideoToolkit::FORMAT_WAV - wav
    1348. 

  1348.    *    	PHPVideoToolkit::FORMAT_JPG - jpg
    1349. 

  1349.    * @return boolean FALSE on error encountered, TRUE otherwise
    1350. 

  1350.    */
    1351. 

  1351.   public function setFormat($format) {
    1352. 

  1352. //			validate input
    1353. 

  1353.     if (!in_array($format, array(self::FORMAT_3GP2, self::FORMAT_3GP, self::FORMAT_AAC, self::FORMAT_AIFF, self::FORMAT_AMR, self::FORMAT_ASF, self::FORMAT_AVI, self::FORMAT_FLV, self::FORMAT_GIF, self::FORMAT_MJ2, self::FORMAT_MP2, self::FORMAT_MP3, self::FORMAT_MP4, self::FORMAT_MPEG4, self::FORMAT_M4A, self::FORMAT_MPEG, self::FORMAT_MPEG1, self::FORMAT_MPEG2, self::FORMAT_MPEGVIDEO, self::FORMAT_PSP, self::FORMAT_RM, self::FORMAT_SWF, self::FORMAT_VOB, self::FORMAT_WAV, self::FORMAT_JPG))) {
    1354. 

  1354.       // return $this->_raiseError('setFormat_valid_format', array('format'=>$format));
    1355. 

  1355. // <-			exits
    1356. 

  1356.     }
    1357. 

  1357.     return $this->addCommand('-f', $format);
    1358. 

  1358.   }
    1359. 

  1359. 

  1360.   public function setPixelFormat($format) {
    1361. 

  1361.     $formats = $this->getAvailablePixelFormats();
    1362. 

  1362.     if (in_array($format, $formats)) {
    1363. 

  1363.       return $this->addCommand('-pix_fmt', $format);
    1364. 

  1364.     }
    1365. 

  1365.     return FALSE;
    1366. 

  1366.   }
    1367. 

  1367. 

  1368.   /**
    1369. 

  1369.    * Sets the audio sample frequency for audio outputs
    1370. 

  1370.    *
    1371. 

  1371.    * @access public
    1372. 

  1372.    * @param integer $audio_sample_frequency Valid values are 11025, 22050, 44100
    1373. 

  1373.    * @return boolean FALSE on error encountered, TRUE otherwise
    1374. 

  1374.    */
    1375. 

  1375.   public function setAudioSampleFrequency($audio_sample_frequency) {
    1376. 

  1376. //			validate input
    1377. 

  1377.     if (!in_array(intval($audio_sample_frequency), array(11025, 22050, 44100))) {
    1378. 

  1378.       return $this->_raiseError('setAudioSampleFrequency_valid_frequency', array('frequency' => $audio_sample_frequency));
    1379. 

  1379. // <-			exits
    1380. 

  1380.     }
    1381. 

  1381.     return $this->addCommand('-ar', $audio_sample_frequency);
    1382. 

  1382.   }
    1383. 

  1383. 

  1384.   /**
    1385. 

  1385.    * Sets the audio format for audio outputs
    1386. 

  1386.    *
    1387. 

  1387.    * @access public
    1388. 

  1388.    * @param integer $audio_codec 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
    1389. 

  1389.    * @param boolean $validate_codec Queries ffmpeg to see if this codec is available to use.
    1390. 

  1390.    * @return boolean FALSE on error encountered, TRUE otherwise
    1391. 

  1391.    */
    1392. 

  1392.   public function setAudioCodec($audio_codec, $validate_codec=TRUE) {
    1393. 

  1393. //			validate input
    1394. 

  1394.     if (!in_array($audio_codec, array(self::FORMAT_AAC, self::FORMAT_AIFF, self::FORMAT_AMR, self::FORMAT_ASF, self::FORMAT_MP2, self::FORMAT_MP3, self::FORMAT_MP4, self::FORMAT_MPEG2, self::FORMAT_RM, self::FORMAT_WAV))) {
    1395. 

  1395.       // return $this->_raiseError('setAudioFormat_valid_format', array('format'=>$audio_codec));
    1396. 

  1396. // <-			exits
    1397. 

  1397.     }
    1398. 

  1398. // 			run a libmp3lame check as it require different mp3 codec
    1399. 

  1399. // 			updated thanks to Varon for providing the research
    1400. 

  1400.     if ($audio_codec == self::FORMAT_MP3) {
    1401. 

  1401.       $info = $this->getFFmpegInfo();
    1402. 

  1402.       if (isset($info['formats']['libmp3lame']) === TRUE || in_array('--enable-libmp3lame', $info['binary']['configuration']) === TRUE) {
    1403. 

  1403.         $audio_codec = 'libmp3lame';
    1404. 

  1404.       }
    1405. 

  1405.     }
    1406. 

  1406. // 			do we need to validate this codec?
    1407. 

  1407.     if ($validate_codec === TRUE) {
    1408. 

  1408.       if ($this->canCodecBeEncoded('audio', $audio_codec) === FALSE) {
    1409. 

  1409.         return $this->_raiseError('setAudioFormat_cannnot_encode', array('codec' => $audio_codec));
    1410. 

  1410. // <-		   		exits
    1411. 

  1411.       }
    1412. 

  1412.     }
    1413. 

  1413.     return $this->addCommand('-acodec', $audio_codec);
    1414. 

  1414.   }
    1415. 

  1415. 

  1416.   /**
    1417. 

  1417.    * Forces the video format for video outputs to a specific codec. This should not be confused with setFormat. setVideoFormat does not generally need to
    1418. 

  1418.    * be called unless setting a specific video format for a type of media format. It gets a little confusing...
    1419. 

  1419.    *
    1420. 

  1420.    * @access public
    1421. 

  1421.    * @param integer $video_codec 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
    1422. 

  1422.    * @param boolean $validate_codec Queries ffmpeg to see if this codec is available to use.
    1423. 

  1423.    * @return boolean FALSE on error encountered, TRUE otherwise
    1424. 

  1424.    */
    1425. 

  1425.   public function setVideoCodec($video_codec, $validate_codec=TRUE) {
    1426. 

  1426. //			validate input
    1427. 

  1427.     if (!in_array($video_codec, array(self::FORMAT_3GP2, self::FORMAT_3GP, self::FORMAT_AVI, self::FORMAT_FLV, self::FORMAT_GIF, self::FORMAT_MJ2, self::FORMAT_MP4, self::FORMAT_MPEG4, self::FORMAT_M4A, self::FORMAT_MPEG, self::FORMAT_MPEG1, self::FORMAT_MPEG2, self::FORMAT_MPEGVIDEO))) {
    1428. 

  1428.       // return $this->_raiseError('setVideoFormat_valid_format', array('format'=>$video_codec));
    1429. 

  1429. // <-			exits
    1430. 

  1430.     }
    1431. 

  1431. // 			do we need to validate this codec?
    1432. 

  1432.     if ($validate_codec === TRUE) {
    1433. 

  1433.       if ($this->canCodecBeEncoded('video', $video_codec) === FALSE) {
    1434. 

  1434.         return $this->_raiseError('setVideoFormat_cannnot_encode', array('codec' => $video_codec));
    1435. 

  1435. // <-		   		exits
    1436. 

  1436.       }
    1437. 

  1437.     }
    1438. 

  1438.     return $this->addCommand('-strict experimental -vcodec', $video_codec);
    1439. 

  1439.   }
    1440. 

  1440. 

  1441.   /**
    1442. 

  1442.    * Disables audio encoding
    1443. 

  1443.    *
    1444. 

  1444.    * @access public
    1445. 

  1445.    * @return boolean FALSE on error encountered, TRUE otherwise
    1446. 

  1446.    */
    1447. 

  1447.   public function disableAudio() {
    1448. 

  1448.     return $this->addCommand('-an');
    1449. 

  1449.   }
    1450. 

  1450. 

  1451.   /**
    1452. 

  1452.    * Disables video encoding
    1453. 

  1453.    *
    1454. 

  1454.    * @access public
    1455. 

  1455.    * @return boolean FALSE on error encountered, TRUE otherwise
    1456. 

  1456.    */
    1457. 

  1457.   public function disableVideo() {
    1458. 

  1458.     return $this->addCommand('-vn');
    1459. 

  1459.   }
    1460. 

  1460. 

  1461.   /**
    1462. 

  1462.    * Sets the number of audio channels
    1463. 

  1463.    *
    1464. 

  1464.    * @access public
    1465. 

  1465.    * @param integer $channel_type Valid values are PHPVideoToolkit::AUDIO_MONO, PHPVideoToolkit::AUDIO_STEREO
    1466. 

  1466.    * @return boolean FALSE on error encountered, TRUE otherwise
    1467. 

  1467.    */
    1468. 

  1468.   public function setAudioChannels($channel_type=PHPVideoToolkit::AUDIO_MONO) {
    1469. 

  1469. //			validate input
    1470. 

  1470.     if (!in_array($channel_type, array(self::AUDIO_MONO, self::AUDIO_STEREO))) {
    1471. 

  1471.       return $this->_raiseError('setAudioChannels_valid_channels', array('channels' => $channel_type));
    1472. 

  1472. // <-			exits
    1473. 

  1473.     }
    1474. 

  1474.     return $this->addCommand('-ac', $channel_type);
    1475. 

  1475.   }
    1476. 

  1476. 

  1477.   /**
    1478. 

  1478.    * Sets the audio bitrate
    1479. 

  1479.    *
    1480. 

  1480.    * @access public
    1481. 

  1481.    * @param integer $audio_bitrate Valid values are 16, 32, 64
    1482. 

  1482.    * @return boolean FALSE on error encountered, TRUE otherwise
    1483. 

  1483.    */
    1484. 

  1484.   public function setAudioBitRate($bitrate) {
    1485. 

  1485. //			validate input
    1486. 

  1486.     if (!in_array(intval($bitrate), array(16, 32, 64, 128, 160, 256, 320))) {
    1487. 

  1487.       // return $this->_raiseError('setAudioBitRate_valid_bitrate', array('bitrate'=>$bitrate));
    1488. 

  1488. // <-			exits
    1489. 

  1489.     }
    1490. 

  1490.     return $this->addCommand('-ab', $bitrate);
    1491. 

  1491.   }
    1492. 

  1492. 

  1493.   /**
    1494. 

  1494.    * Compiles an array of images into a video. This sets the input file (setInputFile) so you do not need to set it.
    1495. 

  1495.    * The images should be a full absolute path to the actual image file.
    1496. 

  1496.    * NOTE 1; This copies and renames all the supplied images into a temporary folder so the images don't have to be specifically named. However, when
    1497. 

  1497.    * creating the ffmpeg instance you will need to set the absolute path to the temporary folder. The default path is '/tmp/'.
    1498. 

  1498.    * NOTE 2; Please make sure all of the images are all of the same type.
    1499. 

  1499.    *
    1500. 

  1500.    * @access public
    1501. 

  1501.    * @param array $images An array of images that are to be joined and converted into a video
    1502. 

  1502.    * @param integer $input_frame_rate An integer that will specify the input frame rate for the images.
    1503. 

  1503.    * @return boolean Returns FALSE on encountering an error
    1504. 

  1504.    */
    1505. 

  1505.   public function prepareImagesForConversionToVideo($images, $input_frame_rate) {
    1506. 

  1506. //			http://ffmpeg.mplayerhq.hu/faq.html#TOC3
    1507. 

  1507. //			ffmpeg -f image2 -i img%d.jpg /tmp/a.mpg
    1508. 

  1508.     if (empty($images)) {
    1509. 

  1509.       return $this->_raiseError('prepareImagesForConversionToVideo_one_img');
    1510. 

  1510. // <-			exits
    1511. 

  1511.     }
    1512. 

  1512. //			loop through and validate existence first before making a temporary copy
    1513. 

  1513.     foreach ($images as $key => $img) {
    1514. 

  1514.       if (!is_file($img)) {
    1515. 

  1515.         return $this->_raiseError('prepareImagesForConversionToVideo_img_404', array('img' => $img));
    1516. 

  1516. // <-				exits
    1517. 

  1517.       }
    1518. 

  1518.     }
    1519. 

  1519.     if (!is_dir($this->_tmp_directory)) {
    1520. 

  1520.       return $this->_raiseError('generic_temp_404');
    1521. 

  1521. // <-			exits
    1522. 

  1522.     }
    1523. 

  1523.     if (!is_writable($this->_tmp_directory)) {
    1524. 

  1524.       return $this->_raiseError('generic_temp_writable');
    1525. 

  1525. // <-			exits
    1526. 

  1526.     }
    1527. 

  1527. //			get the number of preceding places for the files based on how many files there are to copy
    1528. 

  1528.     $total = count($images);
    1529. 

  1529. //			create a temp dir in the temp dir
    1530. 

  1530.     $uniqid = $this->unique();
    1531. 

  1531.     mkdir($this->_tmp_directory . $uniqid, 0777);
    1532. 

  1532. //			loop through, copy and rename specified images to the temp dir
    1533. 

  1533.     $ext = FALSE;
    1534. 

  1534.     foreach ($images as $key => $img) {
    1535. 

  1535.       $file_ext = array_pop(explode('.', $img));
    1536. 

  1536.       if ($ext !== FALSE && $ext !== $file_ext) {
    1537. 

  1537.         return $this->_raiseError('prepareImagesForConversionToVideo_img_type');
    1538. 

  1538. // <-				exits
    1539. 

  1539.       }
    1540. 

  1540.       $ext = $file_ext;
    1541. 

  1541.       $tmp_file = $this->_tmp_directory . $uniqid . DS . $this->_tmp_file_prefix . $key . '.' . $ext;
    1542. 

  1542.       if (!@copy($img, $tmp_file)) {
    1543. 

  1543.         return $this->_raiseError('prepareImagesForConversionToVideo_img_copy', array('img' => $img, 'tmpfile' => $tmp_file));
    1544. 

  1544. // <-				exits
    1545. 

  1545.       }
    1546. 

  1546. //				push the tmp file name into the unlinks so they can be deleted on class destruction
    1547. 

  1547.       array_push($this->_unlink_files, $tmp_file);
    1548. 

  1548.     }
    1549. 

  1549. // 			the inputr is a hack for -r to come before the input
    1550. 

  1550.     $this->addCommand('-r', $input_frame_rate, TRUE);
    1551. 

  1551. // 			exit;
    1552. 

  1552. //			add the directory to the unlinks
    1553. 

  1553.     array_push($this->_unlink_dirs, $this->_tmp_directory . $uniqid);
    1554. 

  1554. //			get the input file format
    1555. 

  1555.     $file_iteration = $this->_tmp_file_prefix . '%d.' . $ext;
    1556. 

  1556. //			set the input filename
    1557. 

  1557.     return $this->setInputFile($this->_tmp_directory . $uniqid . DS . $file_iteration);
    1558. 

  1558.   }
    1559. 

  1559. 

  1560.   /**
    1561. 

  1561.    * Sets the video bitrate
    1562. 

  1562.    *
    1563. 

  1563.    * @access public
    1564. 

  1564.    * @param integer $bitrate
    1565. 

  1565.    * @return boolean
    1566. 

  1566.    */
    1567. 

  1567.   public function setVideoBitRate($bitrate) {
    1568. 

  1568.     $bitrate = intval($bitrate);
    1569. 

  1569.     return $this->addCommand('-b', $bitrate . 'k');
    1570. 

  1570.   }
    1571. 

  1571. 

  1572.   /**
    1573. 

  1573.    * Sets the amount of time an animated gif output will loop
    1574. 

  1574.    *
    1575. 

  1575.    * @access public
    1576. 

  1576.    * @param integer $loop_count If FALSE the gif will not loop, if 0 it will loop endlessly, any other number it will loop that amount.
    1577. 

  1577.    */
    1578. 

  1578.   public function setGifLoops($loop_count) {
    1579. 

  1579.     if ($loop_count !== FALSE) {
    1580. 

  1580.       $this->addCommand('-loop_output', $loop_count);
    1581. 

  1581.     }
    1582. 

  1582.   }
    1583. 

  1583. 

  1584.   /**
    1585. 

  1585.    * Sets the video output dimensions (in pixels)
    1586. 

  1586.    *
    1587. 

  1587.    * @access public
    1588. 

  1588.    * @param mixed $width If an integer height also has to be specified, otherwise you can use one of the class constants
    1589. 

  1589.    * 		PHPVideoToolkit::SIZE_SAS		= Same as input source
    1590. 

  1590.    * 		PHPVideoToolkit::SIZE_SQCIF 	= 128 x 96
    1591. 

  1591.    * 		PHPVideoToolkit::SIZE_QCIF 		= 176 x 144
    1592. 

  1592.    * 		PHPVideoToolkit::SIZE_CIF 		= 352 x 288
    1593. 

  1593.    * 		PHPVideoToolkit::SIZE_4CIF 		= 704 x 576
    1594. 

  1594.    * 		PHPVideoToolkit::SIZE_QQVGA 	= 160 x 120
    1595. 

  1595.    * 		PHPVideoToolkit::SIZE_QVGA 		= 320 x 240
    1596. 

  1596.    * 		PHPVideoToolkit::SIZE_VGA 		= 640 x 480
    1597. 

  1597.    * 		PHPVideoToolkit::SIZE_SVGA 		= 800 x 600
    1598. 

  1598.    * 		PHPVideoToolkit::SIZE_XGA 		= 1024 x 768
    1599. 

  1599.    * 		PHPVideoToolkit::SIZE_UXGA 		= 1600 x 1200
    1600. 

  1600.    * 		PHPVideoToolkit::SIZE_QXGA 		= 2048 x 1536
    1601. 

  1601.    * 		PHPVideoToolkit::SIZE_SXGA 		= 1280 x 1024
    1602. 

  1602.    * 		PHPVideoToolkit::SIZE_QSXGA 	= 2560 x 2048
    1603. 

  1603.    * 		PHPVideoToolkit::SIZE_HSXGA 	= 5120 x 4096
    1604. 

  1604.    * 		PHPVideoToolkit::SIZE_WVGA 		= 852 x 480
    1605. 

  1605.    * 		PHPVideoToolkit::SIZE_WXGA 		= 1366 x 768
    1606. 

  1606.    * 		PHPVideoToolkit::SIZE_WSXGA 	= 1600 x 1024
    1607. 

  1607.    * 		PHPVideoToolkit::SIZE_WUXGA 	= 1920 x 1200
    1608. 

  1608.    * 		PHPVideoToolkit::SIZE_WOXGA 	= 2560 x 1600
    1609. 

  1609.    * 		PHPVideoToolkit::SIZE_WQSXGA	= 3200 x 2048
    1610. 

  1610.    * 		PHPVideoToolkit::SIZE_WQUXGA 	= 3840 x 2400
    1611. 

  1611.    * 		PHPVideoToolkit::SIZE_WHSXGA 	= 6400 x 4096
    1612. 

  1612.    * 		PHPVideoToolkit::SIZE_WHUXGA 	= 7680 x 4800
    1613. 

  1613.    * 		PHPVideoToolkit::SIZE_CGA 		= 320 x 200
    1614. 

  1614.    * 		PHPVideoToolkit::SIZE_EGA		= 640 x 350
    1615. 

  1615.    * 		PHPVideoToolkit::SIZE_HD480 	= 852 x 480
    1616. 

  1616.    * 		PHPVideoToolkit::SIZE_HD720 	= 1280 x 720
    1617. 

  1617.    * 		PHPVideoToolkit::SIZE_HD1080	= 1920 x 1080
    1618. 

  1618.    * @param integer $height
    1619. 

  1619.    * @return boolean
    1620. 

  1620.    */
    1621. 

  1621.   public function setVideoDimensions($width=PHPVideoToolkit::SIZE_SAS, $height=NULL) {
    1622. 

  1622.     if ($height === NULL || $height === TRUE) {
    1623. 

  1623. //				validate input
    1624. 

  1624.       if (!in_array($width, array(self::SIZE_SAS, self::SIZE_SQCIF, self::SIZE_QCIF, self::SIZE_CIF, self::SIZE_4CIF, self::SIZE_QQVGA, self::SIZE_QVGA, self::SIZE_VGA, self::SIZE_SVGA, self::SIZE_XGA, self::SIZE_UXGA, self::SIZE_QXGA, self::SIZE_SXGA, self::SIZE_QSXGA, self::SIZE_HSXGA, self::SIZE_WVGA, self::SIZE_WXGA, self::SIZE_WSXGA, self::SIZE_WUXGA, self::SIZE_WOXGA, self::SIZE_WQSXGA, self::SIZE_WQUXGA, self::SIZE_WHSXGA, self::SIZE_WHUXGA, self::SIZE_CGA, self::SIZE_EGA, self::SIZE_HD480, self::SIZE_HD720, self::SIZE_HD1080))) {
    1625. 

  1625.         return $this->_raiseError('setVideoOutputDimensions_valid_format', array('format' => $format));
    1626. 

  1626. // <-				exits
    1627. 

  1627.       }
    1628. 

  1628.       if ($width === self::SIZE_SAS) {
    1629. 

  1629. // 					and override is made so no command is added in the hope that ffmpeg will just output the source
    1630. 

  1630.         if ($height === TRUE) {
    1631. 

  1631.           return TRUE;
    1632. 

  1632.         }
    1633. 

  1633. // 					get the file info
    1634. 

  1634.         $info = $this->getFileInfo();
    1635. 

  1635.         if (isset($info['video']) === FALSE || isset($info['video']['dimensions']) === FALSE) {
    1636. 

  1636.           return $this->_raiseError('setVideoOutputDimensions_sas_dim');
    1637. 

  1637.         }
    1638. 

  1638.         else {
    1639. 

  1639.           $width = $info['video']['dimensions']['width'] . 'x' . $info['video']['dimensions']['height'];
    1640. 

  1640.         }
    1641. 

  1641.       }
    1642. 

  1642.     }
    1643. 

  1643.     else {
    1644. 

  1644.       $height_split = explode(' ', $height);
    1645. 

  1645. // 				check that the width and height are even
    1646. 

  1646.       if ($width % 2 !== 0 || $height_split[0] % 2 !== 0) {
    1647. 

  1647.         return $this->_raiseError('setVideoOutputDimensions_valid_integer');
    1648. 

  1648. // <-				exits
    1649. 

  1649.       }
    1650. 

  1650.       $width = $width . 'x' . $height_split[0];
    1651. 

  1651.     }
    1652. 

  1652.     $this->addCommand('-s', $width);
    1653. 

  1653.     if (isset($height_split) && count($height_split) > 1) {
    1654. 

  1654.       $commands = $height_split;
    1655. 

  1655.       array_shift($commands);
    1656. 

  1656.       $commands = implode(' ', $commands);
    1657. 

  1657.       preg_match_all('/-(\S*)\s(\S*)/', $commands, $matches);
    1658. 

  1658.       foreach ($matches[0] as $match) {
    1659. 

  1659.         $command = explode(' ', $match);
    1660. 

  1660.         if (count($command) == 2) {
    1661. 

  1661.           $command[0] = preg_replace('/\"/', '', $command[0]);
    1662. 

  1662.           $command[1] = preg_replace('/\"/', '', $command[1]);
    1663. 

  1663. 

  1664.           $this->addCommand($command[0], $command[1]);
    1665. 

  1665.         }
    1666. 

  1666.       }
    1667. 

  1667.     }
    1668. 

  1668.     return TRUE;
    1669. 

  1669.   }
    1670. 

  1670. 

  1671.   /**
    1672. 

  1672.    * Sets the video aspect ratio.
    1673. 

  1673.    * IMPORTANT! Setting an aspect ratio will change the width of the video output if the specified dimensions aren't already
    1674. 

  1674.    * in the correct ratio. ie, Setting the aspect ratio to RATIO_STANDARD when you set the output dimensions to 176 x 144
    1675. 

  1675.    * will in fact output a video with 192 x 144, but the information returned by ffmpeg will give return the size as 176 x 144
    1676. 

  1676.    * which is obviously invalid.
    1677. 

  1677.    *
    1678. 

  1678.    * @access public
    1679. 

  1679.    * @param string|integer $ratio Valid values are PHPVideoToolkit::RATIO_STANDARD, PHPVideoToolkit::RATIO_WIDE, PHPVideoToolkit::RATIO_CINEMATIC, or '4:3', '16:9', '1.85'
    1680. 

  1680.    * @return boolean
    1681. 

  1681.    */
    1682. 

  1682.   public function setVideoAspectRatio($ratio) {
    1683. 

  1683.     if (!in_array($ratio, array(self::RATIO_STANDARD, self::RATIO_WIDE, self::RATIO_CINEMATIC))) {
    1684. 

  1684.       return $this->_raiseError('setVideoAspectRatio_valid_ratio', array('ratio' => $ratio));
    1685. 

  1685.     }
    1686. 

  1686.     $this->addCommand('-aspect', $ratio);
    1687. 

  1687.     return TRUE;
    1688. 

  1688.   }
    1689. 

  1689. 

  1690.   /**
    1691. 

  1691.    * Sets the frame rate of the video
    1692. 

  1692.    *
    1693. 

  1693.    * @access public
    1694. 

  1694.    * @param string|integer $fps 1 being 1 frame per second, 1:2 being 0.5 frames per second
    1695. 

  1695.    * @return boolean
    1696. 

  1696.    */
    1697. 

  1697.   public function setVideoFrameRate($fps) {
    1698. 

  1698.     return $this->addCommand('-r', $fps);
    1699. 

  1699.   }
    1700. 

  1700. 

  1701.   /**
    1702. 

  1702.    * Sets the video bitrate
    1703. 

  1703.    *
    1704. 

  1704.    * @access public
    1705. 

  1705.    * @param integer $bitrate
    1706. 

  1706.    * @return boolean
    1707. 

  1707.    */
    1708. 

  1708.   public function setVideoPreset($preset) {
    1709. 

  1709.     return $this->addCommand('-vpre', $preset);
    1710. 

  1710.   }
    1711. 

  1711. 

  1712.   /**
    1713. 

  1713.    * Extracts a segment of video and/or audio
    1714. 

  1714.    * (Note; If set to 1 and the duration set by $extract_begin_timecode and $extract_end_timecode is equal to 1 you get more than one frame.
    1715. 

  1715.    * For example if you set $extract_begin_timecode='00:00:00' and $extract_end_timecode='00:00:01' you might expect because the time span is
    1716. 

  1716.    * 1 second only to get one frame if you set $frames_per_second=1. However this is not correct. The timecode you set in $extract_begin_timecode
    1717. 

  1717.    * acts as the beginning frame. Thus in this example the first frame exported will be from the very beginning of the video, the video will
    1718. 

  1718.    * then move onto the next frame and export a frame there. Therefore if you wish to export just one frame from one position in the video,
    1719. 

  1719.    * say 1 second in you should set $extract_begin_timecode='00:00:01' and set $extract_end_timecode='00:00:01'.)
    1720. 

  1720.    *
    1721. 

  1721.    * @access public
    1722. 

  1722.    * @param string $extract_begin_timecode A timecode (hh:mm:ss.fn - you can change the timecode format by changing the $timecode_format param
    1723. 

  1723.    * 		it obeys the formatting of PHPVideoToolkit::formatTimecode(), see below for more info)
    1724. 

  1724.    * @param string|integer|boolean $extract_end_timecode A timecode (hh:mm:ss.fn - you can change the timecode format by changing the $timecode_format param
    1725. 

  1725.    * 		it obeys the formatting of PHPVideoToolkit::formatTimecode(), see below for more info)
    1726. 

  1726.    * @param integer $timecode_format The format of the $extract_begin_timecode and $extract_end_timecode timecodes are being given in.
    1727. 

  1727.    * 		default '%hh:%mm:%ss'
    1728. 

  1728.    * 			- %hh (hours) representative of hours
    1729. 

  1729.    * 			- %mm (minutes) representative of minutes
    1730. 

  1730.    * 			- %ss (seconds) representative of seconds
    1731. 

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

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

  1733.    * 			- %ft (frames total) representative of total frames (ie frame number)
    1734. 

  1734.    * 			- %st (seconds total) representative of total seconds (rounded).
    1735. 

  1735.    * 			- %sf (seconds floored) representative of total seconds (floored).
    1736. 

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

  1737.    * 		Thus you could use an alternative, '%hh:%mm:%ss:%ms', or '%hh:%mm:%ss' dependent on your usage.
    1738. 

  1738.    * @param boolean $check_frames_exist Determines if a frame exists check should be made to ensure the timecode given by $extract_end_timecode
    1739. 

  1739.    * 		actually exists.
    1740. 

  1740.    */
    1741. 

  1741.   public function extractSegment($extract_begin_timecode, $extract_end_timecode, $timecode_format='%hh:%mm:%ss.%fn', $frames_per_second=FALSE, $check_frames_exist=TRUE) {
    1742. 

  1742. // 			check for frames per second, if it's not set auto set it.
    1743. 

  1743.     if ($frames_per_second === FALSE) {
    1744. 

  1744.       $info = $this->getFileInfo();
    1745. 

  1745.       $frames_per_second = $info['duration']['timecode']['frames']['frame_rate'];
    1746. 

  1746.     }
    1747. 

  1747. 

  1748. // 			check if frame exists
    1749. 

  1749.     if ($check_frames_exist) {
    1750. 

  1750.       if ($info['duration']['seconds'] < floatval($this->formatTimecode($extract_end_timecode, $timecode_format, '%ss.%ms', $frames_per_second))) {
    1751. 

  1751. // 					the input has not returned any video data so the frame rate can not be guessed
    1752. 

  1752.         return $this->_raiseError('extractSegment_end_timecode');
    1753. 

  1753.       }
    1754. 

  1754.       elseif ($extract_end_timecode !== FALSE && $info['duration']['seconds'] < floatval($this->formatTimecode($extract_begin_timecode, $timecode_format, '%ss.%ms', $frames_per_second))) {
    1755. 

  1755. // 					the input has not returned any video data so the frame rate can not be guessed
    1756. 

  1756.         return $this->_raiseError('extractSegment_begin_timecode');
    1757. 

  1757.       }
    1758. 

  1758.     }
    1759. 

  1759. 

  1760. // 			format the begin timecode if the timecode format is not already ok.
    1761. 

  1761.     $begin_position = (float) $this->formatTimecode($extract_begin_timecode, $timecode_format, '%ss.%ms', $frames_per_second);
    1762. 

  1762.     if ($timecode_format !== '%hh:%mm:%ss.%ms') {
    1763. 

  1763.       $extract_begin_timecode = $this->formatTimecode($extract_begin_timecode, $timecode_format, '%hh:%mm:%ss.%ms', $frames_per_second);
    1764. 

  1764.     }
    1765. 

  1765.     $this->addCommand('-ss', $extract_begin_timecode);
    1766. 

  1766. 

  1767. //			allows for exporting the entire timeline
    1768. 

  1768.     if ($extract_end_timecode !== FALSE) {
    1769. 

  1769.       $end_position = (float) $this->formatTimecode($extract_end_timecode, $timecode_format, '%ss.%ms', $frames_per_second);
    1770. 

  1770. // 				format the end timecode if the timecode format is not already ok.
    1771. 

  1771.       if ($timecode_format !== '%hh:%mm:%ss.%ms') {
    1772. 

  1772.         $extract_end_timecode = $this->formatTimecode($extract_end_timecode, $timecode_format, '%hh:%mm:%ss.%ms', $frames_per_second);
    1773. 

  1773.       }
    1774. 

  1774.       $this->addCommand('-t', $end_position - $begin_position);
    1775. 

  1775.     }
    1776. 

  1776.     return TRUE;
    1777. 

  1777.   }
    1778. 

  1778. 

  1779.   /**
    1780. 

  1780.    * Extracts frames from a video.
    1781. 

  1781.    * (Note; If set to 1 and the duration set by $extract_begin_timecode and $extract_end_timecode is equal to 1 you get more than one frame.
    1782. 

  1782.    * For example if you set $extract_begin_timecode='00:00:00' and $extract_end_timecode='00:00:01' you might expect because the time span is
    1783. 

  1783.    * 1 second only to get one frame if you set $frames_per_second=1. However this is not correct. The timecode you set in $extract_begin_timecode
    1784. 

  1784.    * acts as the beginning frame. Thus in this example the first frame exported will be from the very beginning of the video, the video will
    1785. 

  1785.    * then move onto the next frame and export a frame there. Therefore if you wish to export just one frame from one position in the video,
    1786. 

  1786.    * say 1 second in you should set $extract_begin_timecode='00:00:01' and set $extract_end_timecode='00:00:01'.)
    1787. 

  1787.    *
    1788. 

  1788.    * @access public
    1789. 

  1789.    * @param string $extract_begin_timecode A timecode (hh:mm:ss.fn - you can change the timecode format by changing the $timecode_format param
    1790. 

  1790.    * 		it obeys the formatting of PHPVideoToolkit::formatTimecode(), see below for more info)
    1791. 

  1791.    * @param string|integer|boolean $extract_end_timecode A timecode (hh:mm:ss.fn - you can change the timecode format by changing the $timecode_format param
    1792. 

  1792.    * 		it obeys the formatting of PHPVideoToolkit::formatTimecode(), see below for more info), or FALSE
    1793. 

  1793.    * 		if all frames from the begin timecode are to be exported. (Boolean added by Matthias. Thanks. 12th March 2007)
    1794. 

  1794.    * @param boolean|integer $frames_per_second The number of frames per second to extract. If left as default FALSE, then the number of frames per second
    1795. 

  1795.    * 		will be automagically gained from PHPVideoToolkit::fileGetInfo();
    1796. 

  1796.    * @param boolean|integer $frame_limit Frame limiter. If set to FALSE then all the frames will be exported from the given time codes, however
    1797. 

  1797.    * 		if you wish to set a export limit to the number of frames that are exported you can set an integer. For example; if you set
    1798. 

  1798.    * 		$extract_begin_timecode='00:00:11.01', $extract_end_timecode='00:01:10.01', $frames_per_second=1, you will get one frame for every second
    1799. 

  1799.    * 		in the video between 00:00:11 and 00:01:10 (ie 60 frames), however if you ant to artificially limit this to exporting only ten frames
    1800. 

  1800.    * 		then you set $frame_limit=10. You could of course alter the timecode to reflect you desired frame number, however there are situations
    1801. 

  1801.    * 		when a shortcut such as this is useful and necessary.
    1802. 

  1802.    * @param integer $timecode_format The format of the $extract_begin_timecode and $extract_end_timecode timecodes are being given in.
    1803. 

  1803.    * 		default '%hh:%mm:%ss'
    1804. 

  1804.    * 			- %hh (hours) representative of hours
    1805. 

  1805.    * 			- %mm (minutes) representative of minutes
    1806. 

  1806.    * 			- %ss (seconds) representative of seconds
    1807. 

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

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

  1809.    * 			- %ft (frames total) representative of total frames (ie frame number)
    1810. 

  1810.    * 			- %st (seconds total) representative of total seconds (rounded).
    1811. 

  1811.    * 			- %sf (seconds floored) representative of total seconds (floored).
    1812. 

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

  1813.    * 		Thus you could use an alternative, '%hh:%mm:%ss:%ms', or '%hh:%mm:%ss' dependent on your usage.
    1814. 

  1814.    * @param boolean $check_frames_exist Determines if a frame exists check should be made to ensure the timecode given by $extract_end_timecode
    1815. 

  1815.    * 		actually exists.
    1816. 

  1816.    */
    1817. 

  1817.   public function extractFrames($extract_begin_timecode, $extract_end_timecode, $frames_per_second=FALSE, $frame_limit=FALSE, $timecode_format='%hh:%mm:%ss.%fn', $check_frames_exist=TRUE) {
    1818. 

  1818. // 			are we autoguessing the frame rate?
    1819. 

  1819.     if ($frames_per_second === FALSE || $check_frames_exist) {
    1820. 

  1820. // 				get the file info, will exit if no input has been set
    1821. 

  1821.       $info = $this->getFileInfo();
    1822. 

  1822.       if ($info === FALSE || isset($info['video']) === FALSE) {
    1823. 

  1823. // 					the input has not returned any video data so the frame rate can not be guessed
    1824. 

  1824.         return $this->_raiseError('extractFrame_video_frame_rate_404');
    1825. 

  1825.       }
    1826. 

  1826.       $frames_per_second = $info['video']['frame_rate'];
    1827. 

  1827.     }
    1828. 

  1828. // 			check if frame exists
    1829. 

  1829.     if ($check_frames_exist) {
    1830. 

  1830.       if ($info['video']['frame_count'] < $this->formatTimecode($extract_end_timecode, $timecode_format, '%ft', $frames_per_second)) {
    1831. 

  1831. // 					the input has not returned any video data so the frame rate can not be guessed
    1832. 

  1832.         return $this->_raiseError('extractFrames_video_end_frame_count');
    1833. 

  1833.       }
    1834. 

  1834.       elseif ($extract_end_timecode !== FALSE && $info['video']['frame_count'] < $this->formatTimecode($extract_begin_timecode, $timecode_format, '%ft', $frames_per_second)) {
    1835. 

  1835. // 					the input has not returned any video data so the frame rate can not be guessed
    1836. 

  1836.         return $this->_raiseError('extractFrames_video_begin_frame_count');
    1837. 

  1837.       }
    1838. 

  1838.     }
    1839. 

  1839. // 			disable audio output
    1840. 

  1840.     $this->disableAudio();
    1841. 

  1841. 

  1842. // 			format the begin timecode if the timecode format is not already ok.
    1843. 

  1843.     /*
    1844. 

  1844.       if($timecode_format !== '%hh:%mm:%ss.%ms')
    1845. 

  1845.       {
    1846. 

  1846.       $extract_begin_timecode = $this->formatTimecode($extract_begin_timecode, $timecode_format, '%hh:%mm:%ss.%ms', $frames_per_second);
    1847. 

  1847.       }
    1848. 

  1848.      */
    1849. 

  1849. 

  1850.     // Use seek before the input tag to quickly move to the approximate location,
    1851. 

  1851.     // then use the seek after the input tag to locate the exact frames.
    1852. 

  1852.     // See http://ffmpeg.org/trac/ffmpeg/wiki/Seeking%20with%20FFmpeg
    1853. 

  1853.     $seconds = $this->formatTimecode($extract_begin_timecode, $timecode_format, '%st', $frames_per_second);
    1854. 

  1854.     if ($seconds > 5) {
    1855. 

  1855.       $this->addCommand('-ss', $this->formatTimecode($seconds - 5, $timecode_format, '%hh:%mm:%ss:%ms', $frames_per_second), TRUE);
    1856. 

  1856.       $this->addCommand('-ss', $this->formatTimecode(5, $timecode_format, '%hh:%mm:%ss:%ms', $frames_per_second), FALSE);
    1857. 

  1857.     }
    1858. 

  1858.     else {
    1859. 

  1859.       $this->addCommand('-ss', $extract_begin_timecode);
    1860. 

  1860.     }
    1861. 

  1861. 

  1862. //			added by Matthias on 12th March 2007
    1863. 

  1863. //			allows for exporting the entire timeline
    1864. 

  1864.     if ($extract_end_timecode !== FALSE) {
    1865. 

  1865. // 				format the end timecode if the timecode format is not already ok.
    1866. 

  1866.       if ($timecode_format !== '%hh:%mm:%ss.%ms') {
    1867. 

  1867.         $extract_end_timecode = $this->formatTimecode($extract_end_timecode, $timecode_format, '%hh:%mm:%ss.%ms', $frames_per_second);
    1868. 

  1868.       }
    1869. 

  1869.       $this->addCommand('-t', $extract_end_timecode);
    1870. 

  1870.     }
    1871. 

  1871. // 			set the output frame rate
    1872. 

  1872.     $this->setVideoFrameRate($frames_per_second);
    1873. 

  1873. // 			do we need to limit the number of frames outputted?
    1874. 

  1874.     if ($frame_limit !== FALSE) {
    1875. 

  1875.       $this->addCommand('-vframes', $frame_limit);
    1876. 

  1876.     }
    1877. 

  1877.     $this->_image_output_timecode_start = $extract_begin_timecode;
    1878. 

  1878.     $this->_image_output_timecode_fps = $frames_per_second;
    1879. 

  1879.   }
    1880. 

  1880. 

  1881.   /**
    1882. 

  1882.    * Extracts exactly one frame
    1883. 

  1883.    *
    1884. 

  1884.    * @access public
    1885. 

  1885.    * @uses $toolkit->extractFrames
    1886. 

  1886.    * @param string $frame_timecode A timecode (hh:mm:ss.fn) where fn is the frame number of that second
    1887. 

  1887.    * @param integer|boolean $frames_per_second The frame rate of the movie. If left as the default, FALSE. We will use PHPVideoToolkit::getFileInfo() to get
    1888. 

  1888.    * 			the actual frame rate. It is recommended that it is left as FALSE because an incorrect frame rate may produce unexpected results.
    1889. 

  1889.    * @param integer $timecode_format The format of the $extract_begin_timecode and $extract_end_timecode timecodes are being given in.
    1890. 

  1890.    * 		default '%hh:%mm:%ss'
    1891. 

  1891.    * 			- %hh (hours) representative of hours
    1892. 

  1892.    * 			- %mm (minutes) representative of minutes
    1893. 

  1893.    * 			- %ss (seconds) representative of seconds
    1894. 

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

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

  1896.    * 			- %ft (frames total) representative of total frames (ie frame number)
    1897. 

  1897.    * 			- %st (seconds total) representative of total seconds (rounded).
    1898. 

  1898.    * 			- %sf (seconds floored) representative of total seconds (floored).
    1899. 

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

  1900.    * 		Thus you could use an alternative, '%hh:%mm:%ss:%ms', or '%hh:%mm:%ss' dependent on your usage.
    1901. 

  1901.    * @param boolean $check_frame_exists Makes an explicit check to see if the frame exists, default = TRUE.
    1902. 

  1902.    * 		Thanks to Istvan Szakacs for suggesting this check. Note, to improve performance disable this check.
    1903. 

  1903.    */
    1904. 

  1904.   public function extractFrame($frame_timecode, $frames_per_second=FALSE, $frame_timecode_format='%hh:%mm:%ss.%fn', $check_frame_exists=TRUE) {
    1905. 

  1905. // 			get the file info, will exit if no input has been set
    1906. 

  1906.     if ($check_frame_exists || $frames_per_second === FALSE) {
    1907. 

  1907.       $info = $this->getFileInfo();
    1908. 

  1908.       if ($info === FALSE || isset($info['video']) === FALSE) {
    1909. 

  1909. // 					the input has not returned any video data so the frame rate can not be guessed
    1910. 

  1910.         return $this->_raiseError('extractFrame_video_info_404');
    1911. 

  1911.       }
    1912. 

  1912.     }
    1913. 

  1913. // 			are we autoguessing the frame rate?
    1914. 

  1914.     if ($frames_per_second === FALSE) {
    1915. 

  1915.       if (isset($info['video']['frame_rate']) === FALSE) {
    1916. 

  1916. // 					the input has not returned any video data so the frame rate can not be guessed
    1917. 

  1917.         return $this->_raiseError('extractFrame_video_frame_rate_404');
    1918. 

  1918.       }
    1919. 

  1919.       $frames_per_second = $info['video']['frame_rate'];
    1920. 

  1920.     }
    1921. 

  1921. // 			check if frame exists
    1922. 

  1922.     if ($check_frame_exists) {
    1923. 

  1923.       if ($info['video']['frame_count'] < $this->formatTimecode($frame_timecode, $frame_timecode_format, '%ft', $frames_per_second)) {
    1924. 

  1924. // 					the input has not returned any video data so the frame rate can not be guessed
    1925. 

  1925.         return $this->_raiseError('extractFrame_video_frame_count');
    1926. 

  1926.       }
    1927. 

  1927.     }
    1928. 

  1928. // 			format the frame details if the timecode format is not already ok.
    1929. 

  1929.     /*
    1930. 

  1930.       if($frame_timecode_format !== '%hh:%mm:%ss.%ms')
    1931. 

  1931.       $frame_timecode = $this->formatTimecode($frame_timecode, $frame_timecode_format, '%hh:%mm:%ss.%ms', $frames_per_second);
    1932. 

  1932.       }
    1933. 

  1933.      */
    1934. 

  1934.     $this->_single_frame_extraction = 1;
    1935. 

  1935. // 			we will limit the number of frames produced so the desired frame is the last image
    1936. 

  1936. // 			this way we limit the cpu usage of ffmpeg
    1937. 

  1937. // 			Thanks to Istvan Szakacs for pointing out that ffmpeg can export frames using the -ss hh:mm:ss[.xxx]
    1938. 

  1938. // 			it has saved a lot of cpu intensive processes.
    1939. 

  1939.     $this->extractFrames($frame_timecode, $frame_timecode, $frames_per_second, 1, $frame_timecode_format, FALSE);
    1940. 

  1940. // 			register the post tidy process
    1941. 

  1941. // 			$this->registerPostProcess('_extractFrameTidy', $this);
    1942. 

  1942.   }
    1943. 

  1943. 

  1944. // 		/**
    1945. 

  1945. // 		 * Tidies up after ffmpeg exports all frames from one second of video.
    1946. 

  1946. // 		 *
    1947. 

  1947. // 		 * @access public
    1948. 

  1948. // 		 * @uses $toolkit->extractFrames
    1949. 

  1949. // 		 * @param string $frame_timecode A timecode (hh:mm:ss.fn) where fn is the frame number of that second
    1950. 

  1950. // 		 * @param integer|boolean $frames_per_second The frame rate of the movie. If left as the default, FALSE. We will use PHPVideoToolkit::getFileInfo() to get
    1951. 

  1951. // 		 * 			the actual frame rate. It is recommended that it is left as FALSE because an incorrect frame rate may produce unexpected results.
    1952. 

  1952. // 		 */
    1953. 

  1953. // 		protected function _extractFrameTidy(&$files)
    1954. 

  1954. // 		{
    1955. 

  1955. // 			$frame_number = 1;
    1956. 

  1956. // 			$frame_file = array();
    1957. 

  1957. // // 			print_r($files);
    1958. 

  1958. // 			foreach($files as $file=>$filename)
    1959. 

  1959. // 			{
    1960. 

  1960. // // 				print_R(array($this->_single_frame_extraction, $frame_number));
    1961. 

  1961. // 				if($this->_single_frame_extraction == $frame_number)
    1962. 

  1962. // 				{
    1963. 

  1963. // // 					leave this file alone as it is the required frame
    1964. 

  1964. // 					$frame_file[$file] = $filename;
    1965. 

  1965. // 				}
    1966. 

  1966. // 				else
    1967. 

  1967. // 				{
    1968. 

  1968. // // 					add the frame to the unlink files list
    1969. 

  1969. // 					array_push($this->_unlink_files, $file);
    1970. 

  1970. // 				}
    1971. 

  1971. // 				$frame_number += 1;
    1972. 

  1972. // 			}
    1973. 

  1973. // // 				print_r($frame_file);
    1974. 

  1974. // // 			update the files list
    1975. 

  1975. // 			$files = $frame_file;
    1976. 

  1976. // 			return TRUE;
    1977. 

  1977. // 		}
    1978. 

  1978. 

  1979.   /**
    1980. 

  1980.    * Adds a watermark to the outputted files. This effects both video and image output.
    1981. 

  1981.    *
    1982. 

  1982.    * @access public
    1983. 

  1983.    * @param string $watermark_url The absolute path to the watermark image.
    1984. 

  1984.    * @param string $vhook The absolute path to the ffmpeg vhook watermark library.
    1985. 

  1985.    * @param string $watermark_options Any additional options to supply to the vhook.
    1986. 

  1986.    */
    1987. 

  1987.   public function addWatermark($watermark_url, $vhook=PHPVIDEOTOOLKIT_FFMPEG_WATERMARK_VHOOK, $watermark_options=FALSE) {
    1988. 

  1988. // 			check to see if the ffmpeg binary has support for vhooking
    1989. 

  1989.     if (!$this->hasVHookSupport()) {
    1990. 

  1990.       return $this->_raiseError('addWatermark_vhook_disabled');
    1991. 

  1991.     }
    1992. 

  1992. // 			does the file exist?
    1993. 

  1993.     if (!is_file($watermark_url)) {
    1994. 

  1994.       return $this->_raiseError('addWatermark_img_404', array('watermark' => $watermark_url));
    1995. 

  1995.     }
    1996. 

  1996. //          determine which vhook library is being called and set appropriate input param
    1997. 

  1997.     // vhook depricated so now we have to ues http://ffmpeg.org/libavfilter.html
    1998. 

  1998.     $file_input_switch = preg_match("/watermark.*/", $vhook) ? ' -f ' : ' -i ';
    1999. 

  1999.     $this->addCommand('-vhook', $vhook . $file_input_switch . $watermark_url . ($watermark_options !== FALSE ? ' ' . $watermark_options : ''));
    2000. 

  2000.   }
    2001. 

  2001. 

  2002.   /**
    2003. 

  2003.    * Adds a watermark to the outputted image files using the PHP GD module.
    2004. 

  2004.    * This effects only image output.
    2005. 

  2005.    *
    2006. 

  2006.    * @access public
    2007. 

  2007.    * @param string $watermark_url The absolute path to the watermark image.
    2008. 

  2008.    */
    2009. 

  2009.   public function addGDWatermark($watermark_url, $options=array('x-offset' => 0, 'y-offset' => 0, 'position' => 'bottom-right')) {
    2010. 

  2010. // 			does the file exist?
    2011. 

  2011.     if (!is_file($watermark_url)) {
    2012. 

  2012.       return $this->_raiseError('addWatermark_img_404', array('watermark' => $watermark_url));
    2013. 

  2013.     }
    2014. 

  2014. // 			save the watermark_url
    2015. 

  2015.     $this->_watermark_url = $watermark_url;
    2016. 

  2016.     $this->_watermark_options = array_merge(array('x-offset' => 0, 'y-offset' => 0, 'position' => 'bottom-right'), $options);
    2017. 

  2017. // 			register the post process
    2018. 

  2018.     $this->registerPostProcess('_addGDWatermark', $this);
    2019. 

  2019.   }
    2020. 

  2020. 

  2021.   /**
    2022. 

  2022.    * Adds watermark to any outputted images via GD instead of using vhooking.
    2023. 

  2023.    *
    2024. 

  2024.    * @access protected
    2025. 

  2025.    * @param array $files An array of image files.
    2026. 

  2026.    * @return array
    2027. 

  2027.    */
    2028. 

  2028.   protected function _addGDWatermark($files) {
    2029. 

  2029. // 			create the watermark resource and give it alpha blending
    2030. 

  2030.     $info = pathinfo($this->_watermark_url);
    2031. 

  2031.     switch (strtolower($info['extension'])) {
    2032. 

  2032.       case 'jpeg' :
    2033. 

  2033.       case 'jpg' :
    2034. 

  2034.         $watermark = imagecreatefromjpeg($this->_watermark_url);
    2035. 

  2035.         break;
    2036. 

  2036.       case 'gif' :
    2037. 

  2037.         $watermark = imagecreatefromgif($this->_watermark_url);
    2038. 

  2038.         break;
    2039. 

  2039.       case 'png' :
    2040. 

  2040.         $watermark = imagecreatefrompng($this->_watermark_url);
    2041. 

  2041.         break;
    2042. 

  2042.       default :
    2043. 

  2043.         return FALSE;
    2044. 

  2044.     }
    2045. 

  2045.     imagealphablending($watermark, TRUE);
    2046. 

  2046.     imagesavealpha($watermark, TRUE);
    2047. 

  2047. // 			get the watermark dimensions
    2048. 

  2048.     $watermark_width = imagesx($watermark);
    2049. 

  2049.     $watermark_height = imagesy($watermark);
    2050. 

  2050. // 			$image = imagecreatetruecolor($watermark_width, $watermark_height);
    2051. 

  2051. // 			loop and watermark each file
    2052. 

  2052.     $blended_files = array();
    2053. 

  2053.     foreach ($files as $file => $filename) {
    2054. 

  2054. // 				detect the file extension and create the resource from them appropriate function
    2055. 

  2055.       $info = pathinfo($file);
    2056. 

  2056.       $quality = $output_function = NULL;
    2057. 

  2057.       switch (strtolower($info['extension'])) {
    2058. 

  2058.         case 'jpeg' :
    2059. 

  2059.         case 'jpg' :
    2060. 

  2060.           $quality = 80;
    2061. 

  2061.           $output_function = 'imagejpeg';
    2062. 

  2062.           $image = imagecreatefromjpeg($file);
    2063. 

  2063.           break;
    2064. 

  2064.         case 'gif' :
    2065. 

  2065.           $output_function = 'imagegif';
    2066. 

  2066.           $image = imagecreatefromgif($file);
    2067. 

  2067.           break;
    2068. 

  2068.         case 'png' :
    2069. 

  2069.           $quality = 9;
    2070. 

  2070.           $output_function = 'imagepng';
    2071. 

  2071.           $image = imagecreatefrompng($file);
    2072. 

  2072.           break;
    2073. 

  2073.         default :
    2074. 

  2074.           continue 1;
    2075. 

  2075.       }
    2076. 

  2076. 

  2077. // 				the dimensions will/should be the same for each image however still best to check
    2078. 

  2078.       $image_width = imagesx($image);
    2079. 

  2079.       $image_height = imagesy($image);
    2080. 

  2080. // 				calculate where to position the watermark
    2081. 

  2081.       $dest_x = 0;
    2082. 

  2082.       $dest_y = 0;
    2083. 

  2083.       switch ($this->_watermark_options['position']) {
    2084. 

  2084.         case 'top-left' :
    2085. 

  2085.           $dest_x = 0;
    2086. 

  2086.           $dest_y = 0;
    2087. 

  2087.           break;
    2088. 

  2088.         case 'top-middle' :
    2089. 

  2089.           $dest_x = ($image_width - $watermark_width) / 2;
    2090. 

  2090.           $dest_y = 0;
    2091. 

  2091.           break;
    2092. 

  2092.         case 'top-right' :
    2093. 

  2093.           $dest_x = $image_width - $watermark_width;
    2094. 

  2094.           $dest_y = 0;
    2095. 

  2095.           break;
    2096. 

  2096.         case 'center-left' :
    2097. 

  2097.           $dest_x = 0;
    2098. 

  2098.           $dest_y = ($image_height - $watermark_height) / 2;
    2099. 

  2099.           break;
    2100. 

  2100.         case 'center-middle' :
    2101. 

  2101.           $dest_x = ($image_width - $watermark_width) / 2;
    2102. 

  2102.           $dest_y = ($image_height - $watermark_height) / 2;
    2103. 

  2103.           break;
    2104. 

  2104.         case 'center-right' :
    2105. 

  2105.           $dest_x = $image_width - $watermark_width;
    2106. 

  2106.           $dest_y = ($image_height - $watermark_height) / 2;
    2107. 

  2107.           break;
    2108. 

  2108.         case 'bottom-left' :
    2109. 

  2109.           $dest_x = 0;
    2110. 

  2110.           $dest_y = $image_height - $watermark_height;
    2111. 

  2111.           break;
    2112. 

  2112.         case 'bottom-middle' :
    2113. 

  2113.           $dest_x = ($image_width - $watermark_width) / 2;
    2114. 

  2114.           $dest_y = $image_height - $watermark_height;
    2115. 

  2115.           break;
    2116. 

  2116.         case 'bottom-right' :
    2117. 

  2117.         default :
    2118. 

  2118.           $dest_x = $image_width - $watermark_width;
    2119. 

  2119.           $dest_y = $image_height - $watermark_height;
    2120. 

  2120.           break;
    2121. 

  2121.       }
    2122. 

  2122.       $dest_x += $this->_watermark_options['x-offset'];
    2123. 

  2123.       $dest_y += $this->_watermark_options['y-offset'];
    2124. 

  2124. // 				copy the watermark to the new image
    2125. 

  2125.       imagecopy($image, $watermark, $dest_x, $dest_y, 0, 0, $watermark_width, $watermark_height);
    2126. 

  2126. // 				delete the old image
    2127. 

  2127.       unlink($file);
    2128. 

  2128. // 				save the new image in place of the old
    2129. 

  2129.       $output_function($image, $file, $quality);
    2130. 

  2130. // 				remove the image resouce
    2131. 

  2131.       imagedestroy($image);
    2132. 

  2132.       array_push($blended_files, $file);
    2133. 

  2133.     }
    2134. 

  2134. // 			remove the watermark resource
    2135. 

  2135.     imagedestroy($watermark);
    2136. 

  2136.     return $blended_files;
    2137. 

  2137.   }
    2138. 

  2138. 

  2139. // 		/**
    2140. 

  2140. // 		 * This will overlay an audio file over the top of a video file
    2141. 

  2141. // 		 **/
    2142. 

  2142. // 		public function overlayAudio($audio_file)
    2143. 

  2143. // 		{
    2144. 

  2144. // 			$this->addCommand('-newaudio', '');
    2145. 

  2145. // 		}
    2146. 

  2146. 

  2147.   /**
    2148. 

  2148.    * This will adjust the audio volume.
    2149. 

  2149.    *
    2150. 

  2150.    * @access public
    2151. 

  2151.    * @param integer $vol 256 = normal
    2152. 

  2152.    * */
    2153. 

  2153.   public function adjustVolume($vol=256) {
    2154. 

  2154.     $this->addCommand('-vol', '');
    2155. 

  2155.   }
    2156. 

  2156. 

  2157.   /**
    2158. 

  2158.    * This process will combine the original input video with the video specified by this function.
    2159. 

  2159.    * This function accepts more than one video as arguments. They will be added in order of the arguments.
    2160. 

  2160.    * 	ie. input_video -> video1 -> video2 etc
    2161. 

  2161.    * The process of doing this can take a long time as each incoming video has to be first converted
    2162. 

  2162.    * into a format that accepts joining. The default joining codec is "mpg". However for almost lossless
    2163. 

  2163.    * quality you can use the "yuv4mpegpipe" format. This is of course dependent upon your ffmpeg binary.
    2164. 

  2164.    * You can check to see if you server supports yuv4mpegpipe by typing "ffmpeg -formats" into the
    2165. 

  2165.    * command line. If you want to use the yuv4mpegpipe format you can add the flag, FFMPEG_USE_HQ_JOIN to the
    2166. 

  2166.    * end of the video inputs. WARNING: High Quality joins will take longer to process. (well duh!)
    2167. 

  2167.    *
    2168. 

  2168.    * @access public
    2169. 

  2169.    * @param $video1, $video2, $video3... $video(n) Paths of videos to attach to the input video.
    2170. 

  2170.    * @param $flag integer FFMPEG_USE_HQ_JOIN If you wish to use the yuv4mpegpipe format for join add this to the end of the video list.
    2171. 

  2171.    */
    2172. 

  2172.   public function addVideo() {
    2173. 

  2173.     $videos = func_get_args();
    2174. 

  2174.     $videos_length = count($videos);
    2175. 

  2175. // 			is last arg the hq join flag
    2176. 

  2176. // 			check to see if a starter file has been added, if not set the input as an array
    2177. 

  2177.     if ($this->_input_file === NULL) {
    2178. 

  2178.       $this->_input_file = array();
    2179. 

  2179.     }
    2180. 

  2180. // 			if the input file is already set as a string that means as start file has been added so absorb into the input array
    2181. 

  2181.     elseif (is_string($this->_input_file)) {
    2182. 

  2182.       $this->_input_file = array($this->_input_file);
    2183. 

  2183.     }
    2184. 

  2184.     foreach ($videos as $key => $file) {
    2185. 

  2185.       if (!preg_match('/\%([0-9]+)d/', $file) && strpos($file, '%d') === FALSE && !is_file($file)) {
    2186. 

  2186. // 					input file not valid
    2187. 

  2187.         return $this->_raiseError('addVideo_file_404', array('file' => $file));
    2188. 

  2188. // <-				exits
    2189. 

  2189.       }
    2190. 

  2190.       array_push($this->_input_file, $file);
    2191. 

  2191. // 				array_push($this->_input_file, escapeshellarg($file));
    2192. 

  2192.     }
    2193. 

  2193.   }
    2194. 

  2194. 

  2195.   /**
    2196. 

  2196.    * @access public
    2197. 

  2197.    * @uses addVideo()
    2198. 

  2198.    */
    2199. 

  2199.   public function addVideos() {
    2200. 

  2200.     $videos = func_get_args();
    2201. 

  2201.     call_user_func_array(array(&$this, 'addVideo'), $videos);
    2202. 

  2202.   }
    2203. 

  2203. 

  2204.   /**
    2205. 

  2205.    * Sets the output.
    2206. 

  2206.    *
    2207. 

  2207.    * @access public
    2208. 

  2208.    * @param string $output_directory The directory to output the command output to
    2209. 

  2209.    * @param string $output_name The filename to output to.
    2210. 

  2210.    * 			(Note; if you are outputting frames from a video then you will need to add an extra item to the output_name. The output name you set is required
    2211. 

  2211.    * 			to contain '%d'. '%d' is replaced by the image number. Thus entering setting output_name $output_name='img%d.jpg' will output
    2212. 

  2212.    * 			'img1.jpg', 'img2.jpg', etc... However 'img%03d.jpg' generates `img001.jpg', `img002.jpg', etc...)
    2213. 

  2213.    * @param boolean $overwrite_mode Accepts one of the following class constants
    2214. 

  2214.    * 	- PHPVideoToolkit::OVERWRITE_FAIL		- This produces an error if there is a file conflict and the processing is halted.
    2215. 

  2215.    * 	- PHPVideoToolkit::OVERWRITE_PRESERVE	- This continues with the processing but no file overwrite takes place. The processed file is left in the temp directory
    2216. 

  2216.    * 									  for you to manually move.
    2217. 

  2217.    * 	- PHPVideoToolkit::OVERWRITE_EXISTING	- This will replace any existing files with the freshly processed ones.
    2218. 

  2218.    * 	- PHPVideoToolkit::OVERWRITE_UNIQUE		- This will appended every output with a unique hash so that the filesystem is preserved.
    2219. 

  2219.    * @return boolean FALSE on error encountered, TRUE otherwise
    2220. 

  2220.    */
    2221. 

  2221.   public function setOutput($output_directory, $output_name, $overwrite_mode=PHPVideoToolkit::OVERWRITE_FAIL) {
    2222. 

  2222. //			check if directoy exists
    2223. 

  2223.     if (!is_dir($output_directory)) {
    2224. 

  2224.       return $this->_raiseError('setOutput_output_dir_404', array('dir' => $output_directory));
    2225. 

  2225. // <-			exits
    2226. 

  2226.     }
    2227. 

  2227. //			check if directory is writeable
    2228. 

  2228.     if (!is_writable($output_directory)) {
    2229. 

  2229.       return $this->_raiseError('setOutput_output_dir_writable', array('dir' => $output_directory));
    2230. 

  2230. // <-			exits
    2231. 

  2231.     }
    2232. 

  2232.     $process_name = '';
    2233. 

  2233. //			check to see if a output delimiter is set
    2234. 

  2234.     $has_d = preg_match('/\%([0-9]+)d/', $output_name) || strpos($output_name, '%d') !== FALSE;
    2235. 

  2235.     if ($has_d) {
    2236. 

  2236.       return $this->_raiseError('setOutput_%d_depreciated');
    2237. 

  2237. // <-			exits
    2238. 

  2238.     }
    2239. 

  2239.     else {
    2240. 

  2240. //				determine if the extension is an image. If it is then we will be extracting frames so check for %d
    2241. 

  2241.       $output_name_info = pathinfo($output_name);
    2242. 

  2242.       $is_image = in_array(strtolower($output_name_info['extension']), array('jpg', 'jpeg', 'png'));
    2243. 

  2243.       $is_gif = strtolower($output_name_info['extension']) === 'gif';
    2244. 

  2244. //				NOTE: for now we'll just stick to the common image formats, SUBNOTE: gif is ignore because ffmpeg can create animated gifs
    2245. 

  2245.       if ($this->_single_frame_extraction !== NULL && strpos($output_name, '%timecode') === FALSE && !(preg_match('/\%index/', $output_name) || strpos($output_name, '%index') !== FALSE) && $is_image) {
    2246. 

  2246.         // return $this->_raiseError('setOutput_%_missing');
    2247. 

  2247. // <-				exits
    2248. 

  2248.       }
    2249. 

  2249.       $process_name = '.' . $output_name_info['extension'];
    2250. 

  2250.       if ($is_image || ($this->_single_frame_extraction !== NULL && $is_gif)) {
    2251. 

  2251.         $process_name = '-%12d' . $process_name;
    2252. 

  2252.       }
    2253. 

  2253.     }
    2254. 

  2254. //			set the output address
    2255. 

  2255.     $this->_output_address = $output_directory . $output_name;
    2256. 

  2256. // 			set the processing address in the temp folder so it does not conflict with any other conversions
    2257. 

  2257.     $this->_process_address = $this->_tmp_directory . $this->unique() . $process_name;
    2258. 

  2258.     $this->_overwrite_mode = $overwrite_mode;
    2259. 

  2259.     return TRUE;
    2260. 

  2260.   }
    2261. 

  2261. 

  2262.   /**
    2263. 

  2263.    * Sets a constant quality value to the encoding. (but a variable bitrate)
    2264. 

  2264.    *
    2265. 

  2265.    * @param integer $quality The quality to adhere to. 100 is highest quality, 1 is the lowest quality
    2266. 

  2266.    */
    2267. 

  2267.   public function setConstantQuality($quality) {
    2268. 

  2268. // 			interpret quality into ffmpeg value
    2269. 

  2269.     $quality = 31 - round(($quality / 100) * 31);
    2270. 

  2270.     if ($quality > 31) {
    2271. 

  2271.       $quality = 31;
    2272. 

  2272.     }
    2273. 

  2273.     elseif ($quality < 1) {
    2274. 

  2274.       $quality = 1;
    2275. 

  2275.     }
    2276. 

  2276.     return $this->addCommand('-qscale', $quality);
    2277. 

  2277.   }
    2278. 

  2278. 

  2279.   /**
    2280. 

  2280.    * Translates a number of seconds to a timecode.
    2281. 

  2281.    * NOTE: this is now a depreciated, use formatSeconds() instead.
    2282. 

  2282.    *
    2283. 

  2283.    * @deprecated Use formatSeconds() instead.
    2284. 

  2284.    * @access public
    2285. 

  2285.    * @uses PHPVideoToolkit::formatSeconds()
    2286. 

  2286.    * @param integer $input_seconds The number of seconds you want to calculate the timecode for.
    2287. 

  2287.    */
    2288. 

  2288.   public function secondsToTimecode($input_seconds=0) {
    2289. 

  2289.     return $this->formatSeconds($input_seconds, '%hh:%mm:%ss');
    2290. 

  2290.   }
    2291. 

  2291. 

  2292.   /**
    2293. 

  2293.    * Translates a timecode to the number of seconds.
    2294. 

  2294.    * NOTE: this is now a depreciated, use formatTimecode() instead.
    2295. 

  2295.    *
    2296. 

  2296.    * @deprecated Use formatTimecode() instead.
    2297. 

  2297.    * @access public
    2298. 

  2298.    * @uses PHPVideoToolkit::formatTimecode()
    2299. 

  2299.    * @param integer $input_seconds The number of seconds you want to calculate the timecode for.
    2300. 

  2300.    */
    2301. 

  2301.   public function timecodeToSeconds($input_timecode='00:00:00') {
    2302. 

  2302.     return $this->formatTimecode($input_timecode, '%hh:%mm:%ss', '%st');
    2303. 

  2303.   }
    2304. 

  2304. 

  2305.   /**
    2306. 

  2306.    * Translates a number of seconds to a timecode.
    2307. 

  2307.    *
    2308. 

  2308.    * @access public
    2309. 

  2309.    * @param integer $input_seconds The number of seconds you want to calculate the timecode for.
    2310. 

  2310.    * @param integer $return_format The format of the timecode to return. The default is
    2311. 

  2311.    * 		default '%hh:%mm:%ss'
    2312. 

  2312.    * 			- %hh (hours) representative of hours
    2313. 

  2313.    * 			- %mm (minutes) representative of minutes
    2314. 

  2314.    * 			- %ss (seconds) representative of seconds
    2315. 

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

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

  2317.    * 			- %ft (frames total) representative of total frames (ie frame number)
    2318. 

  2318.    * 			- %st (seconds total) representative of total seconds (rounded).
    2319. 

  2319.    * 			- %sf (seconds floored) representative of total seconds (floored).
    2320. 

  2320.    * 			- %sc (seconds ceiled) representative of total seconds (ceiled).
    2321. 

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

  2322.    * 		Thus you could use an alternative, '%hh:%mm:%ss:%ms', or '%hh:%mm:%ss' dependent on your usage.
    2323. 

  2323.    * @param mixed|boolean|integer $frames_per_second The number of frames per second to translate for. If left FALSE
    2324. 

  2324.    * 		the class automagically gets the fps from PHPVideoToolkit::getFileInfo(), but the input has to be set
    2325. 

  2325.    * 		first for this to work properly.
    2326. 

  2326.    * @param boolean $use_smart_values Default value is TRUE, if a format is found (ie %ss - secs) but no higher format (ie %mm - mins)
    2327. 

  2327.    * 		is found then if $use_smart_values is TRUE the value of of the format will be totaled.
    2328. 

  2328.    * @return string|integer Returns the timecode, but if $frames_per_second is not set and a frame rate lookup is required
    2329. 

  2329.    * 		but can't be reached then -1 will be returned.
    2330. 

  2330.    */
    2331. 

  2331.   public function formatSeconds($input_seconds, $return_format='%hh:%mm:%ss', $frames_per_second=FALSE, $use_smart_values=TRUE) {
    2332. 

  2332.     $timestamp = mktime(0, 0, $input_seconds, 0, 0);
    2333. 

  2333.     $floored = floor($input_seconds);
    2334. 

  2334.     $hours = $input_seconds > 3600 ? floor($input_seconds / 3600) : 0;
    2335. 

  2335.     $mins = date('i', $timestamp);
    2336. 

  2336.     $searches = array();
    2337. 

  2337.     $replacements = array();
    2338. 

  2338. // 			these ones are the simple replacements
    2339. 

  2339. // 			replace the hours
    2340. 

  2340.     $using_hours = strpos($return_format, '%hh') !== FALSE;
    2341. 

  2341.     if ($using_hours) {
    2342. 

  2342.       array_push($searches, '%hh');
    2343. 

  2343.       array_push($replacements, $hours);
    2344. 

  2344.     }
    2345. 

  2345. 

  2346. // 			replace the minutes
    2347. 

  2347.     $using_mins = strpos($return_format, '%mm') !== FALSE;
    2348. 

  2348.     if ($using_mins) {
    2349. 

  2349.       array_push($searches, '%mm');
    2350. 

  2350. // 				check if hours are being used, if not and hours are required enable smart minutes
    2351. 

  2351.       if ($use_smart_values === TRUE && !$using_hours && $hours > 0) {
    2352. 

  2352.         $value = ($hours * 60) + $mins;
    2353. 

  2353.       }
    2354. 

  2354.       else {
    2355. 

  2355.         $value = $mins;
    2356. 

  2356.       }
    2357. 

  2357.       array_push($replacements, $value);
    2358. 

  2358.     }
    2359. 

  2359. 

  2360. // 			replace the seconds
    2361. 

  2361.     if (strpos($return_format, '%ss') !== FALSE) {
    2362. 

  2362. // 				check if hours are being used, if not and hours are required enable smart minutes
    2363. 

  2363.       if ($use_smart_values === TRUE && !$using_mins && !$using_hours && $hours > 0) {
    2364. 

  2364.         $mins = ($hours * 60) + $mins;
    2365. 

  2365.       }
    2366. 

  2366. // 				check if mins are being used, if not and hours are required enable smart minutes
    2367. 

  2367.       if ($use_smart_values === TRUE && !$using_mins && $mins > 0) {
    2368. 

  2368.         $value = ($mins * 60) + date('s', $timestamp);
    2369. 

  2369.       }
    2370. 

  2370.       else {
    2371. 

  2371.         $value = date('s', $timestamp);
    2372. 

  2372.       }
    2373. 

  2373.       array_push($searches, '%ss');
    2374. 

  2374.       array_push($replacements, $value);
    2375. 

  2375.     }
    2376. 

  2376. // 			replace the milliseconds
    2377. 

  2377.     if (strpos($return_format, '%ms') !== FALSE) {
    2378. 

  2378.       $milli = round($input_seconds - $floored, 3);
    2379. 

  2379.       $milli = substr($milli, 2);
    2380. 

  2380.       $milli = empty($milli) ? '0' : $milli;
    2381. 

  2381.       array_push($searches, '%ms');
    2382. 

  2382.       array_push($replacements, $milli);
    2383. 

  2383.     }
    2384. 

  2384. // 			replace the total seconds (rounded)
    2385. 

  2385.     if (strpos($return_format, '%st') !== FALSE) {
    2386. 

  2386.       array_push($searches, '%st');
    2387. 

  2387.       array_push($replacements, round($input_seconds));
    2388. 

  2388.     }
    2389. 

  2389. // 			replace the total seconds (floored)
    2390. 

  2390.     if (strpos($return_format, '%sf') !== FALSE) {
    2391. 

  2391.       array_push($searches, '%sf');
    2392. 

  2392.       array_push($replacements, floor($input_seconds));
    2393. 

  2393.     }
    2394. 

  2394. // 			replace the total seconds (ceiled)
    2395. 

  2395.     if (strpos($return_format, '%sc') !== FALSE) {
    2396. 

  2396.       array_push($searches, '%sc');
    2397. 

  2397.       array_push($replacements, ceil($input_seconds));
    2398. 

  2398.     }
    2399. 

  2399. // 			replace the total seconds
    2400. 

  2400.     if (strpos($return_format, '%mt') !== FALSE) {
    2401. 

  2401.       array_push($searches, '%mt');
    2402. 

  2402.       array_push($replacements, round($input_seconds, 3));
    2403. 

  2403.     }
    2404. 

  2404. // 			these are the more complicated as they depend on $frames_per_second / frames per second of the current input
    2405. 

  2405.     $has_frames = strpos($return_format, '%fn') !== FALSE;
    2406. 

  2406.     $has_total_frames = strpos($return_format, '%ft') !== FALSE;
    2407. 

  2407.     if ($has_frames || $has_total_frames) {
    2408. 

  2408. // 				if the fps is FALSE then we must automagically detect it from the input file
    2409. 

  2409.       if ($frames_per_second === FALSE) {
    2410. 

  2410.         $info = $this->getFileInfo();
    2411. 

  2411. // 					check the information has been received
    2412. 

  2412.         if ($info === FALSE || (isset($info['video']) === FALSE || isset($info['video']['frame_rate']) === FALSE)) {
    2413. 

  2413. // 						fps cannot be reached so return -1
    2414. 

  2414.           return -1;
    2415. 

  2415.         }
    2416. 

  2416.         $frames_per_second = $info['video']['frame_rate'];
    2417. 

  2417.       }
    2418. 

  2418. // 				replace the frames
    2419. 

  2419.       $excess_frames = FALSE;
    2420. 

  2420.       if ($has_frames) {
    2421. 

  2421.         $excess_frames = ceil(($input_seconds - $floored) * $frames_per_second);
    2422. 

  2422.         array_push($searches, '%fn');
    2423. 

  2423.         array_push($replacements, $excess_frames);
    2424. 

  2424.       }
    2425. 

  2425. // 				replace the total frames (ie frame number)
    2426. 

  2426.       if ($has_total_frames) {
    2427. 

  2427.         $round_frames = $floored * $frames_per_second;
    2428. 

  2428.         if (!$excess_frames) {
    2429. 

  2429.           $excess_frames = ceil(($input_seconds - $floored) * $frames_per_second);
    2430. 

  2430.         }
    2431. 

  2431.         array_push($searches, '%ft');
    2432. 

  2432.         array_push($replacements, $round_frames + $excess_frames);
    2433. 

  2433.       }
    2434. 

  2434.     }
    2435. 

  2435.     return str_replace($searches, $replacements, $return_format);
    2436. 

  2436.   }
    2437. 

  2437. 

  2438.   /**
    2439. 

  2439.    * Translates a timecode to the number of seconds
    2440. 

  2440.    *
    2441. 

  2441.    * @access public
    2442. 

  2442.    * @param integer $input_seconds The number of seconds you want to calculate the timecode for.
    2443. 

  2443.    * @param integer $input_format The format of the timecode is being given in.
    2444. 

  2444.    * 		default '%hh:%mm:%ss'
    2445. 

  2445.    * 			- %hh (hours) representative of hours
    2446. 

  2446.    * 			- %mm (minutes) representative of minutes
    2447. 

  2447.    * 			- %ss (seconds) representative of seconds
    2448. 

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

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

  2450.    * 			- %ft (frames total) representative of total frames (ie frame number)
    2451. 

  2451.    * 			- %st (seconds total) representative of total seconds (rounded).
    2452. 

  2452.    * 			- %sf (seconds floored) representative of total seconds (floored).
    2453. 

  2453.    * 			- %sc (seconds ceiled) representative of total seconds (ceiled).
    2454. 

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

  2455.    * 		Thus you could use an alternative, '%hh:%mm:%ss:%ms', or '%hh:%mm:%ss' dependent on your usage.
    2456. 

  2456.    * @param integer $return_format The format of the timecode to return. The default is
    2457. 

  2457.    * 		default '%ts'
    2458. 

  2458.    * 			- %hh (hours) representative of hours
    2459. 

  2459.    * 			- %mm (minutes) representative of minutes
    2460. 

  2460.    * 			- %ss (seconds) representative of seconds
    2461. 

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

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

  2463.    * 			- %ft (frames total) representative of total frames (ie frame number)
    2464. 

  2464.    * 			- %st (seconds total) representative of total seconds (rounded).
    2465. 

  2465.    * 			- %sf (seconds floored) representative of total seconds (floored).
    2466. 

  2466.    * 			- %sc (seconds ceiled) representative of total seconds (ceiled).
    2467. 

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

  2468.    * 		Thus you could use an alternative, '%hh:%mm:%ss:%ms', or '%hh:%mm:%ss' dependent on your usage.
    2469. 

  2469.    * @param mixed|boolean|integer $frames_per_second The number of frames per second to translate for. If left FALSE
    2470. 

  2470.    * 		the class automagically gets the fps from PHPVideoToolkit::getFileInfo(), but the input has to be set
    2471. 

  2471.    * 		first for this to work properly.
    2472. 

  2472.    * @param boolean $use_smart_values Default value is TRUE, if a format is found (ie %ss - secs) but no higher format (ie %mm - mins)
    2473. 

  2473.    * 		is found then if $use_smart_values is TRUE the value of of the format will be totaled.
    2474. 

  2474.    * @return float Returns the value of the timecode in seconds.
    2475. 

  2475.    */
    2476. 

  2476.   public function formatTimecode($input_timecode, $input_format='%hh:%mm:%ss', $return_format='%ts', $frames_per_second=FALSE, $use_smart_values=TRUE) {
    2477. 

  2477. // 			first we must get the timecode into the current seconds
    2478. 

  2478.     $input_quoted = preg_quote($input_format);
    2479. 

  2479.     $placeholders = array('%hh', '%mm', '%ss', '%fn', '%ms', '%ft', '%st', '%sf', '%sc', '%mt');
    2480. 

  2480.     $seconds = 0;
    2481. 

  2481.     $input_regex = str_replace($placeholders, '([0-9]+)', preg_quote($input_format));
    2482. 

  2482.     preg_match('/' . $input_regex . '/', $input_timecode, $matches);
    2483. 

  2483. // 			work out the sort order for the placeholders
    2484. 

  2484.     $sort_table = array();
    2485. 

  2485.     foreach ($placeholders as $key => $placeholder) {
    2486. 

  2486.       if (($pos = strpos($input_format, $placeholder)) !== FALSE) {
    2487. 

  2487.         $sort_table[$pos] = $placeholder;
    2488. 

  2488.       }
    2489. 

  2489.     }
    2490. 

  2490.     ksort($sort_table);
    2491. 

  2491. // 			check to see if frame related values are in the input
    2492. 

  2492.     $has_frames = strpos($input_format, '%fn') !== FALSE;
    2493. 

  2493.     $has_total_frames = strpos($input_format, '%ft') !== FALSE;
    2494. 

  2494.     if ($has_frames || $has_total_frames) {
    2495. 

  2495. // 				if the fps is FALSE then we must automagically detect it from the input file
    2496. 

  2496.       if ($frames_per_second === FALSE) {
    2497. 

  2497.         $info = $this->getFileInfo();
    2498. 

  2498. // 					check the information has been received
    2499. 

  2499.         if ($info === FALSE || (isset($info['duration']) === FALSE || isset($info['duration']['timecode']['frames']['frame_rate']) === FALSE)) {
    2500. 

  2500. // 						fps cannot be reached so return -1
    2501. 

  2501.           return -1;
    2502. 

  2502.         }
    2503. 

  2503.         $frames_per_second = $info['duration']['timecode']['frames']['frame_rate'];
    2504. 

  2504.       }
    2505. 

  2505.     }
    2506. 

  2506. // 			increment the seconds with each placeholder value
    2507. 

  2507.     $key = 1;
    2508. 

  2508.     foreach ($sort_table as $placeholder) {
    2509. 

  2509.       if (isset($matches[$key]) === FALSE) {
    2510. 

  2510.         break;
    2511. 

  2511.       }
    2512. 

  2512.       $value = $matches[$key];
    2513. 

  2513.       switch ($placeholder) {
    2514. 

  2514. // 					time related ones
    2515. 

  2515.         case '%hh' :
    2516. 

  2516.           $seconds += $value * 3600;
    2517. 

  2517.           break;
    2518. 

  2518.         case '%mm' :
    2519. 

  2519.           $seconds += $value * 60;
    2520. 

  2520.           break;
    2521. 

  2521.         case '%ss' :
    2522. 

  2522.         case '%sf' :
    2523. 

  2523.         case '%sc' :
    2524. 

  2524.           $seconds += $value;
    2525. 

  2525.           break;
    2526. 

  2526.         case '%ms' :
    2527. 

  2527.           $seconds += floatval('0.' . $value);
    2528. 

  2528.           break;
    2529. 

  2529.         case '%st' :
    2530. 

  2530.         case '%mt' :
    2531. 

  2531.           $seconds = $value;
    2532. 

  2532.           break 1;
    2533. 

  2533.           break;
    2534. 

  2534. // 					frame related ones
    2535. 

  2535.         case '%fn' :
    2536. 

  2536.           $seconds += $value / $frames_per_second;
    2537. 

  2537.           break;
    2538. 

  2538.         case '%ft' :
    2539. 

  2539.           $seconds = $value / $frames_per_second;
    2540. 

  2540.           break 1;
    2541. 

  2541.           break;
    2542. 

  2542.       }
    2543. 

  2543.       $key += 1;
    2544. 

  2544.     }
    2545. 

  2545. // 			then we just format the seconds
    2546. 

  2546.     return $this->formatSeconds($seconds, $return_format, $frames_per_second, $use_smart_values);
    2547. 

  2547.   }
    2548. 

  2548. 

  2549.   /**
    2550. 

  2550.    * Checks to see if a given codec can be encoded by the current ffmpeg binary.
    2551. 

  2551.    * @access public
    2552. 

  2552.    * @param $codec string The shortcode for the codec to check for.
    2553. 

  2553.    * @return boolean True if the codec can be encoded by ffmpeg, otherwise FALSE.
    2554. 

  2554.    */
    2555. 

  2555.   public function canCodecBeEncoded($type, $codec) {
    2556. 

  2556.     return $this->validateCodec($codec, $type, 'encode');
    2557. 

  2557.   }
    2558. 

  2558. 

  2559.   /**
    2560. 

  2560.    * Checks to see if a given codec can be decoded by the current ffmpeg binary.
    2561. 

  2561.    * @access public
    2562. 

  2562.    * @param $codec string The shortcode for the codec to check for.
    2563. 

  2563.    * @return boolean True if the codec can be decoded by ffmpeg, otherwise FALSE.
    2564. 

  2564.    */
    2565. 

  2565.   public function canCodecBeDecoded($type, $codec) {
    2566. 

  2566.     return $this->validateCodec($codec, $type, 'decode');
    2567. 

  2567.   }
    2568. 

  2568. 

  2569.   /**
    2570. 

  2570.    * Checks to see if a given codec can be decoded/encoded by the current ffmpeg binary.
    2571. 

  2571.    * @access public
    2572. 

  2572.    * @param $codec string The shortcode for the codec to check for.
    2573. 

  2573.    * @param $type string either 'video', 'audio', or 'subtitle'. The type of codec to check for.
    2574. 

  2574.    * @param $method string 'encode' or 'decode', The method to check against the codec
    2575. 

  2575.    * @return boolean True if the codec can be used with the given method by ffmpeg, otherwise FALSE.
    2576. 

  2576.    */
    2577. 

  2577.   public function validateCodec($codec, $type, $method) {
    2578. 

  2578.     $info = $this->getFFmpegInfo();
    2579. 

  2579.     return isset($info['codecs'][$type]) === TRUE && isset($info['codecs'][$type][$codec]) === TRUE && isset($info['codecs'][$type][$codec][$method]) === TRUE ? $info['codecs'][$type][$codec][$method] : FALSE;
    2580. 

  2580.   }
    2581. 

  2581. 

  2582.   /**
    2583. 

  2583.    * Checks to see if a given format can be muxed by the current ffmpeg binary.
    2584. 

  2584.    * @access public
    2585. 

  2585.    * @param $format string The shortcode for the codec to check for.
    2586. 

  2586.    * @return boolean True if the codec can be encoded by ffmpeg, otherwise FALSE.
    2587. 

  2587.    */
    2588. 

  2588.   public function canFormatBeMuxed($format) {
    2589. 

  2589.     return $this->validateFormat($format, 'mux');
    2590. 

  2590.   }
    2591. 

  2591. 

  2592.   /**
    2593. 

  2593.    * Checks to see if a given format can be demuxed by the current ffmpeg binary.
    2594. 

  2594.    * @access public
    2595. 

  2595.    * @param $codec string The shortcode for the codec to check for.
    2596. 

  2596.    * @return boolean True if the codec can be decoded by ffmpeg, otherwise FALSE.
    2597. 

  2597.    */
    2598. 

  2598.   public function canFormatBeDemuxed($format) {
    2599. 

  2599.     return $this->validateFormat($format, 'demux');
    2600. 

  2600.   }
    2601. 

  2601. 

  2602.   /**
    2603. 

  2603.    * Checks to see if a given codec can be decoded/encoded by the current ffmpeg binary.
    2604. 

  2604.    * @access public
    2605. 

  2605.    * @param $format string The shortcode for the codec to check for.
    2606. 

  2606.    * @param $method string 'mux' or 'demux', The method to check against the format
    2607. 

  2607.    * @return boolean True if the format can be used with the given method by ffmpeg, otherwise FALSE.
    2608. 

  2608.    */
    2609. 

  2609.   public function validateFormat($format, $method) {
    2610. 

  2610.     $info = $this->getFFmpegInfo();
    2611. 

  2611.     return isset($info['formats'][$format]) === TRUE && isset($info['formats'][$format][$method]) === TRUE ? $info['formats'][$format][$method] : FALSE;
    2612. 

  2612.   }
    2613. 

  2613. 

  2614.   /**
    2615. 

  2615.    * Returns the available formats.
    2616. 

  2616.    * @access public
    2617. 

  2617.    * @param mixed $method The mux method to check for, either 'muxing', 'demuxing' or 'both' (formats that can both mux and demux), otherwise FALSE will return a complete list.
    2618. 

  2618.    * @return array An array of formats available to ffmpeg.
    2619. 

  2619.    */
    2620. 

  2620.   public function getAvailableFormats($method=FALSE) {
    2621. 

  2621.     $info = $this->getFFmpegInfo();
    2622. 

  2622.     $return_vals = array();
    2623. 

  2623.     switch ($method) {
    2624. 

  2624.       case FALSE :
    2625. 

  2625.         return array_keys($info['formats']);
    2626. 

  2626.       case 'both' :
    2627. 

  2627.         foreach ($info['formats'] as $id => $data) {
    2628. 

  2628.           if ($data['mux'] === TRUE && $data['demux'] === TRUE) {
    2629. 

  2629.             array_push($return_vals, $id);
    2630. 

  2630.           }
    2631. 

  2631.         }
    2632. 

  2632.         break;
    2633. 

  2633.       case 'muxing' :
    2634. 

  2634.         foreach ($info['formats'] as $id => $data) {
    2635. 

  2635.           if ($data['mux'] === TRUE) {
    2636. 

  2636.             array_push($return_vals, $id);
    2637. 

  2637.           }
    2638. 

  2638.         }
    2639. 

  2639.         break;
    2640. 

  2640.       case 'demuxing' :
    2641. 

  2641.         foreach ($info['formats'] as $id => $data) {
    2642. 

  2642.           if ($data['demux'] === TRUE) {
    2643. 

  2643.             array_push($return_vals, $id);
    2644. 

  2644.           }
    2645. 

  2645.         }
    2646. 

  2646.         break;
    2647. 

  2647.     }
    2648. 

  2648.     return $return_vals;
    2649. 

  2649.   }
    2650. 

  2650. 

  2651.   /**
    2652. 

  2652.    * Returns the available codecs.
    2653. 

  2653.    * @access public
    2654. 

  2654.    * @param mixed $type The type of codec list to return, FALSE (to return all codecs), or either 'audio', 'video', or 'subtitle'.
    2655. 

  2655.    * @return array An array of codecs available to ffmpeg.
    2656. 

  2656.    */
    2657. 

  2657.   public static function getAvailableCodecs($type=FALSE) {
    2658. 

  2658. // 			check to see if this is a static call
    2659. 

  2659.     if (isset($this) === FALSE) {
    2660. 

  2660.       $toolkit = new PHPVideoToolkit();
    2661. 

  2661.       $info = $toolkit->getFFmpegInfo();
    2662. 

  2662.     }
    2663. 

  2663.     else {
    2664. 

  2664.       $info = $this->getFFmpegInfo();
    2665. 

  2665.     }
    2666. 

  2666. // 			are we checking for particluar method?
    2667. 

  2667.     $return_vals = array();
    2668. 

  2668.     if ($type === FALSE) {
    2669. 

  2669.       $video_keys = array_keys($info['codecs']['video']);
    2670. 

  2670.       $audio_keys = array_keys($info['codecs']['audio']);
    2671. 

  2671.       $subtitle_keys = array_keys($info['codecs']['subtitle']);
    2672. 

  2672.       return array_merge($video_keys, $audio_keys, $subtitle_keys);
    2673. 

  2673.     }
    2674. 

  2674.     return isset($info['codecs'][$type]) === TRUE ? array_keys($info['codecs'][$type]) : FALSE;
    2675. 

  2675.   }
    2676. 

  2676. 

  2677.   /**
    2678. 

  2678.    * Returns the available pixel formats.
    2679. 

  2679.    *
    2680. 

  2680.    * @return
    2681. 

  2681.    *   array An array of pixel formats available to ffmpeg.
    2682. 

  2682.    */
    2683. 

  2683.   public function getAvailablePixelFormats() {
    2684. 

  2684.     $info = $this->getFFmpegInfo();
    2685. 

  2685. 

  2686.     if (!isset($info['pixelformats'])) {
    2687. 

  2687.       $info = $this->getFFmpegInfo(FALSE);
    2688. 

  2688. 

  2689.       if (!isset($info['pixelformats'])) {
    2690. 

  2690.         return array();
    2691. 

  2691.       }
    2692. 

  2692.     }
    2693. 

  2693. 

  2694.     return array_keys($info['pixelformats']);
    2695. 

  2695.   }
    2696. 

  2696. 

  2697.   /**
    2698. 

  2698.    * Commits all the commands and executes the ffmpeg procedure. This will also attempt to validate any outputted files in order to provide
    2699. 

  2699.    * some level of stop and check system.
    2700. 

  2700.    *
    2701. 

  2701.    * @access public
    2702. 

  2702.    * @param $multi_pass_encode boolean Determines if multi (2) pass encoding should be used.
    2703. 

  2703.    * @param $log boolean Determines if a log file of the results should be generated.
    2704. 

  2704.    * @return mixed
    2705. 

  2705.    * 		- FALSE 										On error encountered.
    2706. 

  2706.    * 		- PHPVideoToolkit::RESULT_OK (bool TRUE)					If the file has successfully been processed and moved ok to the output address
    2707. 

  2707.    * 		- PHPVideoToolkit::RESULT_OK_BUT_UNWRITABLE (int -1)		If the file has successfully been processed but was not able to be moved correctly to the output address
    2708. 

  2708.    * 														If this is the case you will manually need to move the processed file from the temp directory. You can
    2709. 

  2709.    * 														get around this by settings the third argument from PHPVideoToolkit::setOutput(), $overwrite to TRUE.
    2710. 

  2710.    * 		- n (int)										A positive integer is only returned when outputting a series of frame grabs from a movie. It dictates
    2711. 

  2711.    * 														the total number of frames grabbed from the input video. You should also not however, that if a conflict exists
    2712. 

  2712.    * 														with one of the filenames then this return value will not be returned, but PHPVideoToolkit::RESULT_OK_BUT_UNWRITABLE
    2713. 

  2713.    * 														will be returned instead.
    2714. 

  2714.    * 	Because of the mixed return value you should always go a strict evaluation of the returned value. ie
    2715. 

  2715.    *
    2716. 

  2716.    * 	$result = $toolkit->excecute();
    2717. 

  2717.    *  if($result === FALSE)
    2718. 

  2718.    *  {
    2719. 

  2719.    * 		// error
    2720. 

  2720.    *  }
    2721. 

  2721.    *  elseif($result === PHPVideoToolkit::RESULT_OK_BUT_UNWRITABLE)
    2722. 

  2722.    *  {
    2723. 

  2723.    * 		// ok but a manual move is required. The file to move can be it can be retrieved by $toolkit->getLastOutput();
    2724. 

  2724.    *  }
    2725. 

  2725.    *  elseif($result === PHPVideoToolkit::RESULT_OK)
    2726. 

  2726.    *  {
    2727. 

  2727.    * 		// everything is ok.
    2728. 

  2728.    *  }
    2729. 

  2729.    */
    2730. 

  2730.   public function execute($multi_pass_encode=FALSE, $log=FALSE) {
    2731. 

  2731. // 			check for inut and output params
    2732. 

  2732.     $has_placeholder = preg_match('/\%([0-9]+)index/', $this->_process_address) || (strpos($this->_process_address, '%index') === FALSE && strpos($this->_process_address, '%timecode') === FALSE);
    2733. 

  2733.     if ($this->_input_file === NULL && !$has_placeholder) {
    2734. 

  2734.       return $this->_raiseError('execute_input_404');
    2735. 

  2735. // <-			exits
    2736. 

  2736.     }
    2737. 

  2737. 

  2738. //			check to see if the output address has been set
    2739. 

  2739.     if ($this->_process_address === NULL) {
    2740. 

  2740.       return $this->_raiseError('execute_output_not_set');
    2741. 

  2741. // <-			exits
    2742. 

  2742.     }
    2743. 

  2743. 

  2744. // 			check if temp dir is required and is writable
    2745. 

  2745.     if (($multi_pass_encode || $log) && !is_writable($this->_tmp_directory)) {
    2746. 

  2746.       return $this->_raiseError('execute_temp_unwritable');
    2747. 

  2747. // <-			exits
    2748. 

  2748.     }
    2749. 

  2749. 

  2750.     if (($this->_overwrite_mode == self::OVERWRITE_PRESERVE || $this->_overwrite_mode == self::OVERWRITE_FAIL) && is_file($this->_process_address)) {
    2751. 

  2751.       return $this->_raiseError('execute_overwrite_process');
    2752. 

  2752. // <-			exits
    2753. 

  2753.     }
    2754. 

  2754. 

  2755. // 			carry out some overwrite checks if required
    2756. 

  2756.     $overwrite = '';
    2757. 

  2757.     switch ($this->_overwrite_mode) {
    2758. 

  2758.       case self::OVERWRITE_UNIQUE :
    2759. 

  2759. // 					insert a unique id into the output address (the process address already has one)
    2760. 

  2760.         $unique = $this->unique();
    2761. 

  2761.         $last_index = strrpos($this->_output_address, DS);
    2762. 

  2762.         $this->_output_address = substr($this->_output_address, 0, $last_index + 1) . $unique . '-' . substr($this->_output_address, $last_index + 1);
    2763. 

  2763.         break;
    2764. 

  2764. 

  2765.       case self::OVERWRITE_EXISTING :
    2766. 

  2766. // 					add an overwrite command to ffmpeg execution call
    2767. 

  2767.         $overwrite = '-y ';
    2768. 

  2768.         break;
    2769. 

  2769. 

  2770.       case self::OVERWRITE_PRESERVE :
    2771. 

  2771. // 					do nothing as the preservation comes later
    2772. 

  2772.         break;
    2773. 

  2773. 

  2774.       case self::OVERWRITE_FAIL :
    2775. 

  2775.       default :
    2776. 

  2776. // 					if the file should fail
    2777. 

  2777.         if (!$has_placeholder && is_file($this->_output_address)) {
    2778. 

  2778.           return $this->_raiseError('execute_overwrite_fail');
    2779. 

  2779. // <-					exits
    2780. 

  2780.         }
    2781. 

  2781.         break;
    2782. 

  2782.     }
    2783. 

  2783. 

  2784.     $this->_timer_start = self::microtimeFloat();
    2785. 

  2785. 

  2786. // 			check to see if the format has been set and if it hasn't been set and the extension is a gif
    2787. 

  2787. // 			we need to add an extra argument to set the pix format.
    2788. 

  2788.     $format = $this->hasCommand('-f');
    2789. 

  2789.     if ($format === FALSE) {
    2790. 

  2790.       $extension = pathinfo($this->_input_file, PATHINFO_EXTENSION);
    2791. 

  2791.       if ($extension === 'gif') {
    2792. 

  2792.         $this->addCommand('-pix_fmt', 'rgb24');
    2793. 

  2793.       }
    2794. 

  2794.     }
    2795. 

  2795.     elseif ($format === self::FORMAT_GIF) {
    2796. 

  2796.       $this->addCommand('-pix_fmt', 'rgb24');
    2797. 

  2797.     }
    2798. 

  2798. 

  2799. // 			check to see if an aspect ratio is set, if it is correct the width and heights to reflect that aspect ratio.
    2800. 

  2800. // 			This isn't strictly needed it is purely for informational purposes that this is done, because if the width is not
    2801. 

  2801. // 			inline with what is should be according to the aspect ratio ffmpeg will report the wrong final width and height
    2802. 

  2802. // 			when using it to lookup information about the file.
    2803. 

  2803.     $ratio = $this->hasCommand('-aspect');
    2804. 

  2804.     if ($ratio !== FALSE) {
    2805. 

  2805.       $size = $this->hasCommand('-s');
    2806. 

  2806.       if ($size === FALSE) {
    2807. 

  2807.         $info = $this->getFileInfo();
    2808. 

  2808.         if (isset($info['video']) === TRUE && isset($info['video']['dimensions']) === TRUE) {
    2809. 

  2809.           $size = $info['video']['dimensions']['width'] . 'x' . $info['video']['dimensions']['height'];
    2810. 

  2810.         }
    2811. 

  2811.       }
    2812. 

  2812.       if ($size !== FALSE) {
    2813. 

  2813.         $dim = explode('x', substr($size, 1, -1));
    2814. 

  2814.         if (($boundry = strpos($ratio, ':')) !== FALSE) {
    2815. 

  2815.           $ratio = substr($ratio, 1, $boundry - 1) / substr($ratio, $boundry + 1, -1);
    2816. 

  2816.           $new_width = round($dim[1] * $ratio);
    2817. 

  2817. // 						make sure new width is an even number
    2818. 

  2818.           $ceiled = ceil($new_width);
    2819. 

  2819.           $new_width = $ceiled % 2 !== 0 ? floor($new_width) : $ceiled;
    2820. 

  2820.           if ($new_width != $dim[0]) {
    2821. 

  2821.             $this->setVideoDimensions($new_width, $dim[1]);
    2822. 

  2822.           }
    2823. 

  2823.         }
    2824. 

  2824.         elseif (strpos($ratio, '.') !== FALSE) {
    2825. 

  2825.           $ratio = floatval($ratio);
    2826. 

  2826.           $new_width = $dim[1] * $ratio;
    2827. 

  2827. // 						make sure new width is an even number
    2828. 

  2828.           $ceiled = ceil($new_width);
    2829. 

  2829.           $new_width = $ceiled % 2 !== 0 ? floor($new_width) : $ceiled;
    2830. 

  2830.           if ($new_width != $dim[0]) {
    2831. 

  2831.             $this->setVideoDimensions($new_width, $dim[1]);
    2832. 

  2832.           }
    2833. 

  2833.         }
    2834. 

  2834.       }
    2835. 

  2835.     }
    2836. 

  2836. 

  2837. //			add the input file command to the mix
    2838. 

  2838.     $this->addCommand('-i', $this->_input_file);
    2839. 

  2839. 

  2840. // 			if multi pass encoding is enabled add the commands and logfile
    2841. 

  2841.     if ($multi_pass_encode) {
    2842. 

  2842.       $multi_pass_file = $this->_tmp_directory . $this->unique() . '-multipass';
    2843. 

  2843.       $this->addCommand('-pass', 1);
    2844. 

  2844.       $this->addCommand('-passlogfile', $multi_pass_file);
    2845. 

  2845.     }
    2846. 

  2846. 

  2847. //			combine all the output commands
    2848. 

  2848.     $command_string = $this->_combineCommands();
    2849. 

  2849. //			prepare the command suitable for exec
    2850. 

  2850. //			the input and overwrite commands have specific places to be set so they have to be added outside of the combineCommands function
    2851. 

  2851.     $exec_string = $this->_prepareCommand($this->_ffmpeg_binary, $command_string, $overwrite . $this->_process_address);
    2852. 

  2852. // 			$exec_string = $this->_prepareCommand(PHPVIDEOTOOLKIT_FFMPEG_BINARY, '-i '.$this->_commands['-i'].' '.$command_string, $overwrite.escapeshellcmd($this->_process_address));
    2853. 

  2853. 

  2854.     if ($log) {
    2855. 

  2855.       $this->_log_file = $this->_tmp_directory . $this->unique() . '.info';
    2856. 

  2856.       array_push($this->_unlink_files, $this->_log_file);
    2857. 

  2857.     }
    2858. 

  2858. 

  2859. //			execute the command
    2860. 

  2860. // 			$exec_string = $exec_string.' 2>&1';// &> '.$this->_log_file;
    2861. 

  2861.     $buffer = $this->_captureExecBuffer($exec_string);
    2862. 

  2862. // 			exec($exec_string, $buffer);
    2863. 

  2863.     if ($log) {
    2864. 

  2864.       $this->_addToLog($buffer, 'a+');
    2865. 

  2865.     }
    2866. 

  2866. 

  2867. //			track the processed command by adding it to the class
    2868. 

  2868.     array_unshift($this->_processed, $exec_string);
    2869. 

  2869. 

  2870. // 			scan buffer for any errors
    2871. 

  2871.     $last_line = $buffer[count($buffer) - 1];
    2872. 

  2872. 

  2873.     if (preg_match('/(.*)(Unsupported codec|Error while opening)(.*)/s', $last_line, $error_matches) > 0) {
    2874. 

  2874.       $type = $error_matches[2];
    2875. 

  2875.       switch ($error_matches[2]) {
    2876. 

  2876.         case 'Unsupported codec' :
    2877. 

  2877.           break;
    2878. 

  2878.         case 'Error while opening' :
    2879. 

  2879.           break;
    2880. 

  2880.       }
    2881. 

  2881.       $stream = 'could be with either the audio or video codec';
    2882. 

  2882.       if (preg_match('/#0.(0|1)/', $last_line, $stream_matches) > 0) {
    2883. 

  2883.         $stream = $stream_matches[1] === '0' ? 'is with the video codec' : 'is with the audio codec';
    2884. 

  2884.       }
    2885. 

  2885. // 						add the error to the log file
    2886. 

  2886.       if ($log) {
    2887. 

  2887.         $this->_logResult('execute_ffmpeg_return_error', array('input' => $this->_input_file, 'type' => $type, 'message' => $error_matches[0], 'stream' => $stream));
    2888. 

  2888.       }
    2889. 

  2889.       return $this->_raiseError('execute_ffmpeg_return_error', array('input' => $this->_input_file, 'type' => $type, 'message' => $error_matches[0], 'stream' => $stream));
    2890. 

  2890.     }
    2891. 

  2891. 

  2892. 

  2893. // 			create the multiple pass encode
    2894. 

  2894.     if ($multi_pass_encode) {
    2895. 

  2895.       $pass2_exc_string = str_replace('-pass ' . escapeshellarg(1), '-pass ' . escapeshellarg(2), $exec_string);
    2896. 

  2896.       $buffer = $this->_captureExecBuffer($pass2_exc_string);
    2897. 

  2897. // 				exec($pass2_exc_string, $buffer);
    2898. 

  2898.       if ($log) {
    2899. 

  2899.         $this->_addToLog($buffer, 'a+');
    2900. 

  2900.       }
    2901. 

  2901.       $this->_processed[0] = array($this->_processed[0], $pass2_exc_string);
    2902. 

  2902. 

  2903. // 				tidy up the multipass log file
    2904. 

  2904.       array_push($this->_unlink_files, $multi_pass_file . '-0.log');
    2905. 

  2905. 

  2906. // 				scan buffer for any errors
    2907. 

  2907.       $last_line = $buffer[count($buffer) - 1];
    2908. 

  2908.       if (preg_match('/(.*)(Unsupported codec|Error while opening)(.*)/s', $last_line, $error_matches) > 0) {
    2909. 

  2909.         $type = $error_matches[2];
    2910. 

  2910.         switch ($error_matches[2]) {
    2911. 

  2911.           case 'Unsupported codec' :
    2912. 

  2912.             break;
    2913. 

  2913.           case 'Error while opening' :
    2914. 

  2914.             break;
    2915. 

  2915.         }
    2916. 

  2916.         $stream = 'could be with either the audio or video codec';
    2917. 

  2917.         if (preg_match('/#0.(0|1)/', $last_line, $stream_matches) > 0) {
    2918. 

  2918.           $stream = $stream_matches[1] === '0' ? 'is with the video codec' : 'is with the audio codec';
    2919. 

  2919.         }
    2920. 

  2920.         // 						add the error to the log file
    2921. 

  2921.         if ($log) {
    2922. 

  2922.           $this->_logResult('execute_ffmpeg_return_error_multipass', array('input' => $this->_input_file, 'type' => $type, 'message' => $error_matches[0], 'stream' => $stream));
    2923. 

  2923.         }
    2924. 

  2924.         return $this->_raiseError('execute_ffmpeg_return_error_multipass', array('input' => $this->_input_file, 'type' => $type, 'message' => $error_matches[0], 'stream' => $stream));
    2925. 

  2925.       }
    2926. 

  2926.     }
    2927. 

  2927. 

  2928. // 			keep track of the time taken
    2929. 

  2929.     $execution_time = self::microtimeFloat() - $this->_timer_start;
    2930. 

  2930.     array_unshift($this->_timers, $execution_time);
    2931. 

  2931. 

  2932. // 			add the exec string to the log file
    2933. 

  2933.     if ($log) {
    2934. 

  2934.       $lines = $this->_processed[0];
    2935. 

  2935.       if (!is_array($lines)) {
    2936. 

  2936.         $lines = array($lines);
    2937. 

  2937.       }
    2938. 

  2938. // 				array_unshift($lines, $exec_string);
    2939. 

  2939.       array_unshift($lines, $this->_getMessage('ffmpeg_log_separator'), $this->_getMessage('ffmpeg_log_ffmpeg_command'), $this->_getMessage('ffmpeg_log_separator'));
    2940. 

  2940. // 				if($multi_pass_encode)
    2941. 

  2941. // 				{
    2942. 

  2942. // 					array_unshift($lines, $pass2_exc_string);
    2943. 

  2943. // 				}
    2944. 

  2944.       array_unshift($lines, $this->_getMessage('ffmpeg_log_separator'), $this->_getMessage('ffmpeg_log_ffmpeg_gunk'), $this->_getMessage('ffmpeg_log_separator'));
    2945. 

  2945.       $this->_addToLog($lines, 'a+');
    2946. 

  2946.     }
    2947. 

  2947. //			must validate a series of outputed items
    2948. 

  2948. //			detect if the output address is a sequence output
    2949. 

  2949.     if (preg_match('/\%([0-9]+)d/', $this->_process_address, $d_matches) || strpos($this->_process_address, '%d') !== FALSE) {
    2950. 

  2950. //				get the path details
    2951. 

  2951.       $process_info = pathinfo($this->_process_address);
    2952. 

  2952.       $output_info = pathinfo($this->_output_address);
    2953. 

  2953.       $pad_amount = intval($d_matches[1]);
    2954. 

  2954. // 				print_r(array($process_info, $output_info));
    2955. 

  2955. // 				get the %index padd amounts
    2956. 

  2956.       $has_preg_index = preg_match('/\%([0-9]+)index/', $output_info['basename'], $index_matches);
    2957. 

  2957.       $output_index_pad_amount = isset($index_matches[1]) === TRUE ? intval($index_matches[1], 1) : 0;
    2958. 

  2958. // 				var_dump($index_matches);
    2959. 

  2959. //				init the iteration values
    2960. 

  2960.       $num = 1;
    2961. 

  2961.       $files = array();
    2962. 

  2962.       $produced = array();
    2963. 

  2963.       $error = FALSE;
    2964. 

  2964.       $name_conflict = FALSE;
    2965. 

  2965.       $file_exists = FALSE;
    2966. 

  2966. 

  2967. // 				get the first files name
    2968. 

  2968.       $filename = $process_info['dirname'] . DS . str_replace($d_matches[0], str_pad($num, $pad_amount, '0', STR_PAD_LEFT), $process_info['basename']);
    2969. 

  2969.       $use_timecode = strpos($output_info['basename'], '%timecode') !== FALSE;
    2970. 

  2970.       $use_index = $has_preg_index || strpos($output_info['basename'], '%index') !== FALSE;
    2971. 

  2971. 

  2972. // 				start the timecode pattern replacement values
    2973. 

  2973.       if ($use_timecode) {
    2974. 

  2974.         $secs_start = $this->formatTimecode($this->_image_output_timecode_start, '%hh:%mm:%ss.%ms', '%mt', $this->_image_output_timecode_fps);
    2975. 

  2975.         $fps_inc = 1 / $this->_image_output_timecode_fps;
    2976. 

  2976.         $fps_current_sec = 0;
    2977. 

  2977.         $fps_current_frame = 0;
    2978. 

  2978.       }
    2979. 

  2979. //				loop checking for file existence
    2980. 

  2980.       while (@is_file($filename)) {
    2981. 

  2981. //					check for empty file
    2982. 

  2982.         $size = filesize($filename);
    2983. 

  2983.         if ($size == 0) {
    2984. 

  2984.           $error = TRUE;
    2985. 

  2985.         }
    2986. 

  2986.         array_push($produced, $filename);
    2987. 

  2987. // 					create the substitution arrays
    2988. 

  2988.         $searches = array();
    2989. 

  2989.         $replacements = array();
    2990. 

  2990.         if ($use_index) {
    2991. 

  2991.           array_push($searches, isset($index_matches[0]) === TRUE ? $index_matches[0] : '%index');
    2992. 

  2992.           array_push($replacements, str_pad($num, $output_index_pad_amount, '0', STR_PAD_LEFT));
    2993. 

  2993.         }
    2994. 

  2994. // 					check if timecode is in the output name, no need to use it if not
    2995. 

  2995.         if ($use_timecode) {
    2996. 

  2996.           $fps_current_sec += $fps_inc;
    2997. 

  2997.           $fps_current_frame += 1;
    2998. 

  2998.           if ($fps_current_sec >= 1) {
    2999. 

  2999.             $fps_current_sec = $fps_inc;
    3000. 

  3000.             $secs_start += 1;
    3001. 

  3001.             $fps_current_frame = 1;
    3002. 

  3002.           }
    3003. 

  3003.           $timecode = $this->formatSeconds($secs_start, $this->image_output_timecode_format, $this->_image_output_timecode_fps);
    3004. 

  3004.           $timecode = str_replace(array(':', '.'), $this->timecode_seperator_output, $timecode);
    3005. 

  3005. // 						add to the substitution array
    3006. 

  3006.           array_push($searches, '%timecode');
    3007. 

  3007.           array_push($replacements, $timecode);
    3008. 

  3008.         }
    3009. 

  3009. // 					check if the file exists already and if it does check that it can be overriden
    3010. 

  3010.         $old_filename = $filename;
    3011. 

  3011. // 					print_r(array($searches, $replacements, $output_info['basename']));
    3012. 

  3012.         $new_file = str_replace($searches, $replacements, $output_info['basename']);
    3013. 

  3013.         $new_filename = $output_info['dirname'] . DS . $new_file;
    3014. 

  3014. // 					var_dump($filename, $new_filename);
    3015. 

  3015.         if (!is_file($new_filename) || $this->_overwrite_mode == self::OVERWRITE_EXISTING) {
    3016. 

  3016.           if (is_file($new_filename)) {
    3017. 

  3017.             unlink($new_filename);
    3018. 

  3018.           }
    3019. 

  3019.           rename($filename, $new_filename);
    3020. 

  3020.           $filename = $new_filename;
    3021. 

  3021.         }
    3022. 

  3022. // 					the file exists and is not allowed to be overriden so just rename in the temp directory using the timecode
    3023. 

  3023.         elseif ($this->_overwrite_mode == self::OVERWRITE_PRESERVE) {
    3024. 

  3024.           $new_filename = $process_info['dirname'] . DS . 'tbm-' . $this->unique() . '-' . $new_file;
    3025. 

  3025.           rename($filename, $new_filename);
    3026. 

  3026.           $filename = $new_filename;
    3027. 

  3027. // 						add the error to the log file
    3028. 

  3028.           if ($log) {
    3029. 

  3029.             $this->_logResult('execute_image_file_exists', array('file' => $new_filename));
    3030. 

  3030.           }
    3031. 

  3031. // 						flag the conflict
    3032. 

  3032.           $file_exists = TRUE;
    3033. 

  3033.         }
    3034. 

  3034. // 					the file exists so the process must fail
    3035. 

  3035.         else {
    3036. 

  3036. // 						add the error to the log file
    3037. 

  3037.           if ($log) {
    3038. 

  3038.             $this->_logResult('execute_overwrite_fail');
    3039. 

  3039.           }
    3040. 

  3040. // 						tidy up the produced files
    3041. 

  3041.           array_merge($this->_unlink_files, $produced);
    3042. 

  3042.           return $this->_raiseError('execute_overwrite_fail');
    3043. 

  3043.         }
    3044. 

  3044. //					process the name change if the %d is to be replaced with the timecode
    3045. 

  3045.         $num += 1;
    3046. 

  3046.         $files[$filename] = $size > 0 ? basename($filename) : FALSE;
    3047. 

  3047. // 					print_r("\r\n\r\n".is_file($old_filename)." - ".$old_filename.' => '.$new_filename);
    3048. 

  3048. // 					print_r($files);
    3049. 

  3049. // 					get the next incremented filename to check for existance
    3050. 

  3050.         $filename = $process_info['dirname'] . DS . str_replace($d_matches[0], str_pad($num, $pad_amount, '0', STR_PAD_LEFT), $process_info['basename']);
    3051. 

  3051.       }
    3052. 

  3052. //				de-increment the last num as it wasn't found
    3053. 

  3053.       $num -= 1;
    3054. 

  3054. 

  3055. //				if the file was detected but were empty then display a different error
    3056. 

  3056.       if ($error === TRUE) {
    3057. 

  3057. // 					add the error to the log file
    3058. 

  3058.         if ($log) {
    3059. 

  3059.           $this->_logResult('execute_partial_error', array('input' => $this->_input_file));
    3060. 

  3060.         }
    3061. 

  3061.         return $this->_raiseError('execute_partial_error', array('input' => $this->_input_file));
    3062. 

  3062. // <-				exits
    3063. 

  3063.       }
    3064. 

  3064. 

  3065. // 				post process any files
    3066. 

  3066. // 				print_r($files);
    3067. 

  3067.       $post_process_result = $this->_postProcess($log, $files);
    3068. 

  3068. // 				print_r($files);
    3069. 

  3069.       if (is_array($post_process_result)) {
    3070. 

  3070. // 					post process has occurred and everything is fine
    3071. 

  3071.         $num = count($files);
    3072. 

  3072.       }
    3073. 

  3073.       elseif ($post_process_result !== FALSE) {
    3074. 

  3074. // 					the file has encountered an error in the post processing of the files
    3075. 

  3075.         return $post_process_result;
    3076. 

  3076.       }
    3077. 

  3077. // 				var_dump("\r\n\r\n", $files, __LINE__, __FILE__, "\r\n\r\n"); exit;
    3078. 

  3078.       $this->_process_file_count = $num;
    3079. 

  3079. 

  3080. //				no files were generated in this sequence
    3081. 

  3081.       if ($num == 0) {
    3082. 

  3082. // 					add the error to the log file
    3083. 

  3083.         if ($log) {
    3084. 

  3084.           $this->_logResult('execute_image_error', array('input' => $this->_input_file));
    3085. 

  3085.         }
    3086. 

  3086.         return $this->_raiseError('execute_image_error', array('input' => $this->_input_file));
    3087. 

  3087. // <-				exits
    3088. 

  3088.       }
    3089. 

  3089. 

  3090. //				add the files the the class a record of what has been generated
    3091. 

  3091.       array_unshift($this->_files, $files);
    3092. 

  3092. 

  3093.       if ($log) {
    3094. 

  3094.         array_push($lines, $this->_getMessage('ffmpeg_log_separator'), $this->_getMessage('ffmpeg_log_ffmpeg_output'), $this->_getMessage('ffmpeg_log_separator'), implode("\n", $files));
    3095. 

  3095.         $this->_addToLog($lines, 'a+');
    3096. 

  3096.       }
    3097. 

  3097. 

  3098.       return $file_exists ? self::RESULT_OK_BUT_UNWRITABLE : self::RESULT_OK;
    3099. 

  3099.     }
    3100. 

  3100. //			must validate one file
    3101. 

  3101.     else {
    3102. 

  3102. //				check that it is a file
    3103. 

  3103.       if (!is_file($this->_process_address)) {
    3104. 

  3104. // 					add the error to the log file
    3105. 

  3105.         if ($log) {
    3106. 

  3106.           $this->_logResult('execute_output_404', array('input' => $this->_input_file));
    3107. 

  3107.         }
    3108. 

  3108.         return $this->_raiseError('execute_output_404', array('input' => $this->_input_file));
    3109. 

  3109. // <-				exits
    3110. 

  3110.       }
    3111. 

  3111. //				the file does exist but is it empty?
    3112. 

  3112.       if (filesize($this->_process_address) == 0) {
    3113. 

  3113. // 					add the error to the log file
    3114. 

  3114.         if ($log) {
    3115. 

  3115.           $this->_logResult('execute_output_empty', array('input' => $this->_input_file));
    3116. 

  3116.         }
    3117. 

  3117.         return $this->_raiseError('execute_output_empty', array('input' => $this->_input_file));
    3118. 

  3118. // <-				exits
    3119. 

  3119.       }
    3120. 

  3120. // 				the file is ok so move to output address
    3121. 

  3121.       if (!is_file($this->_output_address) || $this->_overwrite_mode == self::OVERWRITE_EXISTING) {
    3122. 

  3122. // 					post process any files
    3123. 

  3123.         $post_process_result = $this->_postProcess($log, array($this->_process_address));
    3124. 

  3124.         if (is_array($post_process_result) || $post_process_result === TRUE) {
    3125. 

  3125. // 						post process has occurred and everything is fine
    3126. 

  3126.         }
    3127. 

  3127.         elseif ($post_process_result !== FALSE) {
    3128. 

  3128.           return $post_process_result;
    3129. 

  3129.         }
    3130. 

  3130. // 					if the result is FALSE then no post process has taken place
    3131. 

  3131. 

  3132.         if (is_file($this->_output_address)) {
    3133. 

  3133.           unlink($this->_output_address);
    3134. 

  3134.         }
    3135. 

  3135. 

  3136. // 					rename the file to the final destination and check it went ok
    3137. 

  3137.         if (rename($this->_process_address, $this->_output_address)) {
    3138. 

  3138.           if ($log) {
    3139. 

  3139.             array_push($lines, $this->_getMessage('ffmpeg_log_separator'), $this->_getMessage('ffmpeg_log_ffmpeg_output'), $this->_getMessage('ffmpeg_log_separator'), $this->_output_address);
    3140. 

  3140.             $this->_addToLog($lines, 'a+');
    3141. 

  3141.           }
    3142. 

  3142. 

  3143. // 						the file has been renamed ok
    3144. 

  3144. // 						add the error to the log file
    3145. 

  3145.           if ($log) {
    3146. 

  3146.             $this->_logResult('execute_result_ok', array('output' => $this->_output_address));
    3147. 

  3147.           }
    3148. 

  3148.           $this->_process_file_count = 1;
    3149. 

  3149. //						add the file the the class a record of what has been generated
    3150. 

  3150.           array_unshift($this->_files, array($this->_output_address));
    3151. 

  3151.           return self::RESULT_OK;
    3152. 

  3152.         }
    3153. 

  3153. // 					renaming failed so return ok but erro
    3154. 

  3154.         else {
    3155. 

  3155. // 						add the error to the log file
    3156. 

  3156.           if ($log) {
    3157. 

  3157.             $this->_logResult('execute_result_ok_but_unwritable', array('process' => $this->_process_address, 'output' => $this->_output_address));
    3158. 

  3158.           }
    3159. 

  3159. //						add the file the the class a record of what has been generated
    3160. 

  3160.           array_unshift($this->_files, array($this->_process_address));
    3161. 

  3161.           array_push($lines, $this->_getMessage('ffmpeg_log_separator'), $this->_getMessage('ffmpeg_log_ffmpeg_output'), $this->_getMessage('ffmpeg_log_separator'), $this->_process_address);
    3162. 

  3162.           $this->_addToLog($lines, 'a+');
    3163. 

  3163.           return self::RESULT_OK_BUT_UNWRITABLE;
    3164. 

  3164.         }
    3165. 

  3165.       }
    3166. 

  3166. // 				if it is not we signal that it has been created but has not been moved.
    3167. 

  3167.       elseif ($this->_overwrite_mode == self::OVERWRITE_PRESERVE) {
    3168. 

  3168. // 					add the error to the log file
    3169. 

  3169.         if ($log) {
    3170. 

  3170.           $this->_logResult('execute_result_ok_but_unwritable', array('process' => $this->_process_address, 'output' => $this->_output_address));
    3171. 

  3171.         }
    3172. 

  3172. //					add the file the the class a record of what has been generated
    3173. 

  3173.         array_unshift($this->_files, array($this->_process_address));
    3174. 

  3174.         return self::RESULT_OK_BUT_UNWRITABLE;
    3175. 

  3175.       }
    3176. 

  3176. // 				the file exists so the process must fail
    3177. 

  3177.       else {
    3178. 

  3178. // 					add the error to the log file
    3179. 

  3179.         if ($log) {
    3180. 

  3180.           $this->_logResult('execute_overwrite_fail');
    3181. 

  3181.         }
    3182. 

  3182. // 					tidy up the produced files
    3183. 

  3183.         array_push($this->_unlink_files, $this->_process_address);
    3184. 

  3184.         return $this->_raiseError('execute_overwrite_fail');
    3185. 

  3185.       }
    3186. 

  3186.     }
    3187. 

  3187. 

  3188.     return NULL;
    3189. 

  3189.   }
    3190. 

  3190. 

  3191.   /**
    3192. 

  3192.    * This function registers a post process after the internal handling of the ffmpeg output has been cleaned and checked.
    3193. 

  3193.    * Each function that is set will be called in the order it is set unless an index is specified. All callbacks will be
    3194. 

  3194.    * supplied with one argument with is an array of the outputted files.
    3195. 

  3195.    *
    3196. 

  3196.    * NOTE1: If a post process function is being applied to an outputted video or audio then the process will be applied
    3197. 

  3197.    * before it has been moved to it's final destination, however if the output is an image sequence the post process
    3198. 

  3198.    * function will be called after the images have been moved to their final destinations.
    3199. 

  3199.    *
    3200. 

  3200.    * NOTE2: Also it is important to return a boolean 'true' if the post process has been carried out ok. If the process is not
    3201. 

  3201.    * a TRUE value then the value will be treated/returned as an error and if applicable logged.
    3202. 

  3202.    *
    3203. 

  3203.    * @access public
    3204. 

  3204.    * @param string $function The name of a function
    3205. 

  3205.    * @param object|boolean $class The name of the callback class. If left as FALSE the callback will be treated as a standalone function.
    3206. 

  3206.    * @param integer|boolean $index The index of the callback array to put the callback into. If left as FALSE it will be pushed to the end of the array.
    3207. 

  3207.    */
    3208. 

  3208.   public function registerPostProcess($function, $class=FALSE, $index=FALSE) {
    3209. 

  3209. // 			create the callback
    3210. 

  3210.     $callback = $class === FALSE ? $function : array(&$class, $function);
    3211. 

  3211. // 			add it to the post process array
    3212. 

  3212.     if ($index === FALSE) {
    3213. 

  3213.       array_push($this->_post_processes, $callback);
    3214. 

  3214.     }
    3215. 

  3215.     else {
    3216. 

  3216.       $this->_post_processes[$index] = $callback;
    3217. 

  3217.     }
    3218. 

  3218.   }
    3219. 

  3219. 

  3220.   /**
    3221. 

  3221.    * Carries out the post processing of the files.
    3222. 

  3222.    *
    3223. 

  3223.    * @access protected
    3224. 

  3224.    * @param boolean $log Determines if logging of errors should be carried out.
    3225. 

  3225.    * @param array $files The array of files that have just been processed.
    3226. 

  3226.    * @return mixed
    3227. 

  3227.    */
    3228. 

  3228.   protected function _postProcess($log, $files) {
    3229. 

  3229.     if (count($this->_post_processes)) {
    3230. 

  3230. // 				loop through the post processes
    3231. 

  3231.       foreach ($this->_post_processes as $key => $process) {
    3232. 

  3232. // 					call the process
    3233. 

  3233.         $return_value = call_user_func_array($process, array($files));
    3234. 

  3234. // 					if the return value is not strictly equal to TRUE the result will be treated as an error and exit the process loop
    3235. 

  3235.         if (!is_array($return_value) && $return_value !== TRUE) {
    3236. 

  3236.           if ($log) {
    3237. 

  3237.             $this->_logResult($return_value);
    3238. 

  3238.           }
    3239. 

  3239.           return $this->_raiseError($return_value);
    3240. 

  3240.         }
    3241. 

  3241.       }
    3242. 

  3242.       return $return_value;
    3243. 

  3243.     }
    3244. 

  3244.     return FALSE;
    3245. 

  3245.   }
    3246. 

  3246. 

  3247.   /**
    3248. 

  3248.    * Returns the number of files outputted in this run. It will be reset when you call PHPVideoToolkit::reset();
    3249. 

  3249.    *
    3250. 

  3250.    * @access public
    3251. 

  3251.    * @return integer
    3252. 

  3252.    */
    3253. 

  3253.   public function getFileOutputCount() {
    3254. 

  3254.     return $this->_process_file_count;
    3255. 

  3255.   }
    3256. 

  3256. 

  3257.   /**
    3258. 

  3258.    * Adds lines to the current log file.
    3259. 

  3259.    *
    3260. 

  3260.    * @access protected
    3261. 

  3261.    * @param $message
    3262. 

  3262.    * @param $replacements
    3263. 

  3263.    */
    3264. 

  3264.   protected function _logResult($message, $replacements=FALSE) {
    3265. 

  3265.     $last = $this->getLastCommand();
    3266. 

  3266.     if (is_array($last) === TRUE) {
    3267. 

  3267.       $last = implode("\r", $last);
    3268. 

  3268.     }
    3269. 

  3269.     $this->_addToLog(array(
    3270. 

  3270.       $this->_getMessage('ffmpeg_log_separator'),
    3271. 

  3271.       $this->_getMessage('ffmpeg_log_ffmpeg_result'),
    3272. 

  3272.       $this->_getMessage('ffmpeg_log_separator'),
    3273. 

  3273.       $this->_getMessage($message, $replacements),
    3274. 

  3274.       $this->_getMessage('ffmpeg_log_separator'),
    3275. 

  3275.       $this->_getMessage('ffmpeg_log_ffmpeg_command'),
    3276. 

  3276.       $this->_getMessage('ffmpeg_log_separator'),
    3277. 

  3277.       $last
    3278. 

  3278.     ));
    3279. 

  3279.   }
    3280. 

  3280. 

  3281.   /**
    3282. 

  3282.    * Adds lines to the current log file.
    3283. 

  3283.    *
    3284. 

  3284.    * @access protected
    3285. 

  3285.    * @param $lines array An array of lines to add to the log file.
    3286. 

  3286.    */
    3287. 

  3287.   protected function _addToLog($lines, $where='a') {
    3288. 

  3288.     $handle = fopen($this->_log_file, $where);
    3289. 

  3289.     if (is_array($lines)) {
    3290. 

  3290.       $data = implode("\n", $lines) . "\n";
    3291. 

  3291.     }
    3292. 

  3292.     else {
    3293. 

  3293.       $data = $lines . "\n";
    3294. 

  3294.     }
    3295. 

  3295.     fwrite($handle, $data);
    3296. 

  3296.     fclose($handle);
    3297. 

  3297.   }
    3298. 

  3298. 

  3299.   /**
    3300. 

  3300.    * Moves the current log file to another file.
    3301. 

  3301.    *
    3302. 

  3302.    * @access public
    3303. 

  3303.    * @param $destination string The absolute path of the new filename for the log.
    3304. 

  3304.    * @return boolean Returns the result of the log file rename.
    3305. 

  3305.    */
    3306. 

  3306.   public function moveLog($destination) {
    3307. 

  3307.     $result = FALSE;
    3308. 

  3308.     if ($this->_log_file !== NULL && is_file($this->_log_file)) {
    3309. 

  3309.       if (is_file($destination)) {
    3310. 

  3310.         unlink($destination);
    3311. 

  3311.       }
    3312. 

  3312.       $result = rename($this->_log_file, $destination);
    3313. 

  3313.       $this->_log_file = $destination;
    3314. 

  3314.     }
    3315. 

  3315.     return $result;
    3316. 

  3316.   }
    3317. 

  3317. 

  3318.   /**
    3319. 

  3319.    * Reads the current log file
    3320. 

  3320.    *
    3321. 

  3321.    * @access public
    3322. 

  3322.    * @return string|boolean Returns the current log file content. Returns FALSE on failure.
    3323. 

  3323.    */
    3324. 

  3324.   public function readLog() {
    3325. 

  3325.     if ($this->_log_file !== NULL && is_file($this->_log_file)) {
    3326. 

  3326.       $handle = fopen($this->_log_file, 'r');
    3327. 

  3327.       $contents = fread($handle, filesize($this->_log_file));
    3328. 

  3328.       fclose($handle);
    3329. 

  3329.       return $contents;
    3330. 

  3330.     }
    3331. 

  3331.     return FALSE;
    3332. 

  3332.   }
    3333. 

  3333. 

  3334.   /**
    3335. 

  3335.    * Returns the last outputted file that was processed by ffmpeg from this class.
    3336. 

  3336.    *
    3337. 

  3337.    * @access public
    3338. 

  3338.    * @return mixed array|string Will return an array if the output was a sequence, or string if it was a single file output
    3339. 

  3339.    */
    3340. 

  3340.   public function getLastOutput() {
    3341. 

  3341.     return $this->_files[0];
    3342. 

  3342.   }
    3343. 

  3343. 

  3344.   /**
    3345. 

  3345.    * Returns all the outputted files that were processed by ffmpeg from this class.
    3346. 

  3346.    *
    3347. 

  3347.    * @access public
    3348. 

  3348.    * @return array
    3349. 

  3349.    */
    3350. 

  3350.   public function getOutput() {
    3351. 

  3351.     return $this->_files;
    3352. 

  3352.   }
    3353. 

  3353. 

  3354.   /**
    3355. 

  3355.    * Returns the amount of time taken of the last file to be processed by ffmpeg.
    3356. 

  3356.    *
    3357. 

  3357.    * @access public
    3358. 

  3358.    * @return mixed integer Will return the time taken in seconds.
    3359. 

  3359.    */
    3360. 

  3360.   public function getLastProcessTime() {
    3361. 

  3361.     return $this->_timers[0];
    3362. 

  3362.   }
    3363. 

  3363. 

  3364.   /**
    3365. 

  3365.    * Returns the amount of time taken of all the files to be processed by ffmpeg.
    3366. 

  3366.    *
    3367. 

  3367.    * @access public
    3368. 

  3368.    * @return array
    3369. 

  3369.    */
    3370. 

  3370.   public function getProcessTime() {
    3371. 

  3371.     return $this->_timers;
    3372. 

  3372.   }
    3373. 

  3373. 

  3374.   /**
    3375. 

  3375.    * Returns the last encountered error message.
    3376. 

  3376.    *
    3377. 

  3377.    * @access public
    3378. 

  3378.    * @return string
    3379. 

  3379.    */
    3380. 

  3380.   public function getLastError() {
    3381. 

  3381.     return $this->_errors[0];
    3382. 

  3382.   }
    3383. 

  3383. 

  3384.   /**
    3385. 

  3385.    * Returns all the encountered errors as an array of strings
    3386. 

  3386.    *
    3387. 

  3387.    * @access public
    3388. 

  3388.    * @return array
    3389. 

  3389.    */
    3390. 

  3390.   public function getErrors() {
    3391. 

  3391.     return $this->_errors;
    3392. 

  3392.   }
    3393. 

  3393. 

  3394.   /**
    3395. 

  3395.    * Returns the last command that ffmpeg was given.
    3396. 

  3396.    * (Note; if setFormatToFLV was used in the last command then an array is returned as a command was also sent to FLVTool2)
    3397. 

  3397.    *
    3398. 

  3398.    * @access public
    3399. 

  3399.    * @return mixed array|string
    3400. 

  3400.    */
    3401. 

  3401.   public function getLastCommand() {
    3402. 

  3402.     return isset($this->_processed[0]) === TRUE ? $this->_processed[0] : FALSE;
    3403. 

  3403.   }
    3404. 

  3404. 

  3405.   /**
    3406. 

  3406.    * Returns all the commands sent to ffmpeg from this class
    3407. 

  3407.    *
    3408. 

  3408.    * @access public
    3409. 

  3409.    */
    3410. 

  3410.   public function getCommands() {
    3411. 

  3411.     return $this->_processed;
    3412. 

  3412.   }
    3413. 

  3413. 

  3414.   /**
    3415. 

  3415.    * Returns all commands and their output
    3416. 

  3416.    *
    3417. 

  3417.    * @return
    3418. 

  3418.    *   array of arrays, the inner array contains keys command and output.
    3419. 

  3419.    */
    3420. 

  3420.   public function getCommandOutput() {
    3421. 

  3421.     return $this->_command_output;
    3422. 

  3422.   }
    3423. 

  3423. 

  3424.   /**
    3425. 

  3425.    * Raises an error
    3426. 

  3426.    *
    3427. 

  3427.    * @access protected
    3428. 

  3428.    * @param string $message
    3429. 

  3429.    * @param array $replacements a list of replacements in search=>replacement format
    3430. 

  3430.    * @return boolean Only returns FALSE if $toolkit->on_error_die is set to FALSE
    3431. 

  3431.    */
    3432. 

  3432.   protected function _raiseError($message, $replacements=FALSE) {
    3433. 

  3433.     $msg = 'PHPVideoToolkit error: ' . $this->_getMessage($message, $replacements);
    3434. 

  3434. //			check what the error is supposed to do
    3435. 

  3435.     if ($this->on_error_die === TRUE) {
    3436. 

  3436.       exit($msg);
    3437. 

  3437. // <-			exits
    3438. 

  3438.     }
    3439. 

  3439. //			add the error message to the collection
    3440. 

  3440.     array_unshift($this->_errors, $msg);
    3441. 

  3441.     return FALSE;
    3442. 

  3442.   }
    3443. 

  3443. 

  3444.   /**
    3445. 

  3445.    * Gets a message.
    3446. 

  3446.    *
    3447. 

  3447.    * @access protected
    3448. 

  3448.    * @param string $message
    3449. 

  3449.    * @param array $replacements a list of replacements in search=>replacement format
    3450. 

  3450.    * @return boolean Only returns FALSE if $toolkit->on_error_die is set to FALSE
    3451. 

  3451.    */
    3452. 

  3452.   protected function _getMessage($message, $replacements=FALSE) {
    3453. 

  3453.     $message = isset($this->_messages[$message]) === TRUE ? $this->_messages[$message] : 'Unknown!!!';
    3454. 

  3454.     if ($replacements) {
    3455. 

  3455.       $searches = $replaces = array();
    3456. 

  3456.       foreach ($replacements as $search => $replace) {
    3457. 

  3457.         array_push($searches, '#' . $search);
    3458. 

  3458.         array_push($replaces, $replace);
    3459. 

  3459.       }
    3460. 

  3460.       $message = str_replace($searches, $replaces, $message);
    3461. 

  3461.     }
    3462. 

  3462.     return $message;
    3463. 

  3463.   }
    3464. 

  3464. 

  3465.   /**
    3466. 

  3466.    * Adds a command to be bundled into the ffmpeg command call.
    3467. 

  3467.    * (SPECIAL NOTE; None of the arguments are checked or sanitized by this function. BE CAREFUL if manually using this. The commands and arguments are escaped
    3468. 

  3468.    * however it is still best to check and sanitize any params given to this function)
    3469. 

  3469.    *
    3470. 

  3470.    * @access public
    3471. 

  3471.    * @param string $command
    3472. 

  3472.    * @param mixed $argument
    3473. 

  3473.    * @return boolean
    3474. 

  3474.    */
    3475. 

  3475.   public function addCommand($command, $argument = FALSE, $before_input = FALSE) {
    3476. 

  3476.     $this->_commands[$before_input][$command] = $argument === FALSE ? FALSE : escapeshellarg($argument);
    3477. 

  3477.     return TRUE;
    3478. 

  3478.   }
    3479. 

  3479. 

  3480.   /**
    3481. 

  3481.    * Determines if the the command exits.
    3482. 

  3482.    *
    3483. 

  3483.    * @access public
    3484. 

  3484.    * @param string $command
    3485. 

  3485.    * @return mixed boolean if failure or value if exists.
    3486. 

  3486.    */
    3487. 

  3487.   public function hasCommand($command, $before_input = FALSE) {
    3488. 

  3488.     return isset($this->_commands[$before_input][$command]) ? ($this->_commands[$before_input][$command] === FALSE ? TRUE : $this->_commands[$before_input][$command]) : FALSE;
    3489. 

  3489.   }
    3490. 

  3490. 

  3491.   /**
    3492. 

  3492.    * Combines the commands stored into a string
    3493. 

  3493.    *
    3494. 

  3494.    * @access protected
    3495. 

  3495.    * @return string
    3496. 

  3496.    */
    3497. 

  3497.   protected function _combineCommands() {
    3498. 

  3498.     $before_input = array();
    3499. 

  3499.     $after_input = array();
    3500. 

  3500.     $input = NULL;
    3501. 

  3501. 

  3502.     foreach ($this->_commands as $is_before_input => $commands) {
    3503. 

  3503.       foreach ($commands as $command => $argument) {
    3504. 

  3504.         $command_string = trim($command . (!empty($argument) ? ' ' . $argument : ''));
    3505. 

  3505. 

  3506.         if ($command === '-i') {
    3507. 

  3507.           $input = $command_string;
    3508. 

  3508.         }
    3509. 

  3509.         else {
    3510. 

  3510.           if ($is_before_input) {
    3511. 

  3511.             array_push($before_input, $command_string);
    3512. 

  3512.           }
    3513. 

  3513.           else {
    3514. 

  3514.             array_push($after_input, $command_string);
    3515. 

  3515.           }
    3516. 

  3516.         }
    3517. 

  3517.       }
    3518. 

  3518.     }
    3519. 

  3519. 

  3520.     $before_input = count($before_input) ? implode(' ', $before_input) . ' ' : '';
    3521. 

  3521.     $after_input_string = ' ';
    3522. 

  3522.     if (count($after_input)) {
    3523. 

  3523.       $input .= ' ';
    3524. 

  3524.       $after_input_string = implode(' ', $after_input) . ' ';
    3525. 

  3525.     }
    3526. 

  3526. 

  3527.     return $before_input . $input . $after_input_string;
    3528. 

  3528.   }
    3529. 

  3529. 

  3530.   /**
    3531. 

  3531.    * Prepares the command for execution
    3532. 

  3532.    *
    3533. 

  3533.    * @access protected
    3534. 

  3534.    * @param string $path Path to the binary
    3535. 

  3535.    * @param string $command Command string to execute
    3536. 

  3536.    * @param string $args Any additional arguments
    3537. 

  3537.    * @return string
    3538. 

  3538.    */
    3539. 

  3539.   protected function _prepareCommand($path, $command, $args='') {
    3540. 

  3540.     if (strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN' || !preg_match('/\s/', $path)) {
    3541. 

  3541.       return $path . ' ' . $command . ' ' . $args;
    3542. 

  3542.     }
    3543. 

  3543.     return 'start /D "' . $path . '" /B ' . $command . ' ' . $args;
    3544. 

  3544.   }
    3545. 

  3545. 

  3546.   /**
    3547. 

  3547.    * Generates a unique id. Primarily used in jpeg to movie production
    3548. 

  3548.    *
    3549. 

  3549.    * @access public
    3550. 

  3550.    * @param string $prefix
    3551. 

  3551.    * @return string
    3552. 

  3552.    */
    3553. 

  3553.   public function unique($prefix='') {
    3554. 

  3554.     return uniqid($prefix . time() . '-');
    3555. 

  3555.   }
    3556. 

  3556. 

  3557.   public function getInputFile() {
    3558. 

  3558.     return $this->_input_file;
    3559. 

  3559.   }
    3560. 

  3560. 

  3561.   /**
    3562. 

  3562.    * Destructs ffmpeg and removes any temp files/dirs
    3563. 

  3563.    */
    3564. 

  3564.   function __destruct() {
    3565. 

  3565. //			loop through the temp files to remove first as they have to be removed before the dir can be removed
    3566. 

  3566.     if (!empty($this->_unlink_files)) {
    3567. 

  3567.       foreach ($this->_unlink_files as $key => $file) {
    3568. 

  3568.         if (is_file($file)) {
    3569. 

  3569.           @unlink($file);
    3570. 

  3570.         }
    3571. 

  3571.       }
    3572. 

  3572.       $this->_unlink_files = array();
    3573. 

  3573.     }
    3574. 

  3574. //			loop through the dirs to remove
    3575. 

  3575.     if (!empty($this->_unlink_dirs)) {
    3576. 

  3576.       foreach ($this->_unlink_dirs as $key => $dir) {
    3577. 

  3577.         if (is_dir($dir)) {
    3578. 

  3578.           @rmdir($dir);
    3579. 

  3579.         }
    3580. 

  3580.       }
    3581. 

  3581.       $this->_unlink_dirs = array();
    3582. 

  3582.     }
    3583. 

  3583.   }
    3584. 

  3584. 

  3585. }
    3586. 

  3586.