blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 754 Projects 19 Wiki Activity

FFmpeg interface improvements 

This patch changes a couple of things in the video output encoding.

{F362527}

- Clearer separation between container and codec. No more "format", as this is
  too ambiguous. As a result, codecs were removed from the container list.
- Added FFmpeg speed presets, so the user can choosen from the range "Very
  slow" to "Ultra fast". By default no preset is used.
- Added Constant Rate Factor (CRF) mode, which allows changing the bit-rate
  depending on the desired quality and the input. This generally produces the
  best quality videos, at the expense of not knowing the exact bit-rate and
  file size.
- Added optional maximum of non-B-frames between B-frames (`max_b_frames`).
- Presets were adjusted for these changes, and new presets added. One of the
  new presets is [recommended](https://trac.ffmpeg.org/wiki/Encode/VFX#H.264)
  for reviewing videos, as it allows players to scrub through it easily. Might
  be nice in weeklies. This preset also requires control over the
  `max_b_frames` setting.

GUI-only changes:
- Renamed "MPEG" in the output file format menu with "FFmpeg", as this is more
  accurate. After all, FFmpeg is used when this option is chosen, which can
  also output non-MPEG files.
- Certain parts of the GUI are disabled when not in use:
    - bit rate options are not used when a constant rate factor is given.
    - audio bitrate & volume are not used when no audio is exported.

Note that I did not touch `BKE_ffmpeg_preset_set()`. There are currently two
preset systems for FFmpeg (`BKE_ffmpeg_preset_set()` and the Python preset
system). Before we do more work on `BKE_ffmpeg_preset_set()`, I think it's a
good idea to determine whether we want to keep it at all.

After this patch has been accepted, I'd be happy to go through the code and
remove any then-obsolete bits, such as the handling of "XVID" as a container
format.

Reviewers: sergey, mont29, brecht

Subscribers: mpan3, Blendify, brecht, fsiddi

Tags: #bf_blender

Differential Revision: https://developer.blender.org/D2242
This commit is contained in:
Sybren A. Stüvel 2016-09-21 15:01:51 +02:00
parent 2476faebd7
commit a7e7479122
Notes: blender-bot 2023-12-09 20:43:55 +01:00 
Referenced by pull request #115987, Creator: update image formats shown in the CLI help
15 changed files with 240 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
release/scripts/presets/ffmpeg/DV.py
View File

@ -1,14 +0,0 @@
import bpy
is_ntsc = (bpy.context.scene.render.fps != 25)
bpy.context.scene.render.ffmpeg.format = "DV"
bpy.context.scene.render.resolution_x = 720
if is_ntsc:
bpy.context.scene.render.resolution_y = 480
else:
bpy.context.scene.render.resolution_y = 576
bpy.context.scene.render.ffmpeg.audio_mixrate = 48000
bpy.context.scene.render.ffmpeg.audio_codec = "PCM"
bpy.context.scene.render.ffmpeg.audio_channels = "STEREO"

0
release/scripts/presets/ffmpeg/DVD.py → release/scripts/presets/ffmpeg/DVD (note_colon_ this changes render resolution).py
View File

24
release/scripts/presets/ffmpeg/SVCD.py
View File

@ -1,24 +0,0 @@
import bpy
is_ntsc = (bpy.context.scene.render.fps != 25)
bpy.context.scene.render.ffmpeg.format = "MPEG2"
bpy.context.scene.render.resolution_x = 480
if is_ntsc:
bpy.context.scene.render.resolution_y = 480
bpy.context.scene.render.ffmpeg.gopsize = 18
else:
bpy.context.scene.render.resolution_y = 576
bpy.context.scene.render.ffmpeg.gopsize = 15
bpy.context.scene.render.ffmpeg.video_bitrate = 2040
bpy.context.scene.render.ffmpeg.maxrate = 2516
bpy.context.scene.render.ffmpeg.minrate = 0
bpy.context.scene.render.ffmpeg.buffersize = 224 * 8
bpy.context.scene.render.ffmpeg.packetsize = 2324
bpy.context.scene.render.ffmpeg.muxrate = 0
bpy.context.scene.render.ffmpeg.audio_bitrate = 224
bpy.context.scene.render.ffmpeg.audio_mixrate = 44100
bpy.context.scene.render.ffmpeg.audio_codec = "MP2"
bpy.context.scene.render.ffmpeg.audio_channels = "STEREO"

24
release/scripts/presets/ffmpeg/VCD.py
View File

@ -1,24 +0,0 @@
import bpy
is_ntsc = (bpy.context.scene.render.fps != 25)
bpy.context.scene.render.ffmpeg.format = "MPEG1"
bpy.context.scene.render.resolution_x = 352
if is_ntsc:
bpy.context.scene.render.resolution_y = 240
bpy.context.scene.render.ffmpeg.gopsize = 18
else:
bpy.context.scene.render.resolution_y = 288
bpy.context.scene.render.ffmpeg.gopsize = 15
bpy.context.scene.render.ffmpeg.video_bitrate = 1150
bpy.context.scene.render.ffmpeg.maxrate = 1150
bpy.context.scene.render.ffmpeg.minrate = 1150
bpy.context.scene.render.ffmpeg.buffersize = 40 * 8
bpy.context.scene.render.ffmpeg.packetsize = 2324
bpy.context.scene.render.ffmpeg.muxrate = 2352 * 75 * 8
bpy.context.scene.render.ffmpeg.audio_bitrate = 224
bpy.context.scene.render.ffmpeg.audio_mixrate = 44100
bpy.context.scene.render.ffmpeg.audio_codec = "MP2"
bpy.context.scene.render.ffmpeg.audio_channels = "STEREO"

18
release/scripts/presets/ffmpeg/h264 in MP4.py Normal file
View File

@ -0,0 +1,18 @@
import bpy
is_ntsc = (bpy.context.scene.render.fps != 25)
bpy.context.scene.render.ffmpeg.format = "MPEG4"
bpy.context.scene.render.ffmpeg.codec = "H264"
if is_ntsc:
bpy.context.scene.render.ffmpeg.gopsize = 18
else:
bpy.context.scene.render.ffmpeg.gopsize = 15
bpy.context.scene.render.ffmpeg.use_max_b_frames = False
bpy.context.scene.render.ffmpeg.video_bitrate = 6000
bpy.context.scene.render.ffmpeg.maxrate = 9000
bpy.context.scene.render.ffmpeg.minrate = 0
bpy.context.scene.render.ffmpeg.buffersize = 224 * 8
bpy.context.scene.render.ffmpeg.packetsize = 2048
bpy.context.scene.render.ffmpeg.muxrate = 10080000

14
release/scripts/presets/ffmpeg/h264 in Matroska for scrubbing.py Normal file
View File

@ -0,0 +1,14 @@
"""Sets up FFmpeg to output files that can easily be scrubbed through.
Information was taken from https://trac.ffmpeg.org/wiki/Encode/VFX#H.264
"""
import bpy
bpy.context.scene.render.ffmpeg.format = "MKV"
bpy.context.scene.render.ffmpeg.codec = "H264"
bpy.context.scene.render.ffmpeg.gopsize = 1
bpy.context.scene.render.ffmpeg.constant_rate_factor = 'PERC_LOSSLESS'
bpy.context.scene.render.ffmpeg.use_max_b_frames = True
bpy.context.scene.render.ffmpeg.max_b_frames = 0

2
release/scripts/presets/ffmpeg/h264.py → release/scripts/presets/ffmpeg/h264 in Matroska.py
View File

@ -1,7 +1,7 @@
import bpy
is_ntsc = (bpy.context.scene.render.fps != 25)
bpy.context.scene.render.ffmpeg.format = "H264"
bpy.context.scene.render.ffmpeg.format = "MKV"
bpy.context.scene.render.ffmpeg.codec = "H264"
if is_ntsc:

1
release/scripts/presets/ffmpeg/theora.py → release/scripts/presets/ffmpeg/ogg_theora.py
View File

@ -8,6 +8,7 @@ if is_ntsc:
bpy.context.scene.render.ffmpeg.gopsize = 18
else:
bpy.context.scene.render.ffmpeg.gopsize = 15
bpy.context.scene.render.ffmpeg.use_max_b_frames = False
bpy.context.scene.render.ffmpeg.video_bitrate = 6000
bpy.context.scene.render.ffmpeg.maxrate = 9000

4
release/scripts/presets/ffmpeg/xvid.py
View File

@ -1,12 +1,14 @@
import bpy
is_ntsc = (bpy.context.scene.render.fps != 25)
bpy.context.scene.render.ffmpeg.format = "XVID"
bpy.context.scene.render.ffmpeg.format = "AVI"
bpy.context.scene.render.ffmpeg.codec = "MPEG4"
if is_ntsc:
bpy.context.scene.render.ffmpeg.gopsize = 18
else:
bpy.context.scene.render.ffmpeg.gopsize = 15
bpy.context.scene.render.ffmpeg.use_max_b_frames = False
bpy.context.scene.render.ffmpeg.video_bitrate = 6000
bpy.context.scene.render.ffmpeg.maxrate = 9000

40
release/scripts/startup/bl_ui/properties_render.py
View File

@ -461,31 +461,42 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
split = layout.split()
split.prop(rd.ffmpeg, "format")
if ffmpeg.format in {'AVI', 'QUICKTIME', 'MKV', 'OGG', 'MPEG4'}:
split.prop(ffmpeg, "codec")
if ffmpeg.codec == 'H264':
row = layout.row()
row.label()
row.prop(ffmpeg, "use_lossless_output")
elif rd.ffmpeg.format == 'H264':
split.prop(ffmpeg, "use_lossless_output")
else:
split.label()
split.prop(ffmpeg, "use_autosplit")
layout.separator()
needs_codec = ffmpeg.format in {'AVI', 'QUICKTIME', 'MKV', 'OGG', 'MPEG4'}
if needs_codec:
layout.prop(ffmpeg, "codec")
if ffmpeg.codec in {'DNXHD'}:
layout.prop(ffmpeg, "use_lossless_output")
# Output quality
if needs_codec and ffmpeg.codec in {'H264', 'MPEG4'}:
layout.prop(ffmpeg, "constant_rate_factor")
# Encoding speed
layout.prop(ffmpeg, "ffmpeg_preset")
# I-frames
layout.prop(ffmpeg, "gopsize")
# B-Frames
row = layout.row()
row.prop(ffmpeg, "video_bitrate")
row.prop(ffmpeg, "gopsize")
row.prop(ffmpeg, "use_max_b_frames", text='Max B-frames')
pbox = row.split()
pbox.prop(ffmpeg, "max_b_frames", text='')
pbox.enabled = ffmpeg.use_max_b_frames
split = layout.split()
split.enabled = ffmpeg.constant_rate_factor == 'NONE'
col = split.column()
col.label(text="Rate:")
col.prop(ffmpeg, "video_bitrate")
col.prop(ffmpeg, "minrate", text="Minimum")
col.prop(ffmpeg, "maxrate", text="Maximum")
col.prop(ffmpeg, "buffersize", text="Buffer")
col = split.column()
col.prop(ffmpeg, "use_autosplit")
col.label(text="Mux:")
col.prop(ffmpeg, "muxrate", text="Rate")
col.prop(ffmpeg, "packetsize", text="Packet Size")
@ -497,6 +508,7 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
layout.prop(ffmpeg, "audio_codec", text="Audio Codec")
row = layout.row()
row.enabled = ffmpeg.audio_codec != 'NONE'
row.prop(ffmpeg, "audio_bitrate")
row.prop(ffmpeg, "audio_volume", slider=True)

2
source/blender/blenkernel/intern/image.c
View File

@ -1325,7 +1325,7 @@ char BKE_imtype_from_arg(const char *imtype_arg)
else if (STREQ(imtype_arg, "EXR")) return R_IMF_IMTYPE_OPENEXR;
else if (STREQ(imtype_arg, "MULTILAYER")) return R_IMF_IMTYPE_MULTILAYER;
#endif
else if (STREQ(imtype_arg, "MPEG")) return R_IMF_IMTYPE_FFMPEG;
else if (STREQ(imtype_arg, "FFMPEG")) return R_IMF_IMTYPE_FFMPEG;
else if (STREQ(imtype_arg, "FRAMESERVER")) return R_IMF_IMTYPE_FRAMESERVER;
#ifdef WITH_CINEON
else if (STREQ(imtype_arg, "CINEON")) return R_IMF_IMTYPE_CINEON;

76
source/blender/blenkernel/intern/writeffmpeg.c
View File

@ -69,10 +69,14 @@ typedef struct FFMpegContext {
int ffmpeg_video_bitrate;
int ffmpeg_audio_bitrate;
int ffmpeg_gop_size;
int ffmpeg_max_b_frames;
int ffmpeg_autosplit;
int ffmpeg_autosplit_count;
bool ffmpeg_preview;
int ffmpeg_crf; /* set to 0 to not use CRF mode; we have another flag for lossless anyway. */
int ffmpeg_preset; /* see FFMpegPreset */
AVFormatContext *outfile;
AVStream *video_stream;
AVStream *audio_stream;
@ -560,10 +564,37 @@ static AVStream *alloc_video_stream(FFMpegContext *context, RenderData *rd, int
}
c->gop_size = context->ffmpeg_gop_size;
c->bit_rate = context->ffmpeg_video_bitrate * 1000;
c->rc_max_rate = rd->ffcodecdata.rc_max_rate * 1000;
c->rc_min_rate = rd->ffcodecdata.rc_min_rate * 1000;
c->rc_buffer_size = rd->ffcodecdata.rc_buffer_size * 1024;
c->max_b_frames = context->ffmpeg_max_b_frames;
if (context->ffmpeg_crf >= 0) {
ffmpeg_dict_set_int(&opts, "crf", context->ffmpeg_crf);
} else {
c->bit_rate = context->ffmpeg_video_bitrate * 1000;
c->rc_max_rate = rd->ffcodecdata.rc_max_rate * 1000;
c->rc_min_rate = rd->ffcodecdata.rc_min_rate * 1000;
c->rc_buffer_size = rd->ffcodecdata.rc_buffer_size * 1024;
}
if (context->ffmpeg_preset) {
char const * preset_name;
switch(context->ffmpeg_preset) {
case FFM_PRESET_ULTRAFAST: preset_name = "ultrafast"; break;
case FFM_PRESET_SUPERFAST: preset_name = "superfast"; break;
case FFM_PRESET_VERYFAST: preset_name = "veryfast"; break;
case FFM_PRESET_FASTER: preset_name = "faster"; break;
case FFM_PRESET_FAST: preset_name = "fast"; break;
case FFM_PRESET_MEDIUM: preset_name = "medium"; break;
case FFM_PRESET_SLOW: preset_name = "slow"; break;
case FFM_PRESET_SLOWER: preset_name = "slower"; break;
case FFM_PRESET_VERYSLOW: preset_name = "veryslow"; break;
default:
printf("Unknown preset number %i, ignoring.\n", context->ffmpeg_preset);
preset_name = NULL;
}
if (preset_name != NULL) {
av_dict_set(&opts, "preset", preset_name, 0);
}
}
#if 0
/* this options are not set in ffmpeg.c and leads to artifacts with MPEG-4
@ -819,6 +850,12 @@ static int start_ffmpeg_impl(FFMpegContext *context, struct RenderData *rd, int
context->ffmpeg_audio_bitrate = rd->ffcodecdata.audio_bitrate;
context->ffmpeg_gop_size = rd->ffcodecdata.gop_size;
context->ffmpeg_autosplit = rd->ffcodecdata.flags & FFMPEG_AUTOSPLIT_OUTPUT;
context->ffmpeg_crf = rd->ffcodecdata.constant_rate_factor;
context->ffmpeg_preset = rd->ffcodecdata.ffmpeg_preset;
if ((rd->ffcodecdata.flags & FFMPEG_USE_MAX_B_FRAMES) != 0) {
context->ffmpeg_max_b_frames = rd->ffcodecdata.max_b_frames;
}
/* Determine the correct filename */
ffmpeg_filepath_get(context, name, rd, context->ffmpeg_preview, suffix);
@ -852,12 +889,16 @@ static int start_ffmpeg_impl(FFMpegContext *context, struct RenderData *rd, int
/* Returns after this must 'goto fail;' */
of->oformat = fmt;
of->packet_size = rd->ffcodecdata.mux_packet_size;
if (context->ffmpeg_audio_codec != AV_CODEC_ID_NONE) {
ffmpeg_dict_set_int(&opts, "muxrate", rd->ffcodecdata.mux_rate);
}
else {
av_dict_set(&opts, "muxrate", "0", 0);
/* Only bother with setting packet size & mux rate when CRF is not used. */
if (context->ffmpeg_crf == 0) {
of->packet_size = rd->ffcodecdata.mux_packet_size;
if (context->ffmpeg_audio_codec != AV_CODEC_ID_NONE) {
ffmpeg_dict_set_int(&opts, "muxrate", rd->ffcodecdata.mux_rate);
}
else {
av_dict_set(&opts, "muxrate", "0", 0);
}
}
ffmpeg_dict_set_int(&opts, "preload", (int)(0.5 * AV_TIME_BASE));
@ -1503,14 +1544,6 @@ static void ffmpeg_set_expert_options(RenderData *rd)
BKE_ffmpeg_property_add_string(rd, "video", "fast-pskip:1");
BKE_ffmpeg_property_add_string(rd, "video", "wpredp:2");
#endif
if (rd->ffcodecdata.flags & FFMPEG_LOSSLESS_OUTPUT) {
#ifdef FFMPEG_HAVE_DEPRECATED_FLAGS2
BKE_ffmpeg_property_add_string(rd, "video", "cqp:0");
#else
BKE_ffmpeg_property_add_string(rd, "video", "qp:0");
#endif
}
}
else if (codec_id == AV_CODEC_ID_DNXHD) {
if (rd->ffcodecdata.flags & FFMPEG_LOSSLESS_OUTPUT)
@ -1622,9 +1655,10 @@ void BKE_ffmpeg_image_type_verify(RenderData *rd, ImageFormatData *imf)
rd->ffcodecdata.audio_codec <= 0 ||
rd->ffcodecdata.video_bitrate <= 1)
{
rd->ffcodecdata.codec = AV_CODEC_ID_MPEG2VIDEO;
BKE_ffmpeg_preset_set(rd, FFMPEG_PRESET_DVD);
BKE_ffmpeg_preset_set(rd, FFMPEG_PRESET_H264);
rd->ffcodecdata.constant_rate_factor = FFM_CRF_MEDIUM;
rd->ffcodecdata.ffmpeg_preset = FFM_PRESET_MEDIUM;
rd->ffcodecdata.type = FFMPEG_MKV;
}
if (rd->ffcodecdata.type == FFMPEG_OGG) {
rd->ffcodecdata.type = FFMPEG_MPEG2;

14
source/blender/blenloader/intern/versioning_270.c
View File

@ -1392,4 +1392,18 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *main)
}
}
}
if (!MAIN_VERSION_ATLEAST(main, 279, 0)) {
if (!DNA_struct_elem_find(fd->filesdna, "FFMpegCodecData", "int", "ffmpeg_preset")) {
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
/* "medium" is the preset FFmpeg uses when no presets are given. */
scene->r.ffcodecdata.ffmpeg_preset = FFM_PRESET_MEDIUM;
}
}
if (!DNA_struct_elem_find(fd->filesdna, "FFMpegCodecData", "int", "constant_rate_factor")) {
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
/* fall back to behaviour from before we introduced CRF for old files */
scene->r.ffcodecdata.constant_rate_factor = FFM_CRF_NONE;
}
}
}
}

