| @chapter Muxers |
| @c man begin MUXERS |
| |
| Muxers are configured elements in FFmpeg which allow writing |
| multimedia streams to a particular type of file. |
| |
| When you configure your FFmpeg build, all the supported muxers |
| are enabled by default. You can list all available muxers using the |
| configure option @code{--list-muxers}. |
| |
| You can disable all the muxers with the configure option |
| @code{--disable-muxers} and selectively enable / disable single muxers |
| with the options @code{--enable-muxer=@var{MUXER}} / |
| @code{--disable-muxer=@var{MUXER}}. |
| |
| The option @code{-formats} of the ff* tools will display the list of |
| enabled muxers. |
| |
| A description of some of the currently available muxers follows. |
| |
| @anchor{aiff} |
| @section aiff |
| |
| Audio Interchange File Format muxer. |
| |
| @subsection Options |
| |
| It accepts the following options: |
| |
| @table @option |
| @item write_id3v2 |
| Enable ID3v2 tags writing when set to 1. Default is 0 (disabled). |
| |
| @item id3v2_version |
| Select ID3v2 version to write. Currently only version 3 and 4 (aka. |
| ID3v2.3 and ID3v2.4) are supported. The default is version 4. |
| |
| @end table |
| |
| @anchor{crc} |
| @section crc |
| |
| CRC (Cyclic Redundancy Check) testing format. |
| |
| This muxer computes and prints the Adler-32 CRC of all the input audio |
| and video frames. By default audio frames are converted to signed |
| 16-bit raw audio and video frames to raw video before computing the |
| CRC. |
| |
| The output of the muxer consists of a single line of the form: |
| CRC=0x@var{CRC}, where @var{CRC} is a hexadecimal number 0-padded to |
| 8 digits containing the CRC for all the decoded input frames. |
| |
| See also the @ref{framecrc} muxer. |
| |
| @subsection Examples |
| |
| For example to compute the CRC of the input, and store it in the file |
| @file{out.crc}: |
| @example |
| ffmpeg -i INPUT -f crc out.crc |
| @end example |
| |
| You can print the CRC to stdout with the command: |
| @example |
| ffmpeg -i INPUT -f crc - |
| @end example |
| |
| You can select the output format of each frame with @command{ffmpeg} by |
| specifying the audio and video codec and format. For example to |
| compute the CRC of the input audio converted to PCM unsigned 8-bit |
| and the input video converted to MPEG-2 video, use the command: |
| @example |
| ffmpeg -i INPUT -c:a pcm_u8 -c:v mpeg2video -f crc - |
| @end example |
| |
| @anchor{framecrc} |
| @section framecrc |
| |
| Per-packet CRC (Cyclic Redundancy Check) testing format. |
| |
| This muxer computes and prints the Adler-32 CRC for each audio |
| and video packet. By default audio frames are converted to signed |
| 16-bit raw audio and video frames to raw video before computing the |
| CRC. |
| |
| The output of the muxer consists of a line for each audio and video |
| packet of the form: |
| @example |
| @var{stream_index}, @var{packet_dts}, @var{packet_pts}, @var{packet_duration}, @var{packet_size}, 0x@var{CRC} |
| @end example |
| |
| @var{CRC} is a hexadecimal number 0-padded to 8 digits containing the |
| CRC of the packet. |
| |
| @subsection Examples |
| |
| For example to compute the CRC of the audio and video frames in |
| @file{INPUT}, converted to raw audio and video packets, and store it |
| in the file @file{out.crc}: |
| @example |
| ffmpeg -i INPUT -f framecrc out.crc |
| @end example |
| |
| To print the information to stdout, use the command: |
| @example |
| ffmpeg -i INPUT -f framecrc - |
| @end example |
| |
| With @command{ffmpeg}, you can select the output format to which the |
| audio and video frames are encoded before computing the CRC for each |
| packet by specifying the audio and video codec. For example, to |
| compute the CRC of each decoded input audio frame converted to PCM |
| unsigned 8-bit and of each decoded input video frame converted to |
| MPEG-2 video, use the command: |
| @example |
| ffmpeg -i INPUT -c:a pcm_u8 -c:v mpeg2video -f framecrc - |
| @end example |
| |
| See also the @ref{crc} muxer. |
| |
| @anchor{framemd5} |
| @section framemd5 |
| |
| Per-packet MD5 testing format. |
| |
| This muxer computes and prints the MD5 hash for each audio |
| and video packet. By default audio frames are converted to signed |
| 16-bit raw audio and video frames to raw video before computing the |
| hash. |
| |
| The output of the muxer consists of a line for each audio and video |
| packet of the form: |
| @example |
| @var{stream_index}, @var{packet_dts}, @var{packet_pts}, @var{packet_duration}, @var{packet_size}, @var{MD5} |
| @end example |
| |
| @var{MD5} is a hexadecimal number representing the computed MD5 hash |
| for the packet. |
| |
| @subsection Examples |
| |
| For example to compute the MD5 of the audio and video frames in |
| @file{INPUT}, converted to raw audio and video packets, and store it |
| in the file @file{out.md5}: |
| @example |
| ffmpeg -i INPUT -f framemd5 out.md5 |
| @end example |
| |
| To print the information to stdout, use the command: |
| @example |
| ffmpeg -i INPUT -f framemd5 - |
| @end example |
| |
| See also the @ref{md5} muxer. |
| |
| @anchor{gif} |
| @section gif |
| |
| Animated GIF muxer. |
| |
| It accepts the following options: |
| |
| @table @option |
| @item loop |
| Set the number of times to loop the output. Use @code{-1} for no loop, @code{0} |
| for looping indefinitely (default). |
| |
| @item final_delay |
| Force the delay (expressed in centiseconds) after the last frame. Each frame |
| ends with a delay until the next frame. The default is @code{-1}, which is a |
| special value to tell the muxer to re-use the previous delay. In case of a |
| loop, you might want to customize this value to mark a pause for instance. |
| @end table |
| |
| For example, to encode a gif looping 10 times, with a 5 seconds delay between |
| the loops: |
| @example |
| ffmpeg -i INPUT -loop 10 -final_delay 500 out.gif |
| @end example |
| |
| Note 1: if you wish to extract the frames in separate GIF files, you need to |
| force the @ref{image2} muxer: |
| @example |
| ffmpeg -i INPUT -c:v gif -f image2 "out%d.gif" |
| @end example |
| |
| Note 2: the GIF format has a very small time base: the delay between two frames |
| can not be smaller than one centi second. |
| |
| @anchor{hls} |
| @section hls |
| |
| Apple HTTP Live Streaming muxer that segments MPEG-TS according to |
| the HTTP Live Streaming (HLS) specification. |
| |
| It creates a playlist file, and one or more segment files. The output filename |
| specifies the playlist filename. |
| |
| By default, the muxer creates a file for each segment produced. These files |
| have the same name as the playlist, followed by a sequential number and a |
| .ts extension. |
| |
| For example, to convert an input file with @command{ffmpeg}: |
| @example |
| ffmpeg -i in.nut out.m3u8 |
| @end example |
| This example will produce the playlist, @file{out.m3u8}, and segment files: |
| @file{out0.ts}, @file{out1.ts}, @file{out2.ts}, etc. |
| |
| See also the @ref{segment} muxer, which provides a more generic and |
| flexible implementation of a segmenter, and can be used to perform HLS |
| segmentation. |
| |
| @subsection Options |
| |
| This muxer supports the following options: |
| |
| @table @option |
| @item hls_time @var{seconds} |
| Set the segment length in seconds. Default value is 2. |
| |
| @item hls_list_size @var{size} |
| Set the maximum number of playlist entries. If set to 0 the list file |
| will contain all the segments. Default value is 5. |
| |
| @item hls_ts_options @var{options_list} |
| Set output format options using a :-separated list of key=value |
| parameters. Values containing @code{:} special characters must be |
| escaped. |
| |
| @item hls_wrap @var{wrap} |
| Set the number after which the segment filename number (the number |
| specified in each segment file) wraps. If set to 0 the number will be |
| never wrapped. Default value is 0. |
| |
| This option is useful to avoid to fill the disk with many segment |
| files, and limits the maximum number of segment files written to disk |
| to @var{wrap}. |
| |
| @item start_number @var{number} |
| Start the playlist sequence number from @var{number}. Default value is |
| 0. |
| |
| @item hls_allow_cache @var{allowcache} |
| Explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments. |
| |
| @item hls_base_url @var{baseurl} |
| Append @var{baseurl} to every entry in the playlist. |
| Useful to generate playlists with absolute paths. |
| |
| Note that the playlist sequence number must be unique for each segment |
| and it is not to be confused with the segment filename sequence number |
| which can be cyclic, for example if the @option{wrap} option is |
| specified. |
| |
| @item hls_segment_filename @var{filename} |
| Set the segment filename. Unless hls_flags single_file is set @var{filename} |
| is used as a string format with the segment number: |
| @example |
| ffmpeg in.nut -hls_segment_filename 'file%03d.ts' out.m3u8 |
| @end example |
| This example will produce the playlist, @file{out.m3u8}, and segment files: |
| @file{file000.ts}, @file{file001.ts}, @file{file002.ts}, etc. |
| |
| @item hls_flags single_file |
| If this flag is set, the muxer will store all segments in a single MPEG-TS |
| file, and will use byte ranges in the playlist. HLS playlists generated with |
| this way will have the version number 4. |
| For example: |
| @example |
| ffmpeg -i in.nut -hls_flags single_file out.m3u8 |
| @end example |
| Will produce the playlist, @file{out.m3u8}, and a single segment file, |
| @file{out.ts}. |
| |
| @item hls_flags delete_segments |
| Segment files removed from the playlist are deleted after a period of time |
| equal to the duration of the segment plus the duration of the playlist. |
| @end table |
| |
| @anchor{ico} |
| @section ico |
| |
| ICO file muxer. |
| |
| Microsoft's icon file format (ICO) has some strict limitations that should be noted: |
| |
| @itemize |
| @item |
| Size cannot exceed 256 pixels in any dimension |
| |
| @item |
| Only BMP and PNG images can be stored |
| |
| @item |
| If a BMP image is used, it must be one of the following pixel formats: |
| @example |
| BMP Bit Depth FFmpeg Pixel Format |
| 1bit pal8 |
| 4bit pal8 |
| 8bit pal8 |
| 16bit rgb555le |
| 24bit bgr24 |
| 32bit bgra |
| @end example |
| |
| @item |
| If a BMP image is used, it must use the BITMAPINFOHEADER DIB header |
| |
| @item |
| If a PNG image is used, it must use the rgba pixel format |
| @end itemize |
| |
| @anchor{image2} |
| @section image2 |
| |
| Image file muxer. |
| |
| The image file muxer writes video frames to image files. |
| |
| The output filenames are specified by a pattern, which can be used to |
| produce sequentially numbered series of files. |
| The pattern may contain the string "%d" or "%0@var{N}d", this string |
| specifies the position of the characters representing a numbering in |
| the filenames. If the form "%0@var{N}d" is used, the string |
| representing the number in each filename is 0-padded to @var{N} |
| digits. The literal character '%' can be specified in the pattern with |
| the string "%%". |
| |
| If the pattern contains "%d" or "%0@var{N}d", the first filename of |
| the file list specified will contain the number 1, all the following |
| numbers will be sequential. |
| |
| The pattern may contain a suffix which is used to automatically |
| determine the format of the image files to write. |
| |
| For example the pattern "img-%03d.bmp" will specify a sequence of |
| filenames of the form @file{img-001.bmp}, @file{img-002.bmp}, ..., |
| @file{img-010.bmp}, etc. |
| The pattern "img%%-%d.jpg" will specify a sequence of filenames of the |
| form @file{img%-1.jpg}, @file{img%-2.jpg}, ..., @file{img%-10.jpg}, |
| etc. |
| |
| @subsection Examples |
| |
| The following example shows how to use @command{ffmpeg} for creating a |
| sequence of files @file{img-001.jpeg}, @file{img-002.jpeg}, ..., |
| taking one image every second from the input video: |
| @example |
| ffmpeg -i in.avi -vsync 1 -r 1 -f image2 'img-%03d.jpeg' |
| @end example |
| |
| Note that with @command{ffmpeg}, if the format is not specified with the |
| @code{-f} option and the output filename specifies an image file |
| format, the image2 muxer is automatically selected, so the previous |
| command can be written as: |
| @example |
| ffmpeg -i in.avi -vsync 1 -r 1 'img-%03d.jpeg' |
| @end example |
| |
| Note also that the pattern must not necessarily contain "%d" or |
| "%0@var{N}d", for example to create a single image file |
| @file{img.jpeg} from the input video you can employ the command: |
| @example |
| ffmpeg -i in.avi -f image2 -frames:v 1 img.jpeg |
| @end example |
| |
| The @option{strftime} option allows you to expand the filename with |
| date and time information. Check the documentation of |
| the @code{strftime()} function for the syntax. |
| |
| For example to generate image files from the @code{strftime()} |
| "%Y-%m-%d_%H-%M-%S" pattern, the following @command{ffmpeg} command |
| can be used: |
| @example |
| ffmpeg -f v4l2 -r 1 -i /dev/video0 -f image2 -strftime 1 "%Y-%m-%d_%H-%M-%S.jpg" |
| @end example |
| |
| @subsection Options |
| |
| @table @option |
| @item start_number |
| Start the sequence from the specified number. Default value is 0. |
| |
| @item update |
| If set to 1, the filename will always be interpreted as just a |
| filename, not a pattern, and the corresponding file will be continuously |
| overwritten with new images. Default value is 0. |
| |
| @item strftime |
| If set to 1, expand the filename with date and time information from |
| @code{strftime()}. Default value is 0. |
| @end table |
| |
| The image muxer supports the .Y.U.V image file format. This format is |
| special in that that each image frame consists of three files, for |
| each of the YUV420P components. To read or write this image file format, |
| specify the name of the '.Y' file. The muxer will automatically open the |
| '.U' and '.V' files as required. |
| |
| @section matroska |
| |
| Matroska container muxer. |
| |
| This muxer implements the matroska and webm container specs. |
| |
| @subsection Metadata |
| |
| The recognized metadata settings in this muxer are: |
| |
| @table @option |
| @item title |
| Set title name provided to a single track. |
| |
| @item language |
| Specify the language of the track in the Matroska languages form. |
| |
| The language can be either the 3 letters bibliographic ISO-639-2 (ISO |
| 639-2/B) form (like "fre" for French), or a language code mixed with a |
| country code for specialities in languages (like "fre-ca" for Canadian |
| French). |
| |
| @item stereo_mode |
| Set stereo 3D video layout of two views in a single video track. |
| |
| The following values are recognized: |
| @table @samp |
| @item mono |
| video is not stereo |
| @item left_right |
| Both views are arranged side by side, Left-eye view is on the left |
| @item bottom_top |
| Both views are arranged in top-bottom orientation, Left-eye view is at bottom |
| @item top_bottom |
| Both views are arranged in top-bottom orientation, Left-eye view is on top |
| @item checkerboard_rl |
| Each view is arranged in a checkerboard interleaved pattern, Left-eye view being first |
| @item checkerboard_lr |
| Each view is arranged in a checkerboard interleaved pattern, Right-eye view being first |
| @item row_interleaved_rl |
| Each view is constituted by a row based interleaving, Right-eye view is first row |
| @item row_interleaved_lr |
| Each view is constituted by a row based interleaving, Left-eye view is first row |
| @item col_interleaved_rl |
| Both views are arranged in a column based interleaving manner, Right-eye view is first column |
| @item col_interleaved_lr |
| Both views are arranged in a column based interleaving manner, Left-eye view is first column |
| @item anaglyph_cyan_red |
| All frames are in anaglyph format viewable through red-cyan filters |
| @item right_left |
| Both views are arranged side by side, Right-eye view is on the left |
| @item anaglyph_green_magenta |
| All frames are in anaglyph format viewable through green-magenta filters |
| @item block_lr |
| Both eyes laced in one Block, Left-eye view is first |
| @item block_rl |
| Both eyes laced in one Block, Right-eye view is first |
| @end table |
| @end table |
| |
| For example a 3D WebM clip can be created using the following command line: |
| @example |
| ffmpeg -i sample_left_right_clip.mpg -an -c:v libvpx -metadata stereo_mode=left_right -y stereo_clip.webm |
| @end example |
| |
| @subsection Options |
| |
| This muxer supports the following options: |
| |
| @table @option |
| @item reserve_index_space |
| By default, this muxer writes the index for seeking (called cues in Matroska |
| terms) at the end of the file, because it cannot know in advance how much space |
| to leave for the index at the beginning of the file. However for some use cases |
| -- e.g. streaming where seeking is possible but slow -- it is useful to put the |
| index at the beginning of the file. |
| |
| If this option is set to a non-zero value, the muxer will reserve a given amount |
| of space in the file header and then try to write the cues there when the muxing |
| finishes. If the available space does not suffice, muxing will fail. A safe size |
| for most use cases should be about 50kB per hour of video. |
| |
| Note that cues are only written if the output is seekable and this option will |
| have no effect if it is not. |
| @end table |
| |
| @anchor{md5} |
| @section md5 |
| |
| MD5 testing format. |
| |
| This muxer computes and prints the MD5 hash of all the input audio |
| and video frames. By default audio frames are converted to signed |
| 16-bit raw audio and video frames to raw video before computing the |
| hash. |
| |
| The output of the muxer consists of a single line of the form: |
| MD5=@var{MD5}, where @var{MD5} is a hexadecimal number representing |
| the computed MD5 hash. |
| |
| For example to compute the MD5 hash of the input converted to raw |
| audio and video, and store it in the file @file{out.md5}: |
| @example |
| ffmpeg -i INPUT -f md5 out.md5 |
| @end example |
| |
| You can print the MD5 to stdout with the command: |
| @example |
| ffmpeg -i INPUT -f md5 - |
| @end example |
| |
| See also the @ref{framemd5} muxer. |
| |
| @section mov, mp4, ismv |
| |
| MOV/MP4/ISMV (Smooth Streaming) muxer. |
| |
| The mov/mp4/ismv muxer supports fragmentation. Normally, a MOV/MP4 |
| file has all the metadata about all packets stored in one location |
| (written at the end of the file, it can be moved to the start for |
| better playback by adding @var{faststart} to the @var{movflags}, or |
| using the @command{qt-faststart} tool). A fragmented |
| file consists of a number of fragments, where packets and metadata |
| about these packets are stored together. Writing a fragmented |
| file has the advantage that the file is decodable even if the |
| writing is interrupted (while a normal MOV/MP4 is undecodable if |
| it is not properly finished), and it requires less memory when writing |
| very long files (since writing normal MOV/MP4 files stores info about |
| every single packet in memory until the file is closed). The downside |
| is that it is less compatible with other applications. |
| |
| @subsection Options |
| |
| Fragmentation is enabled by setting one of the AVOptions that define |
| how to cut the file into fragments: |
| |
| @table @option |
| @item -moov_size @var{bytes} |
| Reserves space for the moov atom at the beginning of the file instead of placing the |
| moov atom at the end. If the space reserved is insufficient, muxing will fail. |
| @item -movflags frag_keyframe |
| Start a new fragment at each video keyframe. |
| @item -frag_duration @var{duration} |
| Create fragments that are @var{duration} microseconds long. |
| @item -frag_size @var{size} |
| Create fragments that contain up to @var{size} bytes of payload data. |
| @item -movflags frag_custom |
| Allow the caller to manually choose when to cut fragments, by |
| calling @code{av_write_frame(ctx, NULL)} to write a fragment with |
| the packets written so far. (This is only useful with other |
| applications integrating libavformat, not from @command{ffmpeg}.) |
| @item -min_frag_duration @var{duration} |
| Don't create fragments that are shorter than @var{duration} microseconds long. |
| @end table |
| |
| If more than one condition is specified, fragments are cut when |
| one of the specified conditions is fulfilled. The exception to this is |
| @code{-min_frag_duration}, which has to be fulfilled for any of the other |
| conditions to apply. |
| |
| Additionally, the way the output file is written can be adjusted |
| through a few other options: |
| |
| @table @option |
| @item -movflags empty_moov |
| Write an initial moov atom directly at the start of the file, without |
| describing any samples in it. Generally, an mdat/moov pair is written |
| at the start of the file, as a normal MOV/MP4 file, containing only |
| a short portion of the file. With this option set, there is no initial |
| mdat atom, and the moov atom only describes the tracks but has |
| a zero duration. |
| |
| This option is implicitly set when writing ismv (Smooth Streaming) files. |
| @item -movflags separate_moof |
| Write a separate moof (movie fragment) atom for each track. Normally, |
| packets for all tracks are written in a moof atom (which is slightly |
| more efficient), but with this option set, the muxer writes one moof/mdat |
| pair for each track, making it easier to separate tracks. |
| |
| This option is implicitly set when writing ismv (Smooth Streaming) files. |
| @item -movflags faststart |
| Run a second pass moving the index (moov atom) to the beginning of the file. |
| This operation can take a while, and will not work in various situations such |
| as fragmented output, thus it is not enabled by default. |
| @item -movflags rtphint |
| Add RTP hinting tracks to the output file. |
| @item -movflags disable_chpl |
| Disable Nero chapter markers (chpl atom). Normally, both Nero chapters |
| and a QuickTime chapter track are written to the file. With this option |
| set, only the QuickTime chapter track will be written. Nero chapters can |
| cause failures when the file is reprocessed with certain tagging programs, like |
| mp3Tag 2.61a and iTunes 11.3, most likely other versions are affected as well. |
| @item -movflags omit_tfhd_offset |
| Do not write any absolute base_data_offset in tfhd atoms. This avoids |
| tying fragments to absolute byte positions in the file/streams. |
| @item -movflags default_base_moof |
| Similarly to the omit_tfhd_offset, this flag avoids writing the |
| absolute base_data_offset field in tfhd atoms, but does so by using |
| the new default-base-is-moof flag instead. This flag is new from |
| 14496-12:2012. This may make the fragments easier to parse in certain |
| circumstances (avoiding basing track fragment location calculations |
| on the implicit end of the previous track fragment). |
| @end table |
| |
| @subsection Example |
| |
| Smooth Streaming content can be pushed in real time to a publishing |
| point on IIS with this muxer. Example: |
| @example |
| ffmpeg -re @var{<normal input/transcoding options>} -movflags isml+frag_keyframe -f ismv http://server/publishingpoint.isml/Streams(Encoder1) |
| @end example |
| |
| @section mp3 |
| |
| The MP3 muxer writes a raw MP3 stream with the following optional features: |
| @itemize @bullet |
| @item |
| An ID3v2 metadata header at the beginning (enabled by default). Versions 2.3 and |
| 2.4 are supported, the @code{id3v2_version} private option controls which one is |
| used (3 or 4). Setting @code{id3v2_version} to 0 disables the ID3v2 header |
| completely. |
| |
| The muxer supports writing attached pictures (APIC frames) to the ID3v2 header. |
| The pictures are supplied to the muxer in form of a video stream with a single |
| packet. There can be any number of those streams, each will correspond to a |
| single APIC frame. The stream metadata tags @var{title} and @var{comment} map |
| to APIC @var{description} and @var{picture type} respectively. See |
| @url{http://id3.org/id3v2.4.0-frames} for allowed picture types. |
| |
| Note that the APIC frames must be written at the beginning, so the muxer will |
| buffer the audio frames until it gets all the pictures. It is therefore advised |
| to provide the pictures as soon as possible to avoid excessive buffering. |
| |
| @item |
| A Xing/LAME frame right after the ID3v2 header (if present). It is enabled by |
| default, but will be written only if the output is seekable. The |
| @code{write_xing} private option can be used to disable it. The frame contains |
| various information that may be useful to the decoder, like the audio duration |
| or encoder delay. |
| |
| @item |
| A legacy ID3v1 tag at the end of the file (disabled by default). It may be |
| enabled with the @code{write_id3v1} private option, but as its capabilities are |
| very limited, its usage is not recommended. |
| @end itemize |
| |
| Examples: |
| |
| Write an mp3 with an ID3v2.3 header and an ID3v1 footer: |
| @example |
| ffmpeg -i INPUT -id3v2_version 3 -write_id3v1 1 out.mp3 |
| @end example |
| |
| To attach a picture to an mp3 file select both the audio and the picture stream |
| with @code{map}: |
| @example |
| ffmpeg -i input.mp3 -i cover.png -c copy -map 0 -map 1 |
| -metadata:s:v title="Album cover" -metadata:s:v comment="Cover (Front)" out.mp3 |
| @end example |
| |
| Write a "clean" MP3 without any extra features: |
| @example |
| ffmpeg -i input.wav -write_xing 0 -id3v2_version 0 out.mp3 |
| @end example |
| |
| @section mpegts |
| |
| MPEG transport stream muxer. |
| |
| This muxer implements ISO 13818-1 and part of ETSI EN 300 468. |
| |
| The recognized metadata settings in mpegts muxer are @code{service_provider} |
| and @code{service_name}. If they are not set the default for |
| @code{service_provider} is "FFmpeg" and the default for |
| @code{service_name} is "Service01". |
| |
| @subsection Options |
| |
| The muxer options are: |
| |
| @table @option |
| @item -mpegts_original_network_id @var{number} |
| Set the original_network_id (default 0x0001). This is unique identifier |
| of a network in DVB. Its main use is in the unique identification of a |
| service through the path Original_Network_ID, Transport_Stream_ID. |
| @item -mpegts_transport_stream_id @var{number} |
| Set the transport_stream_id (default 0x0001). This identifies a |
| transponder in DVB. |
| @item -mpegts_service_id @var{number} |
| Set the service_id (default 0x0001) also known as program in DVB. |
| @item -mpegts_service_type @var{number} |
| Set the program service_type (default @var{digital_tv}), see below |
| a list of pre defined values. |
| @item -mpegts_pmt_start_pid @var{number} |
| Set the first PID for PMT (default 0x1000, max 0x1f00). |
| @item -mpegts_start_pid @var{number} |
| Set the first PID for data packets (default 0x0100, max 0x0f00). |
| @item -mpegts_m2ts_mode @var{number} |
| Enable m2ts mode if set to 1. Default value is -1 which disables m2ts mode. |
| @item -muxrate @var{number} |
| Set a constant muxrate (default VBR). |
| @item -pcr_period @var{numer} |
| Override the default PCR retransmission time (default 20ms), ignored |
| if variable muxrate is selected. |
| @item -pes_payload_size @var{number} |
| Set minimum PES packet payload in bytes. |
| @item -mpegts_flags @var{flags} |
| Set flags (see below). |
| @item -mpegts_copyts @var{number} |
| Preserve original timestamps, if value is set to 1. Default value is -1, which |
| results in shifting timestamps so that they start from 0. |
| @item -tables_version @var{number} |
| Set PAT, PMT and SDT version (default 0, valid values are from 0 to 31, inclusively). |
| This option allows updating stream structure so that standard consumer may |
| detect the change. To do so, reopen output AVFormatContext (in case of API |
| usage) or restart ffmpeg instance, cyclically changing tables_version value: |
| @example |
| ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111 |
| ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111 |
| ... |
| ffmpeg -i source3.ts -codec copy -f mpegts -tables_version 31 udp://1.1.1.1:1111 |
| ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111 |
| ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111 |
| ... |
| @end example |
| @end table |
| |
| Option mpegts_service_type accepts the following values: |
| |
| @table @option |
| @item hex_value |
| Any hexdecimal value between 0x01 to 0xff as defined in ETSI 300 468. |
| @item digital_tv |
| Digital TV service. |
| @item digital_radio |
| Digital Radio service. |
| @item teletext |
| Teletext service. |
| @item advanced_codec_digital_radio |
| Advanced Codec Digital Radio service. |
| @item mpeg2_digital_hdtv |
| MPEG2 Digital HDTV service. |
| @item advanced_codec_digital_sdtv |
| Advanced Codec Digital SDTV service. |
| @item advanced_codec_digital_hdtv |
| Advanced Codec Digital HDTV service. |
| @end table |
| |
| Option mpegts_flags may take a set of such flags: |
| |
| @table @option |
| @item resend_headers |
| Reemit PAT/PMT before writing the next packet. |
| @item latm |
| Use LATM packetization for AAC. |
| @end table |
| |
| @subsection Example |
| |
| @example |
| ffmpeg -i file.mpg -c copy \ |
| -mpegts_original_network_id 0x1122 \ |
| -mpegts_transport_stream_id 0x3344 \ |
| -mpegts_service_id 0x5566 \ |
| -mpegts_pmt_start_pid 0x1500 \ |
| -mpegts_start_pid 0x150 \ |
| -metadata service_provider="Some provider" \ |
| -metadata service_name="Some Channel" \ |
| -y out.ts |
| @end example |
| |
| @section null |
| |
| Null muxer. |
| |
| This muxer does not generate any output file, it is mainly useful for |
| testing or benchmarking purposes. |
| |
| For example to benchmark decoding with @command{ffmpeg} you can use the |
| command: |
| @example |
| ffmpeg -benchmark -i INPUT -f null out.null |
| @end example |
| |
| Note that the above command does not read or write the @file{out.null} |
| file, but specifying the output file is required by the @command{ffmpeg} |
| syntax. |
| |
| Alternatively you can write the command as: |
| @example |
| ffmpeg -benchmark -i INPUT -f null - |
| @end example |
| |
| @section nut |
| |
| @table @option |
| @item -syncpoints @var{flags} |
| Change the syncpoint usage in nut: |
| @table @option |
| @item @var{default} use the normal low-overhead seeking aids. |
| @item @var{none} do not use the syncpoints at all, reducing the overhead but making the stream non-seekable; |
| Use of this option is not recommended, as the resulting files are very damage |
| sensitive and seeking is not possible. Also in general the overhead from |
| syncpoints is negligible. Note, -@code{write_index} 0 can be used to disable |
| all growing data tables, allowing to mux endless streams with limited memory |
| and without these disadvantages. |
| @item @var{timestamped} extend the syncpoint with a wallclock field. |
| @end table |
| The @var{none} and @var{timestamped} flags are experimental. |
| @item -write_index @var{bool} |
| Write index at the end, the default is to write an index. |
| @end table |
| |
| @example |
| ffmpeg -i INPUT -f_strict experimental -syncpoints none - | processor |
| @end example |
| |
| @section ogg |
| |
| Ogg container muxer. |
| |
| @table @option |
| @item -page_duration @var{duration} |
| Preferred page duration, in microseconds. The muxer will attempt to create |
| pages that are approximately @var{duration} microseconds long. This allows the |
| user to compromise between seek granularity and container overhead. The default |
| is 1 second. A value of 0 will fill all segments, making pages as large as |
| possible. A value of 1 will effectively use 1 packet-per-page in most |
| situations, giving a small seek granularity at the cost of additional container |
| overhead. |
| @item -serial_offset @var{value} |
| Serial value from which to set the streams serial number. |
| Setting it to different and sufficiently large values ensures that the produced |
| ogg files can be safely chained. |
| |
| @end table |
| |
| @anchor{segment} |
| @section segment, stream_segment, ssegment |
| |
| Basic stream segmenter. |
| |
| This muxer outputs streams to a number of separate files of nearly |
| fixed duration. Output filename pattern can be set in a fashion |
| similar to @ref{image2}, or by using a @code{strftime} template if |
| the @option{strftime} option is enabled. |
| |
| @code{stream_segment} is a variant of the muxer used to write to |
| streaming output formats, i.e. which do not require global headers, |
| and is recommended for outputting e.g. to MPEG transport stream segments. |
| @code{ssegment} is a shorter alias for @code{stream_segment}. |
| |
| Every segment starts with a keyframe of the selected reference stream, |
| which is set through the @option{reference_stream} option. |
| |
| Note that if you want accurate splitting for a video file, you need to |
| make the input key frames correspond to the exact splitting times |
| expected by the segmenter, or the segment muxer will start the new |
| segment with the key frame found next after the specified start |
| time. |
| |
| The segment muxer works best with a single constant frame rate video. |
| |
| Optionally it can generate a list of the created segments, by setting |
| the option @var{segment_list}. The list type is specified by the |
| @var{segment_list_type} option. The entry filenames in the segment |
| list are set by default to the basename of the corresponding segment |
| files. |
| |
| See also the @ref{hls} muxer, which provides a more specific |
| implementation for HLS segmentation. |
| |
| @subsection Options |
| |
| The segment muxer supports the following options: |
| |
| @table @option |
| @item reference_stream @var{specifier} |
| Set the reference stream, as specified by the string @var{specifier}. |
| If @var{specifier} is set to @code{auto}, the reference is chosen |
| automatically. Otherwise it must be a stream specifier (see the ``Stream |
| specifiers'' chapter in the ffmpeg manual) which specifies the |
| reference stream. The default value is @code{auto}. |
| |
| @item segment_format @var{format} |
| Override the inner container format, by default it is guessed by the filename |
| extension. |
| |
| @item segment_format_options @var{options_list} |
| Set output format options using a :-separated list of key=value |
| parameters. Values containing the @code{:} special character must be |
| escaped. |
| |
| @item segment_list @var{name} |
| Generate also a listfile named @var{name}. If not specified no |
| listfile is generated. |
| |
| @item segment_list_flags @var{flags} |
| Set flags affecting the segment list generation. |
| |
| It currently supports the following flags: |
| @table @samp |
| @item cache |
| Allow caching (only affects M3U8 list files). |
| |
| @item live |
| Allow live-friendly file generation. |
| @end table |
| |
| @item segment_list_type @var{type} |
| Select the listing format. |
| @table @option |
| @item @var{flat} use a simple flat list of entries. |
| @item @var{hls} use a m3u8-like structure. |
| @end table |
| |
| @item segment_list_size @var{size} |
| Update the list file so that it contains at most @var{size} |
| segments. If 0 the list file will contain all the segments. Default |
| value is 0. |
| |
| @item segment_list_entry_prefix @var{prefix} |
| Prepend @var{prefix} to each entry. Useful to generate absolute paths. |
| By default no prefix is applied. |
| |
| The following values are recognized: |
| @table @samp |
| @item flat |
| Generate a flat list for the created segments, one segment per line. |
| |
| @item csv, ext |
| Generate a list for the created segments, one segment per line, |
| each line matching the format (comma-separated values): |
| @example |
| @var{segment_filename},@var{segment_start_time},@var{segment_end_time} |
| @end example |
| |
| @var{segment_filename} is the name of the output file generated by the |
| muxer according to the provided pattern. CSV escaping (according to |
| RFC4180) is applied if required. |
| |
| @var{segment_start_time} and @var{segment_end_time} specify |
| the segment start and end time expressed in seconds. |
| |
| A list file with the suffix @code{".csv"} or @code{".ext"} will |
| auto-select this format. |
| |
| @samp{ext} is deprecated in favor or @samp{csv}. |
| |
| @item ffconcat |
| Generate an ffconcat file for the created segments. The resulting file |
| can be read using the FFmpeg @ref{concat} demuxer. |
| |
| A list file with the suffix @code{".ffcat"} or @code{".ffconcat"} will |
| auto-select this format. |
| |
| @item m3u8 |
| Generate an extended M3U8 file, version 3, compliant with |
| @url{http://tools.ietf.org/id/draft-pantos-http-live-streaming}. |
| |
| A list file with the suffix @code{".m3u8"} will auto-select this format. |
| @end table |
| |
| If not specified the type is guessed from the list file name suffix. |
| |
| @item segment_time @var{time} |
| Set segment duration to @var{time}, the value must be a duration |
| specification. Default value is "2". See also the |
| @option{segment_times} option. |
| |
| Note that splitting may not be accurate, unless you force the |
| reference stream key-frames at the given time. See the introductory |
| notice and the examples below. |
| |
| @item segment_atclocktime @var{1|0} |
| If set to "1" split at regular clock time intervals starting from 00:00 |
| o'clock. The @var{time} value specified in @option{segment_time} is |
| used for setting the length of the splitting interval. |
| |
| For example with @option{segment_time} set to "900" this makes it possible |
| to create files at 12:00 o'clock, 12:15, 12:30, etc. |
| |
| Default value is "0". |
| |
| @item segment_time_delta @var{delta} |
| Specify the accuracy time when selecting the start time for a |
| segment, expressed as a duration specification. Default value is "0". |
| |
| When delta is specified a key-frame will start a new segment if its |
| PTS satisfies the relation: |
| @example |
| PTS >= start_time - time_delta |
| @end example |
| |
| This option is useful when splitting video content, which is always |
| split at GOP boundaries, in case a key frame is found just before the |
| specified split time. |
| |
| In particular may be used in combination with the @file{ffmpeg} option |
| @var{force_key_frames}. The key frame times specified by |
| @var{force_key_frames} may not be set accurately because of rounding |
| issues, with the consequence that a key frame time may result set just |
| before the specified time. For constant frame rate videos a value of |
| 1/(2*@var{frame_rate}) should address the worst case mismatch between |
| the specified time and the time set by @var{force_key_frames}. |
| |
| @item segment_times @var{times} |
| Specify a list of split points. @var{times} contains a list of comma |
| separated duration specifications, in increasing order. See also |
| the @option{segment_time} option. |
| |
| @item segment_frames @var{frames} |
| Specify a list of split video frame numbers. @var{frames} contains a |
| list of comma separated integer numbers, in increasing order. |
| |
| This option specifies to start a new segment whenever a reference |
| stream key frame is found and the sequential number (starting from 0) |
| of the frame is greater or equal to the next value in the list. |
| |
| @item segment_wrap @var{limit} |
| Wrap around segment index once it reaches @var{limit}. |
| |
| @item segment_start_number @var{number} |
| Set the sequence number of the first segment. Defaults to @code{0}. |
| |
| @item strftime @var{1|0} |
| Use the @code{strftime} function to define the name of the new |
| segments to write. If this is selected, the output segment name must |
| contain a @code{strftime} function template. Default value is |
| @code{0}. |
| |
| @item reset_timestamps @var{1|0} |
| Reset timestamps at the begin of each segment, so that each segment |
| will start with near-zero timestamps. It is meant to ease the playback |
| of the generated segments. May not work with some combinations of |
| muxers/codecs. It is set to @code{0} by default. |
| |
| @item initial_offset @var{offset} |
| Specify timestamp offset to apply to the output packet timestamps. The |
| argument must be a time duration specification, and defaults to 0. |
| @end table |
| |
| @subsection Examples |
| |
| @itemize |
| @item |
| Remux the content of file @file{in.mkv} to a list of segments |
| @file{out-000.nut}, @file{out-001.nut}, etc., and write the list of |
| generated segments to @file{out.list}: |
| @example |
| ffmpeg -i in.mkv -codec copy -map 0 -f segment -segment_list out.list out%03d.nut |
| @end example |
| |
| @item |
| Segment input and set output format options for the output segments: |
| @example |
| ffmpeg -i in.mkv -f segment -segment_time 10 -segment_format_options movflags=+faststart out%03d.mp4 |
| @end example |
| |
| @item |
| Segment the input file according to the split points specified by the |
| @var{segment_times} option: |
| @example |
| ffmpeg -i in.mkv -codec copy -map 0 -f segment -segment_list out.csv -segment_times 1,2,3,5,8,13,21 out%03d.nut |
| @end example |
| |
| @item |
| Use the @command{ffmpeg} @option{force_key_frames} |
| option to force key frames in the input at the specified location, together |
| with the segment option @option{segment_time_delta} to account for |
| possible roundings operated when setting key frame times. |
| @example |
| ffmpeg -i in.mkv -force_key_frames 1,2,3,5,8,13,21 -codec:v mpeg4 -codec:a pcm_s16le -map 0 \ |
| -f segment -segment_list out.csv -segment_times 1,2,3,5,8,13,21 -segment_time_delta 0.05 out%03d.nut |
| @end example |
| In order to force key frames on the input file, transcoding is |
| required. |
| |
| @item |
| Segment the input file by splitting the input file according to the |
| frame numbers sequence specified with the @option{segment_frames} option: |
| @example |
| ffmpeg -i in.mkv -codec copy -map 0 -f segment -segment_list out.csv -segment_frames 100,200,300,500,800 out%03d.nut |
| @end example |
| |
| @item |
| Convert the @file{in.mkv} to TS segments using the @code{libx264} |
| and @code{libfaac} encoders: |
| @example |
| ffmpeg -i in.mkv -map 0 -codec:v libx264 -codec:a libfaac -f ssegment -segment_list out.list out%03d.ts |
| @end example |
| |
| @item |
| Segment the input file, and create an M3U8 live playlist (can be used |
| as live HLS source): |
| @example |
| ffmpeg -re -i in.mkv -codec copy -map 0 -f segment -segment_list playlist.m3u8 \ |
| -segment_list_flags +live -segment_time 10 out%03d.mkv |
| @end example |
| @end itemize |
| |
| @section smoothstreaming |
| |
| Smooth Streaming muxer generates a set of files (Manifest, chunks) suitable for serving with conventional web server. |
| |
| @table @option |
| @item window_size |
| Specify the number of fragments kept in the manifest. Default 0 (keep all). |
| |
| @item extra_window_size |
| Specify the number of fragments kept outside of the manifest before removing from disk. Default 5. |
| |
| @item lookahead_count |
| Specify the number of lookahead fragments. Default 2. |
| |
| @item min_frag_duration |
| Specify the minimum fragment duration (in microseconds). Default 5000000. |
| |
| @item remove_at_exit |
| Specify whether to remove all fragments when finished. Default 0 (do not remove). |
| |
| @end table |
| |
| @section tee |
| |
| The tee muxer can be used to write the same data to several files or any |
| other kind of muxer. It can be used, for example, to both stream a video to |
| the network and save it to disk at the same time. |
| |
| It is different from specifying several outputs to the @command{ffmpeg} |
| command-line tool because the audio and video data will be encoded only once |
| with the tee muxer; encoding can be a very expensive process. It is not |
| useful when using the libavformat API directly because it is then possible |
| to feed the same packets to several muxers directly. |
| |
| The slave outputs are specified in the file name given to the muxer, |
| separated by '|'. If any of the slave name contains the '|' separator, |
| leading or trailing spaces or any special character, it must be |
| escaped (see @ref{quoting_and_escaping,,the "Quoting and escaping" |
| section in the ffmpeg-utils(1) manual,ffmpeg-utils}). |
| |
| Muxer options can be specified for each slave by prepending them as a list of |
| @var{key}=@var{value} pairs separated by ':', between square brackets. If |
| the options values contain a special character or the ':' separator, they |
| must be escaped; note that this is a second level escaping. |
| |
| The following special options are also recognized: |
| @table @option |
| @item f |
| Specify the format name. Useful if it cannot be guessed from the |
| output name suffix. |
| |
| @item bsfs[/@var{spec}] |
| Specify a list of bitstream filters to apply to the specified |
| output. |
| |
| It is possible to specify to which streams a given bitstream filter |
| applies, by appending a stream specifier to the option separated by |
| @code{/}. @var{spec} must be a stream specifier (see @ref{Format |
| stream specifiers}). If the stream specifier is not specified, the |
| bitstream filters will be applied to all streams in the output. |
| |
| Several bitstream filters can be specified, separated by ",". |
| |
| @item select |
| Select the streams that should be mapped to the slave output, |
| specified by a stream specifier. If not specified, this defaults to |
| all the input streams. |
| @end table |
| |
| @subsection Examples |
| |
| @itemize |
| @item |
| Encode something and both archive it in a WebM file and stream it |
| as MPEG-TS over UDP (the streams need to be explicitly mapped): |
| @example |
| ffmpeg -i ... -c:v libx264 -c:a mp2 -f tee -map 0:v -map 0:a |
| "archive-20121107.mkv|[f=mpegts]udp://10.0.1.255:1234/" |
| @end example |
| |
| @item |
| Use @command{ffmpeg} to encode the input, and send the output |
| to three different destinations. The @code{dump_extra} bitstream |
| filter is used to add extradata information to all the output video |
| keyframes packets, as requested by the MPEG-TS format. The select |
| option is applied to @file{out.aac} in order to make it contain only |
| audio packets. |
| @example |
| ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac -strict experimental |
| -f tee "[bsfs/v=dump_extra]out.ts|[movflags=+faststart]out.mp4|[select=a]out.aac" |
| @end example |
| |
| @item |
| As below, but select only stream @code{a:1} for the audio output. Note |
| that a second level escaping must be performed, as ":" is a special |
| character used to separate options. |
| @example |
| ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac -strict experimental |
| -f tee "[bsfs/v=dump_extra]out.ts|[movflags=+faststart]out.mp4|[select=\'a:1\']out.aac" |
| @end example |
| @end itemize |
| |
| Note: some codecs may need different options depending on the output format; |
| the auto-detection of this can not work with the tee muxer. The main example |
| is the @option{global_header} flag. |
| |
| @section webm_dash_manifest |
| |
| WebM DASH Manifest muxer. |
| |
| This muxer implements the WebM DASH Manifest specification to generate the DASH manifest XML. |
| |
| @subsection Options |
| |
| This muxer supports the following options: |
| |
| @table @option |
| @item adaptation_sets |
| This option has the following syntax: "id=x,streams=a,b,c id=y,streams=d,e" where x and y are the |
| unique identifiers of the adaptation sets and a,b,c,d and e are the indices of the corresponding |
| audio and video streams. Any number of adaptation sets can be added using this option. |
| @end table |
| |
| @subsection Example |
| @example |
| ffmpeg -f webm_dash_manifest -i video1.webm \ |
| -f webm_dash_manifest -i video2.webm \ |
| -f webm_dash_manifest -i audio1.webm \ |
| -f webm_dash_manifest -i audio2.webm \ |
| -map 0 -map 1 -map 2 -map 3 \ |
| -c copy \ |
| -f webm_dash_manifest \ |
| -adaptation_sets "id=0,streams=0,1 id=1,streams=2,3" \ |
| manifest.xml |
| @end example |
| |
| @c man end MUXERS |