Cycles: support loading images from arbitrary OpenColorIO color space
[blender.git] / intern / cycles / render / image.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __IMAGE_H__
18 #define __IMAGE_H__
19
20 #include "device/device.h"
21 #include "device/device_memory.h"
22
23 #include "render/colorspace.h"
24
25 #include "util/util_image.h"
26 #include "util/util_string.h"
27 #include "util/util_thread.h"
28 #include "util/util_unique_ptr.h"
29 #include "util/util_vector.h"
30
31 CCL_NAMESPACE_BEGIN
32
33 class Device;
34 class Progress;
35 class RenderStats;
36 class Scene;
37 class ColorSpaceProcessor;
38
39 class ImageMetaData {
40  public:
41   /* Must be set by image file or builtin callback. */
42   bool is_float, is_half;
43   int channels;
44   size_t width, height, depth;
45   bool builtin_free_cache;
46
47   /* Automatically set. */
48   ImageDataType type;
49   ustring colorspace;
50   bool compress_as_srgb;
51
52   ImageMetaData()
53       : is_float(false),
54         is_half(false),
55         channels(0),
56         width(0),
57         height(0),
58         depth(0),
59         builtin_free_cache(NULL),
60         type(IMAGE_DATA_NUM_TYPES),
61         colorspace(u_colorspace_raw),
62         compress_as_srgb(false)
63   {
64   }
65
66   bool operator==(const ImageMetaData &other) const
67   {
68     return is_float == other.is_float && is_half == other.is_half && channels == other.channels &&
69            width == other.width && height == other.height && depth == other.depth &&
70            type == other.type && colorspace == other.colorspace &&
71            compress_as_srgb == other.compress_as_srgb;
72   }
73 };
74
75 class ImageManager {
76  public:
77   explicit ImageManager(const DeviceInfo &info);
78   ~ImageManager();
79
80   int add_image(const string &filename,
81                 void *builtin_data,
82                 bool animated,
83                 float frame,
84                 InterpolationType interpolation,
85                 ExtensionType extension,
86                 bool use_alpha,
87                 ustring colorspace,
88                 ImageMetaData &metadata);
89   void remove_image(int flat_slot);
90   void remove_image(const string &filename,
91                     void *builtin_data,
92                     InterpolationType interpolation,
93                     ExtensionType extension,
94                     bool use_alpha,
95                     ustring colorspace);
96   void tag_reload_image(const string &filename,
97                         void *builtin_data,
98                         InterpolationType interpolation,
99                         ExtensionType extension,
100                         bool use_alpha,
101                         ustring colorspace);
102   bool get_image_metadata(const string &filename,
103                           void *builtin_data,
104                           ustring colorspace,
105                           ImageMetaData &metadata);
106   bool get_image_metadata(int flat_slot, ImageMetaData &metadata);
107
108   void device_update(Device *device, Scene *scene, Progress &progress);
109   void device_update_slot(Device *device, Scene *scene, int flat_slot, Progress *progress);
110   void device_free(Device *device);
111
112   void device_load_builtin(Device *device, Scene *scene, Progress &progress);
113   void device_free_builtin(Device *device);
114
115   void set_osl_texture_system(void *texture_system);
116   bool set_animation_frame_update(int frame);
117
118   device_memory *image_memory(int flat_slot);
119
120   void collect_statistics(RenderStats *stats);
121
122   bool need_update;
123
124   /* NOTE: Here pixels_size is a size of storage, which equals to
125    *       width * height * depth.
126    *       Use this to avoid some nasty memory corruptions.
127    */
128   function<void(const string &filename, void *data, ImageMetaData &metadata)>
129       builtin_image_info_cb;
130   function<bool(const string &filename,
131                 void *data,
132                 unsigned char *pixels,
133                 const size_t pixels_size,
134                 const bool free_cache)>
135       builtin_image_pixels_cb;
136   function<bool(const string &filename,
137                 void *data,
138                 float *pixels,
139                 const size_t pixels_size,
140                 const bool free_cache)>
141       builtin_image_float_pixels_cb;
142
143   struct Image {
144     string filename;
145     void *builtin_data;
146     ImageMetaData metadata;
147
148     ustring colorspace;
149     bool use_alpha;
150     bool need_load;
151     bool animated;
152     float frame;
153     InterpolationType interpolation;
154     ExtensionType extension;
155
156     string mem_name;
157     device_memory *mem;
158
159     int users;
160   };
161
162  private:
163   int tex_num_images[IMAGE_DATA_NUM_TYPES];
164   int max_num_images;
165   bool has_half_images;
166
167   thread_mutex device_mutex;
168   int animation_frame;
169
170   vector<Image *> images[IMAGE_DATA_NUM_TYPES];
171   void *osl_texture_system;
172
173   bool file_load_image_generic(Image *img, unique_ptr<ImageInput> *in);
174
175   template<TypeDesc::BASETYPE FileFormat, typename StorageType, typename DeviceType>
176   bool file_load_image(Image *img,
177                        ImageDataType type,
178                        int texture_limit,
179                        device_vector<DeviceType> &tex_img);
180
181   void metadata_detect_colorspace(ImageMetaData &metadata, const char *file_format);
182
183   void device_load_image(
184       Device *device, Scene *scene, ImageDataType type, int slot, Progress *progress);
185   void device_free_image(Device *device, ImageDataType type, int slot);
186 };
187
188 CCL_NAMESPACE_END
189
190 #endif /* __IMAGE_H__ */