Cleanup: add image_format.cc for functions related to ImageFormatData
Also fixes missing code to read/write/free/copy color management settings in various places. This can't be set through the UI currently, but still should be handled consistently.
This commit is contained in:
parent
4abb8a14a2
commit
6e4d2fa914
|
@ -90,7 +90,6 @@ int BKE_imbuf_write_stamp(struct Scene *scene,
|
|||
/**
|
||||
* \note imf->planes is ignored here, its assumed the image channels are already set.
|
||||
*/
|
||||
void BKE_imbuf_write_prepare(struct ImBuf *ibuf, const struct ImageFormatData *imf);
|
||||
int BKE_imbuf_write(struct ImBuf *ibuf, const char *name, const struct ImageFormatData *imf);
|
||||
/**
|
||||
* Same as #BKE_imbuf_write() but crappy workaround not to permanently modify _some_,
|
||||
|
@ -100,43 +99,6 @@ int BKE_imbuf_write_as(struct ImBuf *ibuf,
|
|||
const char *name,
|
||||
struct ImageFormatData *imf,
|
||||
bool save_copy);
|
||||
void BKE_image_path_from_imformat(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const struct ImageFormatData *im_format,
|
||||
bool use_ext,
|
||||
bool use_frames,
|
||||
const char *suffix);
|
||||
void BKE_image_path_from_imtype(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
char imtype,
|
||||
bool use_ext,
|
||||
bool use_frames,
|
||||
const char *suffix);
|
||||
int BKE_image_path_ensure_ext_from_imformat(char *string, const struct ImageFormatData *im_format);
|
||||
int BKE_image_path_ensure_ext_from_imtype(char *string, char imtype);
|
||||
char BKE_image_ftype_to_imtype(int ftype, const struct ImbFormatOptions *options);
|
||||
int BKE_image_imtype_to_ftype(char imtype, struct ImbFormatOptions *r_options);
|
||||
|
||||
bool BKE_imtype_is_movie(char imtype);
|
||||
bool BKE_imtype_supports_zbuf(char imtype);
|
||||
bool BKE_imtype_supports_compress(char imtype);
|
||||
bool BKE_imtype_supports_quality(char imtype);
|
||||
bool BKE_imtype_requires_linear_float(char imtype);
|
||||
char BKE_imtype_valid_channels(char imtype, bool write_file);
|
||||
char BKE_imtype_valid_depths(char imtype);
|
||||
|
||||
/**
|
||||
* String is from command line `--render-format` argument,
|
||||
* keep in sync with `creator_args.c` help info.
|
||||
*/
|
||||
char BKE_imtype_from_arg(const char *arg);
|
||||
|
||||
void BKE_imformat_defaults(struct ImageFormatData *im_format);
|
||||
void BKE_imbuf_to_image_format(struct ImageFormatData *im_format, const struct ImBuf *imbuf);
|
||||
|
||||
/**
|
||||
* Used by sequencer too.
|
||||
|
@ -171,10 +133,6 @@ struct RenderResult;
|
|||
#define IMA_SIGNAL_USER_NEW_IMAGE 6
|
||||
#define IMA_SIGNAL_COLORMANAGE 7
|
||||
|
||||
#define IMA_CHAN_FLAG_BW 1
|
||||
#define IMA_CHAN_FLAG_RGB 2
|
||||
#define IMA_CHAN_FLAG_ALPHA 4
|
||||
|
||||
/**
|
||||
* Checks whether there's an image buffer for given image and user.
|
||||
*/
|
||||
|
|
|
@ -0,0 +1,80 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later
|
||||
* Copyright 2001-2002 NaN Holding BV. All rights reserved. */
|
||||
|
||||
#pragma once
|
||||
|
||||
/** \file
|
||||
* \ingroup bke
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct BlendDataReader;
|
||||
struct BlendWriter;
|
||||
struct ImbFormatOptions;
|
||||
struct ImageFormatData;
|
||||
struct ImBuf;
|
||||
|
||||
/* Init/Copy/Free */
|
||||
|
||||
void BKE_image_format_init(struct ImageFormatData *imf, const bool render);
|
||||
void BKE_image_format_copy(struct ImageFormatData *imf_dst, const struct ImageFormatData *imf_src);
|
||||
void BKE_image_format_free(struct ImageFormatData *imf);
|
||||
|
||||
void BKE_image_format_blend_read_data(struct BlendDataReader *reader, struct ImageFormatData *imf);
|
||||
void BKE_image_format_blend_write(struct BlendWriter *writer, struct ImageFormatData *imf);
|
||||
|
||||
/* File Paths */
|
||||
|
||||
void BKE_image_path_from_imformat(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const struct ImageFormatData *im_format,
|
||||
bool use_ext,
|
||||
bool use_frames,
|
||||
const char *suffix);
|
||||
void BKE_image_path_from_imtype(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
char imtype,
|
||||
bool use_ext,
|
||||
bool use_frames,
|
||||
const char *suffix);
|
||||
int BKE_image_path_ensure_ext_from_imformat(char *string, const struct ImageFormatData *im_format);
|
||||
int BKE_image_path_ensure_ext_from_imtype(char *string, char imtype);
|
||||
|
||||
/* File Types */
|
||||
|
||||
#define IMA_CHAN_FLAG_BW 1
|
||||
#define IMA_CHAN_FLAG_RGB 2
|
||||
#define IMA_CHAN_FLAG_ALPHA 4
|
||||
|
||||
char BKE_ftype_to_imtype(int ftype, const struct ImbFormatOptions *options);
|
||||
int BKE_imtype_to_ftype(char imtype, struct ImbFormatOptions *r_options);
|
||||
|
||||
bool BKE_imtype_is_movie(char imtype);
|
||||
bool BKE_imtype_supports_zbuf(char imtype);
|
||||
bool BKE_imtype_supports_compress(char imtype);
|
||||
bool BKE_imtype_supports_quality(char imtype);
|
||||
bool BKE_imtype_requires_linear_float(char imtype);
|
||||
char BKE_imtype_valid_channels(char imtype, bool write_file);
|
||||
char BKE_imtype_valid_depths(char imtype);
|
||||
|
||||
/**
|
||||
* String is from command line `--render-format` argument,
|
||||
* keep in sync with `creator_args.c` help info.
|
||||
*/
|
||||
char BKE_imtype_from_arg(const char *arg);
|
||||
|
||||
/* Conversion between ImBuf settings. */
|
||||
|
||||
void BKE_image_format_from_imbuf(struct ImageFormatData *im_format, const struct ImBuf *imbuf);
|
||||
void BKE_image_format_to_imbuf(struct ImBuf *ibuf, const struct ImageFormatData *imf);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
|
@ -36,6 +36,8 @@ typedef struct ImageSaveOptions {
|
|||
void BKE_image_save_options_init(struct ImageSaveOptions *opts,
|
||||
struct Main *bmain,
|
||||
struct Scene *scene);
|
||||
void BKE_image_save_options_free(struct ImageSaveOptions *opts);
|
||||
|
||||
bool BKE_image_save(struct ReportList *reports,
|
||||
struct Main *bmain,
|
||||
struct Image *ima,
|
||||
|
|
|
@ -156,6 +156,7 @@ set(SRC
|
|||
intern/idprop_utils.c
|
||||
intern/idtype.c
|
||||
intern/image.cc
|
||||
intern/image_format.cc
|
||||
intern/image_partial_update.cc
|
||||
intern/image_gen.c
|
||||
intern/image_gpu.cc
|
||||
|
@ -383,6 +384,7 @@ set(SRC
|
|||
BKE_idprop.hh
|
||||
BKE_idtype.h
|
||||
BKE_image.h
|
||||
BKE_image_format.h
|
||||
BKE_image_partial_update.hh
|
||||
BKE_image_save.h
|
||||
BKE_ipo.h
|
||||
|
|
|
@ -44,6 +44,7 @@
|
|||
#include "BKE_dynamicpaint.h"
|
||||
#include "BKE_effect.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_material.h"
|
||||
|
|
|
@ -68,6 +68,7 @@
|
|||
#include "BKE_icons.h"
|
||||
#include "BKE_idtype.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_node.h"
|
||||
|
@ -1490,607 +1491,6 @@ void BKE_image_all_free_anim_ibufs(Main *bmain, int cfra)
|
|||
/** \name Read and Write
|
||||
* \{ */
|
||||
|
||||
int BKE_image_imtype_to_ftype(const char imtype, ImbFormatOptions *r_options)
|
||||
{
|
||||
memset(r_options, 0, sizeof(*r_options));
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_TARGA) {
|
||||
return IMB_FTYPE_TGA;
|
||||
}
|
||||
if (imtype == R_IMF_IMTYPE_RAWTGA) {
|
||||
r_options->flag = RAWTGA;
|
||||
return IMB_FTYPE_TGA;
|
||||
}
|
||||
if (imtype == R_IMF_IMTYPE_IRIS) {
|
||||
return IMB_FTYPE_IMAGIC;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
if (imtype == R_IMF_IMTYPE_RADHDR) {
|
||||
return IMB_FTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
if (imtype == R_IMF_IMTYPE_PNG) {
|
||||
r_options->quality = 15;
|
||||
return IMB_FTYPE_PNG;
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
if (imtype == R_IMF_IMTYPE_DDS) {
|
||||
return IMB_FTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
if (imtype == R_IMF_IMTYPE_BMP) {
|
||||
return IMB_FTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
if (imtype == R_IMF_IMTYPE_TIFF) {
|
||||
return IMB_FTYPE_TIF;
|
||||
}
|
||||
#endif
|
||||
if (ELEM(imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER)) {
|
||||
return IMB_FTYPE_OPENEXR;
|
||||
}
|
||||
#ifdef WITH_CINEON
|
||||
if (imtype == R_IMF_IMTYPE_CINEON) {
|
||||
return IMB_FTYPE_CINEON;
|
||||
}
|
||||
if (imtype == R_IMF_IMTYPE_DPX) {
|
||||
return IMB_FTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENJPEG
|
||||
if (imtype == R_IMF_IMTYPE_JP2) {
|
||||
r_options->flag |= JP2_JP2;
|
||||
r_options->quality = 90;
|
||||
return IMB_FTYPE_JP2;
|
||||
}
|
||||
#endif
|
||||
|
||||
r_options->quality = 90;
|
||||
return IMB_FTYPE_JPG;
|
||||
}
|
||||
|
||||
char BKE_image_ftype_to_imtype(const int ftype, const ImbFormatOptions *options)
|
||||
{
|
||||
if (ftype == IMB_FTYPE_NONE) {
|
||||
return R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
if (ftype == IMB_FTYPE_IMAGIC) {
|
||||
return R_IMF_IMTYPE_IRIS;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
if (ftype == IMB_FTYPE_RADHDR) {
|
||||
return R_IMF_IMTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_PNG) {
|
||||
return R_IMF_IMTYPE_PNG;
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
if (ftype == IMB_FTYPE_DDS) {
|
||||
return R_IMF_IMTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_BMP) {
|
||||
return R_IMF_IMTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
if (ftype == IMB_FTYPE_TIF) {
|
||||
return R_IMF_IMTYPE_TIFF;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_OPENEXR) {
|
||||
return R_IMF_IMTYPE_OPENEXR;
|
||||
}
|
||||
#ifdef WITH_CINEON
|
||||
if (ftype == IMB_FTYPE_CINEON) {
|
||||
return R_IMF_IMTYPE_CINEON;
|
||||
}
|
||||
if (ftype == IMB_FTYPE_DPX) {
|
||||
return R_IMF_IMTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_TGA) {
|
||||
if (options && (options->flag & RAWTGA)) {
|
||||
return R_IMF_IMTYPE_RAWTGA;
|
||||
}
|
||||
|
||||
return R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
#ifdef WITH_OPENJPEG
|
||||
if (ftype == IMB_FTYPE_JP2) {
|
||||
return R_IMF_IMTYPE_JP2;
|
||||
}
|
||||
#endif
|
||||
|
||||
return R_IMF_IMTYPE_JPEG90;
|
||||
}
|
||||
|
||||
bool BKE_imtype_is_movie(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_AVIRAW:
|
||||
case R_IMF_IMTYPE_AVIJPEG:
|
||||
case R_IMF_IMTYPE_FFMPEG:
|
||||
case R_IMF_IMTYPE_H264:
|
||||
case R_IMF_IMTYPE_THEORA:
|
||||
case R_IMF_IMTYPE_XVID:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_supports_zbuf(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_IRIZ:
|
||||
case R_IMF_IMTYPE_OPENEXR: /* But not #R_IMF_IMTYPE_MULTILAYER. */
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_supports_compress(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_supports_quality(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_JPEG90:
|
||||
case R_IMF_IMTYPE_JP2:
|
||||
case R_IMF_IMTYPE_AVIJPEG:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_requires_linear_float(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_CINEON:
|
||||
case R_IMF_IMTYPE_DPX:
|
||||
case R_IMF_IMTYPE_RADHDR:
|
||||
case R_IMF_IMTYPE_OPENEXR:
|
||||
case R_IMF_IMTYPE_MULTILAYER:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
char BKE_imtype_valid_channels(const char imtype, bool write_file)
|
||||
{
|
||||
char chan_flag = IMA_CHAN_FLAG_RGB; /* Assume all support RGB. */
|
||||
|
||||
/* Alpha. */
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_BMP:
|
||||
if (write_file) {
|
||||
break;
|
||||
}
|
||||
ATTR_FALLTHROUGH;
|
||||
case R_IMF_IMTYPE_TARGA:
|
||||
case R_IMF_IMTYPE_RAWTGA:
|
||||
case R_IMF_IMTYPE_IRIS:
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
case R_IMF_IMTYPE_TIFF:
|
||||
case R_IMF_IMTYPE_OPENEXR:
|
||||
case R_IMF_IMTYPE_MULTILAYER:
|
||||
case R_IMF_IMTYPE_DDS:
|
||||
case R_IMF_IMTYPE_JP2:
|
||||
case R_IMF_IMTYPE_DPX:
|
||||
chan_flag |= IMA_CHAN_FLAG_ALPHA;
|
||||
break;
|
||||
}
|
||||
|
||||
/* BW. */
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_BMP:
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
case R_IMF_IMTYPE_JPEG90:
|
||||
case R_IMF_IMTYPE_TARGA:
|
||||
case R_IMF_IMTYPE_RAWTGA:
|
||||
case R_IMF_IMTYPE_TIFF:
|
||||
case R_IMF_IMTYPE_IRIS:
|
||||
chan_flag |= IMA_CHAN_FLAG_BW;
|
||||
break;
|
||||
}
|
||||
|
||||
return chan_flag;
|
||||
}
|
||||
|
||||
char BKE_imtype_valid_depths(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_RADHDR:
|
||||
return R_IMF_CHAN_DEPTH_32;
|
||||
case R_IMF_IMTYPE_TIFF:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_16;
|
||||
case R_IMF_IMTYPE_OPENEXR:
|
||||
return R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_32;
|
||||
case R_IMF_IMTYPE_MULTILAYER:
|
||||
return R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_32;
|
||||
/* NOTE: CINEON uses an unusual 10bits-LOG per channel. */
|
||||
case R_IMF_IMTYPE_DPX:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_10 | R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16;
|
||||
case R_IMF_IMTYPE_CINEON:
|
||||
return R_IMF_CHAN_DEPTH_10;
|
||||
case R_IMF_IMTYPE_JP2:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16;
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_16;
|
||||
/* Most formats are 8bit only. */
|
||||
default:
|
||||
return R_IMF_CHAN_DEPTH_8;
|
||||
}
|
||||
}
|
||||
|
||||
char BKE_imtype_from_arg(const char *imtype_arg)
|
||||
{
|
||||
if (STREQ(imtype_arg, "TGA")) {
|
||||
return R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
if (STREQ(imtype_arg, "IRIS")) {
|
||||
return R_IMF_IMTYPE_IRIS;
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
if (STREQ(imtype_arg, "DDS")) {
|
||||
return R_IMF_IMTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
if (STREQ(imtype_arg, "JPEG")) {
|
||||
return R_IMF_IMTYPE_JPEG90;
|
||||
}
|
||||
if (STREQ(imtype_arg, "IRIZ")) {
|
||||
return R_IMF_IMTYPE_IRIZ;
|
||||
}
|
||||
if (STREQ(imtype_arg, "RAWTGA")) {
|
||||
return R_IMF_IMTYPE_RAWTGA;
|
||||
}
|
||||
if (STREQ(imtype_arg, "AVIRAW")) {
|
||||
return R_IMF_IMTYPE_AVIRAW;
|
||||
}
|
||||
if (STREQ(imtype_arg, "AVIJPEG")) {
|
||||
return R_IMF_IMTYPE_AVIJPEG;
|
||||
}
|
||||
if (STREQ(imtype_arg, "PNG")) {
|
||||
return R_IMF_IMTYPE_PNG;
|
||||
}
|
||||
if (STREQ(imtype_arg, "BMP")) {
|
||||
return R_IMF_IMTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
if (STREQ(imtype_arg, "HDR")) {
|
||||
return R_IMF_IMTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_TIFF
|
||||
if (STREQ(imtype_arg, "TIFF")) {
|
||||
return R_IMF_IMTYPE_TIFF;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENEXR
|
||||
if (STREQ(imtype_arg, "OPEN_EXR")) {
|
||||
return R_IMF_IMTYPE_OPENEXR;
|
||||
}
|
||||
if (STREQ(imtype_arg, "OPEN_EXR_MULTILAYER")) {
|
||||
return R_IMF_IMTYPE_MULTILAYER;
|
||||
}
|
||||
if (STREQ(imtype_arg, "EXR")) {
|
||||
return R_IMF_IMTYPE_OPENEXR;
|
||||
}
|
||||
if (STREQ(imtype_arg, "MULTILAYER")) {
|
||||
return R_IMF_IMTYPE_MULTILAYER;
|
||||
}
|
||||
#endif
|
||||
if (STREQ(imtype_arg, "FFMPEG")) {
|
||||
return R_IMF_IMTYPE_FFMPEG;
|
||||
}
|
||||
#ifdef WITH_CINEON
|
||||
if (STREQ(imtype_arg, "CINEON")) {
|
||||
return R_IMF_IMTYPE_CINEON;
|
||||
}
|
||||
if (STREQ(imtype_arg, "DPX")) {
|
||||
return R_IMF_IMTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENJPEG
|
||||
if (STREQ(imtype_arg, "JP2")) {
|
||||
return R_IMF_IMTYPE_JP2;
|
||||
}
|
||||
#endif
|
||||
|
||||
return R_IMF_IMTYPE_INVALID;
|
||||
}
|
||||
|
||||
static bool do_add_image_extension(char *string,
|
||||
const char imtype,
|
||||
const ImageFormatData *im_format)
|
||||
{
|
||||
const char *extension = nullptr;
|
||||
const char *extension_test;
|
||||
(void)im_format; /* may be unused, depends on build options */
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_IRIS) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".rgb")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_IRIZ) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".rgb")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
else if (imtype == R_IMF_IMTYPE_RADHDR) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".hdr")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else if (ELEM(imtype,
|
||||
R_IMF_IMTYPE_PNG,
|
||||
R_IMF_IMTYPE_FFMPEG,
|
||||
R_IMF_IMTYPE_H264,
|
||||
R_IMF_IMTYPE_THEORA,
|
||||
R_IMF_IMTYPE_XVID)) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".png")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
else if (imtype == R_IMF_IMTYPE_DDS) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".dds")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else if (ELEM(imtype, R_IMF_IMTYPE_TARGA, R_IMF_IMTYPE_RAWTGA)) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".tga")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_BMP) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".bmp")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
else if (imtype == R_IMF_IMTYPE_TIFF) {
|
||||
if (!BLI_path_extension_check_n(string, extension_test = ".tif", ".tiff", nullptr)) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENIMAGEIO
|
||||
else if (imtype == R_IMF_IMTYPE_PSD) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".psd")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENEXR
|
||||
else if (ELEM(imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER)) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".exr")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_CINEON
|
||||
else if (imtype == R_IMF_IMTYPE_CINEON) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".cin")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_DPX) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".dpx")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENJPEG
|
||||
else if (imtype == R_IMF_IMTYPE_JP2) {
|
||||
if (im_format) {
|
||||
if (im_format->jp2_codec == R_IMF_JP2_CODEC_JP2) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".jp2")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (im_format->jp2_codec == R_IMF_JP2_CODEC_J2K) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".j2c")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else {
|
||||
BLI_assert_msg(0, "Unsupported jp2 codec was specified in im_format->jp2_codec");
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".jp2")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else { // R_IMF_IMTYPE_AVIRAW, R_IMF_IMTYPE_AVIJPEG, R_IMF_IMTYPE_JPEG90 etc
|
||||
if (!(BLI_path_extension_check_n(string, extension_test = ".jpg", ".jpeg", nullptr))) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
|
||||
if (extension) {
|
||||
/* prefer this in many cases to avoid .png.tga, but in certain cases it breaks */
|
||||
/* remove any other known image extension */
|
||||
if (BLI_path_extension_check_array(string, imb_ext_image)) {
|
||||
return BLI_path_extension_replace(string, FILE_MAX, extension);
|
||||
}
|
||||
|
||||
return BLI_path_extension_ensure(string, FILE_MAX, extension);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
int BKE_image_path_ensure_ext_from_imformat(char *string, const ImageFormatData *im_format)
|
||||
{
|
||||
return do_add_image_extension(string, im_format->imtype, im_format);
|
||||
}
|
||||
|
||||
int BKE_image_path_ensure_ext_from_imtype(char *string, const char imtype)
|
||||
{
|
||||
return do_add_image_extension(string, imtype, nullptr);
|
||||
}
|
||||
|
||||
void BKE_imformat_defaults(ImageFormatData *im_format)
|
||||
{
|
||||
memset(im_format, 0, sizeof(*im_format));
|
||||
im_format->planes = R_IMF_PLANES_RGBA;
|
||||
im_format->imtype = R_IMF_IMTYPE_PNG;
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_8;
|
||||
im_format->quality = 90;
|
||||
im_format->compress = 15;
|
||||
|
||||
BKE_color_managed_display_settings_init(&im_format->display_settings);
|
||||
BKE_color_managed_view_settings_init_default(&im_format->view_settings,
|
||||
&im_format->display_settings);
|
||||
}
|
||||
|
||||
void BKE_imbuf_to_image_format(struct ImageFormatData *im_format, const ImBuf *imbuf)
|
||||
{
|
||||
int ftype = imbuf->ftype;
|
||||
int custom_flags = imbuf->foptions.flag;
|
||||
char quality = imbuf->foptions.quality;
|
||||
|
||||
BKE_imformat_defaults(im_format);
|
||||
|
||||
/* file type */
|
||||
|
||||
if (ftype == IMB_FTYPE_IMAGIC) {
|
||||
im_format->imtype = R_IMF_IMTYPE_IRIS;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
else if (ftype == IMB_FTYPE_RADHDR) {
|
||||
im_format->imtype = R_IMF_IMTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
else if (ftype == IMB_FTYPE_PNG) {
|
||||
im_format->imtype = R_IMF_IMTYPE_PNG;
|
||||
|
||||
if (custom_flags & PNG_16BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
|
||||
im_format->compress = quality;
|
||||
}
|
||||
|
||||
#ifdef WITH_DDS
|
||||
else if (ftype == IMB_FTYPE_DDS) {
|
||||
im_format->imtype = R_IMF_IMTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
else if (ftype == IMB_FTYPE_BMP) {
|
||||
im_format->imtype = R_IMF_IMTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
else if (ftype == IMB_FTYPE_TIF) {
|
||||
im_format->imtype = R_IMF_IMTYPE_TIFF;
|
||||
if (custom_flags & TIF_16BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_NONE) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_NONE;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_DEFLATE) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_DEFLATE;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_LZW) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_LZW;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_PACKBITS) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_PACKBITS;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef WITH_OPENEXR
|
||||
else if (ftype == IMB_FTYPE_OPENEXR) {
|
||||
im_format->imtype = R_IMF_IMTYPE_OPENEXR;
|
||||
if (custom_flags & OPENEXR_HALF) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
if (custom_flags & OPENEXR_COMPRESS) {
|
||||
im_format->exr_codec = R_IMF_EXR_CODEC_ZIP; /* Can't determine compression */
|
||||
}
|
||||
if (imbuf->zbuf_float) {
|
||||
im_format->flag |= R_IMF_FLAG_ZBUF;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef WITH_CINEON
|
||||
else if (ftype == IMB_FTYPE_CINEON) {
|
||||
im_format->imtype = R_IMF_IMTYPE_CINEON;
|
||||
}
|
||||
else if (ftype == IMB_FTYPE_DPX) {
|
||||
im_format->imtype = R_IMF_IMTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
else if (ftype == IMB_FTYPE_TGA) {
|
||||
if (custom_flags & RAWTGA) {
|
||||
im_format->imtype = R_IMF_IMTYPE_RAWTGA;
|
||||
}
|
||||
else {
|
||||
im_format->imtype = R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_OPENJPEG
|
||||
else if (ftype == IMB_FTYPE_JP2) {
|
||||
im_format->imtype = R_IMF_IMTYPE_JP2;
|
||||
im_format->quality = quality;
|
||||
|
||||
if (custom_flags & JP2_16BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
else if (custom_flags & JP2_12BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_12;
|
||||
}
|
||||
|
||||
if (custom_flags & JP2_YCC) {
|
||||
im_format->jp2_flag |= R_IMF_JP2_FLAG_YCC;
|
||||
}
|
||||
|
||||
if (custom_flags & JP2_CINE) {
|
||||
im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_PRESET;
|
||||
if (custom_flags & JP2_CINE_48FPS) {
|
||||
im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_48;
|
||||
}
|
||||
}
|
||||
|
||||
if (custom_flags & JP2_JP2) {
|
||||
im_format->jp2_codec = R_IMF_JP2_CODEC_JP2;
|
||||
}
|
||||
else if (custom_flags & JP2_J2K) {
|
||||
im_format->jp2_codec = R_IMF_JP2_CODEC_J2K;
|
||||
}
|
||||
else {
|
||||
BLI_assert_msg(0, "Unsupported jp2 codec was specified in file type");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
else {
|
||||
im_format->imtype = R_IMF_IMTYPE_JPEG90;
|
||||
im_format->quality = quality;
|
||||
}
|
||||
|
||||
/* planes */
|
||||
im_format->planes = imbuf->planes;
|
||||
}
|
||||
|
||||
#define STAMP_NAME_SIZE ((MAX_ID_NAME - 2) + 16)
|
||||
/* could allow access externally - 512 is for long names,
|
||||
* STAMP_NAME_SIZE is for id names, allowing them some room for description */
|
||||
|
@ -2994,171 +2394,9 @@ bool BKE_imbuf_alpha_test(ImBuf *ibuf)
|
|||
return false;
|
||||
}
|
||||
|
||||
void BKE_imbuf_write_prepare(ImBuf *ibuf, const ImageFormatData *imf)
|
||||
{
|
||||
char imtype = imf->imtype;
|
||||
char compress = imf->compress;
|
||||
char quality = imf->quality;
|
||||
|
||||
/* initialize all from image format */
|
||||
ibuf->foptions.flag = 0;
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_IRIS) {
|
||||
ibuf->ftype = IMB_FTYPE_IMAGIC;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
else if (imtype == R_IMF_IMTYPE_RADHDR) {
|
||||
ibuf->ftype = IMB_FTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
else if (ELEM(imtype,
|
||||
R_IMF_IMTYPE_PNG,
|
||||
R_IMF_IMTYPE_FFMPEG,
|
||||
R_IMF_IMTYPE_H264,
|
||||
R_IMF_IMTYPE_THEORA,
|
||||
R_IMF_IMTYPE_XVID)) {
|
||||
ibuf->ftype = IMB_FTYPE_PNG;
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_PNG) {
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= PNG_16BIT;
|
||||
}
|
||||
|
||||
ibuf->foptions.quality = compress;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
else if (imtype == R_IMF_IMTYPE_DDS) {
|
||||
ibuf->ftype = IMB_FTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
else if (imtype == R_IMF_IMTYPE_BMP) {
|
||||
ibuf->ftype = IMB_FTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
else if (imtype == R_IMF_IMTYPE_TIFF) {
|
||||
ibuf->ftype = IMB_FTYPE_TIF;
|
||||
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= TIF_16BIT;
|
||||
}
|
||||
if (imf->tiff_codec == R_IMF_TIFF_CODEC_NONE) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_NONE;
|
||||
}
|
||||
else if (imf->tiff_codec == R_IMF_TIFF_CODEC_DEFLATE) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_DEFLATE;
|
||||
}
|
||||
else if (imf->tiff_codec == R_IMF_TIFF_CODEC_LZW) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_LZW;
|
||||
}
|
||||
else if (imf->tiff_codec == R_IMF_TIFF_CODEC_PACKBITS) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_PACKBITS;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENEXR
|
||||
else if (ELEM(imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER)) {
|
||||
ibuf->ftype = IMB_FTYPE_OPENEXR;
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= OPENEXR_HALF;
|
||||
}
|
||||
ibuf->foptions.flag |= (imf->exr_codec & OPENEXR_COMPRESS);
|
||||
|
||||
if (!(imf->flag & R_IMF_FLAG_ZBUF)) {
|
||||
/* Signal for exr saving. */
|
||||
IMB_freezbuffloatImBuf(ibuf);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_CINEON
|
||||
else if (imtype == R_IMF_IMTYPE_CINEON) {
|
||||
ibuf->ftype = IMB_FTYPE_CINEON;
|
||||
if (imf->cineon_flag & R_IMF_CINEON_FLAG_LOG) {
|
||||
ibuf->foptions.flag |= CINEON_LOG;
|
||||
}
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= CINEON_16BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
|
||||
ibuf->foptions.flag |= CINEON_12BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_10) {
|
||||
ibuf->foptions.flag |= CINEON_10BIT;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_DPX) {
|
||||
ibuf->ftype = IMB_FTYPE_DPX;
|
||||
if (imf->cineon_flag & R_IMF_CINEON_FLAG_LOG) {
|
||||
ibuf->foptions.flag |= CINEON_LOG;
|
||||
}
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= CINEON_16BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
|
||||
ibuf->foptions.flag |= CINEON_12BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_10) {
|
||||
ibuf->foptions.flag |= CINEON_10BIT;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else if (imtype == R_IMF_IMTYPE_TARGA) {
|
||||
ibuf->ftype = IMB_FTYPE_TGA;
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_RAWTGA) {
|
||||
ibuf->ftype = IMB_FTYPE_TGA;
|
||||
ibuf->foptions.flag = RAWTGA;
|
||||
}
|
||||
#ifdef WITH_OPENJPEG
|
||||
else if (imtype == R_IMF_IMTYPE_JP2) {
|
||||
if (quality < 10) {
|
||||
quality = 90;
|
||||
}
|
||||
ibuf->ftype = IMB_FTYPE_JP2;
|
||||
ibuf->foptions.quality = quality;
|
||||
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= JP2_16BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
|
||||
ibuf->foptions.flag |= JP2_12BIT;
|
||||
}
|
||||
|
||||
if (imf->jp2_flag & R_IMF_JP2_FLAG_YCC) {
|
||||
ibuf->foptions.flag |= JP2_YCC;
|
||||
}
|
||||
|
||||
if (imf->jp2_flag & R_IMF_JP2_FLAG_CINE_PRESET) {
|
||||
ibuf->foptions.flag |= JP2_CINE;
|
||||
if (imf->jp2_flag & R_IMF_JP2_FLAG_CINE_48) {
|
||||
ibuf->foptions.flag |= JP2_CINE_48FPS;
|
||||
}
|
||||
}
|
||||
|
||||
if (imf->jp2_codec == R_IMF_JP2_CODEC_JP2) {
|
||||
ibuf->foptions.flag |= JP2_JP2;
|
||||
}
|
||||
else if (imf->jp2_codec == R_IMF_JP2_CODEC_J2K) {
|
||||
ibuf->foptions.flag |= JP2_J2K;
|
||||
}
|
||||
else {
|
||||
BLI_assert_msg(0, "Unsupported jp2 codec was specified in im_format->jp2_codec");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else {
|
||||
/* #R_IMF_IMTYPE_JPEG90, etc. fallback to JPEG image. */
|
||||
if (quality < 10) {
|
||||
quality = 90;
|
||||
}
|
||||
ibuf->ftype = IMB_FTYPE_JPG;
|
||||
ibuf->foptions.quality = quality;
|
||||
}
|
||||
}
|
||||
|
||||
int BKE_imbuf_write(ImBuf *ibuf, const char *name, const ImageFormatData *imf)
|
||||
{
|
||||
BKE_imbuf_write_prepare(ibuf, imf);
|
||||
BKE_image_format_to_imbuf(ibuf, imf);
|
||||
|
||||
BLI_make_existing_file(name);
|
||||
|
||||
|
@ -3203,60 +2441,6 @@ int BKE_imbuf_write_stamp(Scene *scene,
|
|||
return BKE_imbuf_write(ibuf, name, imf);
|
||||
}
|
||||
|
||||
static void do_makepicstring(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const char imtype,
|
||||
const ImageFormatData *im_format,
|
||||
const bool use_ext,
|
||||
const bool use_frames,
|
||||
const char *suffix)
|
||||
{
|
||||
if (string == nullptr) {
|
||||
return;
|
||||
}
|
||||
BLI_strncpy(string, base, FILE_MAX - 10); /* weak assumption */
|
||||
BLI_path_abs(string, relbase);
|
||||
|
||||
if (use_frames) {
|
||||
BLI_path_frame(string, frame, 4);
|
||||
}
|
||||
|
||||
if (suffix) {
|
||||
BLI_path_suffix(string, FILE_MAX, suffix, "");
|
||||
}
|
||||
|
||||
if (use_ext) {
|
||||
do_add_image_extension(string, imtype, im_format);
|
||||
}
|
||||
}
|
||||
|
||||
void BKE_image_path_from_imformat(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const ImageFormatData *im_format,
|
||||
const bool use_ext,
|
||||
const bool use_frames,
|
||||
const char *suffix)
|
||||
{
|
||||
do_makepicstring(
|
||||
string, base, relbase, frame, im_format->imtype, im_format, use_ext, use_frames, suffix);
|
||||
}
|
||||
|
||||
void BKE_image_path_from_imtype(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const char imtype,
|
||||
const bool use_ext,
|
||||
const bool use_frames,
|
||||
const char *suffix)
|
||||
{
|
||||
do_makepicstring(string, base, relbase, frame, imtype, nullptr, use_ext, use_frames, suffix);
|
||||
}
|
||||
|
||||
struct anim *openanim_noload(const char *name,
|
||||
int flags,
|
||||
int streamindex,
|
||||
|
@ -6116,8 +5300,8 @@ bool BKE_image_buffer_format_writable(ImBuf *ibuf)
|
|||
{
|
||||
ImageFormatData im_format;
|
||||
ImbFormatOptions options_dummy;
|
||||
BKE_imbuf_to_image_format(&im_format, ibuf);
|
||||
return (BKE_image_imtype_to_ftype(im_format.imtype, &options_dummy) == ibuf->ftype);
|
||||
BKE_image_format_from_imbuf(&im_format, ibuf);
|
||||
return (BKE_imtype_to_ftype(im_format.imtype, &options_dummy) == ibuf->ftype);
|
||||
}
|
||||
|
||||
void BKE_image_file_format_set(Image *image, int ftype, const ImbFormatOptions *options)
|
||||
|
|
|
@ -0,0 +1,874 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later
|
||||
* Copyright 2001-2002 NaN Holding BV. All rights reserved. */
|
||||
|
||||
/** \file
|
||||
* \ingroup bke
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "DNA_defaults.h"
|
||||
#include "DNA_scene_types.h"
|
||||
|
||||
#include "BLI_path_util.h"
|
||||
#include "BLI_string.h"
|
||||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "IMB_imbuf.h"
|
||||
#include "IMB_imbuf_types.h"
|
||||
|
||||
#include "BKE_colortools.h"
|
||||
#include "BKE_image_format.h"
|
||||
|
||||
/* Init/Copy/Free */
|
||||
|
||||
void BKE_image_format_init(ImageFormatData *imf, const bool render)
|
||||
{
|
||||
*imf = *DNA_struct_default_get(ImageFormatData);
|
||||
|
||||
BKE_color_managed_display_settings_init(&imf->display_settings);
|
||||
|
||||
if (render) {
|
||||
BKE_color_managed_view_settings_init_render(
|
||||
&imf->view_settings, &imf->display_settings, "Filmic");
|
||||
}
|
||||
else {
|
||||
BKE_color_managed_view_settings_init_default(&imf->view_settings, &imf->display_settings);
|
||||
}
|
||||
|
||||
BKE_color_managed_colorspace_settings_init(&imf->linear_colorspace_settings);
|
||||
}
|
||||
|
||||
void BKE_image_format_copy(ImageFormatData *imf_dst, const ImageFormatData *imf_src)
|
||||
{
|
||||
memcpy(imf_dst, imf_src, sizeof(*imf_dst));
|
||||
BKE_color_managed_display_settings_copy(&imf_dst->display_settings, &imf_src->display_settings);
|
||||
BKE_color_managed_view_settings_copy(&imf_dst->view_settings, &imf_src->view_settings);
|
||||
BKE_color_managed_colorspace_settings_copy(&imf_dst->linear_colorspace_settings,
|
||||
&imf_src->linear_colorspace_settings);
|
||||
}
|
||||
|
||||
void BKE_image_format_free(ImageFormatData *imf)
|
||||
{
|
||||
BKE_color_managed_view_settings_free(&imf->view_settings);
|
||||
}
|
||||
|
||||
void BKE_image_format_blend_read_data(BlendDataReader *reader, ImageFormatData *imf)
|
||||
{
|
||||
BKE_color_managed_view_settings_blend_read_data(reader, &imf->view_settings);
|
||||
}
|
||||
|
||||
void BKE_image_format_blend_write(BlendWriter *writer, ImageFormatData *imf)
|
||||
{
|
||||
BKE_color_managed_view_settings_blend_write(writer, &imf->view_settings);
|
||||
}
|
||||
|
||||
/* File Types */
|
||||
|
||||
int BKE_imtype_to_ftype(const char imtype, ImbFormatOptions *r_options)
|
||||
{
|
||||
memset(r_options, 0, sizeof(*r_options));
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_TARGA) {
|
||||
return IMB_FTYPE_TGA;
|
||||
}
|
||||
if (imtype == R_IMF_IMTYPE_RAWTGA) {
|
||||
r_options->flag = RAWTGA;
|
||||
return IMB_FTYPE_TGA;
|
||||
}
|
||||
if (imtype == R_IMF_IMTYPE_IRIS) {
|
||||
return IMB_FTYPE_IMAGIC;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
if (imtype == R_IMF_IMTYPE_RADHDR) {
|
||||
return IMB_FTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
if (imtype == R_IMF_IMTYPE_PNG) {
|
||||
r_options->quality = 15;
|
||||
return IMB_FTYPE_PNG;
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
if (imtype == R_IMF_IMTYPE_DDS) {
|
||||
return IMB_FTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
if (imtype == R_IMF_IMTYPE_BMP) {
|
||||
return IMB_FTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
if (imtype == R_IMF_IMTYPE_TIFF) {
|
||||
return IMB_FTYPE_TIF;
|
||||
}
|
||||
#endif
|
||||
if (ELEM(imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER)) {
|
||||
return IMB_FTYPE_OPENEXR;
|
||||
}
|
||||
#ifdef WITH_CINEON
|
||||
if (imtype == R_IMF_IMTYPE_CINEON) {
|
||||
return IMB_FTYPE_CINEON;
|
||||
}
|
||||
if (imtype == R_IMF_IMTYPE_DPX) {
|
||||
return IMB_FTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENJPEG
|
||||
if (imtype == R_IMF_IMTYPE_JP2) {
|
||||
r_options->flag |= JP2_JP2;
|
||||
r_options->quality = 90;
|
||||
return IMB_FTYPE_JP2;
|
||||
}
|
||||
#endif
|
||||
|
||||
r_options->quality = 90;
|
||||
return IMB_FTYPE_JPG;
|
||||
}
|
||||
|
||||
char BKE_ftype_to_imtype(const int ftype, const ImbFormatOptions *options)
|
||||
{
|
||||
if (ftype == IMB_FTYPE_NONE) {
|
||||
return R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
if (ftype == IMB_FTYPE_IMAGIC) {
|
||||
return R_IMF_IMTYPE_IRIS;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
if (ftype == IMB_FTYPE_RADHDR) {
|
||||
return R_IMF_IMTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_PNG) {
|
||||
return R_IMF_IMTYPE_PNG;
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
if (ftype == IMB_FTYPE_DDS) {
|
||||
return R_IMF_IMTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_BMP) {
|
||||
return R_IMF_IMTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
if (ftype == IMB_FTYPE_TIF) {
|
||||
return R_IMF_IMTYPE_TIFF;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_OPENEXR) {
|
||||
return R_IMF_IMTYPE_OPENEXR;
|
||||
}
|
||||
#ifdef WITH_CINEON
|
||||
if (ftype == IMB_FTYPE_CINEON) {
|
||||
return R_IMF_IMTYPE_CINEON;
|
||||
}
|
||||
if (ftype == IMB_FTYPE_DPX) {
|
||||
return R_IMF_IMTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
if (ftype == IMB_FTYPE_TGA) {
|
||||
if (options && (options->flag & RAWTGA)) {
|
||||
return R_IMF_IMTYPE_RAWTGA;
|
||||
}
|
||||
|
||||
return R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
#ifdef WITH_OPENJPEG
|
||||
if (ftype == IMB_FTYPE_JP2) {
|
||||
return R_IMF_IMTYPE_JP2;
|
||||
}
|
||||
#endif
|
||||
|
||||
return R_IMF_IMTYPE_JPEG90;
|
||||
}
|
||||
|
||||
bool BKE_imtype_is_movie(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_AVIRAW:
|
||||
case R_IMF_IMTYPE_AVIJPEG:
|
||||
case R_IMF_IMTYPE_FFMPEG:
|
||||
case R_IMF_IMTYPE_H264:
|
||||
case R_IMF_IMTYPE_THEORA:
|
||||
case R_IMF_IMTYPE_XVID:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_supports_zbuf(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_IRIZ:
|
||||
case R_IMF_IMTYPE_OPENEXR: /* but not R_IMF_IMTYPE_MULTILAYER */
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_supports_compress(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_supports_quality(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_JPEG90:
|
||||
case R_IMF_IMTYPE_JP2:
|
||||
case R_IMF_IMTYPE_AVIJPEG:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BKE_imtype_requires_linear_float(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_CINEON:
|
||||
case R_IMF_IMTYPE_DPX:
|
||||
case R_IMF_IMTYPE_RADHDR:
|
||||
case R_IMF_IMTYPE_OPENEXR:
|
||||
case R_IMF_IMTYPE_MULTILAYER:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
char BKE_imtype_valid_channels(const char imtype, bool write_file)
|
||||
{
|
||||
char chan_flag = IMA_CHAN_FLAG_RGB; /* Assume all support RGB. */
|
||||
|
||||
/* Alpha. */
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_BMP:
|
||||
if (write_file) {
|
||||
break;
|
||||
}
|
||||
ATTR_FALLTHROUGH;
|
||||
case R_IMF_IMTYPE_TARGA:
|
||||
case R_IMF_IMTYPE_RAWTGA:
|
||||
case R_IMF_IMTYPE_IRIS:
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
case R_IMF_IMTYPE_TIFF:
|
||||
case R_IMF_IMTYPE_OPENEXR:
|
||||
case R_IMF_IMTYPE_MULTILAYER:
|
||||
case R_IMF_IMTYPE_DDS:
|
||||
case R_IMF_IMTYPE_JP2:
|
||||
case R_IMF_IMTYPE_DPX:
|
||||
chan_flag |= IMA_CHAN_FLAG_ALPHA;
|
||||
break;
|
||||
}
|
||||
|
||||
/* BW. */
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_BMP:
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
case R_IMF_IMTYPE_JPEG90:
|
||||
case R_IMF_IMTYPE_TARGA:
|
||||
case R_IMF_IMTYPE_RAWTGA:
|
||||
case R_IMF_IMTYPE_TIFF:
|
||||
case R_IMF_IMTYPE_IRIS:
|
||||
chan_flag |= IMA_CHAN_FLAG_BW;
|
||||
break;
|
||||
}
|
||||
|
||||
return chan_flag;
|
||||
}
|
||||
|
||||
char BKE_imtype_valid_depths(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_RADHDR:
|
||||
return R_IMF_CHAN_DEPTH_32;
|
||||
case R_IMF_IMTYPE_TIFF:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_16;
|
||||
case R_IMF_IMTYPE_OPENEXR:
|
||||
return R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_32;
|
||||
case R_IMF_IMTYPE_MULTILAYER:
|
||||
return R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_32;
|
||||
/* NOTE: CINEON uses an unusual 10bits-LOG per channel. */
|
||||
case R_IMF_IMTYPE_DPX:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_10 | R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16;
|
||||
case R_IMF_IMTYPE_CINEON:
|
||||
return R_IMF_CHAN_DEPTH_10;
|
||||
case R_IMF_IMTYPE_JP2:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16;
|
||||
case R_IMF_IMTYPE_PNG:
|
||||
return R_IMF_CHAN_DEPTH_8 | R_IMF_CHAN_DEPTH_16;
|
||||
/* Most formats are 8bit only. */
|
||||
default:
|
||||
return R_IMF_CHAN_DEPTH_8;
|
||||
}
|
||||
}
|
||||
|
||||
char BKE_imtype_from_arg(const char *imtype_arg)
|
||||
{
|
||||
if (STREQ(imtype_arg, "TGA")) {
|
||||
return R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
if (STREQ(imtype_arg, "IRIS")) {
|
||||
return R_IMF_IMTYPE_IRIS;
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
if (STREQ(imtype_arg, "DDS")) {
|
||||
return R_IMF_IMTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
if (STREQ(imtype_arg, "JPEG")) {
|
||||
return R_IMF_IMTYPE_JPEG90;
|
||||
}
|
||||
if (STREQ(imtype_arg, "IRIZ")) {
|
||||
return R_IMF_IMTYPE_IRIZ;
|
||||
}
|
||||
if (STREQ(imtype_arg, "RAWTGA")) {
|
||||
return R_IMF_IMTYPE_RAWTGA;
|
||||
}
|
||||
if (STREQ(imtype_arg, "AVIRAW")) {
|
||||
return R_IMF_IMTYPE_AVIRAW;
|
||||
}
|
||||
if (STREQ(imtype_arg, "AVIJPEG")) {
|
||||
return R_IMF_IMTYPE_AVIJPEG;
|
||||
}
|
||||
if (STREQ(imtype_arg, "PNG")) {
|
||||
return R_IMF_IMTYPE_PNG;
|
||||
}
|
||||
if (STREQ(imtype_arg, "BMP")) {
|
||||
return R_IMF_IMTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
if (STREQ(imtype_arg, "HDR")) {
|
||||
return R_IMF_IMTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_TIFF
|
||||
if (STREQ(imtype_arg, "TIFF")) {
|
||||
return R_IMF_IMTYPE_TIFF;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENEXR
|
||||
if (STREQ(imtype_arg, "OPEN_EXR")) {
|
||||
return R_IMF_IMTYPE_OPENEXR;
|
||||
}
|
||||
if (STREQ(imtype_arg, "OPEN_EXR_MULTILAYER")) {
|
||||
return R_IMF_IMTYPE_MULTILAYER;
|
||||
}
|
||||
if (STREQ(imtype_arg, "EXR")) {
|
||||
return R_IMF_IMTYPE_OPENEXR;
|
||||
}
|
||||
if (STREQ(imtype_arg, "MULTILAYER")) {
|
||||
return R_IMF_IMTYPE_MULTILAYER;
|
||||
}
|
||||
#endif
|
||||
if (STREQ(imtype_arg, "FFMPEG")) {
|
||||
return R_IMF_IMTYPE_FFMPEG;
|
||||
}
|
||||
#ifdef WITH_CINEON
|
||||
if (STREQ(imtype_arg, "CINEON")) {
|
||||
return R_IMF_IMTYPE_CINEON;
|
||||
}
|
||||
if (STREQ(imtype_arg, "DPX")) {
|
||||
return R_IMF_IMTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENJPEG
|
||||
if (STREQ(imtype_arg, "JP2")) {
|
||||
return R_IMF_IMTYPE_JP2;
|
||||
}
|
||||
#endif
|
||||
|
||||
return R_IMF_IMTYPE_INVALID;
|
||||
}
|
||||
|
||||
/* File Paths */
|
||||
|
||||
static bool do_add_image_extension(char *string,
|
||||
const char imtype,
|
||||
const ImageFormatData *im_format)
|
||||
{
|
||||
const char *extension = nullptr;
|
||||
const char *extension_test;
|
||||
(void)im_format; /* may be unused, depends on build options */
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_IRIS) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".rgb")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_IRIZ) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".rgb")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
else if (imtype == R_IMF_IMTYPE_RADHDR) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".hdr")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else if (ELEM(imtype,
|
||||
R_IMF_IMTYPE_PNG,
|
||||
R_IMF_IMTYPE_FFMPEG,
|
||||
R_IMF_IMTYPE_H264,
|
||||
R_IMF_IMTYPE_THEORA,
|
||||
R_IMF_IMTYPE_XVID)) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".png")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
else if (imtype == R_IMF_IMTYPE_DDS) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".dds")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else if (ELEM(imtype, R_IMF_IMTYPE_TARGA, R_IMF_IMTYPE_RAWTGA)) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".tga")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_BMP) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".bmp")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
else if (imtype == R_IMF_IMTYPE_TIFF) {
|
||||
if (!BLI_path_extension_check_n(string, extension_test = ".tif", ".tiff", nullptr)) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENIMAGEIO
|
||||
else if (imtype == R_IMF_IMTYPE_PSD) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".psd")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENEXR
|
||||
else if (ELEM(imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER)) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".exr")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_CINEON
|
||||
else if (imtype == R_IMF_IMTYPE_CINEON) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".cin")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_DPX) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".dpx")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENJPEG
|
||||
else if (imtype == R_IMF_IMTYPE_JP2) {
|
||||
if (im_format) {
|
||||
if (im_format->jp2_codec == R_IMF_JP2_CODEC_JP2) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".jp2")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else if (im_format->jp2_codec == R_IMF_JP2_CODEC_J2K) {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".j2c")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
else {
|
||||
BLI_assert_msg(0, "Unsupported jp2 codec was specified in im_format->jp2_codec");
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (!BLI_path_extension_check(string, extension_test = ".jp2")) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else { // R_IMF_IMTYPE_AVIRAW, R_IMF_IMTYPE_AVIJPEG, R_IMF_IMTYPE_JPEG90 etc
|
||||
if (!(BLI_path_extension_check_n(string, extension_test = ".jpg", ".jpeg", nullptr))) {
|
||||
extension = extension_test;
|
||||
}
|
||||
}
|
||||
|
||||
if (extension) {
|
||||
/* prefer this in many cases to avoid .png.tga, but in certain cases it breaks */
|
||||
/* remove any other known image extension */
|
||||
if (BLI_path_extension_check_array(string, imb_ext_image)) {
|
||||
return BLI_path_extension_replace(string, FILE_MAX, extension);
|
||||
}
|
||||
|
||||
return BLI_path_extension_ensure(string, FILE_MAX, extension);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
int BKE_image_path_ensure_ext_from_imformat(char *string, const ImageFormatData *im_format)
|
||||
{
|
||||
return do_add_image_extension(string, im_format->imtype, im_format);
|
||||
}
|
||||
|
||||
int BKE_image_path_ensure_ext_from_imtype(char *string, const char imtype)
|
||||
{
|
||||
return do_add_image_extension(string, imtype, nullptr);
|
||||
}
|
||||
|
||||
static void do_makepicstring(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const char imtype,
|
||||
const ImageFormatData *im_format,
|
||||
const bool use_ext,
|
||||
const bool use_frames,
|
||||
const char *suffix)
|
||||
{
|
||||
if (string == nullptr) {
|
||||
return;
|
||||
}
|
||||
BLI_strncpy(string, base, FILE_MAX - 10); /* weak assumption */
|
||||
BLI_path_abs(string, relbase);
|
||||
|
||||
if (use_frames) {
|
||||
BLI_path_frame(string, frame, 4);
|
||||
}
|
||||
|
||||
if (suffix) {
|
||||
BLI_path_suffix(string, FILE_MAX, suffix, "");
|
||||
}
|
||||
|
||||
if (use_ext) {
|
||||
do_add_image_extension(string, imtype, im_format);
|
||||
}
|
||||
}
|
||||
|
||||
void BKE_image_path_from_imformat(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const ImageFormatData *im_format,
|
||||
const bool use_ext,
|
||||
const bool use_frames,
|
||||
const char *suffix)
|
||||
{
|
||||
do_makepicstring(
|
||||
string, base, relbase, frame, im_format->imtype, im_format, use_ext, use_frames, suffix);
|
||||
}
|
||||
|
||||
void BKE_image_path_from_imtype(char *string,
|
||||
const char *base,
|
||||
const char *relbase,
|
||||
int frame,
|
||||
const char imtype,
|
||||
const bool use_ext,
|
||||
const bool use_frames,
|
||||
const char *suffix)
|
||||
{
|
||||
do_makepicstring(string, base, relbase, frame, imtype, nullptr, use_ext, use_frames, suffix);
|
||||
}
|
||||
|
||||
/* ImBuf Conversion */
|
||||
|
||||
void BKE_image_format_to_imbuf(ImBuf *ibuf, const ImageFormatData *imf)
|
||||
{
|
||||
/* Write to ImBuf in preparation for file writing. */
|
||||
char imtype = imf->imtype;
|
||||
char compress = imf->compress;
|
||||
char quality = imf->quality;
|
||||
|
||||
/* initialize all from image format */
|
||||
ibuf->foptions.flag = 0;
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_IRIS) {
|
||||
ibuf->ftype = IMB_FTYPE_IMAGIC;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
else if (imtype == R_IMF_IMTYPE_RADHDR) {
|
||||
ibuf->ftype = IMB_FTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
else if (ELEM(imtype,
|
||||
R_IMF_IMTYPE_PNG,
|
||||
R_IMF_IMTYPE_FFMPEG,
|
||||
R_IMF_IMTYPE_H264,
|
||||
R_IMF_IMTYPE_THEORA,
|
||||
R_IMF_IMTYPE_XVID)) {
|
||||
ibuf->ftype = IMB_FTYPE_PNG;
|
||||
|
||||
if (imtype == R_IMF_IMTYPE_PNG) {
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= PNG_16BIT;
|
||||
}
|
||||
|
||||
ibuf->foptions.quality = compress;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_DDS
|
||||
else if (imtype == R_IMF_IMTYPE_DDS) {
|
||||
ibuf->ftype = IMB_FTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
else if (imtype == R_IMF_IMTYPE_BMP) {
|
||||
ibuf->ftype = IMB_FTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
else if (imtype == R_IMF_IMTYPE_TIFF) {
|
||||
ibuf->ftype = IMB_FTYPE_TIF;
|
||||
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= TIF_16BIT;
|
||||
}
|
||||
if (imf->tiff_codec == R_IMF_TIFF_CODEC_NONE) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_NONE;
|
||||
}
|
||||
else if (imf->tiff_codec == R_IMF_TIFF_CODEC_DEFLATE) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_DEFLATE;
|
||||
}
|
||||
else if (imf->tiff_codec == R_IMF_TIFF_CODEC_LZW) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_LZW;
|
||||
}
|
||||
else if (imf->tiff_codec == R_IMF_TIFF_CODEC_PACKBITS) {
|
||||
ibuf->foptions.flag |= TIF_COMPRESS_PACKBITS;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_OPENEXR
|
||||
else if (ELEM(imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER)) {
|
||||
ibuf->ftype = IMB_FTYPE_OPENEXR;
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= OPENEXR_HALF;
|
||||
}
|
||||
ibuf->foptions.flag |= (imf->exr_codec & OPENEXR_COMPRESS);
|
||||
|
||||
if (!(imf->flag & R_IMF_FLAG_ZBUF)) {
|
||||
/* Signal for exr saving. */
|
||||
IMB_freezbuffloatImBuf(ibuf);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef WITH_CINEON
|
||||
else if (imtype == R_IMF_IMTYPE_CINEON) {
|
||||
ibuf->ftype = IMB_FTYPE_CINEON;
|
||||
if (imf->cineon_flag & R_IMF_CINEON_FLAG_LOG) {
|
||||
ibuf->foptions.flag |= CINEON_LOG;
|
||||
}
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= CINEON_16BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
|
||||
ibuf->foptions.flag |= CINEON_12BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_10) {
|
||||
ibuf->foptions.flag |= CINEON_10BIT;
|
||||
}
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_DPX) {
|
||||
ibuf->ftype = IMB_FTYPE_DPX;
|
||||
if (imf->cineon_flag & R_IMF_CINEON_FLAG_LOG) {
|
||||
ibuf->foptions.flag |= CINEON_LOG;
|
||||
}
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= CINEON_16BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
|
||||
ibuf->foptions.flag |= CINEON_12BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_10) {
|
||||
ibuf->foptions.flag |= CINEON_10BIT;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else if (imtype == R_IMF_IMTYPE_TARGA) {
|
||||
ibuf->ftype = IMB_FTYPE_TGA;
|
||||
}
|
||||
else if (imtype == R_IMF_IMTYPE_RAWTGA) {
|
||||
ibuf->ftype = IMB_FTYPE_TGA;
|
||||
ibuf->foptions.flag = RAWTGA;
|
||||
}
|
||||
#ifdef WITH_OPENJPEG
|
||||
else if (imtype == R_IMF_IMTYPE_JP2) {
|
||||
if (quality < 10) {
|
||||
quality = 90;
|
||||
}
|
||||
ibuf->ftype = IMB_FTYPE_JP2;
|
||||
ibuf->foptions.quality = quality;
|
||||
|
||||
if (imf->depth == R_IMF_CHAN_DEPTH_16) {
|
||||
ibuf->foptions.flag |= JP2_16BIT;
|
||||
}
|
||||
else if (imf->depth == R_IMF_CHAN_DEPTH_12) {
|
||||
ibuf->foptions.flag |= JP2_12BIT;
|
||||
}
|
||||
|
||||
if (imf->jp2_flag & R_IMF_JP2_FLAG_YCC) {
|
||||
ibuf->foptions.flag |= JP2_YCC;
|
||||
}
|
||||
|
||||
if (imf->jp2_flag & R_IMF_JP2_FLAG_CINE_PRESET) {
|
||||
ibuf->foptions.flag |= JP2_CINE;
|
||||
if (imf->jp2_flag & R_IMF_JP2_FLAG_CINE_48) {
|
||||
ibuf->foptions.flag |= JP2_CINE_48FPS;
|
||||
}
|
||||
}
|
||||
|
||||
if (imf->jp2_codec == R_IMF_JP2_CODEC_JP2) {
|
||||
ibuf->foptions.flag |= JP2_JP2;
|
||||
}
|
||||
else if (imf->jp2_codec == R_IMF_JP2_CODEC_J2K) {
|
||||
ibuf->foptions.flag |= JP2_J2K;
|
||||
}
|
||||
else {
|
||||
BLI_assert_msg(0, "Unsupported jp2 codec was specified in im_format->jp2_codec");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else {
|
||||
/* R_IMF_IMTYPE_JPEG90, etc. default we save jpegs */
|
||||
if (quality < 10) {
|
||||
quality = 90;
|
||||
}
|
||||
ibuf->ftype = IMB_FTYPE_JPG;
|
||||
ibuf->foptions.quality = quality;
|
||||
}
|
||||
}
|
||||
|
||||
void BKE_image_format_from_imbuf(ImageFormatData *im_format, const ImBuf *imbuf)
|
||||
{
|
||||
/* Read from ImBuf after file read. */
|
||||
int ftype = imbuf->ftype;
|
||||
int custom_flags = imbuf->foptions.flag;
|
||||
char quality = imbuf->foptions.quality;
|
||||
|
||||
BKE_image_format_init(im_format, false);
|
||||
|
||||
/* file type */
|
||||
if (ftype == IMB_FTYPE_IMAGIC) {
|
||||
im_format->imtype = R_IMF_IMTYPE_IRIS;
|
||||
}
|
||||
#ifdef WITH_HDR
|
||||
else if (ftype == IMB_FTYPE_RADHDR) {
|
||||
im_format->imtype = R_IMF_IMTYPE_RADHDR;
|
||||
}
|
||||
#endif
|
||||
else if (ftype == IMB_FTYPE_PNG) {
|
||||
im_format->imtype = R_IMF_IMTYPE_PNG;
|
||||
|
||||
if (custom_flags & PNG_16BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
|
||||
im_format->compress = quality;
|
||||
}
|
||||
|
||||
#ifdef WITH_DDS
|
||||
else if (ftype == IMB_FTYPE_DDS) {
|
||||
im_format->imtype = R_IMF_IMTYPE_DDS;
|
||||
}
|
||||
#endif
|
||||
else if (ftype == IMB_FTYPE_BMP) {
|
||||
im_format->imtype = R_IMF_IMTYPE_BMP;
|
||||
}
|
||||
#ifdef WITH_TIFF
|
||||
else if (ftype == IMB_FTYPE_TIF) {
|
||||
im_format->imtype = R_IMF_IMTYPE_TIFF;
|
||||
if (custom_flags & TIF_16BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_NONE) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_NONE;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_DEFLATE) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_DEFLATE;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_LZW) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_LZW;
|
||||
}
|
||||
if (custom_flags & TIF_COMPRESS_PACKBITS) {
|
||||
im_format->tiff_codec = R_IMF_TIFF_CODEC_PACKBITS;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef WITH_OPENEXR
|
||||
else if (ftype == IMB_FTYPE_OPENEXR) {
|
||||
im_format->imtype = R_IMF_IMTYPE_OPENEXR;
|
||||
if (custom_flags & OPENEXR_HALF) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
if (custom_flags & OPENEXR_COMPRESS) {
|
||||
im_format->exr_codec = R_IMF_EXR_CODEC_ZIP; /* Can't determine compression */
|
||||
}
|
||||
if (imbuf->zbuf_float) {
|
||||
im_format->flag |= R_IMF_FLAG_ZBUF;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef WITH_CINEON
|
||||
else if (ftype == IMB_FTYPE_CINEON) {
|
||||
im_format->imtype = R_IMF_IMTYPE_CINEON;
|
||||
}
|
||||
else if (ftype == IMB_FTYPE_DPX) {
|
||||
im_format->imtype = R_IMF_IMTYPE_DPX;
|
||||
}
|
||||
#endif
|
||||
else if (ftype == IMB_FTYPE_TGA) {
|
||||
if (custom_flags & RAWTGA) {
|
||||
im_format->imtype = R_IMF_IMTYPE_RAWTGA;
|
||||
}
|
||||
else {
|
||||
im_format->imtype = R_IMF_IMTYPE_TARGA;
|
||||
}
|
||||
}
|
||||
#ifdef WITH_OPENJPEG
|
||||
else if (ftype == IMB_FTYPE_JP2) {
|
||||
im_format->imtype = R_IMF_IMTYPE_JP2;
|
||||
im_format->quality = quality;
|
||||
|
||||
if (custom_flags & JP2_16BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_16;
|
||||
}
|
||||
else if (custom_flags & JP2_12BIT) {
|
||||
im_format->depth = R_IMF_CHAN_DEPTH_12;
|
||||
}
|
||||
|
||||
if (custom_flags & JP2_YCC) {
|
||||
im_format->jp2_flag |= R_IMF_JP2_FLAG_YCC;
|
||||
}
|
||||
|
||||
if (custom_flags & JP2_CINE) {
|
||||
im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_PRESET;
|
||||
if (custom_flags & JP2_CINE_48FPS) {
|
||||
im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_48;
|
||||
}
|
||||
}
|
||||
|
||||
if (custom_flags & JP2_JP2) {
|
||||
im_format->jp2_codec = R_IMF_JP2_CODEC_JP2;
|
||||
}
|
||||
else if (custom_flags & JP2_J2K) {
|
||||
im_format->jp2_codec = R_IMF_JP2_CODEC_J2K;
|
||||
}
|
||||
else {
|
||||
BLI_assert_msg(0, "Unsupported jp2 codec was specified in file type");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
else {
|
||||
im_format->imtype = R_IMF_IMTYPE_JPEG90;
|
||||
im_format->quality = quality;
|
||||
}
|
||||
|
||||
/* planes */
|
||||
im_format->planes = imbuf->planes;
|
||||
}
|
|
@ -22,6 +22,7 @@
|
|||
|
||||
#include "BKE_colortools.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_image_save.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_report.h"
|
||||
|
@ -36,7 +37,12 @@ void BKE_image_save_options_init(ImageSaveOptions *opts, Main *bmain, Scene *sce
|
|||
opts->bmain = bmain;
|
||||
opts->scene = scene;
|
||||
|
||||
BKE_imformat_defaults(&opts->im_format);
|
||||
BKE_image_format_init(&opts->im_format, false);
|
||||
}
|
||||
|
||||
void BKE_image_save_options_free(ImageSaveOptions *opts)
|
||||
{
|
||||
BKE_image_format_free(&opts->im_format);
|
||||
}
|
||||
|
||||
static void image_save_post(ReportList *reports,
|
||||
|
@ -349,7 +355,7 @@ static bool image_save_single(ReportList *reports,
|
|||
colormanaged_ibuf = IMB_colormanagement_imbuf_for_write(
|
||||
ibuf, save_as_render, true, &imf->view_settings, &imf->display_settings, imf);
|
||||
|
||||
BKE_imbuf_write_prepare(colormanaged_ibuf, imf);
|
||||
BKE_image_format_to_imbuf(colormanaged_ibuf, imf);
|
||||
IMB_prepare_write_ImBuf(IMB_isfloat(colormanaged_ibuf), colormanaged_ibuf);
|
||||
|
||||
/* duplicate buffer to prevent locker issue when using render result */
|
||||
|
|
|
@ -55,6 +55,7 @@
|
|||
#include "BKE_icons.h"
|
||||
#include "BKE_idprop.h"
|
||||
#include "BKE_idtype.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_lib_query.h"
|
||||
#include "BKE_main.h"
|
||||
|
@ -595,8 +596,13 @@ void ntreeBlendWrite(BlendWriter *writer, bNodeTree *ntree)
|
|||
|
||||
if (node->type == CMP_NODE_OUTPUT_FILE) {
|
||||
/* Inputs have their own storage data. */
|
||||
NodeImageMultiFile *nimf = (NodeImageMultiFile *)node->storage;
|
||||
BKE_image_format_blend_write(writer, &nimf->format);
|
||||
|
||||
LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
|
||||
BLO_write_struct(writer, NodeImageMultiFileSocket, sock->storage);
|
||||
NodeImageMultiFileSocket *sockdata = (NodeImageMultiFileSocket *)sock->storage;
|
||||
BLO_write_struct(writer, NodeImageMultiFileSocket, sockdata);
|
||||
BKE_image_format_blend_write(writer, &sockdata->format);
|
||||
}
|
||||
}
|
||||
if (ELEM(node->type, CMP_NODE_IMAGE, CMP_NODE_R_LAYERS)) {
|
||||
|
@ -749,6 +755,11 @@ void ntreeBlendReadData(BlendDataReader *reader, bNodeTree *ntree)
|
|||
iuser->scene = nullptr;
|
||||
break;
|
||||
}
|
||||
case CMP_NODE_OUTPUT_FILE: {
|
||||
NodeImageMultiFile *nimf = (NodeImageMultiFile *)node->storage;
|
||||
BKE_image_format_blend_read_data(reader, &nimf->format);
|
||||
break;
|
||||
}
|
||||
case FN_NODE_INPUT_STRING: {
|
||||
NodeInputString *storage = (NodeInputString *)node->storage;
|
||||
BLO_read_data_address(reader, &storage->string);
|
||||
|
@ -771,6 +782,14 @@ void ntreeBlendReadData(BlendDataReader *reader, bNodeTree *ntree)
|
|||
LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
|
||||
direct_link_node_socket(reader, sock);
|
||||
}
|
||||
|
||||
/* Socket storage. */
|
||||
if (node->type == CMP_NODE_OUTPUT_FILE) {
|
||||
LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
|
||||
NodeImageMultiFileSocket *sockdata = (NodeImageMultiFileSocket *)sock->storage;
|
||||
BKE_image_format_blend_read_data(reader, &sockdata->format);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* interface socket lists */
|
||||
|
|
|
@ -25,6 +25,7 @@
|
|||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_ocean.h"
|
||||
#include "ocean_intern.h"
|
||||
|
||||
|
|
|
@ -28,6 +28,7 @@
|
|||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_packedFile.h"
|
||||
#include "BKE_report.h"
|
||||
|
@ -503,7 +504,7 @@ static void unpack_generate_paths(const char *name,
|
|||
const PackedFile *pf = imapf->packedfile;
|
||||
enum eImbFileType ftype = IMB_ispic_type_from_memory((const uchar *)pf->data, pf->size);
|
||||
if (ftype != IMB_FTYPE_NONE) {
|
||||
const int imtype = BKE_image_ftype_to_imtype(ftype, NULL);
|
||||
const int imtype = BKE_ftype_to_imtype(ftype, NULL);
|
||||
BKE_image_path_ensure_ext_from_imtype(tempname, imtype);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -70,6 +70,7 @@
|
|||
#include "BKE_idprop.h"
|
||||
#include "BKE_idtype.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_layer.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_lib_query.h"
|
||||
|
@ -201,15 +202,8 @@ static void scene_init_data(ID *id)
|
|||
colorspace_name,
|
||||
sizeof(scene->sequencer_colorspace_settings.name));
|
||||
|
||||
/* Those next two sets (render and baking settings) are not currently in use,
|
||||
* but are exposed to RNA API and hence must have valid data. */
|
||||
BKE_color_managed_display_settings_init(&scene->r.im_format.display_settings);
|
||||
BKE_color_managed_view_settings_init_render(
|
||||
&scene->r.im_format.view_settings, &scene->r.im_format.display_settings, "Filmic");
|
||||
|
||||
BKE_color_managed_display_settings_init(&scene->r.bake.im_format.display_settings);
|
||||
BKE_color_managed_view_settings_init_render(
|
||||
&scene->r.bake.im_format.view_settings, &scene->r.bake.im_format.display_settings, "Filmic");
|
||||
BKE_image_format_init(&scene->r.im_format, true);
|
||||
BKE_image_format_init(&scene->r.bake.im_format, true);
|
||||
|
||||
/* Curve Profile */
|
||||
scene->toolsettings->custom_bevel_profile_preset = BKE_curveprofile_add(PROF_PRESET_LINE);
|
||||
|
@ -295,15 +289,8 @@ static void scene_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int
|
|||
BKE_color_managed_colorspace_settings_copy(&scene_dst->sequencer_colorspace_settings,
|
||||
&scene_src->sequencer_colorspace_settings);
|
||||
|
||||
BKE_color_managed_display_settings_copy(&scene_dst->r.im_format.display_settings,
|
||||
&scene_src->r.im_format.display_settings);
|
||||
BKE_color_managed_view_settings_copy(&scene_dst->r.im_format.view_settings,
|
||||
&scene_src->r.im_format.view_settings);
|
||||
|
||||
BKE_color_managed_display_settings_copy(&scene_dst->r.bake.im_format.display_settings,
|
||||
&scene_src->r.bake.im_format.display_settings);
|
||||
BKE_color_managed_view_settings_copy(&scene_dst->r.bake.im_format.view_settings,
|
||||
&scene_src->r.bake.im_format.view_settings);
|
||||
BKE_image_format_copy(&scene_dst->r.im_format, &scene_src->r.im_format);
|
||||
BKE_image_format_copy(&scene_dst->r.bake.im_format, &scene_src->r.bake.im_format);
|
||||
|
||||
BKE_curvemapping_copy_data(&scene_dst->r.mblur_shutter_curve, &scene_src->r.mblur_shutter_curve);
|
||||
|
||||
|
@ -402,6 +389,8 @@ static void scene_free_data(ID *id)
|
|||
BKE_sound_destroy_scene(scene);
|
||||
|
||||
BKE_color_managed_view_settings_free(&scene->view_settings);
|
||||
BKE_image_format_free(&scene->r.im_format);
|
||||
BKE_image_format_free(&scene->r.bake.im_format);
|
||||
|
||||
BKE_previewimg_free(&scene->preview);
|
||||
BKE_curvemapping_free_data(&scene->r.mblur_shutter_curve);
|
||||
|
@ -1044,6 +1033,8 @@ static void scene_blend_write(BlendWriter *writer, ID *id, const void *id_addres
|
|||
}
|
||||
|
||||
BKE_color_managed_view_settings_blend_write(writer, &sce->view_settings);
|
||||
BKE_image_format_blend_write(writer, &sce->r.im_format);
|
||||
BKE_image_format_blend_write(writer, &sce->r.bake.im_format);
|
||||
|
||||
/* writing RigidBodyWorld data to the blend file */
|
||||
if (sce->rigidbody_world) {
|
||||
|
@ -1276,6 +1267,8 @@ static void scene_blend_read_data(BlendDataReader *reader, ID *id)
|
|||
}
|
||||
|
||||
BKE_color_managed_view_settings_blend_read_data(reader, &sce->view_settings);
|
||||
BKE_image_format_blend_read_data(reader, &sce->r.im_format);
|
||||
BKE_image_format_blend_read_data(reader, &sce->r.bake.im_format);
|
||||
|
||||
BLO_read_data_address(reader, &sce->rigidbody_world);
|
||||
RigidBodyWorld *rbw = sce->rigidbody_world;
|
||||
|
@ -1855,15 +1848,8 @@ Scene *BKE_scene_duplicate(Main *bmain, Scene *sce, eSceneCopyMethod type)
|
|||
BKE_color_managed_colorspace_settings_copy(&sce_copy->sequencer_colorspace_settings,
|
||||
&sce->sequencer_colorspace_settings);
|
||||
|
||||
BKE_color_managed_display_settings_copy(&sce_copy->r.im_format.display_settings,
|
||||
&sce->r.im_format.display_settings);
|
||||
BKE_color_managed_view_settings_copy(&sce_copy->r.im_format.view_settings,
|
||||
&sce->r.im_format.view_settings);
|
||||
|
||||
BKE_color_managed_display_settings_copy(&sce_copy->r.bake.im_format.display_settings,
|
||||
&sce->r.bake.im_format.display_settings);
|
||||
BKE_color_managed_view_settings_copy(&sce_copy->r.bake.im_format.view_settings,
|
||||
&sce->r.bake.im_format.view_settings);
|
||||
BKE_image_format_copy(&sce_copy->r.im_format, &sce->r.im_format);
|
||||
BKE_image_format_copy(&sce_copy->r.bake.im_format, &sce->r.bake.im_format);
|
||||
|
||||
BKE_curvemapping_copy_data(&sce_copy->r.mblur_shutter_curve, &sce->r.mblur_shutter_curve);
|
||||
|
||||
|
|
|
@ -4,6 +4,7 @@
|
|||
#include "COM_OutputFileMultiViewOperation.h"
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_scene.h"
|
||||
|
||||
|
|
|
@ -8,6 +8,7 @@
|
|||
#include "BLI_string.h"
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_scene.h"
|
||||
|
||||
|
|
|
@ -23,6 +23,7 @@
|
|||
#include "BKE_context.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_layer.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_main.h"
|
||||
|
|
|
@ -31,6 +31,7 @@
|
|||
#include "BKE_context.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_node.h"
|
||||
|
|
|
@ -34,6 +34,7 @@
|
|||
#include "BKE_fcurve.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_lib_query.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_report.h"
|
||||
|
|
|
@ -24,6 +24,7 @@
|
|||
#include "BKE_context.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_report.h"
|
||||
#include "BKE_screen.h"
|
||||
|
@ -71,7 +72,7 @@ static int screenshot_data_create(bContext *C, wmOperator *op, ScrArea *area)
|
|||
scd->crop = area->totrct;
|
||||
}
|
||||
|
||||
BKE_imformat_defaults(&scd->im_format);
|
||||
BKE_image_format_init(&scd->im_format, false);
|
||||
|
||||
op->customdata = scd;
|
||||
|
||||
|
|
|
@ -20,6 +20,7 @@
|
|||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_node.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_screen.h"
|
||||
|
|
|
@ -38,6 +38,7 @@
|
|||
#include "BKE_global.h"
|
||||
#include "BKE_icons.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_image_save.h"
|
||||
#include "BKE_layer.h"
|
||||
#include "BKE_lib_id.h"
|
||||
|
@ -1736,7 +1737,7 @@ static int image_save_options_init(Main *bmain,
|
|||
|
||||
if (ELEM(ima->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE)) {
|
||||
/* imtype */
|
||||
opts->im_format = scene->r.im_format;
|
||||
BKE_image_format_copy(&opts->im_format, &scene->r.im_format);
|
||||
is_depth_set = true;
|
||||
if (!BKE_image_is_multiview(ima)) {
|
||||
/* In case multiview is disabled,
|
||||
|
@ -1752,7 +1753,7 @@ static int image_save_options_init(Main *bmain,
|
|||
opts->im_format.planes = ibuf->planes;
|
||||
}
|
||||
else {
|
||||
BKE_imbuf_to_image_format(&opts->im_format, ibuf);
|
||||
BKE_image_format_from_imbuf(&opts->im_format, ibuf);
|
||||
}
|
||||
|
||||
/* use the multiview image settings as the default */
|
||||
|
@ -1829,8 +1830,8 @@ static void image_save_options_from_op(Main *bmain,
|
|||
ImageFormatData *imf)
|
||||
{
|
||||
if (imf) {
|
||||
BKE_color_managed_view_settings_free(&opts->im_format.view_settings);
|
||||
opts->im_format = *imf;
|
||||
BKE_image_format_free(&opts->im_format);
|
||||
BKE_image_format_copy(&opts->im_format, imf);
|
||||
}
|
||||
|
||||
if (RNA_struct_property_is_set(op->ptr, "filepath")) {
|
||||
|
@ -1843,8 +1844,8 @@ static void image_save_options_to_op(ImageSaveOptions *opts, wmOperator *op)
|
|||
{
|
||||
if (op->customdata) {
|
||||
ImageSaveData *isd = op->customdata;
|
||||
BKE_color_managed_view_settings_free(&isd->im_format.view_settings);
|
||||
isd->im_format = opts->im_format;
|
||||
BKE_image_format_free(&isd->im_format);
|
||||
BKE_image_format_copy(&isd->im_format, &opts->im_format);
|
||||
}
|
||||
|
||||
RNA_string_set(op->ptr, "filepath", opts->filepath);
|
||||
|
@ -1878,7 +1879,7 @@ static void image_save_as_free(wmOperator *op)
|
|||
{
|
||||
if (op->customdata) {
|
||||
ImageSaveData *isd = op->customdata;
|
||||
BKE_color_managed_view_settings_free(&isd->im_format.view_settings);
|
||||
BKE_image_format_free(&isd->im_format);
|
||||
|
||||
MEM_freeN(op->customdata);
|
||||
op->customdata = NULL;
|
||||
|
@ -1920,6 +1921,8 @@ static int image_save_as_exec(bContext *C, wmOperator *op)
|
|||
BKE_image_free_packedfiles(image);
|
||||
}
|
||||
|
||||
BKE_image_save_options_free(&opts);
|
||||
|
||||
image_save_as_free(op);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1948,6 +1951,7 @@ static int image_save_as_invoke(bContext *C, wmOperator *op, const wmEvent *UNUS
|
|||
BKE_image_save_options_init(&opts, bmain, scene);
|
||||
|
||||
if (image_save_options_init(bmain, &opts, ima, iuser, true, save_as_render) == 0) {
|
||||
BKE_image_save_options_free(&opts);
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
image_save_options_to_op(&opts, op);
|
||||
|
@ -1964,7 +1968,7 @@ static int image_save_as_invoke(bContext *C, wmOperator *op, const wmEvent *UNUS
|
|||
isd->image = ima;
|
||||
isd->iuser = iuser;
|
||||
|
||||
memcpy(&isd->im_format, &opts.im_format, sizeof(opts.im_format));
|
||||
BKE_image_format_copy(&isd->im_format, &opts.im_format);
|
||||
op->customdata = isd;
|
||||
|
||||
/* show multiview save options only if image has multiviews */
|
||||
|
@ -1974,6 +1978,7 @@ static int image_save_as_invoke(bContext *C, wmOperator *op, const wmEvent *UNUS
|
|||
RNA_property_boolean_set(op->ptr, prop, BKE_image_is_multiview(ima));
|
||||
|
||||
image_filesel(C, op, opts.filepath);
|
||||
BKE_image_save_options_free(&opts);
|
||||
|
||||
return OPERATOR_RUNNING_MODAL;
|
||||
}
|
||||
|
@ -2132,6 +2137,7 @@ static int image_save_exec(bContext *C, wmOperator *op)
|
|||
|
||||
BKE_image_save_options_init(&opts, bmain, scene);
|
||||
if (image_save_options_init(bmain, &opts, image, iuser, false, false) == 0) {
|
||||
BKE_image_save_options_free(&opts);
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
image_save_options_from_op(bmain, &opts, op, NULL);
|
||||
|
@ -2147,7 +2153,7 @@ static int image_save_exec(bContext *C, wmOperator *op)
|
|||
ok = true;
|
||||
}
|
||||
|
||||
BKE_color_managed_view_settings_free(&opts.im_format.view_settings);
|
||||
BKE_image_save_options_free(&opts);
|
||||
|
||||
if (ok) {
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -2399,6 +2405,7 @@ bool ED_image_save_all_modified(const bContext *C, ReportList *reports)
|
|||
bool saved_successfully = BKE_image_save(reports, bmain, ima, NULL, &opts);
|
||||
ok = ok && saved_successfully;
|
||||
}
|
||||
BKE_image_save_options_free(&opts);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -37,6 +37,7 @@
|
|||
#include "BKE_colortools.h"
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_main.h"
|
||||
|
||||
#include "RNA_define.h"
|
||||
|
@ -2508,8 +2509,8 @@ ImBuf *IMB_colormanagement_imbuf_for_write(ImBuf *ibuf,
|
|||
* should be pretty safe since this image buffer is supposed to be used for
|
||||
* saving only and ftype would be overwritten a bit later by BKE_imbuf_write
|
||||
*/
|
||||
colormanaged_ibuf->ftype = BKE_image_imtype_to_ftype(image_format_data->imtype,
|
||||
&colormanaged_ibuf->foptions);
|
||||
colormanaged_ibuf->ftype = BKE_imtype_to_ftype(image_format_data->imtype,
|
||||
&colormanaged_ibuf->foptions);
|
||||
|
||||
/* if file format isn't able to handle float buffer itself,
|
||||
* we need to allocate byte buffer and store color managed
|
||||
|
|
|
@ -14,6 +14,7 @@
|
|||
#include "BKE_customdata.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_mesh.h"
|
||||
|
||||
|
@ -48,7 +49,7 @@ void ImagesExporter::export_UV_Image(Image *image, bool use_copies)
|
|||
bool is_dirty = BKE_image_is_dirty(image);
|
||||
|
||||
ImageFormatData imageFormat;
|
||||
BKE_imbuf_to_image_format(&imageFormat, imbuf);
|
||||
BKE_image_format_from_imbuf(&imageFormat, imbuf);
|
||||
|
||||
short image_source = image->source;
|
||||
bool is_generated = image_source == IMA_SRC_GENERATED;
|
||||
|
|
|
@ -6,6 +6,7 @@
|
|||
#include "usd_exporter_context.h"
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_node.h"
|
||||
|
||||
|
@ -335,7 +336,7 @@ static std::string get_in_memory_texture_filename(Image *ima)
|
|||
}
|
||||
|
||||
ImageFormatData imageFormat;
|
||||
BKE_imbuf_to_image_format(&imageFormat, imbuf);
|
||||
BKE_image_format_from_imbuf(&imageFormat, imbuf);
|
||||
|
||||
char file_name[FILE_MAX];
|
||||
/* Use the image name for the file name. */
|
||||
|
@ -368,7 +369,7 @@ static void export_in_memory_texture(Image *ima,
|
|||
}
|
||||
|
||||
ImageFormatData imageFormat;
|
||||
BKE_imbuf_to_image_format(&imageFormat, imbuf);
|
||||
BKE_image_format_from_imbuf(&imageFormat, imbuf);
|
||||
|
||||
/* This image in its current state only exists in Blender memory.
|
||||
* So we have to export it. The export will keep the image state intact,
|
||||
|
|
|
@ -431,6 +431,7 @@ typedef struct ImageFormatData {
|
|||
/* color management */
|
||||
ColorManagedViewSettings view_settings;
|
||||
ColorManagedDisplaySettings display_settings;
|
||||
ColorManagedColorspaceSettings linear_colorspace_settings;
|
||||
} ImageFormatData;
|
||||
|
||||
/** #ImageFormatData.imtype */
|
||||
|
@ -466,8 +467,8 @@ typedef struct ImageFormatData {
|
|||
#define R_IMF_IMTYPE_INVALID 255
|
||||
|
||||
/** #ImageFormatData.flag */
|
||||
#define R_IMF_FLAG_ZBUF (1 << 0) /* was R_OPENEXR_ZBUF */
|
||||
#define R_IMF_FLAG_PREVIEW_JPG (1 << 1) /* was R_PREVIEW_JPG */
|
||||
#define R_IMF_FLAG_ZBUF (1 << 0)
|
||||
#define R_IMF_FLAG_PREVIEW_JPG (1 << 1)
|
||||
|
||||
/* Return values from #BKE_imtype_valid_depths, note this is depths per channel. */
|
||||
/** #ImageFormatData.depth */
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_node_tree_update.h"
|
||||
|
||||
#include "DEG_depsgraph.h"
|
||||
|
@ -238,8 +239,8 @@ static int rna_Image_file_format_get(PointerRNA *ptr)
|
|||
{
|
||||
Image *image = (Image *)ptr->data;
|
||||
ImBuf *ibuf = BKE_image_acquire_ibuf(image, NULL, NULL);
|
||||
int imtype = BKE_image_ftype_to_imtype(ibuf ? ibuf->ftype : IMB_FTYPE_NONE,
|
||||
ibuf ? &ibuf->foptions : NULL);
|
||||
int imtype = BKE_ftype_to_imtype(ibuf ? ibuf->ftype : IMB_FTYPE_NONE,
|
||||
ibuf ? &ibuf->foptions : NULL);
|
||||
|
||||
BKE_image_release_ibuf(image, ibuf, NULL);
|
||||
|
||||
|
@ -251,7 +252,7 @@ static void rna_Image_file_format_set(PointerRNA *ptr, int value)
|
|||
Image *image = (Image *)ptr->data;
|
||||
if (BKE_imtype_is_movie(value) == 0) { /* should be able to throw an error here */
|
||||
ImbFormatOptions options;
|
||||
int ftype = BKE_image_imtype_to_ftype(value, &options);
|
||||
int ftype = BKE_imtype_to_ftype(value, &options);
|
||||
BKE_image_file_format_set(image, ftype, &options);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -633,6 +633,7 @@ const EnumPropertyItem rna_enum_transform_orientation_items[] = {
|
|||
# include "BKE_gpencil.h"
|
||||
# include "BKE_idprop.h"
|
||||
# include "BKE_image.h"
|
||||
# include "BKE_image_format.h"
|
||||
# include "BKE_layer.h"
|
||||
# include "BKE_main.h"
|
||||
# include "BKE_mesh.h"
|
||||
|
|
|
@ -12,6 +12,7 @@
|
|||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_image_format.h"
|
||||
|
||||
#include "RNA_access.h"
|
||||
#include "RNA_prototypes.h"
|
||||
|
@ -135,7 +136,7 @@ bNodeSocket *ntreeCompositOutputFileAddSocket(bNodeTree *ntree,
|
|||
}
|
||||
}
|
||||
else {
|
||||
BKE_imformat_defaults(&sockdata->format);
|
||||
BKE_image_format_init(&sockdata->format, false);
|
||||
}
|
||||
/* use node data format by default */
|
||||
sockdata->use_node_format = true;
|
||||
|
@ -205,7 +206,7 @@ static void init_output_file(const bContext *C, PointerRNA *ptr)
|
|||
format = &nimf->format;
|
||||
}
|
||||
else {
|
||||
BKE_imformat_defaults(&nimf->format);
|
||||
BKE_image_format_init(&nimf->format, false);
|
||||
}
|
||||
|
||||
/* add one socket by default */
|
||||
|
@ -216,9 +217,13 @@ static void free_output_file(bNode *node)
|
|||
{
|
||||
/* free storage data in sockets */
|
||||
LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
|
||||
NodeImageMultiFileSocket *sockdata = (NodeImageMultiFileSocket *)sock->storage;
|
||||
BKE_image_format_free(&sockdata->format);
|
||||
MEM_freeN(sock->storage);
|
||||
}
|
||||
|
||||
NodeImageMultiFile *nimf = (NodeImageMultiFile *)node->storage;
|
||||
BKE_image_format_free(&nimf->format);
|
||||
MEM_freeN(node->storage);
|
||||
}
|
||||
|
||||
|
@ -229,6 +234,9 @@ static void copy_output_file(bNodeTree *UNUSED(dest_ntree),
|
|||
bNodeSocket *src_sock, *dest_sock;
|
||||
|
||||
dest_node->storage = MEM_dupallocN(src_node->storage);
|
||||
NodeImageMultiFile *dest_nimf = (NodeImageMultiFile *)dest_node->storage;
|
||||
NodeImageMultiFile *src_nimf = (NodeImageMultiFile *)src_node->storage;
|
||||
BKE_image_format_copy(&dest_nimf->format, &src_nimf->format);
|
||||
|
||||
/* duplicate storage data in sockets */
|
||||
for (src_sock = (bNodeSocket *)src_node->inputs.first,
|
||||
|
@ -236,6 +244,9 @@ static void copy_output_file(bNodeTree *UNUSED(dest_ntree),
|
|||
src_sock && dest_sock;
|
||||
src_sock = src_sock->next, dest_sock = (bNodeSocket *)dest_sock->next) {
|
||||
dest_sock->storage = MEM_dupallocN(src_sock->storage);
|
||||
NodeImageMultiFileSocket *dest_sockdata = (NodeImageMultiFileSocket *)dest_sock->storage;
|
||||
NodeImageMultiFileSocket *src_sockdata = (NodeImageMultiFileSocket *)src_sock->storage;
|
||||
BKE_image_format_copy(&dest_sockdata->format, &src_sockdata->format);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -44,6 +44,7 @@
|
|||
#include "BKE_context.h" /* XXX needed by wm_window.h */
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_layer.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_lib_remap.h"
|
||||
|
|
|
@ -26,6 +26,7 @@
|
|||
#include "BKE_camera.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_report.h"
|
||||
#include "BKE_scene.h"
|
||||
|
||||
|
|
|
@ -51,6 +51,7 @@
|
|||
#include "BKE_icons.h"
|
||||
#include "BKE_idprop.h"
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_image_format.h"
|
||||
#include "BKE_lib_id.h"
|
||||
#include "BKE_lib_query.h"
|
||||
#include "BKE_main.h"
|
||||
|
|
|
@ -35,7 +35,7 @@
|
|||
# include "BKE_context.h"
|
||||
|
||||
# include "BKE_global.h"
|
||||
# include "BKE_image.h"
|
||||
# include "BKE_image_format.h"
|
||||
# include "BKE_lib_id.h"
|
||||
# include "BKE_main.h"
|
||||
# include "BKE_report.h"
|
||||
|
|
Loading…
Reference in New Issue