---
updatedAt: 2026-09-22T16:15:09.000Z
agentTools:
  projectIndex: https://api.encoding.com/llms.txt
---

# Video Settings

<a name="videosettings"></a>Here are the basic video settings available for every output, their compatibility with other settings, a description of what they do, and the defaults used if they aren't explicitly set.

```xml
<?xml version="1.0"?>
<query>
    <userid>[UserID]</userid> <!-- required-->
    <userkey>[UserKey]</userkey> <!-- required-->
    <action>AddMedia</action>
    <source>[SourceFile]</source> <!-- required-->
    <format> <!-- required -->
        <output>[output]</output> <!-- required -->
        <video_codec>[VideoCodec]</video_codec>
        <ftyp>[mp42|3gp5]</ftyp>
        <size>[WxH]</size>
        <keep_aspect_ratio>[yes|no]</keep_aspect_ratio>
        <set_aspect_ratio>[AspectRatio]</set_aspect_ratio>
        <bitrate>[BitRate]</bitrate>
        <bitrate_adjust>[yes|no]</bitrate_adjust>
        <maxrate>[MaxBitRate]</maxrate>
        <minrate>[MinBitRate]</minrate>
        <muxrate>[MuxRate]</muxrate>
        <cbr>[yes|no]</cbr>
        <framerate>[FrameRate|copy]</framerate>
        <framerate_upper_threshold>[FrameRateThreshold]</framerate_upper_threshold>
        <keyframe>[KeyFramePeriod]</keyframe>
        <force_keyframes>[KeyFramePosition]</force_keyframes>
        <video_sync>[SyncParam]</video_sync>
        <remove_grain>[RemoveGrainFilter]</remove_grain>
        <video_only>[yes|no]</video_only>
        <dc>[DCPrecision]</dc>
        <lmin>[MinLF]</lmin>
        <lmax>[MaxLF]</lmax>
        <rc_min_vbv_use>[MinRC]</rc_min_vbv_use>
        <rc_max_vbv_use>[MaxRC]</rc_max_vbv_use>
        <color_range>[ColorRange]</color_range>
        <colorspace>[ColorSpace]</colorspace>
        <color_primaries>[ColorPrimaries]</color_primaries>
        <color_trc>[ColorTRC]</color_trc>
        <transfer_characteristics>[TransferCharacteristics]</transfer_characteristics>
        <matrix_coefficients>[MatrixCoefficients]</matrix_coefficients>
        <scaler>[default|fast_bilinear|bilinear|bicubic|neighbor|area|bicublin|gauss|sinc]</scaler>
        <scaler_flags>[ScalerFlags]</scaler_flags>
        <video_tag>[Tag]</video_tag>
        <mxf_profile>[MXFProfile]</mxf_profile>
        <mxf_multiplex_type>[MXFMultiplex]</mxf_multiplex_type>
        <scaler_lib>[default|zscale]</scaler_lib>
        <alpha_mask>[yes|no]</alpha_mask>
        <framerate_interpolation>[yes|no]</framerate_interpolation>
        <framerate_method>[FrameRateConversionMethod]</framerate_method>
        <gxf_sequential_field_num>[yes|no]</gxf_sequential_field_num>
    </format>
</query>
```
```json
{
    "query": {
        "userid": "[UserID]", // required
        "userkey": "[UserKey]", // required
        "action": "AddMedia", // required
        "source": "[SourceFile]", // required
        "format": { // required
            "output": "[output]", // required
            "video_codec": "[VideoCodec]",
            "ftyp": "[mp42|3gp5]",
            "size": "[WxH]",
            "keep_aspect_ratio": "[yes|no]",
            "set_aspect_ratio": "[AspectRatio]",
            "bitrate": "[BitRate]",
            "bitrate_adjust": "[yes|no]",
            "maxrate": "[MaxBitRate]",
            "minrate": "[MinBitRate]",
            "muxrate": "[MuxRate]",
            "cbr": "[yes|no]",
            "framerate": "[FrameRate|copy]",
            "framerate_upper_threshold": "[FrameRateThreshold]",
            "keyframe": "[KeyFramePeriod]",
            "force_keyframes": "[KeyFramePosition]",
            "video_sync": "[SyncParam]",
            "remove_grain": "[RemoveGrainFilter]",
            "video_only": "[yes|no]",
            "dc": "[DCPrecision]",
            "lmin": "[MinLF]",
            "lmax": "[MaxLF]",
            "rc_min_vbv_use": "[MinRC]",
            "rc_max_vbv_use": "[MaxRC]",
            "color_range": "[ColorRange]",
            "colorspace": "[ColorSpace]",
            "color_primaries": "[ColorPrimaries]",
            "color_trc": "[ColorTRC]",
            "transfer_characteristics": "[TransferCharacteristics]",
            "matrix_coefficients": "[MatrixCoefficients]",
            "scaler": "[default|fast_bilinear|bilinear|bicubic|neighbor|area|bicublin|gauss|sinc]",
            "scaler_flags": "[ScalerFlags]",
            "video_tag": "[Tag]",
            "mxf_profile": "[MXFProfile]",
            "mxf_multiplex_type": "[MXFMultiplex]",
            "scaler_lib": "[default|zscale]",
            "alpha_mask": "[yes|no]",
            "framerate_interpolation": "[yes|no]",
            "framerate_method": "[FrameRateConversionMethod]",
            "gxf_sequential_field_num": "[yes|no]"
        }
    }
}
```

