673 lines
16 KiB
ReStructuredText
673 lines
16 KiB
ReStructuredText
Recipes
|
|
=======
|
|
|
|
Initializing FFMpeg
|
|
-------------------
|
|
|
|
In the following examples, we assume we work in an environnment where
|
|
FFMpeg has been initialized to ``$ffmpeg``; there are two ways to
|
|
initialize the environment (see below).
|
|
|
|
PHP-FFMpeg supports both ``avconv`` and legacy ``ffmpeg``. If both are installed
|
|
on your system, ``avconv`` will be loaded in first priority. Please read the
|
|
dedicated chapter below if you want to load ``FFMpeg``.
|
|
|
|
Load FFMpeg automatically
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
The easiest way to initialize ``FMpeg`` it is to call the loader ; this will
|
|
look in your PATH environment variable to find ffmpeg/avconv binary :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use Monolog\Logger;
|
|
use Monolog\Handler\NullHandler;
|
|
use FFMpeg\FFMpeg;
|
|
|
|
// Create a logger
|
|
$logger = new Logger('MyLogger');
|
|
$logger->pushHandler(new NullHandler());
|
|
|
|
// You have to pass a Monolog logger
|
|
// This logger provides some usefull infos about what's happening
|
|
$ffmpeg = FFMpeg::load($logger);
|
|
|
|
.. note:: FFMpeg and FFProbe both requires a logger for giving feedback about
|
|
what's happening. By passing a NullHandler to the logger, you will disable
|
|
the log system.
|
|
|
|
|
|
Use custom binary
|
|
^^^^^^^^^^^^^^^^^
|
|
|
|
You can also initialize with a custom path to the binary :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
$ffmpeg = new FFMpeg('/usr/local/src/ffmpeg/bin/ffmpeg', $logger);
|
|
|
|
Working with Silex Microframework
|
|
---------------------------------
|
|
|
|
If you're using `Silex MicroFramework <http://silex.sensiolabs.org/>`_, you can
|
|
use FFMpeg-PHP with the bundled Service Provider :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use Silex\Application;
|
|
use FFMpeg\FFMpegServiceProvider;
|
|
|
|
$app = new Application();
|
|
$app->register(new FFMpegServiceProvider());
|
|
|
|
// Instance of FFMpeg\FFMpeg
|
|
$app['ffmpeg.ffmpeg'];
|
|
|
|
// Instance of FFMpeg\FFProbe
|
|
$app['ffmpeg.ffprobe'];
|
|
|
|
|
|
Service Provider options
|
|
^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
By default, `FFMpegServiceProvider` will look for monolog service to log
|
|
messages. You can customize FFMpeg logger with the 'ffmpeg.logger' option.
|
|
|
|
You can also customize the number of threads to open and the path to FFMpeg and
|
|
FFProbe binaries :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use Silex\Application;
|
|
use FFMpeg\FFMpegServiceProvider;
|
|
use Monolog\Logger;
|
|
use Monolog\Handler\NullHandler;
|
|
|
|
$app = new Application();
|
|
|
|
$logger = new Logger('FFMpeg');
|
|
$logger->pushHandler(new NullHandler());
|
|
|
|
$options = array(
|
|
'ffmpeg.ffmpeg.binary' => '/path/to/custom/ffmpeg/binary',
|
|
'ffmpeg.ffprobe.binary' => '/path/to/custom/ffprobe/binary',
|
|
'ffmpeg.threads' => 8, # number of threads to open
|
|
'ffmpeg.logger' => $logger, # custom logger service
|
|
);
|
|
|
|
$app->register(new FFMpegServiceProvider(), $options);
|
|
|
|
|
|
Formats
|
|
-------
|
|
|
|
PHP-FFMpeg provides a set of predefined audio and video formats. These formats
|
|
are usefull, but you'll probably need to define your own format with their own
|
|
resize rules, etc...
|
|
|
|
This section describe how to use media formats, and how to define them.
|
|
|
|
.. note:: Defining a format is just about implementing interfaces.
|
|
|
|
.. _video-reference:
|
|
|
|
Video
|
|
^^^^^
|
|
|
|
This section describes video processing and Interfaces for building video
|
|
formats. As Video is an extension of audio, all these features can be combined
|
|
with audio features (see :ref:`dedicated audio section<audio-reference>`).
|
|
|
|
Simple transcoding
|
|
++++++++++++++++++
|
|
|
|
To transcode a video, you have to pass the target format to FFMpeg.
|
|
|
|
When you define a format which implements the
|
|
:ref:`Resizable <resizable-reference>` interface.
|
|
You must set FFprobe (see :ref:`FF-probe<ffprobe-reference>`)
|
|
for probing the media and found its height and size.
|
|
|
|
The following example initialize a Ogg format and encodes a `Video.mpeg` to a
|
|
target file `file.ogv` :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use FFMpeg\FFProbe;
|
|
use FFMpeg\Format\Video\Ogg;
|
|
|
|
$ffprobe = FFProbe::load($logger);
|
|
|
|
$ffmpeg->setProber($ffprobe);
|
|
|
|
$oggFormat = new Ogg();
|
|
|
|
$ffmpeg->open('Video.mpeg')
|
|
->encode($oggFormat, 'file.ogv')
|
|
->close();
|
|
|
|
.. note:: ``FFmpeg`` methods always return the object itself so you can chain
|
|
multiple methods.
|
|
|
|
HTML5
|
|
+++++
|
|
|
|
PHP-FFMpeg provides three video formats out of the box : HTML5 video formats
|
|
|
|
- ``FFMpeg\Format\Video\WebM``
|
|
- ``FFMpeg\Format\Video\X264``
|
|
- ``FFMpeg\Format\Video\Ogg``
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use FFMpeg\Format\Video;
|
|
|
|
$webMFormat = new Video\WebM();
|
|
$webMFormat->setDimensions(320, 240)
|
|
->setFrameRate(15)
|
|
->setGopSize(25);
|
|
|
|
$x264Format = new Video\X264();
|
|
$x264Format->setDimensions(320, 240)
|
|
->setFrameRate(15)
|
|
->setGopSize(25);
|
|
|
|
$oggFormat = new Video\Ogg();
|
|
$oggFormat->setDimensions(320, 240)
|
|
->setFrameRate(15)
|
|
->setGopSize(25);
|
|
|
|
$ffmpeg->open('Video.mpeg')
|
|
->encode($webMFormat, 'file.webm')
|
|
->encode($x264Format, 'file.mp4')
|
|
->encode($oggFormat, 'file.ogv')
|
|
->close();
|
|
|
|
.. note:: All formats provided by PHP-FFMpeg extends DefaultVideo, have a look
|
|
at the API doc for more information on its behavior.
|
|
|
|
.. note:: Use PHP-MP4Box to make it compatible with pseudo stream !
|
|
|
|
Create your own media type
|
|
++++++++++++++++++++++++++
|
|
|
|
PHP-FFMpeg provides ``FFMpeg\Format\VideoInterface``, as base interface for
|
|
creating a Video format. To define a target format, all you need to do is
|
|
implement this Interface.
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\VideoInterface;
|
|
|
|
class MyFormat implements VideoInterface
|
|
{
|
|
public function getKiloBitrate()
|
|
{
|
|
return 1500;
|
|
}
|
|
|
|
public function getExtraParams()
|
|
{
|
|
return '';
|
|
}
|
|
}
|
|
|
|
$format = new MyFormat();
|
|
|
|
$ffmpeg->open('Video.mpeg')
|
|
->encode($format, 'file.mp4')
|
|
->close();
|
|
|
|
PHP-FFmpeg brings more interfaces for your video formats :
|
|
|
|
- ``FFMpeg\Format\Video\Resamplable``
|
|
- ``FFMpeg\Format\Video\Resizable``
|
|
- ``FFMpeg\Format\Video\Transcodable``
|
|
- ``FFMpeg\Format\Video\Interactive``
|
|
|
|
.. note:: You can combine these features in one video format.
|
|
|
|
Advanced media type
|
|
+++++++++++++++++++
|
|
|
|
This section presents usage for the different interfaces. You can combine
|
|
them for your own formats.
|
|
|
|
.. _resizable-reference:
|
|
|
|
Resizable
|
|
.........
|
|
|
|
This interface provide an easy way to resize a video.
|
|
The example below resizes a video by half.
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\Dimension;
|
|
use FFMpeg\Format\Video\Resizable;
|
|
|
|
class MyFormat implements Resizable
|
|
{
|
|
public function getComputedDimensions($originalWidth, $originalHeight)
|
|
{
|
|
return new Dimension(round($originalWidth / 2), round($originalHeight / 2));
|
|
}
|
|
|
|
}
|
|
|
|
$format = new MyFormat();
|
|
|
|
$ffmpeg->open('Video.mpeg')
|
|
->encode($format, 'file.mp4')
|
|
->close();
|
|
|
|
.. _resamplable-reference:
|
|
|
|
Resamplable
|
|
...........
|
|
|
|
This interface provides video resampling. The example below resample the video
|
|
at 15 frame per second with a I-frame every 30 image (see
|
|
`GOP on wikipedia <https://wikipedia.org/wiki/Group_of_pictures>`_) and supports
|
|
B-frames (see `B-frames on wikipedia <https://wikipedia.org/wiki/Video_compression_picture_types>`_)
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\Video\Resamplable;
|
|
|
|
class MyFormat implements Resamplable
|
|
{
|
|
public function getFrameRate()
|
|
{
|
|
return 15;
|
|
}
|
|
|
|
public function getGOPSize()
|
|
{
|
|
return 30;
|
|
}
|
|
|
|
public function supportBFrames()
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
$format = new MyFormat();
|
|
|
|
$ffmpeg->open('Video.mpeg')
|
|
->encode($format, 'file.mp4')
|
|
->close();
|
|
|
|
Interactive
|
|
...........
|
|
|
|
This interface provides a method to list available codecs for the format.
|
|
The example below provides a format object listing available video-codecs for
|
|
video supported in flash player.
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\Video\Interactive;
|
|
|
|
class MyFormat implements Interactive
|
|
{
|
|
|
|
public function getVideoCodec()
|
|
{
|
|
return 'libx264';
|
|
}
|
|
|
|
public function getAvailableVideoCodecs()
|
|
{
|
|
return array('libx264', 'flv');
|
|
}
|
|
}
|
|
|
|
$format = new MyFormat();
|
|
|
|
$ffmpeg->open('Video.mpeg')
|
|
->encode($format, 'file.mp4')
|
|
->close();
|
|
|
|
.. _audio-reference:
|
|
|
|
Audio
|
|
^^^^^
|
|
|
|
This section describes audio processing and Interfaces for building video
|
|
formats. As Video is an extension of audio, all these features can be combined
|
|
with video features (see :ref:`dedicated video section<video-reference>`).
|
|
|
|
Simple transcoding
|
|
++++++++++++++++++
|
|
|
|
To transcode audio file or extract an audio soundtrack from a video, you have to
|
|
pass the target format to FFMpeg.
|
|
|
|
The following example initialize a Mp3 format and transcode the file `tune.wav`
|
|
to `tune.mp3` :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use FFMpeg\Format\Audio\Mp3;
|
|
|
|
$mp3Format = new Mp3();
|
|
|
|
$ffmpeg->open('tune.wav')
|
|
->encode($mp3Format, 'tune.mp3')
|
|
->close();
|
|
|
|
Extract soundtrack from movie
|
|
+++++++++++++++++++++++++++++
|
|
|
|
The following example initialize a Flac format and extract the audio track from
|
|
`Video.mpeg` to a target file `soudtrack.flac` :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use FFMpeg\Format\Audio\Flac;
|
|
|
|
$flacFormat = new Flac();
|
|
|
|
$ffmpeg->open('Video.mpeg')
|
|
->encode($flacFormat, 'soundtrack.flac')
|
|
->close();
|
|
|
|
.. note:: You must ensure that FFmpeg support the format you request, otherwise
|
|
a FFMpeg\Exception\RuntimeException will be thrown.
|
|
|
|
Create your own media type
|
|
++++++++++++++++++++++++++
|
|
|
|
PHP-FFMpeg provides ``FFMpeg\Format\AudioInterface``, as base interface for
|
|
creating an Audio format. To define a target format, all you need to do is
|
|
implement this Interface.
|
|
|
|
This example transcodes the mp3 track to a 128kb mp3 :
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\AudioInterface;
|
|
|
|
class MyFormat implements AudioInterface
|
|
{
|
|
public function getKiloBitrate()
|
|
{
|
|
return 128;
|
|
}
|
|
|
|
public function getExtraParams()
|
|
{
|
|
return '';
|
|
}
|
|
}
|
|
|
|
$format = new MyFormat();
|
|
|
|
$ffmpeg->open('song.mp3')
|
|
->encode($format, 'song-128.mp3')
|
|
->close();
|
|
|
|
PHP-FFmpeg brings more interfaces for your audio formats :
|
|
|
|
- ``FFMpeg\Format\Audio\Resamplable``
|
|
- ``FFMpeg\Format\Audio\Transcodable``
|
|
- ``FFMpeg\Format\Audio\Interactive``
|
|
|
|
.. note:: You can combine these features in one video format.
|
|
|
|
Advanced media type
|
|
+++++++++++++++++++
|
|
|
|
This section presents usage for the different audio interfaces. You can combine
|
|
them for your own formats.
|
|
|
|
Resamplable
|
|
...........
|
|
|
|
This interface provides video resampling. The example below resample the video
|
|
at 15 frame per second with a I-frame every 30 image (see
|
|
`GOP on wikipedia <https://wikipedia.org/wiki/Group_of_pictures>`_).
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\Audio\Resamplable;
|
|
|
|
class MyFormat implements Resamplable
|
|
{
|
|
public function getAudioSampleRate();
|
|
{
|
|
return 44100;
|
|
}
|
|
|
|
}
|
|
|
|
$format = new MyFormat();
|
|
|
|
$ffmpeg->open('song.mp3')
|
|
->encode($format, 'song-44100.mp3')
|
|
->close();
|
|
|
|
|
|
Interactive
|
|
...........
|
|
|
|
This interface provides a method to list available codecs for the format.
|
|
The example below provides a format object listing available audio-codecs for
|
|
a portable player.
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\Audio\Interactive;
|
|
|
|
class MyFormat implements Interactive
|
|
{
|
|
|
|
public function getAudioCodec()
|
|
{
|
|
return 'libvorbis';
|
|
}
|
|
|
|
public function getAvailableVideoCodecs()
|
|
{
|
|
return array('libvorbis', 'libmp3lame', 'libflac');
|
|
}
|
|
}
|
|
|
|
|
|
Custom commandline options
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
If you need to add custom FFmpeg command line option, use the
|
|
``FFMpeg\Format\Audio::getExtraParams`` method.
|
|
As ``Video`` extends ``Audio``, it is also available in any format.
|
|
|
|
The following example shows a ``getExtraParams`` usage for aac encoding. With the
|
|
latest AvConv / FFMPeg version, aac encoding has to be executed with extra command parameters
|
|
``-strict experimental``.
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
namespace Foo\Bar;
|
|
|
|
use FFMpeg\Format\Audio\Transcodable;
|
|
use FFMpeg\Format\VideoInterface;
|
|
|
|
class MyFormat implements VideoInterface, Transcodable
|
|
{
|
|
|
|
public function getAudioCodec()
|
|
{
|
|
return 'aac';
|
|
}
|
|
|
|
public function getKiloBitrate()
|
|
{
|
|
return 128;
|
|
}
|
|
|
|
public function getExtraParams()
|
|
{
|
|
return '-strict experimental';
|
|
}
|
|
}
|
|
|
|
$format = new MyFormat();
|
|
|
|
$ffmpeg->open('Video.mp4')
|
|
->encode($format, 'output-aac.mp4')
|
|
->close();
|
|
|
|
.. _ffprobe-reference:
|
|
|
|
FFProbe recipes
|
|
---------------
|
|
|
|
FFProbe / AvProbe is a usefull tool for probing media files. PHP-FFMpeg
|
|
implementation is currenly light.
|
|
|
|
Load FFProbe
|
|
^^^^^^^^^^^^
|
|
|
|
As FFMpeg, you can load FFProbe two ways ; either with the binary detector or
|
|
specifying the binary you want to use
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
use Monolog\Logger;
|
|
use Monolog\Handler\NullHandler;
|
|
use FFMpeg\FFProbe;
|
|
|
|
// Create a logger
|
|
$logger = new Logger('MyLogger');
|
|
$logger->pushHandler(new NullHandler());
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Load with binary detection
|
|
|
|
// You have to pass a Monolog logger
|
|
// This logger provides some usefull infos about what's happening
|
|
$ffprobe = FFProbe::load($logger);
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Or load manually
|
|
|
|
$ffprobe = new FFProbe('/usr/local/src/ffmpeg/bin/ffprobe', $logger);
|
|
|
|
|
|
Probe streams
|
|
^^^^^^^^^^^^^
|
|
|
|
Probe streams returns the output of ``avprobe -show_streams`` as a json
|
|
object.
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
echo $ffprobe->probeStreams('Video.ogv');
|
|
|
|
will output something like
|
|
|
|
.. code-block:: json
|
|
|
|
[
|
|
{
|
|
"index": 0,
|
|
"codec_name": "theora",
|
|
"codec_long_name": "Theora",
|
|
"codec_type": "video",
|
|
"codec_time_base": "1/15",
|
|
"codec_tag_string": "[0][0][0][0]",
|
|
"codec_tag": "0x0000",
|
|
"width": 400,
|
|
"height": 304,
|
|
"has_b_frames": 0,
|
|
"pix_fmt": "yuv420p",
|
|
"level": "-99",
|
|
"r_frame_rate": "15/1",
|
|
"avg_frame_rate": "15/1",
|
|
"time_base": "1/15",
|
|
"start_time": "0.000000",
|
|
"duration": "29.533333"
|
|
},
|
|
{
|
|
"index": 1,
|
|
"codec_name": "vorbis",
|
|
"codec_long_name": "Vorbis",
|
|
"codec_type": "audio",
|
|
"codec_time_base": "1/44100",
|
|
"codec_tag_string": "[0][0][0][0]",
|
|
"codec_tag": "0x0000",
|
|
"sample_rate": "44100.000000",
|
|
"channels": 2,
|
|
"bits_per_sample": 0,
|
|
"r_frame_rate": "0/0",
|
|
"avg_frame_rate": "0/0",
|
|
"time_base": "1/44100",
|
|
"start_time": "0.000000",
|
|
"duration": "29.489342",
|
|
"TAG:TITLE": "Halo",
|
|
"TAG:LICENSE": "http://creativecommons.org/licenses/publicdomain/",
|
|
"TAG:LOCATION": "http://www.archive.org/details/ctvc"
|
|
}
|
|
]
|
|
|
|
|
|
Probe formats
|
|
^^^^^^^^^^^^^
|
|
|
|
Probe format returns the output of ``avprobe -show_format`` as a json
|
|
object.
|
|
|
|
.. code-block:: php
|
|
|
|
<?php
|
|
echo $ffprobe->probeFormat('Video.ogv');
|
|
|
|
will output something like
|
|
|
|
.. code-block:: json
|
|
|
|
{
|
|
"filename": "Video.ogv",
|
|
"nb_streams": 2,
|
|
"format_name": "ogg",
|
|
"format_long_name": "Ogg",
|
|
"start_time": "0.000000",
|
|
"duration": "29.533333",
|
|
"size": "1786693.000000",
|
|
"bit_rate": "483980.000000"
|
|
}
|