37
source/blender/makesdna/DNA_scene_types.h
View File

@ -135,6 +135,37 @@ typedef struct QuicktimeCodecSettings {
int pad1;
} QuicktimeCodecSettings;
typedef enum FFMpegPreset {
FFM_PRESET_NONE,
FFM_PRESET_ULTRAFAST,
FFM_PRESET_SUPERFAST,
FFM_PRESET_VERYFAST,
FFM_PRESET_FASTER,
FFM_PRESET_FAST,
FFM_PRESET_MEDIUM,
FFM_PRESET_SLOW,
FFM_PRESET_SLOWER,
FFM_PRESET_VERYSLOW,
} FFMpegPreset;
/* Mapping from easily-understandable descriptions to CRF values.
* Assumes we output 8-bit video. Needs to be remapped if 10-bit
* is output.
* We use a slightly wider than "subjectively sane range" according
* to https://trac.ffmpeg.org/wiki/Encode/H.264#a1.ChooseaCRFvalue
*/
typedef enum FFMpegCrf {
FFM_CRF_NONE = -1,
FFM_CRF_LOSSLESS = 0,
FFM_CRF_PERC_LOSSLESS = 17,
FFM_CRF_HIGH = 20,
FFM_CRF_MEDIUM = 23,
FFM_CRF_LOW = 26,
FFM_CRF_VERYLOW = 29,
FFM_CRF_LOWEST = 32,
} FFMpegCrf;
typedef struct FFMpegCodecData {
int type;
int codec;
@ -146,13 +177,18 @@ typedef struct FFMpegCodecData {
int audio_pad;
float audio_volume;
int gop_size;
int max_b_frames; /* only used if FFMPEG_USE_MAX_B_FRAMES flag is set. */
int flags;
int constant_rate_factor;
int ffmpeg_preset; /* see FFMpegPreset */
int rc_min_rate;
int rc_max_rate;
int rc_buffer_size;
int mux_packet_size;
int mux_rate;
int pad1;
IDProperty *properties;
} FFMpegCodecData;
@ -1982,6 +2018,7 @@ enum {
#endif
FFMPEG_AUTOSPLIT_OUTPUT = 2,
FFMPEG_LOSSLESS_OUTPUT = 4,
FFMPEG_USE_MAX_B_FRAMES = (1 << 3),
};
/* Paint.flags */

81
source/blender/makesrna/intern/rna_scene.c
View File

@ -282,15 +282,10 @@ EnumPropertyItem rna_enum_image_type_items[] = {
{R_IMF_IMTYPE_FRAMESERVER, "FRAMESERVER", ICON_FILE_SCRIPT, "Frame Server", "Output image to a frameserver"},
#endif
#ifdef WITH_FFMPEG
{R_IMF_IMTYPE_H264, "H264", ICON_FILE_MOVIE, "H.264", "Output video in H.264 format"},
{R_IMF_IMTYPE_FFMPEG, "FFMPEG", ICON_FILE_MOVIE, "MPEG", "Output video in MPEG format"},
{R_IMF_IMTYPE_THEORA, "THEORA", ICON_FILE_MOVIE, "Ogg Theora", "Output video in Ogg format"},
{R_IMF_IMTYPE_FFMPEG, "FFMPEG", ICON_FILE_MOVIE, "FFmpeg video", "The most versatile way to output video files"},
#endif
#ifdef WITH_QUICKTIME
{R_IMF_IMTYPE_QUICKTIME, "QUICKTIME", ICON_FILE_MOVIE, "QuickTime", "Output video in Quicktime format"},
#endif
#ifdef WITH_FFMPEG
{R_IMF_IMTYPE_XVID, "XVID", ICON_FILE_MOVIE, "Xvid", "Output video in Xvid format"},
#endif
{0, NULL, 0, NULL, NULL}
};
@ -5320,6 +5315,7 @@ static void rna_def_scene_ffmpeg_settings(BlenderRNA *brna)
PropertyRNA *prop;
#ifdef WITH_FFMPEG
/* Container types */
static EnumPropertyItem ffmpeg_format_items[] = {
{FFMPEG_MPEG1, "MPEG1", 0, "MPEG-1", ""},
{FFMPEG_MPEG2, "MPEG2", 0, "MPEG-2", ""},
@ -5327,8 +5323,8 @@ static void rna_def_scene_ffmpeg_settings(BlenderRNA *brna)
{FFMPEG_AVI, "AVI", 0, "AVI", ""},
{FFMPEG_MOV, "QUICKTIME", 0, "Quicktime", ""},
{FFMPEG_DV, "DV", 0, "DV", ""},
{FFMPEG_H264, "H264", 0, "H.264", ""},
{FFMPEG_XVID, "XVID", 0, "Xvid", ""},
// {FFMPEG_H264, "H264", 0, "H.264", ""}, not a container
// {FFMPEG_XVID, "XVID", 0, "Xvid", ""}, not a container
{FFMPEG_OGG, "OGG", 0, "Ogg", ""},
{FFMPEG_MKV, "MKV", 0, "Matroska", ""},
{FFMPEG_FLV, "FLASH", 0, "Flash", ""},
@ -5352,6 +5348,32 @@ static void rna_def_scene_ffmpeg_settings(BlenderRNA *brna)
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem ffmpeg_preset_items[] = {
{FFM_PRESET_ULTRAFAST, "ULTRAFAST", 0, "Ultra fast; biggest file", ""},
{FFM_PRESET_SUPERFAST, "SUPERFAST", 0, "Super fast", ""},
{FFM_PRESET_VERYFAST, "VERYFAST", 0, "Very fast", ""},
{FFM_PRESET_FASTER, "FASTER", 0, "Faster", ""},
{FFM_PRESET_FAST, "FAST", 0, "Fast", ""},
{FFM_PRESET_MEDIUM, "MEDIUM", 0, "Medium speed", ""},
{FFM_PRESET_SLOW, "SLOW", 0, "Slow", ""},
{FFM_PRESET_SLOWER, "SLOWER", 0, "Slower", ""},
{FFM_PRESET_VERYSLOW, "VERYSLOW", 0, "Very slow; smallest file", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem ffmpeg_crf_items[] = {
{FFM_CRF_NONE, "NONE", 0, "None; use constant bit-rate",
"Use constant bit rate, rather than constant output quality"},
{FFM_CRF_LOSSLESS, "LOSSLESS", 0, "Lossless", ""},
{FFM_CRF_PERC_LOSSLESS, "PERC_LOSSLESS", 0, "Perceptually lossless", ""},
{FFM_CRF_HIGH, "HIGH", 0, "High quality", ""},
{FFM_CRF_MEDIUM, "MEDIUM", 0, "Medium quality", ""},
{FFM_CRF_LOW, "LOW", 0, "Low quality", ""},
{FFM_CRF_VERYLOW, "VERYLOW", 0, "Very low quality", ""},
{FFM_CRF_LOWEST, "LOWEST", 0, "Lowest quality", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem ffmpeg_audio_codec_items[] = {
{AV_CODEC_ID_NONE, "NONE", 0, "None", ""},
{AV_CODEC_ID_MP2, "MP2", 0, "MP2", ""},
@ -5383,13 +5405,15 @@ static void rna_def_scene_ffmpeg_settings(BlenderRNA *brna)
RNA_def_property_enum_bitflag_sdna(prop, NULL, "type");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_enum_items(prop, ffmpeg_format_items);
RNA_def_property_ui_text(prop, "Format", "Output file format");
RNA_def_property_enum_default(prop, FFMPEG_MKV);
RNA_def_property_ui_text(prop, "Container", "Output file container");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_FFmpegSettings_codec_settings_update");
prop = RNA_def_property(srna, "codec", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "codec");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_enum_items(prop, ffmpeg_codec_items);
RNA_def_property_enum_default(prop, AV_CODEC_ID_H264);
RNA_def_property_ui_text(prop, "Codec", "FFmpeg codec to use");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_FFmpegSettings_codec_settings_update");
@ -5421,8 +5445,25 @@ static void rna_def_scene_ffmpeg_settings(BlenderRNA *brna)
prop = RNA_def_property(srna, "gopsize", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "gop_size");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_range(prop, 0, 100);
RNA_def_property_ui_text(prop, "GOP Size", "Distance between key frames");
RNA_def_property_range(prop, 0, 500);
RNA_def_property_int_default(prop, 25);
RNA_def_property_ui_text(prop, "Keyframe interval",
"Distance between key frames, also known as GOP size; "
"influences file size and seekability");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
prop = RNA_def_property(srna, "max_b_frames", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "max_b_frames");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_range(prop, 0, 16);
RNA_def_property_ui_text(prop, "Max B-frames",
"Maximum number of B-frames between non-B-frames; influences file size and seekability");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
prop = RNA_def_property(srna, "use_max_b_frames", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flags", FFMPEG_USE_MAX_B_FRAMES);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Use max B-frames", "Set a maximum number of B-frames");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
prop = RNA_def_property(srna, "buffersize", PROP_INT, PROP_NONE);
@ -5439,6 +5480,24 @@ static void rna_def_scene_ffmpeg_settings(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Mux Packet Size", "Mux packet size (byte)");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
prop = RNA_def_property(srna, "constant_rate_factor", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "constant_rate_factor");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_enum_items(prop, ffmpeg_crf_items);
RNA_def_property_enum_default(prop, FFM_CRF_MEDIUM);
RNA_def_property_ui_text(prop, "Output quality",
"Constant Rate Factor (CRF); tradeoff between video quality and file size");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
prop = RNA_def_property(srna, "ffmpeg_preset", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "ffmpeg_preset");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_enum_items(prop, ffmpeg_preset_items);
RNA_def_property_enum_default(prop, FFM_PRESET_MEDIUM);
RNA_def_property_ui_text(prop, "Encoding speed",
"Tradeoff between encoding speed and compression ratio");
RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
prop = RNA_def_property(srna, "use_autosplit", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flags", FFMPEG_AUTOSPLIT_OUTPUT);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);