59static CLG_LogRef
LOG = {
"video.write"};
60static constexpr int64_t ffmpeg_autosplit_size = 2'000'000'000;
62static void ffmpeg_dict_set_int(AVDictionary **dict,
const char *key,
int value)
64 av_dict_set_int(dict, key, value, 0);
67static void ffmpeg_movie_close(MovieWriter *context);
68static bool ffmpeg_filepath_get(MovieWriter *context,
77static AVFrame *alloc_frame(AVPixelFormat pix_fmt,
int width,
int height)
79 AVFrame *f = av_frame_alloc();
87 if (av_frame_get_buffer(f, align) < 0) {
96static const char **get_file_extensions(
int format)
100 static const char *rv[] = {
".dv",
nullptr};
104 static const char *rv[] = {
".mpg",
".mpeg",
nullptr};
108 static const char *rv[] = {
".dvd",
".vob",
".mpg",
".mpeg",
nullptr};
112 static const char *rv[] = {
".mp4",
".mpg",
".mpeg",
nullptr};
116 static const char *rv[] = {
".avi",
nullptr};
120 static const char *rv[] = {
".mov",
nullptr};
125 static const char *rv[] = {
".avi",
nullptr};
131 static const char *rv[] = {
".avi",
nullptr};
135 static const char *rv[] = {
".flv",
nullptr};
139 static const char *rv[] = {
".mkv",
nullptr};
143 static const char *rv[] = {
".ogv",
".ogg",
nullptr};
147 static const char *rv[] = {
".webm",
nullptr};
151 static const char *rv[] = {
".mp4",
".mkv",
nullptr};
159static void add_hdr_mastering_display_metadata(AVCodecParameters *codecpar,
163 if (c->color_primaries != AVCOL_PRI_BT2020) {
169 imf->view_settings.view_transform);
170 if (c->color_trc == AVCOL_TRC_ARIB_STD_B67) {
172 max_luminance = (max_luminance == 0) ? 1000 : std::
min(max_luminance, 1000);
174 else if (c->color_trc == AVCOL_TRC_SMPTEST2084) {
176 max_luminance = std::min(max_luminance, 10000);
181 if (max_luminance == 0) {
185 AVPacketSideData *side_data = av_packet_side_data_new(&codecpar->coded_side_data,
186 &codecpar->nb_coded_side_data,
187 AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
188 sizeof(AVMasteringDisplayMetadata),
190 if (side_data ==
nullptr) {
191 CLOG_ERROR(&
LOG,
"Failed to attached mastering display metadata to stream");
195 AVMasteringDisplayMetadata *mastering_metadata =
reinterpret_cast<AVMasteringDisplayMetadata *
>(
199 mastering_metadata->has_primaries = 1;
200 mastering_metadata->display_primaries[0][0] = av_make_q(34000, 50000);
201 mastering_metadata->display_primaries[0][1] = av_make_q(16000, 50000);
202 mastering_metadata->display_primaries[1][0] = av_make_q(13250, 50000);
203 mastering_metadata->display_primaries[1][1] = av_make_q(34500, 50000);
204 mastering_metadata->display_primaries[2][0] = av_make_q(7500, 50000);
205 mastering_metadata->display_primaries[2][1] = av_make_q(3000, 50000);
207 mastering_metadata->white_point[0] = av_make_q(15635, 50000);
208 mastering_metadata->white_point[1] = av_make_q(16450, 50000);
210 mastering_metadata->has_luminance = 1;
211 mastering_metadata->min_luminance = av_make_q(1, 10000);
212 mastering_metadata->max_luminance = av_make_q(max_luminance, 1);
221static void add_stereo3d_metadata(AVCodecParameters *codecpar,
238 AVPacketSideData *side_data = av_packet_side_data_new(&codecpar->coded_side_data,
239 &codecpar->nb_coded_side_data,
240 AV_PKT_DATA_STEREO3D,
243 if (side_data ==
nullptr) {
244 CLOG_ERROR(&
LOG,
"Failed to attach stereo3d metadata to stream");
247 AVStereo3D *stereo_3d =
reinterpret_cast<AVStereo3D *
>(side_data->data);
248 AVStereo3DType interlace_type = AV_STEREO3D_UNSPEC;
249 switch (imf.stereo3d_format.interlace_type) {
251 interlace_type = AV_STEREO3D_LINES;
254 interlace_type = AV_STEREO3D_COLUMNS;
257 interlace_type = AV_STEREO3D_CHECKERBOARD;
263 switch (imf.stereo3d_format.display_mode) {
265 stereo_3d->type = AV_STEREO3D_SIDEBYSIDE;
266 stereo_3d->view = AV_STEREO3D_VIEW_PACKED;
269 stereo_3d->flags |= AV_STEREO3D_FLAG_INVERT;
275 stereo_3d->type = AV_STEREO3D_TOPBOTTOM;
276 stereo_3d->view = AV_STEREO3D_VIEW_PACKED;
281 stereo_3d->type = interlace_type;
282 stereo_3d->view = AV_STEREO3D_VIEW_PACKED;
285 stereo_3d->flags |= AV_STEREO3D_FLAG_INVERT;
297static void add_spherical_mapping_metadata(AVCodecParameters *codecpar,
const Scene &scene)
299 if (scene.
camera ==
nullptr) {
322 AVPacketSideData *side_data = av_packet_side_data_new(&codecpar->coded_side_data,
323 &codecpar->nb_coded_side_data,
324 AV_PKT_DATA_SPHERICAL,
325 sizeof(AVSphericalMapping),
327 if (side_data ==
nullptr) {
328 CLOG_ERROR(&
LOG,
"Failed to attach spherical mapping metadata to stream");
331 AVSphericalMapping &spherical = *
reinterpret_cast<AVSphericalMapping *
>(side_data->data);
332 spherical.projection = AV_SPHERICAL_EQUIRECTANGULAR;
336static bool write_video_frame(MovieWriter *context, AVFrame *frame,
ReportList *reports)
338 int ret, success = 1;
339 AVPacket *packet = av_packet_alloc();
341 AVCodecContext *c =
context->video_codec;
343 frame->pts =
context->video_time;
346 char error_str[AV_ERROR_MAX_STRING_SIZE];
347 ret = avcodec_send_frame(c, frame);
350 av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE,
ret);
356 ret = avcodec_receive_packet(c, packet);
358 if (
ret == AVERROR(EAGAIN) ||
ret == AVERROR_EOF) {
363 av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE,
ret);
368 packet->stream_index =
context->video_stream->index;
369 av_packet_rescale_ts(packet, c->time_base,
context->video_stream->time_base);
370# ifdef FFMPEG_USE_DURATION_WORKAROUND
374 if (av_interleaved_write_frame(
context->outfile, packet) != 0) {
382 av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE,
ret);
383 CLOG_INFO(&
LOG,
"ffmpeg: error writing video frame: %s", error_str);
386 av_packet_free(&packet);
402static ImBuf *alloc_imbuf_for_colorspace_transform(
const ImBuf *input_ibuf)
414 result_ibuf->color_mode = input_ibuf->color_mode;
415 result_ibuf->channels = input_ibuf->float_data() ? input_ibuf->channels : 4;
420 if (input_ibuf->float_data()) {
423 result_ibuf->float_buffer = input_ibuf->float_buffer;
431 result_ibuf->assign_float_data(buffer);
433 input_ibuf->byte_data(),
444static AVFrame *generate_video_frame(MovieWriter *context,
const ImBuf *input_ibuf)
447 const bool use_float =
448 context->img_convert_frame !=
nullptr &&
449 !(
context->img_convert_frame->format == AV_PIX_FMT_RGBA &&
450 ELEM(
context->img_convert_frame->colorspace, AVCOL_SPC_RGB, AVCOL_SPC_UNSPECIFIED));
452 const ImBuf *
image = (use_float && input_ibuf->float_data() ==
nullptr) ?
453 alloc_imbuf_for_colorspace_transform(input_ibuf) :
457 const float *pixels_fl =
image->float_data();
459 if ((!use_float && (pixels ==
nullptr)) || (use_float && (pixels_fl ==
nullptr))) {
460 if (
image != input_ibuf) {
466 AVCodecParameters *codec =
context->video_stream->codecpar;
467 int height = codec->height;
470 if (
context->img_convert_frame !=
nullptr) {
472 rgb_frame =
context->img_convert_frame;
476 rgb_frame =
context->current_frame;
481 av_frame_make_writable(rgb_frame);
483 const size_t linesize_dst = rgb_frame->linesize[0];
491 rgb_frame->linesize[2] == linesize_dst &&
492 rgb_frame->linesize[3] == linesize_dst,
493 "ffmpeg frame should be 4 same size planes for a floating point image case");
494 for (
int y = 0;
y < height;
y++) {
495 size_t dst_offset = linesize_dst * (height -
y - 1);
496 float *dst_g =
reinterpret_cast<float *
>(rgb_frame->data[0] + dst_offset);
497 float *dst_b =
reinterpret_cast<float *
>(rgb_frame->data[1] + dst_offset);
498 float *dst_r =
reinterpret_cast<float *
>(rgb_frame->data[2] + dst_offset);
499 float *dst_a =
reinterpret_cast<float *
>(rgb_frame->data[3] + dst_offset);
500 const float *src = pixels_fl +
image->x *
y * 4;
503 for (
int x = 0;
x <
image->x;
x++) {
514 for (
int x = 0;
x <
image->x;
x++) {
526 const size_t linesize_src = rgb_frame->width * 4;
527 for (
int y = 0;
y < height;
y++) {
528 uint8_t *target = rgb_frame->data[0] + linesize_dst * (height -
y - 1);
529 const uint8_t *src = pixels + linesize_src *
y;
533 memcpy(target, src, linesize_src);
538 if (
context->img_convert_frame !=
nullptr) {
541 av_frame_make_writable(
context->current_frame);
542 ffmpeg_sws_scale_frame(
context->sws_ctx,
context->current_frame, rgb_frame);
545 if (
image != input_ibuf) {
552static AVRational calc_time_base(
uint den,
double num, AVCodecID codec_id)
560 const uint DENUM_MAX = (codec_id == AV_CODEC_ID_MPEG4) ? (1UL << 16) - 1 : (1UL << 31) - 1;
575 const int max_num_shift =
fabsf(log10f(
eps));
577 const int max_den_shift = log10f(DENUM_MAX) - log10f(den);
578 const int max_iter =
min_ii(max_num_shift, max_den_shift);
587 AVRational time_base;
589 time_base.num = int(
num);
594static const AVCodec *get_av1_encoder(
595 MovieWriter *context,
const RenderData *rd, AVDictionary **opts,
int rectx,
int recty)
601 const AVCodec *codec =
nullptr;
602 switch (
context->ffmpeg_preset) {
606 codec = avcodec_find_encoder_by_name(
"librav1e");
609 codec = avcodec_find_encoder_by_name(
"libaom-av1");
613 codec = avcodec_find_encoder_by_name(
"libsvtav1");
617 codec = avcodec_find_encoder_by_name(
"libaom-av1");
623 codec = avcodec_find_encoder(AV_CODEC_ID_AV1);
628 if (
STREQ(codec->name,
"librav1e")) {
630 if (rd->threads > 8) {
631 ffmpeg_dict_set_int(opts,
"tiles", rd->threads);
634 ffmpeg_dict_set_int(opts,
"tiles", 8);
640 switch (
context->ffmpeg_preset) {
642 ffmpeg_dict_set_int(opts,
"speed", 4);
645 ffmpeg_dict_set_int(opts,
"speed", 10);
649 ffmpeg_dict_set_int(opts,
"speed", 6);
655 av_dict_set(opts,
"rav1e-params", buffer, 0);
657 else if (
STREQ(codec->name,
"libsvtav1")) {
661 switch (
context->ffmpeg_preset) {
663 ffmpeg_dict_set_int(opts,
"preset", 8);
666 ffmpeg_dict_set_int(opts,
"preset", 3);
670 ffmpeg_dict_set_int(opts,
"preset", 5);
674 else if (
STREQ(codec->name,
"libaom-av1")) {
676 ffmpeg_dict_set_int(opts,
"row-mt", 1);
677 const char *tiles_string =
nullptr;
678 bool tiles_string_is_dynamic =
false;
679 if (rd->threads > 0) {
681 int threads_sqrt =
sqrtf(rd->threads);
682 if (threads_sqrt < 4) {
686 if (
is_power_of_2_i(threads_sqrt) && threads_sqrt * threads_sqrt == rd->threads) {
689 for (
int t_sqrt_copy = threads_sqrt; t_sqrt_copy > 0; t_sqrt_copy /= 10) {
693 char *tiles_string_mut = (
char *)calloc(digits * 2 + 2, 1);
694 BLI_snprintf_utf8(tiles_string_mut, digits * 2 + 2,
"%dx%d", threads_sqrt, threads_sqrt);
695 tiles_string_is_dynamic =
true;
696 tiles_string = tiles_string_mut;
707 if (sqrt_p2_next < 1) {
710 if (sqrt_p2 > sqrt_p2_next) {
713 sqrt_p2 = sqrt_p2_next;
716 int combined_digits = 0;
717 for (
int sqrt_p2_copy = sqrt_p2; sqrt_p2_copy > 0; sqrt_p2_copy /= 10) {
720 for (
int sqrt_p2_copy = sqrt_p2_next; sqrt_p2_copy > 0; sqrt_p2_copy /= 10) {
724 char *tiles_string_mut = (
char *)calloc(combined_digits + 2, 1);
727 tiles_string_mut, combined_digits + 2,
"%dx%d", sqrt_p2_next, sqrt_p2);
729 else if (rectx < recty) {
731 tiles_string_mut, combined_digits + 2,
"%dx%d", sqrt_p2, sqrt_p2_next);
734 BLI_snprintf_utf8(tiles_string_mut, combined_digits + 2,
"%dx%d", sqrt_p2, sqrt_p2);
736 tiles_string_is_dynamic =
true;
737 tiles_string = tiles_string_mut;
743 tiles_string =
"4x2";
745 else if (rectx < recty) {
746 tiles_string =
"2x4";
749 tiles_string =
"2x2";
752 av_dict_set(opts,
"tiles", tiles_string, 0);
753 if (tiles_string_is_dynamic) {
754 free((
void *)tiles_string);
760 switch (
context->ffmpeg_preset) {
762 ffmpeg_dict_set_int(opts,
"cpu-used", 8);
765 ffmpeg_dict_set_int(opts,
"cpu-used", 4);
769 ffmpeg_dict_set_int(opts,
"cpu-used", 6);
780static int remap_crf_to_h265_crf(
int crf,
bool is_10_or_12_bpp)
783 const int bias = is_10_or_12_bpp ? -3 : 0;
801static const AVCodec *get_prores_encoder(
const ImageFormatData *imf,
int rectx,
int recty)
807 if ((
size_t(rectx) *
size_t(recty)) > (3840 * 2160)) {
808 return avcodec_find_encoder_by_name(
"prores_ks");
811 return avcodec_find_encoder_by_name(
"prores_aw");
816static int remap_crf_to_h264_10bpp_crf(
int crf)
818 crf = int(-12.0f + (crf / 51.0f) * 63.0f);
823static void set_quality_rate_options(
const MovieWriter *context,
824 const AVCodecID codec_id,
829 AVCodecContext *c =
context->video_codec;
833 c->bit_rate =
context->ffmpeg_video_bitrate * 1000;
834 c->rc_max_rate = ffcodecdata->rc_max_rate * 1000;
835 c->rc_min_rate = ffcodecdata->rc_min_rate * 1000;
836 c->rc_buffer_size = ffcodecdata->rc_buffer_size * 1024;
846 const bool av1_librav1e = codec_id == AV_CODEC_ID_AV1 &&
STREQ(c->codec->name,
"librav1e");
847 const bool av1_libsvtav1 = codec_id == AV_CODEC_ID_AV1 &&
STREQ(c->codec->name,
"libsvtav1");
851 if (codec_id == AV_CODEC_ID_VP9) {
853 ffmpeg_dict_set_int(opts,
"lossless", 1);
855 else if (codec_id == AV_CODEC_ID_H264 && is_10_bpp) {
857 ffmpeg_dict_set_int(opts,
"qp", 0);
859 else if (codec_id == AV_CODEC_ID_H265) {
861 av_dict_set(opts,
"x265-params",
"log-level=1:lossless=1", 0);
863 else if (codec_id == AV_CODEC_ID_AV1 && (av1_librav1e || av1_libsvtav1)) {
865 ffmpeg_dict_set_int(opts,
"qp", 0);
869 ffmpeg_dict_set_int(opts,
"crf", 0);
877 if (codec_id == AV_CODEC_ID_H264 && is_10_bpp) {
878 crf = remap_crf_to_h264_10bpp_crf(crf);
880 else if (codec_id == AV_CODEC_ID_H265) {
882 crf = remap_crf_to_h265_crf(crf, is_10_bpp || is_12_bpp);
885 av_dict_set(opts,
"x265-params",
"log-level=1", 0);
890 int qp = int(
float(crf) / 51.0f * 255.0f);
892 ffmpeg_dict_set_int(opts,
"qp", qp);
894 else if (av1_libsvtav1) {
896 ffmpeg_dict_set_int(opts,
"qp", crf);
899 ffmpeg_dict_set_int(opts,
"crf", crf);
905 const AVPixFmtDescriptor *pix_fmt_desc = av_pix_fmt_desc_get(c->pix_fmt);
906 const bool is_rgb_format = (pix_fmt_desc->flags & AV_PIX_FMT_FLAG_RGB);
907 const bool rgb_matrix =
false;
914 c->color_primaries = AVColorPrimaries(cicp[0]);
915 c->color_trc = AVColorTransferCharacteristic(cicp[1]);
916 c->colorspace = (is_rgb_format) ? AVCOL_SPC_RGB : AVColorSpace(cicp[2]);
918 c->color_range = (is_rgb_format || cicp[3] == 1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
920 else if (!is_rgb_format) {
923 c->color_primaries = AVCOL_PRI_UNSPECIFIED;
924 c->color_trc = AVCOL_TRC_UNSPECIFIED;
925 c->colorspace = AVCOL_SPC_BT709;
927 c->color_range = AVCOL_RANGE_MPEG;
934static AVStream *alloc_video_stream(MovieWriter *context,
945 const AVCodec *codec;
946 AVDictionary *opts =
nullptr;
951 st = avformat_new_stream(of,
nullptr);
959 if (codec_id == AV_CODEC_ID_AV1) {
962 codec = get_av1_encoder(context, rd, &opts, rectx, recty);
964 else if (codec_id == AV_CODEC_ID_PRORES) {
965 codec = get_prores_encoder(imf, rectx, recty);
968 codec = avcodec_find_encoder(codec_id);
972 context->video_codec =
nullptr;
976 context->video_codec = avcodec_alloc_context3(codec);
977 AVCodecContext *c =
context->video_codec;
986 c->time_base.den = 2997;
987 c->time_base.num = 100;
989 else if (
float(
int(rd->frs_sec_base)) == rd->frs_sec_base) {
990 c->time_base.den = rd->frs_sec;
991 c->time_base.num = int(rd->frs_sec_base);
994 c->time_base = calc_time_base(rd->frs_sec, rd->frs_sec_base, codec_id);
1003 if (c->time_base.num != 1) {
1004 AVRational new_time_base;
1006 &new_time_base.num, &new_time_base.den, c->time_base.num, c->time_base.den,
INT_MAX))
1009 c->time_base = new_time_base;
1013 st->time_base = c->time_base;
1015 c->gop_size =
context->ffmpeg_gop_size;
1016 c->max_b_frames =
context->ffmpeg_max_b_frames;
1018 set_quality_rate_options(context, codec_id, &rd->ffcodecdata, imf, &opts);
1024 char const *preset_name =
nullptr;
1025 char const *deadline_name =
nullptr;
1026 switch (
context->ffmpeg_preset) {
1028 preset_name =
"medium";
1029 deadline_name =
"good";
1032 preset_name =
"slower";
1033 deadline_name =
"best";
1036 preset_name =
"superfast";
1037 deadline_name =
"realtime";
1044 if (preset_name !=
nullptr && codec_id != AV_CODEC_ID_AV1) {
1045 av_dict_set(&opts,
"preset", preset_name, 0);
1047 if (deadline_name !=
nullptr) {
1048 av_dict_set(&opts,
"deadline", deadline_name, 0);
1056 c->pix_fmt = pix_fmts[0];
1060 c->pix_fmt = AV_PIX_FMT_YUV422P;
1068 c->pix_fmt = AV_PIX_FMT_YUV420P10LE;
1070 else if (is_12_bpp) {
1071 c->pix_fmt = AV_PIX_FMT_YUV420P12LE;
1076 c->pix_fmt = AV_PIX_FMT_YUV420P;
1077 c->codec_tag = ((
'D' << 24) + (
'I' << 16) + (
'V' << 8) +
'X');
1080 if (codec_id == AV_CODEC_ID_H265) {
1085 c->codec_tag = MKTAG(
'h',
'v',
'c',
'1');
1089 if (codec_id == AV_CODEC_ID_HUFFYUV) {
1091 c->pix_fmt = AV_PIX_FMT_BGRA;
1094 c->pix_fmt = AV_PIX_FMT_RGB32;
1098 if (codec_id == AV_CODEC_ID_DNXHD) {
1105 if (codec_id == AV_CODEC_ID_FFV1) {
1107 c->pix_fmt = AV_PIX_FMT_GRAY8;
1109 c->pix_fmt = AV_PIX_FMT_GRAY10;
1111 else if (is_12_bpp) {
1112 c->pix_fmt = AV_PIX_FMT_GRAY12;
1114 else if (is_16_bpp) {
1115 c->pix_fmt = AV_PIX_FMT_GRAY16;
1119 c->pix_fmt = AV_PIX_FMT_RGB32;
1121 c->pix_fmt = AV_PIX_FMT_GBRAP10;
1123 else if (is_12_bpp) {
1124 c->pix_fmt = AV_PIX_FMT_GBRAP12;
1126 else if (is_16_bpp) {
1127 c->pix_fmt = AV_PIX_FMT_GBRAP16;
1131 c->pix_fmt = AV_PIX_FMT_0RGB32;
1133 c->pix_fmt = AV_PIX_FMT_GBRP10;
1135 else if (is_12_bpp) {
1136 c->pix_fmt = AV_PIX_FMT_GBRP12;
1138 else if (is_16_bpp) {
1139 c->pix_fmt = AV_PIX_FMT_GBRP16;
1144 if (codec_id == AV_CODEC_ID_QTRLE) {
1146 c->pix_fmt = AV_PIX_FMT_GRAY8;
1149 c->pix_fmt = AV_PIX_FMT_ARGB;
1152 c->pix_fmt = AV_PIX_FMT_RGB24;
1157 c->pix_fmt = AV_PIX_FMT_YUVA420P;
1159 else if (
ELEM(codec_id, AV_CODEC_ID_H264, AV_CODEC_ID_H265, AV_CODEC_ID_VP9, AV_CODEC_ID_AV1) &&
1163 c->pix_fmt = AV_PIX_FMT_YUV444P;
1165 c->pix_fmt = AV_PIX_FMT_YUV444P10LE;
1167 else if (is_12_bpp) {
1168 c->pix_fmt = AV_PIX_FMT_YUV444P12LE;
1172 if (codec_id == AV_CODEC_ID_PNG) {
1174 c->pix_fmt = AV_PIX_FMT_GRAY8;
1177 c->pix_fmt = AV_PIX_FMT_RGBA;
1180 c->pix_fmt = AV_PIX_FMT_RGB24;
1183 if (codec_id == AV_CODEC_ID_PRORES) {
1187 c->profile =
context->ffmpeg_profile;
1188 c->pix_fmt = AV_PIX_FMT_YUV422P10LE;
1193 c->profile =
context->ffmpeg_profile;
1194 c->pix_fmt = AV_PIX_FMT_YUV444P10LE;
1197 c->pix_fmt = AV_PIX_FMT_YUVA444P10LE;
1205 if (of->oformat->flags & AVFMT_GLOBALHEADER) {
1207 c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1212 &imf->view_settings, &imf->display_settings);
1213 set_colorspace_options(c, display_colorspace);
1217 st->sample_aspect_ratio = c->sample_aspect_ratio = av_d2q((
double(rd->xasp) /
double(rd->yasp)),
1219 st->avg_frame_rate = av_inv_q(c->time_base);
1221 if (codec->capabilities & AV_CODEC_CAP_OTHER_THREADS) {
1222 c->thread_count = 0;
1225 c->thread_count = MOV_thread_count();
1228 if (codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) {
1229 c->thread_type = FF_THREAD_FRAME;
1231 else if (codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) {
1232 c->thread_type = FF_THREAD_SLICE;
1235 int ret = avcodec_open2(c, codec, &opts);
1238 char error_str[AV_ERROR_MAX_STRING_SIZE];
1239 av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE,
ret);
1240 CLOG_ERROR(&
LOG,
"Couldn't initialize video codec: %s\n", error_str);
1241 BLI_strncpy(error, ffmpeg_last_error(), error_maxncpy);
1242 av_dict_free(&opts);
1243 avcodec_free_context(&c);
1244 context->video_codec =
nullptr;
1247 av_dict_free(&opts);
1250 context->current_frame = alloc_frame(c->pix_fmt, c->width, c->height);
1252 if (c->pix_fmt == AV_PIX_FMT_RGBA &&
ELEM(c->colorspace, AVCOL_SPC_RGB, AVCOL_SPC_UNSPECIFIED)) {
1254 context->img_convert_frame =
nullptr;
1260 const AVPixelFormat src_format = is_10_bpp || is_12_bpp || is_16_bpp ? AV_PIX_FMT_GBRAPF32LE :
1262 context->img_convert_frame = alloc_frame(src_format, c->width, c->height);
1263 context->sws_ctx = ffmpeg_sws_get_context(c->width,
1271 c->color_range == AVCOL_RANGE_JPEG,
1272 c->colorspace != AVCOL_SPC_RGB ? c->colorspace : -1,
1276 avcodec_parameters_from_context(st->codecpar, c);
1278 add_hdr_mastering_display_metadata(st->codecpar, c, imf);
1279 add_stereo3d_metadata(st->codecpar, *rd, *imf);
1280 add_spherical_mapping_metadata(st->codecpar, scene);
1287static void ffmpeg_add_metadata_callback(
void *
data,
1288 const char *propname,
1293 av_dict_set(
metadata, propname, propvalue, 0);
1296static bool start_ffmpeg_impl(MovieWriter *context,
1307 AVFormatContext *of;
1308 const AVOutputFormat *fmt;
1309 char filepath[
FILE_MAX], error[1024];
1313 context->ffmpeg_type = rd->ffcodecdata.type;
1314 context->ffmpeg_codec = mov_av_codec_id_get(rd->ffcodecdata.codec_id_get());
1315 context->ffmpeg_audio_codec = mov_av_codec_id_get(rd->ffcodecdata.audio_codec_id_get());
1316 context->ffmpeg_video_bitrate = rd->ffcodecdata.video_bitrate;
1317 context->ffmpeg_audio_bitrate = rd->ffcodecdata.audio_bitrate;
1318 context->ffmpeg_gop_size = rd->ffcodecdata.gop_size;
1320 context->ffmpeg_crf = rd->ffcodecdata.constant_rate_factor;
1323 context->ffmpeg_crf = rd->ffcodecdata.custom_constant_rate_factor;
1325 context->ffmpeg_preset = rd->ffcodecdata.ffmpeg_preset;
1329 context->ffmpeg_max_b_frames = rd->ffcodecdata.max_b_frames;
1333 if (!ffmpeg_filepath_get(
1334 context, filepath, scene,
project, rd,
context->ffmpeg_preview, suffix, reports))
1339 "ffmpeg: starting output to %s:\n"
1340 " type=%d, codec=%d, audio_codec=%d,\n"
1341 " video_bitrate=%d, audio_bitrate=%d,\n"
1342 " gop_size=%d, autosplit=%d\n"
1343 " width=%d, height=%d",
1348 context->ffmpeg_video_bitrate,
1349 context->ffmpeg_audio_bitrate,
1356 exts = get_file_extensions(
context->ffmpeg_type);
1362 fmt = av_guess_format(
nullptr, exts[0],
nullptr);
1368 of = avformat_alloc_context();
1374 enum AVCodecID audio_codec =
context->ffmpeg_audio_codec;
1375 enum AVCodecID video_codec =
context->ffmpeg_codec;
1377 of->url = av_strdup(filepath);
1379 switch (
context->ffmpeg_type) {
1381 video_codec = AV_CODEC_ID_THEORA;
1384 video_codec = AV_CODEC_ID_DVVIDEO;
1387 video_codec = AV_CODEC_ID_MPEG1VIDEO;
1390 video_codec = AV_CODEC_ID_MPEG2VIDEO;
1393 video_codec = AV_CODEC_ID_H264;
1396 video_codec = AV_CODEC_ID_MPEG4;
1399 video_codec = AV_CODEC_ID_FLV1;
1402 video_codec = AV_CODEC_ID_AV1;
1407 video_codec =
context->ffmpeg_codec;
1412 if ((video_codec == AV_CODEC_ID_AV1) || (video_codec == AV_CODEC_ID_H264) ||
1413 (video_codec == AV_CODEC_ID_H265))
1417 else if (video_codec == AV_CODEC_ID_VP9) {
1420 else if (video_codec == AV_CODEC_ID_MPEG4) {
1427# if LIBAVFORMAT_VERSION_MAJOR >= 59
1431 of->oformat = (AVOutputFormat *)fmt;
1434 if (video_codec == AV_CODEC_ID_DVVIDEO) {
1439 if (rd->frs_sec != 25 && recty != 480) {
1443 if (rd->frs_sec == 25 && recty != 576) {
1450 audio_codec = AV_CODEC_ID_PCM_S16LE;
1451 if (
context->ffmpeg_audio_codec != AV_CODEC_ID_NONE &&
1452 rd->ffcodecdata.audio_mixrate != 48000 && rd->ffcodecdata.audio_channels != 2)
1459 if (video_codec == AV_CODEC_ID_PRORES) {
1460 context->ffmpeg_profile = rd->ffcodecdata.ffmpeg_prores_profile;
1463 if (video_codec != AV_CODEC_ID_NONE) {
1464 context->video_stream = alloc_video_stream(
1465 context, *scene, imf, video_codec, of, rectx, recty, error,
sizeof(error));
1470 CLOG_INFO(&
LOG,
"ffmpeg: video stream error: %s", error);
1480 if (
context->ffmpeg_audio_codec != AV_CODEC_ID_NONE) {
1481 context->audio_stream = alloc_audio_stream(context,
1482 rd->ffcodecdata.audio_mixrate,
1483 rd->ffcodecdata.audio_channels,
1492 CLOG_INFO(&
LOG,
"ffmpeg: audio stream error: %s", error);
1501 if (!(fmt->flags & AVFMT_NOFILE)) {
1502 if (avio_open(&of->pb, filepath, AVIO_FLAG_WRITE) < 0) {
1504 CLOG_INFO(&
LOG,
"ffmpeg: could not open file %s for writing", filepath);
1509 if (
context->stamp_data !=
nullptr) {
1511 &of->metadata,
context->stamp_data, ffmpeg_add_metadata_callback,
false);
1514 ret = avformat_write_header(of,
nullptr);
1518 "Could not initialize streams, probably unsupported codec combination");
1519 char error_str[AV_ERROR_MAX_STRING_SIZE];
1520 av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE,
ret);
1521 CLOG_INFO(&
LOG,
"ffmpeg: could not write media header: %s", error_str);
1526 av_dump_format(of, 0, filepath, 1);
1535 context->video_stream =
nullptr;
1536 context->audio_stream =
nullptr;
1538 avformat_free_context(of);
1546static void flush_delayed_frames(AVCodecContext *c, AVStream *stream, AVFormatContext *outfile)
1548 char error_str[AV_ERROR_MAX_STRING_SIZE];
1549 AVPacket *packet = av_packet_alloc();
1551 avcodec_send_frame(c,
nullptr);
1556 ret = avcodec_receive_packet(c, packet);
1558 if (
ret == AVERROR(EAGAIN) ||
ret == AVERROR_EOF) {
1563 av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE,
ret);
1564 CLOG_ERROR(&
LOG,
"Error encoding delayed frame: %s", error_str);
1568 packet->stream_index = stream->index;
1569 av_packet_rescale_ts(packet, c->time_base, stream->time_base);
1570# ifdef FFMPEG_USE_DURATION_WORKAROUND
1574 int write_ret = av_interleaved_write_frame(outfile, packet);
1575 if (write_ret != 0) {
1576 av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE,
ret);
1577 CLOG_ERROR(&
LOG,
"Error writing delayed frame: %s", error_str);
1582 av_packet_free(&packet);
1592static bool ffmpeg_filepath_get(MovieWriter *context,
1603 const char **exts = get_file_extensions(rd->ffcodecdata.type);
1604 const char **fe = exts;
1607 if (!filepath || !exts) {
1627 filepath,
FILE_MAX, template_variables);
1628 if (!errors.is_empty()) {
1636 CLOG_ERROR(&
LOG,
"Couldn't create directory for file %s: %s", filepath, std::strerror(errno));
1640 autosplit[0] =
'\0';
1650 if (
BLI_strcasecmp(filepath + strlen(filepath) - strlen(*fe), *fe) == 0) {
1656 if (*fe ==
nullptr) {
1663 *(filepath + strlen(filepath) - strlen(*fe)) =
'\0';
1681static void ffmpeg_get_filepath(
char filepath[ 1024],
1689 ffmpeg_filepath_get(
nullptr, filepath, scene,
project, rd, preview, suffix, reports);
1692static MovieWriter *ffmpeg_movie_open(
const Scene *scene,
1702 MovieWriter *
context = MEM_new<MovieWriter>(
"new FFMPEG context");
1704 context->ffmpeg_codec = AV_CODEC_ID_MPEG4;
1705 context->ffmpeg_audio_codec = AV_CODEC_ID_NONE;
1706 context->ffmpeg_video_bitrate = 1150;
1707 context->ffmpeg_audio_bitrate = 128;
1708 context->ffmpeg_gop_size = 12;
1709 context->ffmpeg_autosplit =
false;
1710 context->stamp_data =
nullptr;
1711 context->audio_time_total = 0.0;
1713 context->ffmpeg_autosplit_count = 0;
1714 context->ffmpeg_preview = preview;
1717 bool success = start_ffmpeg_impl(
1718 context, scene,
project, rd, imf, rectx, recty, suffix, reports);
1721 success = movie_audio_open(context,
1723 preview ? rd->psfra : rd->sfra,
1724 rd->ffcodecdata.audio_mixrate,
1725 rd->ffcodecdata.audio_volume,
1730 ffmpeg_movie_close(context);
1736static void end_ffmpeg_impl(MovieWriter *context,
bool is_autosplit);
1738static bool ffmpeg_movie_append(MovieWriter *context,
1750 bool success =
true;
1755 avframe = generate_video_frame(context,
image);
1756 success = (avframe && write_video_frame(context, avframe, reports));
1762 context, (frame - start_frame + 1) / (
double(rd->frs_sec) /
double(rd->frs_sec_base)));
1765 if (
context->ffmpeg_autosplit) {
1766 if (avio_tell(
context->outfile->pb) > ffmpeg_autosplit_size) {
1767 end_ffmpeg_impl(context,
true);
1768 context->ffmpeg_autosplit_count++;
1770 success &= start_ffmpeg_impl(
1778static void end_ffmpeg_impl(MovieWriter *context,
bool is_autosplit)
1782 movie_audio_close(context, is_autosplit);
1795 av_write_trailer(
context->outfile);
1800 context->video_stream =
nullptr;
1801 context->audio_stream =
nullptr;
1803 av_frame_free(&
context->current_frame);
1804 av_frame_free(&
context->img_convert_frame);
1807 if (!(
context->outfile->oformat->flags & AVFMT_NOFILE)) {
1808 avio_close(
context->outfile->pb);
1812 if (
context->video_codec !=
nullptr) {
1813 avcodec_free_context(&
context->video_codec);
1814 context->video_codec =
nullptr;
1816 if (
context->audio_codec !=
nullptr) {
1817 avcodec_free_context(&
context->audio_codec);
1818 context->audio_codec =
nullptr;
1821 if (
context->outfile !=
nullptr) {
1822 avformat_free_context(
context->outfile);
1825 if (
context->audio_input_buffer !=
nullptr) {
1826 av_free(
context->audio_input_buffer);
1827 context->audio_input_buffer =
nullptr;
1830 if (
context->audio_deinterleave_buffer !=
nullptr) {
1831 av_free(
context->audio_deinterleave_buffer);
1832 context->audio_deinterleave_buffer =
nullptr;
1835 if (
context->sws_ctx !=
nullptr) {
1836 ffmpeg_sws_release_context(
context->sws_ctx);
1841static void ffmpeg_movie_close(MovieWriter *context)
1843 if (context ==
nullptr) {
1846 end_ffmpeg_impl(context,
false);
1850 MEM_delete(context);
1870 MovieWriter *writer =
nullptr;
1872 writer = ffmpeg_movie_open(scene,
project, rd, imf, rectx, recty, reports, preview, suffix);
1890 if (writer ==
nullptr) {
1895 bool ok = ffmpeg_movie_append(
1896 writer, scene,
project, rd, imf, start_frame, frame,
image, suffix, reports);
1908 ffmpeg_movie_close(writer);
1925 ffmpeg_get_filepath(filepath, scene,
project, rd, preview, suffix, reports);
Functions and classes for evaluating template expressions in filepaths.
File and directory operations.
#define SNPRINTF(dst, format,...)
#define SNPRINTF_UTF8(dst, format,...)
#define CLOG_ERROR(clg_ref,...)
#define CLOG_WARN(clg_ref,...)
#define CLOG_STR_INFO(clg_ref, str)
#define CLOG_INFO(clg_ref,...)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define BLI_assert_msg(a, msg)
FFMPEG_INLINE size_t ffmpeg_get_buffer_alignment()
FFMPEG_INLINE enum AVPixelFormat * ffmpeg_get_pix_fmts(struct AVCodecContext *context, const AVCodec *codec)
FFMPEG_INLINE void my_guess_pkt_duration(AVFormatContext *s, AVStream *st, AVPacket *pkt)
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
void free(Subdiv *subdiv)
int context(const bContext *C, const char *member, bContextDataResult *result)
T clamp(const T &a, const T &min, const T &max)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
int char char int BLI_strcasecmp(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
bool void bool BLI_path_frame_check_chars(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
size_t size_t size_t BLI_snprintf_utf8(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
void MOV_filepath_from_settings(char filepath[1024], const Scene *scene, const bke::BlenderProject *project, const RenderData *rd, bool preview, const char *suffix, ReportList *reports)
void IMB_buffer_float_from_byte(float *dest, const unsigned char *src, int width, int height, int dest_stride, int src_stride)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
bool BLI_path_abs(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1
void BKE_add_template_variables_general(bke::path_templates::VariableMap &variables, const ID *path_owner_id, const bke::BlenderProject *project)
bool MOV_codec_supports_alpha(IMB_Ffmpeg_Codec_ID codec_id, int ffmpeg_profile)
size_t IMB_get_pixel_count(const ImBuf *ibuf)
Get the length of the data of the given image buffer in pixels.
MINLINE int power_of_2_min_i(int n)
bool bool BLI_path_suffix(char *path, size_t path_maxncpy, const char *suffix, const char *sep) ATTR_NONNULL(1
void BKE_report_path_template_errors(ReportList *reports, eReportType report_type, StringRef path, Span< bke::path_templates::Error > errors)
const char * BKE_main_blendfile_path_from_global()
MINLINE int max_ii(int a, int b)
bool IMB_colormanagement_space_to_cicp(const ColorSpace *colorspace, ColorManagedFileOutput output, bool rgb_matrix, int cicp[4])
bool BLI_path_frame_range(char *path, size_t path_maxncpy, int sta, int end, int digits) ATTR_NONNULL(1)
MovieWriter * MOV_write_begin(const Scene *scene, const bke::BlenderProject *project, const RenderData *rd, const ImageFormatData *imf, int rectx, int recty, ReportList *reports, bool preview, const char *suffix)
void MOV_write_end(MovieWriter *writer)
void BKE_add_template_variables_for_render_path(bke::path_templates::VariableMap &variables, const Scene &scene)
Vector< bke::path_templates::Error > BKE_path_apply_template(char *path, int path_maxncpy, const bke::path_templates::VariableMap &template_variables)
void BKE_stamp_data_free(StampData *stamp_data)
@ CAM_PANORAMA_EQUIRECTANGULAR
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void IMB_freeImBuf(ImBuf *ibuf)
bool MOV_write_append(MovieWriter *writer, const Scene *scene, const bke::BlenderProject *project, const RenderData *rd, const ImageFormatData *imf, int start_frame, int frame, const ImBuf *image, const char *suffix, ReportList *reports)
void BKE_report(ReportList *reports, eReportType type, const char *message)
BMesh const char void * data
@ S3D_INTERLACE_CHECKERBOARD
@ S3D_SIDEBYSIDE_CROSSEYED
int IMB_colormanagement_view_max_nits(const char *display_name, const char *view_name)
ATTR_WARN_UNUSED_RESULT const size_t num
bool BKE_scene_multiview_is_stereo3d(const RenderData *rd)
bool MOV_codec_supports_crf(IMB_Ffmpeg_Codec_ID codec_id)
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
const ColorSpace * IMB_colormangement_display_get_color_space(const ColorManagedViewSettings *view_settings, const ColorManagedDisplaySettings *display_settings)
MINLINE unsigned int log2_floor_u(unsigned int x)
void BKE_stamp_info_callback(void *data, StampData *stamp_data, StampCallback callback, bool noskip)
@ FFMPEG_AUTOSPLIT_OUTPUT
@ FFMPEG_USE_MAX_B_FRAMES
StampData * BKE_stamp_info_from_scene_static(const Scene *scene)
MINLINE int is_power_of_2_i(int n)
@ FFM_PRORES_PROFILE_422_HQ
@ FFM_PRORES_PROFILE_4444_XQ
@ FFM_PRORES_PROFILE_4444
@ FFM_PRORES_PROFILE_422_PROXY
MINLINE int min_ii(int a, int b)
MINLINE int clamp_i(int value, int min, int max)
bool BLI_file_ensure_parent_dir_exists(const char *filepath) ATTR_NONNULL(1)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
MINLINE int compare_ff(float a, float b, float max_diff)
char char size_t char * BLI_strncat(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
ocio::ColorSpace ColorSpace
MINLINE void premul_to_straight_v4_v4(float straight[4], const float premul[4])
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ImageFormatData im_format