| Parameter                       | Description                                                                                                                                                                                                                      | Allowed Values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Default Values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| :------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **video\_codec**                | Defines the codec used for your output.                                                                                                                                                                                          | **flv**: flv, libx264, vp6, beamr4avc, copy  <br/>**fl9**: libx264, beamr4avc, copy  <br/>**wmv, zune**: wmv2, msmpeg4, copy  <br/>**android**: h263, mpeg4, libx264, beamr4avc, copy  <br/>**m4v**: mpeg4, beamr4avc, copy  <br/>**ipod, iphone, ipad**: mpeg4, libx264, beamr4avc, copy  <br/>**advanced\_hls**: libx264, beamr4avc, mainconcept\_avc  <br/>**fmp4\_hls**: libx264, hevc, beamr4avc, beamr5hevc, mainconcept\_avc  <br/>**advanced\_mss**: libx264, beamr4avc  <br/>**advanced\_dash**: libx264, libvpx-vp9, hevc, beamr4avc, beamr5hevc, libaom-av1, libsvtav1, mainconcept\_avc  <br/>**advanced\_fmp4**: libx264, hevc, beamr4avc, beamr5hevc, libaom-av1, libsvtav1, mainconcept\_avc  <br/>**mpeg\_dash**: mpeg4, libx264, beamr4avc, beamr5hevc, hevc  <br/>**mp4**: mpeg4, libx264, hevc, beamr4avc, beamr5hevc,  libaom-av1, libsvtav1, copy  <br/>**ogg**: libtheora, copy  <br/>**webm**: libvpx, libvpx-vp9, vp8, vp9, libaom-av1, libsvtav1, copy  <br/>**mp3, wma**: none  <br/>**mpeg2**: mpeg2video, copy  <br/>**mpeg1**: mpeg1video, copy  <br/>**mov**: mpeg4, libx264, xdcam, dvcpro, dvcpro50, dvcprohd, mjpeg, mpeg2video, copy  <br/>**mpegts**: libx264, mpeg2video, beamr4avc, beamr5hevc  <br/>**mxf**: dvcpro, dvcpro50, dvcprohd, xdcamhd422, imx30, copy  <br/>**kindle\_fire**: mpeg4, libx264, hevc, copy  <br/>**dnxhd, dnxhd\_mxf**: dnxhd, copy  <br/>**adaptive\_intermediate**: libx264, hevc, beamr4avc  <br/>**cablelabs\_mpegts**: libx264, beamr4avc, mpeg2video, hevc, beamr5hevc, mainconcept\_avc, copy  <br/>**mainconcept\_mxf**: mpeg2video, libx264, copy  <br/>**qtrle**: qtrle  <br/>**mxf\_op1a**: mpeg2video, libx264, xdcamhd422, dvcpro, dvcpro50, dvcprohd, imx30, xdcam, dnxhd, copy  <br/>**mxf\_as11**: copy                                                                                                                                                                                                                                                                                                                                                                                                                      | **flv**: flv  <br/>**fl9, ipod, iphone, ipad**: libx264  <br/>**wmv, zune**: wmv2  <br/>**mp4, m4v, android, mov**: mpeg4  <br/>**advanced\_hls, advanced\_dash, advanced\_mss**: libx264  <br/>**mpeg\_dash**: libx264  <br/>**ogg**: libtheora  <br/>**webm**: libvpx  <br/>**mpeg2**: mpeg2video  <br/>**mpeg1**: mpeg1video  <br/>**mpegts**: libx264  <br/>**mxf**: xdcamhd422  <br/>**kindle\_fire**: libx264  <br/>**dnxhd, dnxhd\_mxf**: dnxhd  <br/>**adaptive\_intermediate**: libx264  <br/>**mainconcept\_mxf**: mpeg2video  <br/>**cablelabs\_mpegts**: libx264  <br/>**qtrle**: qtrle  <br/>**mxf\_op1a**: mpeg2video  <br/>**mxf\_as11**: copy |
| **ftyp**                        | Specifies a pre-defined signature for mp4 outputs using the ftyp format.                                                                                                                                                         | mp42,3gp5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **size**                        | Specifies the video frame size.                                                                                                                                                                                                  | All: WxH, where W and N are any even integers.  <br/>zune: 320×180, 320×240  <br/>vp6: WxH, where W and N are multiple of 16  <br/>mxf: 720×480, 960×720, 1280×720, 1280×1080, 1440×1080, 1920×1080  <br/>Custom: To match your source aspect ratio, set X value to zero and Y value to your desired height. For example, 0x360 or 0x480.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **All**: None (any size possible)  <br/>**iPhone**: 480×368  <br/>**iPad**: 1280×720  <br/>**Android**: 800×400  <br/>**zune**: 320×180  <br/>**mxf**: None                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| **keep\_aspect\_ratio**         | Specifies whether to maintain aspect ratio of source file.                                                                                                                                                                       | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | yes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| **set\_aspect\_ratio**          | Specify aspect ratio (DAR). When defined, the option keep\_aspect\_ratio will be ignored. The option only works with the following formats: fl9, mp4, m4v, ipod, iphone, ipad, android, ogg, webm, iphone\_stream, ipad\_stream. | The ratio of width to height specified as:  <br/>• any positive integer in the *w:h* format.  <br/>• positive float number  <br/>• *source* string - aspect ratio will be taken from the source media                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **bitrate**                     | Specifies the video bitrate.                                                                                                                                                                                                     | Nk (where N is any non-zero integer)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **All**: 512k  <br/>**iOS, Android**: 1024k                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| **bitrate\_adjust**             | Round the specified bitrate value to the nearest allowed bitrate from DNxHD profiles                                                                                                                                             | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| **maxrate**                     | Specifies maximum allowed video bitrate.                                                                                                                                                                                         | N or Nk — where N is any non-zero integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **minrate**                     | Specifies minimum allowed video bitrate.                                                                                                                                                                                         | N or Nk — where N is any non-zero integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **muxrate**                     | Set a constant muxrate.                                                                                                                                                                                                          | Nk (where N is any non-zero integer)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **cbr**                         | Specifies whether to use CBR (Constant bitrate).                                                                                                                                                                                 | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| **framerate**                   | Specifies the frame rate.                                                                                                                                                                                                        | Any non-zero float or N/M where N and M are non-zero integers  <br/>‘copy’ – take source’s framerate  <br/>**mxf**: 60, 59.94, 60000/1001, 50, 29.97, 30000/1001, 25, 23.98, 24000/1001                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **all**: *none*,  <br/>**qtrle**: 60000/1001                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| **framerate\_upper\_threshold** | If the source frame rate lower then framerate\_upper\_threshold, then the source frame rate will be used.                                                                                                                        | Any non-zero float or N/M where N and M are non-zero                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **keyframe**                    | Defines the keyframe interval, in number of frames.                                                                                                                                                                              | Positive integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 300                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| **force\_keyframes**            | Specify when to capture keyframes.                                                                                                                                                                                               | • **positive integer number**: *N* - insert IDR frame every N frames  <br/>• **positive integer or float with "s" suffix**. *Ns* - insert IDR frame every N second  <br/>• **comma separated list of integer or float numbers**. *N1,N2,...,Nk* insert IDR frame on N1,N2,...,Nk seconds                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **video\_sync**                 | Specify the method for video synchronization.                                                                                                                                                                                    | **old** — Keep old behavior (for compatibility)  <br/>**passthrough** — Each frame is passed with its timestamp from the demuxer to the muxer  <br/>**cfr** — Frames will be duplicated and dropped to achieve exactly the requested constant framerate  <br/>**vfr** — Frames are passed through with their timestamp or dropped so as to prevent 2 frames from having the same timestamp  <br/>**auto** — Chooses between cfr and vfr depending on muxer capabilities                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **remove\_grain**               | The removegrain filter is a spatial denoiser for progressive video.                                                                                                                                                              | 4 integer numbers(from 0 to 23 including) separated with colon.  <br/>Each number specifies filter for each plane.  <br/>For example: 4:4:4:4  <br/>Available modes:  <br/>0 – Leave input plane unchanged. Default.  <br/>1 – Clips the pixel with the minimum and maximum  <br/>of the 8 neighbour pixels.  <br/>2 – Clips the pixel with the second minimum and maximum  <br/>of the 8 neighbour pixels.  <br/>3 – Clips the pixel with the third minimum and maximum  <br/>of the 8 neighbour pixels.  <br/>4 – Clips the pixel with the fourth minimum and maximum  <br/>of the 8 neighbour pixels. This is equivalent to a median filter.  <br/>5 – Line-sensitive clipping giving the minimal change.  <br/>6 – Line-sensitive clipping, intermediate.  <br/>7 – Line-sensitive clipping, intermediate.  <br/>8 – Line-sensitive clipping, intermediate.  <br/>9 – Line-sensitive clipping on a line where the neighbours pixels  <br/>are the closest.  <br/>10 – Replaces the target pixel with the closest neighbour.  <br/>11 – \[1 2 1] horizontal and vertical kernel blur.  <br/>12 – Same as mode 11.  <br/>13 – Bob mode, interpolates top field from the line  <br/>where the neighbours pixels are the closest.  <br/>14 – Bob mode, interpolates bottom field from the line  <br/>where the neighbours pixels are the closest.  <br/>15 – Bob mode, interpolates top field. Same as 13 but with  <br/>a more complicated interpolation formula.  <br/>16 – Bob mode, interpolates bottom field. Same as 14 but with  <br/>a more complicated interpolation formula.  <br/>17 – Clips the pixel with the minimum and maximum of  <br/>respectively the maximum and minimum  <br/>of each pair of opposite neighbour pixels.  <br/>18 – Line-sensitive clipping using opposite neighbours  <br/>whose greatest distance from the current pixel is minimal.  <br/>19 – Replaces the pixel with the average of its 8 neighbours.  <br/>20 – Averages the 9 pixels (\[1 1 1] horizontal and vertical blur).  <br/>21 – Clips pixels using the averages of opposite neighbour.  <br/>22 – Same as mode 21 but simpler and faster.  <br/>23 – Small edge and halo removal, but reputed useless. | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **video\_only**                 | Use only video streams in output                                                                                                                                                                                                 | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| **dc**                          | Intra DC precision                                                                                                                                                                                                               | Positive integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **lmin**                        | Minimum lagrange factor (VBR)                                                                                                                                                                                                    | Positive integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **lmax**                        | Maximum lagrange factor (VBR)                                                                                                                                                                                                    | Positive integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **rc\_min\_vbv\_use**           | Minimum Rate Control VBV factor                                                                                                                                                                                                  | Positive integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **rc\_max\_vbv\_use**           | Maximum Rate Control VBV factor                                                                                                                                                                                                  | Positive integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **color\_range**                | Color range                                                                                                                                                                                                                      | For **cablelabs\_mpegts**, **apple\_prores**, **mxf**, and **mov** output formats:  <br/>• **0** – unknown  <br/>• **1** – tv  <br/>• **2** – pc  <br/>• **3** – unspecified  <br/>• **4** – mpeg  <br/>• **5** – jpeg  <br/>  <br/>Other output formats:  <br/>• **tv**  <br/>• **mpeg**  <br/>• **pc**  <br/>• **jpeg**  <br/>• **unknown**  <br/>• **unspecified**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **cablelabs\_mpegts**, **apple\_prores**, **mxf**, and **mov**: 0  <br/>**other formats**: *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| **colorspace**                  | Colorspace                                                                                                                                                                                                                       | • **rgb**  <br/>• **bt709**  <br/>• **fcc**  <br/>• **bt470bg**  <br/>• **smpte170m**  <br/>• **smpte240m**  <br/>• **ycocg**  <br/>• **bt2020nc**  <br/>• **bt2020c**  <br/>• **smpte2085**  <br/>• **chroma-derived-nc**  <br/>• **chroma-derived-c**  <br/>• **ictcp**  <br/>• **unknown**  <br/>• **unspecified**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **color\_primaries**            | Color Primaries                                                                                                                                                                                                                  | For **cablelabs\_mpegts**, **apple\_prores**, **mxf**, and **mov** output formats:  <br/>• **2** – auto  <br/>• **1** – ITU-R BT.709  <br/>• **5** – ITU-R BT.601 625-line  <br/>• **6** – ITU-R BT.601 525-line  <br/>• **9** – ITU-R BT.2020  <br/>• **copy**  <br/>  <br/>Other output formats:  <br/>• **bt709**  <br/>• **bt470m**  <br/>• **bt470bg**  <br/>• **smpte170m**  <br/>• **smpte240m**  <br/>• **film**  <br/>• **bt2020**  <br/>• **smpte428**  <br/>• **smpte431**  <br/>• **smpte432**  <br/>• **jedec-p22**  <br/>• **unknown**  <br/>• **unspecified**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **cablelabs\_mpegts**, **apple\_prores**, **mxf**, and **mov**: 2  <br/>**other formats**: *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| **color\_trc**                  | Color transformation characteristics                                                                                                                                                                                             | • **bt709**  <br/>• **gamma22**  <br/>• **gamma28**  <br/>• **smpte170m**  <br/>• **smpte240m**  <br/>• **linear**  <br/>• **log**  <br/>• **log\_sqrt**  <br/>• **log316**  <br/>• **iec61966\_2\_4**  <br/>• **bt1361**  <br/>• **iec61966\_2\_1**  <br/>• **bt2020\_10**  <br/>• **bt2020\_12**  <br/>• **smpte2084**  <br/>• **arib-std-b67**  <br/>• **unknown**  <br/>• **unspecified**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **transfer\_characteristics**   | Transfer Characteristics                                                                                                                                                                                                         | **2** – auto  <br/>**1** – ITU-R BT.709 / BT.601 / BT.2020  <br/>**16** – SMPTE ST 2084 (PQ)  <br/>**18** – BT.2100 Hybrid Log Gamma  <br/>**5** – ITU-R BT.470 / ITU-R BT.601 625-line  <br/>**6** – ITU-R BT.601  <br/>**copy**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| **matrix\_coefficients**        | Matrix Coefficients                                                                                                                                                                                                              | **2** – auto  <br/>**1** – ITU-R BT.709, 6 – ITU-R BT.601  <br/>**9** – ITU-R BT.2020  <br/>**5** – ITU-R BT.470 / ITU-R BT.601 625-line  <br/>**6** – ITU-R BT.601 525-line  <br/>**copy**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| **scaler**                      | Video scaling algorithm                                                                                                                                                                                                          | default, fast\_bilinear, bilinear, bicubic, neighbor, area, bicublin, gauss, sinc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | default                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **scaler\_flags**               | Video scaler flags                                                                                                                                                                                                               | Scaling flags list. Each flag should start with + or - sign.  <br/>For now available flags are: accurate\_rnd, full\_chroma\_int, full\_chroma\_inp, bitexact                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **video\_tag**                  | Video Tag                                                                                                                                                                                                                        | String                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **mxf\_profile**                | MXF profile                                                                                                                                                                                                                      | sony\_xdcam, panasonic\_p2, dci\_2k, dci\_4k, as11\_dpp                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **mxf\_multiplex\_type**        | MXF multiplex type                                                                                                                                                                                                               | xdcam\_hd, xdcam\_imx, xdcam\_dv, xdcam\_sxs\_hd, xdcam\_sxs\_imx, xdcam\_sxs\_dv, xavc\_sxs, xavc\_mel, p2\_dvcpro, p2\_avci, p2\_avc\_ultra                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | *none*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **scaler\_lib**                 | Scaler library                                                                                                                                                                                                                   | default, zscale                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | default                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **alpha\_mask**                 | Apply alpha masking filter                                                                                                                                                                                                       | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| **framerate\_interpolation**    | Change the output frame rate by interpolating new video output frames from the source frames                                                                                                                                     | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| **framerate\_method**           | Frame rate conversion method                                                                                                                                                                                                     | default, filter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | default                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **gxf\_sequential\_field\_num** | Set to "yes" if the GXF source file is out of the SMPTE 360-2009 standard, and use sequential field number increments for frame-encoded video.                                                                                   | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |

> 📘 Remux / track passthrough / copy
>
> Using the '**copy**' parameter value will retain all original source settings in the output and ignore any additional parameters.  For most codecs, this will result in a remux instead of a decode/encode cycle, passing through the original video stream.

> 🚧 Dolby Audio compatibility
>
> '**flv**' output with ‘**vp6**‘ video codec is incompatible with the ‘**dolby\_audio**‘ audio codec.

> 👍 For size parameter
>
> You can specify only one dimension: either width or height. In this case, set other dimension to 0. (I.e. 640×0).  The output will be set to match the same aspect as the source.

> 🚧 For framerate\_upper\_threshold parameter
>
> If **framerate\_upper\_threshold** is specified then the **framerate** parameter will be ignored.

> 🚧 For muxrate parameter
>
> * **\<muxrate />** parameter works only for **mpeg-ts** output format.
> * It's not recommended to use along with **\<bitrate />**, **\<maxrate />**, **\<minrate />**, and **\<bufsize />** parameters as the output may be invalid.

> 🚧 For video\_only parameter
>
> **\<video\_only />** parameter works only for **mp4**, **mainconcept\_mxf** and **[advanced multibitrate](https://api.encoding.com/reference/advanced-mbr)** output formats.

> 🚧 For color\_primaries,  transfer\_characteristics, and matrix\_coefficients parameters
>
> **\<color\_primaries />**,  **\<transfer\_characteristics />**, and **\<matrix\_coefficients />** parameters are supported only in **mov**, **cablelabs\_mpegts**, **mxf**, and **apple\_prores** output formats.

> 🚧 For video\_tag parameter
>
> **\<video\_tag>** parameter available only for **mxf** output format and **mxf\_op1a** output format with **xdcam** video codec.

> 🚧 For mxf\_profile and mxf\_multiplex\_type parameters
>
> **\<mxf\_profile >** and **\<mxf\_multiplex\_type >** parameters available only for **mainconcept\_mxf** output format.