56 const bool guess_path,
57 const bool save_as_render)
61 if (iuser ==
nullptr) {
79 const char *ima_colorspace = ima->colorspace_settings.name;
143 if (guess_path && opts->
filepath[0] == 0) {
144 const bool is_prev_save = !
STREQ(
G.filepath_last_image,
"//");
177 return (ibuf !=
nullptr);
222 const char *filepath,
226 STRNCPY(ima->filepath, filepath);
241 const bool save_copy,
242 const char *filepath,
243 bool *r_colorspace_changed)
248 "Could not write image: %s",
249 errno ? strerror(errno) :
"internal error, see console");
295 *r_colorspace_changed =
true;
304 if (colorspace_name != ima->colorspace_settings.name) {
306 colorspace_name.
c_str());
315 *r_colorspace_changed =
true;
321 if (colormanaged_ibuf != ibuf) {
344 bool *r_colorspace_changed)
356 ImBuf *colormanaged_ibuf =
nullptr;
387 const int layer = (iuser && !is_multilayer) ? iuser->
layer : -1;
403 R
"(Did not write, the image doesn't have a "%s" and "%s" views)",
417 R
"(Did not write, the image doesn't have a "%s" and "%s" views)",
429 double rr_ppm_prev[2] = {0, 0};
431 if (save_as_render && rr) {
435 double ppm[2] = {0, 0};
444 auto render_result_restore_ppm = [rr, save_as_render, rr_ppm_prev]() {
445 if (save_as_render && rr) {
454 reports, rr, opts->
filepath, imf, save_as_render,
nullptr,
layer);
456 render_result_restore_ppm();
465 reports, rr, opts->
filepath, imf, save_as_render,
nullptr,
layer);
473 render_result_restore_ppm();
480 (is_exr_rr ?
true : save_copy),
482 r_colorspace_changed);
488 const int totviews = (rr ? rr->
views.count() : ima->views.count());
494 for (
int i = 0; i < totviews; i++) {
496 bool ok_view =
false;
503 reports, rr, filepath, imf, save_as_render, view,
layer);
504 image_save_post(reports, ima, ibuf, ok_view, opts,
true, filepath, r_colorspace_changed);
536 image_save_post(reports, ima, ibuf, ok_view, opts,
true, filepath, r_colorspace_changed);
542 render_result_restore_ppm();
553 reports, rr, opts->
filepath, imf, save_as_render,
nullptr,
layer);
555 render_result_restore_ppm();
561 ImBuf *ibuf_stereo[2] = {
nullptr};
568 bool stereo_ok =
true;
570 for (
int i = 0; i < 2; i++) {
594 if (ibuf ==
nullptr) {
596 reports,
RPT_ERROR,
"Did not write, unexpected error when saving stereo image");
628 for (
int i = 0; i < 2; i++) {
632 render_result_restore_ppm();
637 render_result_restore_ppm();
650 if (iuser ==
nullptr) {
656 bool colorspace_changed =
false;
659 char *udim_pattern =
nullptr;
667 "When saving a tiled image, the path '%s' must contain a valid UDIM marker",
683 tile_opts.
filepath, udim_pattern, tile_format,
tile.tile_number);
699 MEM_delete(udim_pattern);
708 if (colorspace_changed) {
725 if (imf ==
nullptr) {
734 const size_t size = size_t(width) * size_t(height) * size_t(channels);
736 std::copy_n(rect, size, output_rect);
737 tmp_output_rects.
append(output_rect);
742 output_rect, width, height, channels, from_colorspace, to_colorspace,
false);
744 r_colorspace = to_colorspace;
756 "Gray Scale Buffer For EXR");
757 temporary_buffers.
append(gray_scale_output);
760 for (
const int64_t y : sub_y_range) {
769 return gray_scale_output;
777 "Opaque Alpha Buffer For EXR");
778 temporary_buffers.
append(alpha_output);
781 for (
const int64_t y : sub_y_range) {
783 alpha_output[
y *
int64_t(width) +
x] = 1.0;
795 const char *view_name,
807 if (!is_multi_layer &&
layer != 0) {
820 if (view_name && !
STREQ(view_name, render_view.
name)) {
826 const char *render_view_name = view_name ?
"" : render_view.
name;
829 const int channels_count_in_buffer = 4;
834 if (save_as_render) {
836 render_result->
rectx,
837 render_result->
recty,
838 channels_count_in_buffer,
846 if (is_multi_layer) {
848 "Composite.Combined",
852 channels_count_in_buffer,
853 channels_count_in_buffer * render_result->
rectx,
867 render_result->
rectx,
868 render_result->
recty,
869 channels_count_in_buffer,
877 render_result->
rectx,
891 channels_count_in_buffer,
892 channels_count_in_buffer * render_result->
rectx,
900 const char *filepath,
902 const bool save_as_render,
911 if (!multi_layer &&
layer == -1) {
917 if (first_rview && (first_rview->
next || first_rview->
name[0])) {
933 if (!multi_layer && nr !=
layer) {
946 const char *viewname = render_pass.
view;
948 if (!
STREQ(view, viewname)) {
959 const bool pass_half_float = half_float && pass_RGBA;
966 if (save_as_render && pass_RGBA) {
978 std::string layer_pass_name = render_pass.
name;
981 if (has_multiple_layers || rl.
name[0] !=
'\0') {
982 layer_pass_name = rl.
name + (
"." + layer_pass_name);
1004 const int required_channels = imf ? int(imf->
color_mode) / 8 : 4;
1005 if (required_channels == render_pass.
channels ||
1006 (required_channels != 1 && render_pass.
channels != 1))
1009 std::min(required_channels, render_pass.
channels));
1020 else if (required_channels == 1) {
1035 else if (render_pass.
channels == 1) {
1039 for (
int i = 0; i < 3; i++) {
1042 std::string(1,
"RGB"[i]).c_str(),
1054 if (required_channels == 4 && render_pass.
channels < 4) {
1058 exrhandle,
"",
"A", viewname,
colorspace, 1, rr->
rectx, alpha_output, pass_half_float);
1067 const int compress = (imf ? imf->
exr_codec : 0);
1068 const int quality = (imf ? imf->
quality : 90);
1074 reports,
RPT_ERROR,
"Error writing render result, %s (see console)", strerror(errno));
1077 for (
float *rect : tmp_output_rects) {
1087 const char *filepath,
1098 reports,
RPT_ERROR,
"Render error (%s) cannot save: '%s'", strerror(err), filepath);
1106 const char *filepath,
1129 const char *filepath_basis,
1131 bool save_as_render)
1142 if (!save_as_render) {
1144 &format->linear_colorspace_settings);
1148 const bool is_exr_rr =
ELEM(
1155 reports, rr, filepath_basis, &image_format, save_as_render,
nullptr, -1);
1162 for (
const RenderView *rv = rr->
views.first(); rv; rv = rv->next, view_id++) {
1165 STRNCPY(filepath, filepath_basis);
1173 reports, rr, filepath, &image_format, save_as_render, rv->name, -1);
1182 filepath[strlen(filepath) - 4] = 0;
1191 reports, scene, rr, ibuf, filepath, &image_format, stamp);
1202 reports, scene, rr, ibuf, filepath, &image_format, stamp);
1213 STRNCPY(filepath, filepath_basis);
1216 printf(
"Stereo 3D not supported for MultiLayer image: %s\n", filepath);
1219 ImBuf *ibuf_arr[3] = {
nullptr};
1223 for (i = 0; i < 2; i++) {
1233 reports, scene, rr, ibuf_arr[2], filepath, &image_format, stamp);
1241 filepath[strlen(filepath) - 4] = 0;
1248 reports, scene, rr, ibuf_arr[2], filepath, &image_format, stamp);
1257 for (i = 0; i < 3; i++) {
#define IMA_SIGNAL_COLORMANAGE
File and directory operations.
#define BLI_path_join(...)
#define SNPRINTF(dst, format,...)
#define STR_CONCAT(dst, len, suffix)
#define CLOG_INFO_NOCHECK(clg_ref, format,...)
#define ID_BLEND_PATH(_bmain, _id)
#define RE_PASSNAME_COMBINED
#define STEREO_RIGHT_NAME
Read Blender memory allocation and freeing.
constexpr IndexRange()=default
constexpr const char * c_str() const
void append(const T &value)
const ccl_global KernelWorkTile * tile
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
bool BKE_image_is_multiview(const Image *ima)
char * BKE_image_get_tile_strformat(const char *filepath, eUDIM_TILE_FORMAT *r_tile_format)
bool bool BLI_path_extension_strip(char *path) ATTR_NONNULL(1)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
RenderResult * BKE_image_acquire_renderresult(Scene *scene, Image *ima)
static void add_exr_compositing_result(ExrWriteHandle *exr_handle, const RenderResult *render_result, const ImageFormatData *imf, bool save_as_render, const char *view_name, int layer, Vector< float * > &temporary_buffers)
char * STRNCPY(char(&dst)[N], const char *src)
void IMB_free_byte_pixels(ImBuf *ibuf)
void BKE_image_multiview_index(const Image *ima, ImageUser *iuser)
static CLG_LogRef LOG_RENDER
bool BKE_image_render_write(ReportList *reports, RenderResult *rr, const Scene *scene, bool stamp, const char *filepath_basis, const ImageFormatData *format=nullptr, bool save_as_render=true)
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_image_format_color_management_copy_from_scene(ImageFormatData *imf, const Scene *scene)
void BKE_image_release_renderresult(Scene *scene, Image *ima, RenderResult *render_result)
void BKE_image_signal(Main *bmain, Image *ima, ImageUser *iuser, int signal)
static bool image_render_write_stamp_test(ReportList *reports, const Scene *scene, const RenderResult *rr, ImBuf *ibuf, const char *filepath, const ImageFormatData *imf, const bool stamp)
void BKE_image_format_to_imbuf(ImBuf *ibuf, const ImageFormatData *imf)
void IMB_exr_write_pass(ExrWriteHandle *handle, StringRefNull layerpassname, StringRefNull channelnames, StringRefNull viewname, StringRefNull colorspace, size_t xstride, size_t ystride, const float *rect, bool use_half_float)
static void image_save_update_filepath(Image *ima, const char *filepath, const ImageSaveOptions *opts)
ImageTile * BKE_image_get_tile(Image *ima, int tile_number)
void BKE_color_managed_colorspace_settings_copy(ColorManagedColorspaceSettings *colorspace_settings, const ColorManagedColorspaceSettings *settings)
static const float * image_exr_from_scene_linear_to_output(const float *rect, const int width, const int height, const int channels, const ImageFormatData *imf, Vector< float * > &tmp_output_rects, StringRefNull &r_colorspace)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
bool BKE_imbuf_write_stamp(const Scene *scene, const RenderResult *rr, ImBuf *ibuf, const char *filepath, const ImageFormatData *imf)
@ R_IMF_COLOR_MANAGEMENT_FOLLOW_SCENE
bool IMB_exr_write_end(ExrWriteHandle *handle, const char *filepath, int width, int height, const double ppm[2], int compress, int quality, const StampData *stamp)
@ COLOR_ROLE_SCENE_LINEAR
@ COLOR_ROLE_DEFAULT_BYTE
static float * image_exr_opaque_alpha_buffer(int width, int height, Vector< float * > &temporary_buffers)
bool BKE_image_save_options_init(ImageSaveOptions *opts, Main *bmain, Scene *scene, Image *ima, ImageUser *iuser, bool guess_path, bool save_as_render)
static void image_save_post(ReportList *reports, Image *ima, ImBuf *ibuf, int ok, const ImageSaveOptions *opts, const bool save_copy, const char *filepath, bool *r_colorspace_changed)
ImBuf * RE_render_result_rect_to_ibuf(RenderResult *rr, const ImageFormatData *imf, const float dither, const int view_id)
ImBuf * IMB_stereo3d_ImBuf(const ImageFormatData *im_format, ImBuf *ibuf_left, ImBuf *ibuf_right)
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
void BKE_image_format_from_imbuf(ImageFormatData *im_format, const ImBuf *imbuf)
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
void BKE_scene_ppm_get(const RenderData *rd, double r_ppm[2])
@ R_IMF_IMTYPE_MULTILAYER
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
int BLI_findstringindex(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BKE_image_set_filepath_from_tile_number(char *filepath, const char *pattern, eUDIM_TILE_FORMAT tile_format, int tile_number)
void IMB_freeImBuf(ImBuf *ibuf)
void IMB_exr_write_view(ExrWriteHandle *handle, const char *viewname)
bool BKE_image_is_stereo(const Image *ima)
RenderPass * BKE_image_multilayer_index(RenderResult *rr, ImageUser *iuser)
const char * IMB_colormanagement_role_colorspace_name_get(int role)
void BKE_report(ReportList *reports, eReportType type, const char *message)
void IMB_colormanagement_colorspace_settings_set(ColorManagedColorspaceSettings *settings, const char *name)
MINLINE void copy_v2_v2_db(double r[2], const double a[2])
bool RE_ResultIsMultiView(RenderResult *rr)
bool RE_RenderPassIsColor(const RenderPass *render_pass)
const char * IMB_colormanagement_colorspace_get_name(const ColorSpace *colorspace)
bool void BLI_path_rel(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1)
static bool image_save_single(ReportList *reports, Image *ima, ImageUser *iuser, const ImageSaveOptions *opts, bool *r_colorspace_changed)
bool BKE_imbuf_alpha_test(ImBuf *ibuf)
int BKE_image_path_ext_from_imformat_ensure(char *filepath, size_t filepath_maxncpy, const ImageFormatData *im_format)
void BKE_image_format_init(ImageFormatData *imf)
int BLI_listbase_count_at_most(const ListBase *listbase, int count_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
ExrWriteHandle * IMB_exr_write_begin(bool write_multipart=false)
void BKE_image_format_free(ImageFormatData *imf)
static void image_render_print_save_message(ReportList *reports, const char *filepath, int ok, int err)
void BKE_image_format_init_for_write(ImageFormatData *imf, const Scene *scene_src, const ImageFormatData *imf_src, const bool allow_video=false)
void BKE_imbuf_stamp_info(const RenderResult *rr, ImBuf *ibuf)
ImBuf * IMB_colormanagement_imbuf_for_write(ImBuf *ibuf, bool save_as_render, bool allocate_result, const ImageFormatData *image_format)
bool BKE_imtype_requires_linear_float(char imtype)
bool RE_HasFloatPixels(const RenderResult *result)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
BLI_INLINE float IMB_colormanagement_get_luminance(const float rgb[3])
const ColorSpace * IMB_colormangement_display_get_color_space(const ColorManagedViewSettings *view_settings, const ColorManagedDisplaySettings *display_settings)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
bool BLI_path_extension_check(const char *path, const char *ext) ATTR_NONNULL(1
void BKE_image_save_options_free(ImageSaveOptions *opts)
bool BKE_color_managed_colorspace_settings_equals(const ColorManagedColorspaceSettings *settings1, const ColorManagedColorspaceSettings *settings2)
@ R_IMF_EXR_FLAG_MULTIPART
void BKE_image_save_options_update(ImageSaveOptions *opts, const Image *image)
bool BKE_image_render_write_exr(ReportList *reports, const RenderResult *rr, const char *filepath, const ImageFormatData *imf, bool save_as_render, const char *view, int layer)
static const float * image_exr_from_rgb_to_bw(const float *input_buffer, int width, int height, int channels, Vector< float * > &temporary_buffers)
void BKE_image_clear_autosave(Image *image)
bool BLI_path_make_safe_filename(char *filename) ATTR_NONNULL(1)
bool IMB_colormanagement_space_name_is_data(const char *name)
void BKE_image_format_update_color_space_for_type(ImageFormatData *format)
void BKE_scene_multiview_view_filepath_get(const RenderData *rd, const char *filepath, const char *view, char *r_filepath)
void IMB_colormanagement_transform_float(float *buffer, int width, int height, int channels, const char *from_colorspace, const char *to_colorspace, bool predivide)
void BKE_imageuser_default(ImageUser *iuser)
bool BKE_imbuf_write(ImBuf *ibuf, const char *filepath, const ImageFormatData *imf)
bool BLI_file_ensure_parent_dir_exists(const char *filepath) ATTR_NONNULL(1)
void IMB_free_float_pixels(ImBuf *ibuf)
bool IMB_colormanagement_space_name_is_scene_linear(const char *name)
static void imbuf_save_post(ImBuf *ibuf, ImBuf *colormanaged_ibuf)
bool BKE_image_save(ReportList *reports, Main *bmain, Image *ima, ImageUser *iuser, const ImageSaveOptions *opts)
ocio::ColorSpace ColorSpace
bool BKE_imbuf_write_as(ImBuf *ibuf, const char *filepath, const ImageFormatData *imf, bool save_copy)
void BKE_image_user_file_path_ex(const Main *bmain, const ImageUser *iuser, const Image *ima, char *filepath, const bool resolve_udim, const bool resolve_multiview)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
ImbFormatOptions foptions
const uint8_t * byte_data() const
const float * float_data() const
ImageFormatData im_format
ImageFormatData im_format
ListBaseT< RenderPass > passes
struct StampData * stamp_data
ListBaseT< RenderView > views
ListBaseT< RenderLayer > layers