Cycles: support loading images from arbitrary OpenColorIO color space
[blender.git] / intern / cycles / render / image.cpp
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 #include "render/image.h"
18 #include "device/device.h"
19 #include "render/colorspace.h"
20 #include "render/scene.h"
21 #include "render/stats.h"
22
23 #include "util/util_foreach.h"
24 #include "util/util_image_impl.h"
25 #include "util/util_logging.h"
26 #include "util/util_path.h"
27 #include "util/util_progress.h"
28 #include "util/util_texture.h"
29 #include "util/util_unique_ptr.h"
30
31 #ifdef WITH_OSL
32 #  include <OSL/oslexec.h>
33 #endif
34
35 CCL_NAMESPACE_BEGIN
36
37 namespace {
38
39 /* Some helpers to silence warning in templated function. */
40 bool isfinite(uchar /*value*/)
41 {
42   return true;
43 }
44 bool isfinite(half /*value*/)
45 {
46   return true;
47 }
48 bool isfinite(uint16_t /*value*/)
49 {
50   return true;
51 }
52
53 /* The lower three bits of a device texture slot number indicate its type.
54  * These functions convert the slot ids from ImageManager "images" ones
55  * to device ones and vice verse.
56  */
57 int type_index_to_flattened_slot(int slot, ImageDataType type)
58 {
59   return (slot << IMAGE_DATA_TYPE_SHIFT) | (type);
60 }
61
62 int flattened_slot_to_type_index(int flat_slot, ImageDataType *type)
63 {
64   *type = (ImageDataType)(flat_slot & IMAGE_DATA_TYPE_MASK);
65   return flat_slot >> IMAGE_DATA_TYPE_SHIFT;
66 }
67
68 const char *name_from_type(ImageDataType type)
69 {
70   switch (type) {
71     case IMAGE_DATA_TYPE_FLOAT4:
72       return "float4";
73     case IMAGE_DATA_TYPE_BYTE4:
74       return "byte4";
75     case IMAGE_DATA_TYPE_HALF4:
76       return "half4";
77     case IMAGE_DATA_TYPE_FLOAT:
78       return "float";
79     case IMAGE_DATA_TYPE_BYTE:
80       return "byte";
81     case IMAGE_DATA_TYPE_HALF:
82       return "half";
83     case IMAGE_DATA_TYPE_USHORT4:
84       return "ushort4";
85     case IMAGE_DATA_TYPE_USHORT:
86       return "ushort";
87     case IMAGE_DATA_NUM_TYPES:
88       assert(!"System enumerator type, should never be used");
89       return "";
90   }
91   assert(!"Unhandled image data type");
92   return "";
93 }
94
95 }  // namespace
96
97 ImageManager::ImageManager(const DeviceInfo &info)
98 {
99   need_update = true;
100   osl_texture_system = NULL;
101   animation_frame = 0;
102
103   /* Set image limits */
104   max_num_images = TEX_NUM_MAX;
105   has_half_images = info.has_half_images;
106
107   for (size_t type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
108     tex_num_images[type] = 0;
109   }
110 }
111
112 ImageManager::~ImageManager()
113 {
114   for (size_t type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
115     for (size_t slot = 0; slot < images[type].size(); slot++)
116       assert(!images[type][slot]);
117   }
118 }
119
120 void ImageManager::set_osl_texture_system(void *texture_system)
121 {
122   osl_texture_system = texture_system;
123 }
124
125 bool ImageManager::set_animation_frame_update(int frame)
126 {
127   if (frame != animation_frame) {
128     animation_frame = frame;
129
130     for (size_t type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
131       for (size_t slot = 0; slot < images[type].size(); slot++) {
132         if (images[type][slot] && images[type][slot]->animated)
133           return true;
134       }
135     }
136   }
137
138   return false;
139 }
140
141 device_memory *ImageManager::image_memory(int flat_slot)
142 {
143   ImageDataType type;
144   int slot = flattened_slot_to_type_index(flat_slot, &type);
145
146   Image *img = images[type][slot];
147
148   return img->mem;
149 }
150
151 bool ImageManager::get_image_metadata(int flat_slot, ImageMetaData &metadata)
152 {
153   if (flat_slot == -1) {
154     return false;
155   }
156
157   ImageDataType type;
158   int slot = flattened_slot_to_type_index(flat_slot, &type);
159
160   Image *img = images[type][slot];
161   if (img) {
162     metadata = img->metadata;
163     return true;
164   }
165
166   return false;
167 }
168
169 void ImageManager::metadata_detect_colorspace(ImageMetaData &metadata, const char *file_format)
170 {
171   /* Convert used specified color spaces to one we know how to handle. */
172   metadata.colorspace = ColorSpaceManager::detect_known_colorspace(
173       metadata.colorspace, file_format, metadata.is_float || metadata.is_half);
174
175   if (metadata.colorspace == u_colorspace_raw) {
176     /* Nothing to do. */
177   }
178   else if (metadata.colorspace == u_colorspace_srgb) {
179     /* Keep sRGB colorspace stored as sRGB, to save memory and/or loading time
180      * for the common case of 8bit sRGB images like PNG. */
181     metadata.compress_as_srgb = true;
182   }
183   else {
184     /* Always compress non-raw 8bit images as scene linear + sRGB, as a
185      * heuristic to keep memory usage the same without too much data loss
186      * due to quantization in common cases. */
187     metadata.compress_as_srgb = (metadata.type == IMAGE_DATA_TYPE_BYTE ||
188                                  metadata.type == IMAGE_DATA_TYPE_BYTE4);
189   }
190 }
191
192 bool ImageManager::get_image_metadata(const string &filename,
193                                       void *builtin_data,
194                                       ustring colorspace,
195                                       ImageMetaData &metadata)
196 {
197   memset(&metadata, 0, sizeof(metadata));
198   metadata.colorspace = colorspace;
199
200   if (builtin_data) {
201     if (builtin_image_info_cb) {
202       builtin_image_info_cb(filename, builtin_data, metadata);
203     }
204     else {
205       return false;
206     }
207
208     if (metadata.is_float) {
209       metadata.type = (metadata.channels > 1) ? IMAGE_DATA_TYPE_FLOAT4 : IMAGE_DATA_TYPE_FLOAT;
210     }
211     else {
212       metadata.type = (metadata.channels > 1) ? IMAGE_DATA_TYPE_BYTE4 : IMAGE_DATA_TYPE_BYTE;
213     }
214
215     metadata_detect_colorspace(metadata, "");
216
217     return true;
218   }
219
220   /* Perform preliminary checks, with meaningful logging. */
221   if (!path_exists(filename)) {
222     VLOG(1) << "File '" << filename << "' does not exist.";
223     return false;
224   }
225   if (path_is_directory(filename)) {
226     VLOG(1) << "File '" << filename << "' is a directory, can't use as image.";
227     return false;
228   }
229
230   unique_ptr<ImageInput> in(ImageInput::create(filename));
231
232   if (!in) {
233     return false;
234   }
235
236   ImageSpec spec;
237   if (!in->open(filename, spec)) {
238     return false;
239   }
240
241   metadata.width = spec.width;
242   metadata.height = spec.height;
243   metadata.depth = spec.depth;
244   metadata.compress_as_srgb = false;
245
246   /* Check the main format, and channel formats. */
247   size_t channel_size = spec.format.basesize();
248
249   if (spec.format.is_floating_point()) {
250     metadata.is_float = true;
251   }
252
253   for (size_t channel = 0; channel < spec.channelformats.size(); channel++) {
254     channel_size = max(channel_size, spec.channelformats[channel].basesize());
255     if (spec.channelformats[channel].is_floating_point()) {
256       metadata.is_float = true;
257     }
258   }
259
260   /* check if it's half float */
261   if (spec.format == TypeDesc::HALF) {
262     metadata.is_half = true;
263   }
264
265   /* set type and channels */
266   metadata.channels = spec.nchannels;
267
268   if (metadata.is_half) {
269     metadata.type = (metadata.channels > 1) ? IMAGE_DATA_TYPE_HALF4 : IMAGE_DATA_TYPE_HALF;
270   }
271   else if (metadata.is_float) {
272     metadata.type = (metadata.channels > 1) ? IMAGE_DATA_TYPE_FLOAT4 : IMAGE_DATA_TYPE_FLOAT;
273   }
274   else if (spec.format == TypeDesc::USHORT) {
275     metadata.type = (metadata.channels > 1) ? IMAGE_DATA_TYPE_USHORT4 : IMAGE_DATA_TYPE_USHORT;
276   }
277   else {
278     metadata.type = (metadata.channels > 1) ? IMAGE_DATA_TYPE_BYTE4 : IMAGE_DATA_TYPE_BYTE;
279   }
280
281   metadata_detect_colorspace(metadata, in->format_name());
282
283   in->close();
284
285   return true;
286 }
287
288 static bool image_equals(ImageManager::Image *image,
289                          const string &filename,
290                          void *builtin_data,
291                          InterpolationType interpolation,
292                          ExtensionType extension,
293                          bool use_alpha,
294                          ustring colorspace)
295 {
296   return image->filename == filename && image->builtin_data == builtin_data &&
297          image->interpolation == interpolation && image->extension == extension &&
298          image->use_alpha == use_alpha && image->colorspace == colorspace;
299 }
300
301 int ImageManager::add_image(const string &filename,
302                             void *builtin_data,
303                             bool animated,
304                             float frame,
305                             InterpolationType interpolation,
306                             ExtensionType extension,
307                             bool use_alpha,
308                             ustring colorspace,
309                             ImageMetaData &metadata)
310 {
311   Image *img;
312   size_t slot;
313
314   get_image_metadata(filename, builtin_data, colorspace, metadata);
315   ImageDataType type = metadata.type;
316
317   thread_scoped_lock device_lock(device_mutex);
318
319   /* No half textures on OpenCL, use full float instead. */
320   if (!has_half_images) {
321     if (type == IMAGE_DATA_TYPE_HALF4) {
322       type = IMAGE_DATA_TYPE_FLOAT4;
323     }
324     else if (type == IMAGE_DATA_TYPE_HALF) {
325       type = IMAGE_DATA_TYPE_FLOAT;
326     }
327   }
328
329   /* Fnd existing image. */
330   for (slot = 0; slot < images[type].size(); slot++) {
331     img = images[type][slot];
332     if (img && image_equals(
333                    img, filename, builtin_data, interpolation, extension, use_alpha, colorspace)) {
334       if (img->frame != frame) {
335         img->frame = frame;
336         img->need_load = true;
337       }
338       if (img->use_alpha != use_alpha) {
339         img->use_alpha = use_alpha;
340         img->need_load = true;
341       }
342       if (img->colorspace != colorspace) {
343         img->colorspace = colorspace;
344         img->need_load = true;
345       }
346       if (!(img->metadata == metadata)) {
347         img->metadata = metadata;
348         img->need_load = true;
349       }
350       img->users++;
351       return type_index_to_flattened_slot(slot, type);
352     }
353   }
354
355   /* Find free slot. */
356   for (slot = 0; slot < images[type].size(); slot++) {
357     if (!images[type][slot])
358       break;
359   }
360
361   /* Count if we're over the limit.
362    * Very unlikely, since max_num_images is insanely big. But better safe
363    * than sorry.
364    */
365   int tex_count = 0;
366   for (int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
367     tex_count += tex_num_images[type];
368   }
369   if (tex_count > max_num_images) {
370     printf(
371         "ImageManager::add_image: Reached image limit (%d), "
372         "skipping '%s'\n",
373         max_num_images,
374         filename.c_str());
375     return -1;
376   }
377
378   if (slot == images[type].size()) {
379     images[type].resize(images[type].size() + 1);
380   }
381
382   /* Add new image. */
383   img = new Image();
384   img->filename = filename;
385   img->builtin_data = builtin_data;
386   img->metadata = metadata;
387   img->need_load = true;
388   img->animated = animated;
389   img->frame = frame;
390   img->interpolation = interpolation;
391   img->extension = extension;
392   img->users = 1;
393   img->use_alpha = use_alpha;
394   img->colorspace = colorspace;
395   img->mem = NULL;
396
397   images[type][slot] = img;
398
399   ++tex_num_images[type];
400
401   need_update = true;
402
403   return type_index_to_flattened_slot(slot, type);
404 }
405
406 void ImageManager::remove_image(int flat_slot)
407 {
408   ImageDataType type;
409   int slot = flattened_slot_to_type_index(flat_slot, &type);
410
411   Image *image = images[type][slot];
412   assert(image && image->users >= 1);
413
414   /* decrement user count */
415   image->users--;
416
417   /* don't remove immediately, rather do it all together later on. one of
418    * the reasons for this is that on shader changes we add and remove nodes
419    * that use them, but we do not want to reload the image all the time. */
420   if (image->users == 0)
421     need_update = true;
422 }
423
424 void ImageManager::remove_image(const string &filename,
425                                 void *builtin_data,
426                                 InterpolationType interpolation,
427                                 ExtensionType extension,
428                                 bool use_alpha,
429                                 ustring colorspace)
430 {
431   size_t slot;
432
433   for (int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
434     for (slot = 0; slot < images[type].size(); slot++) {
435       if (images[type][slot] && image_equals(images[type][slot],
436                                              filename,
437                                              builtin_data,
438                                              interpolation,
439                                              extension,
440                                              use_alpha,
441                                              colorspace)) {
442         remove_image(type_index_to_flattened_slot(slot, (ImageDataType)type));
443         return;
444       }
445     }
446   }
447 }
448
449 /* TODO(sergey): Deduplicate with the iteration above, but make it pretty,
450  * without bunch of arguments passing around making code readability even
451  * more cluttered.
452  */
453 void ImageManager::tag_reload_image(const string &filename,
454                                     void *builtin_data,
455                                     InterpolationType interpolation,
456                                     ExtensionType extension,
457                                     bool use_alpha,
458                                     ustring colorspace)
459 {
460   for (size_t type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
461     for (size_t slot = 0; slot < images[type].size(); slot++) {
462       if (images[type][slot] && image_equals(images[type][slot],
463                                              filename,
464                                              builtin_data,
465                                              interpolation,
466                                              extension,
467                                              use_alpha,
468                                              colorspace)) {
469         images[type][slot]->need_load = true;
470         break;
471       }
472     }
473   }
474 }
475
476 bool ImageManager::file_load_image_generic(Image *img, unique_ptr<ImageInput> *in)
477 {
478   if (img->filename == "")
479     return false;
480
481   if (!img->builtin_data) {
482     /* NOTE: Error logging is done in meta data acquisition. */
483     if (!path_exists(img->filename) || path_is_directory(img->filename)) {
484       return false;
485     }
486
487     /* load image from file through OIIO */
488     *in = unique_ptr<ImageInput>(ImageInput::create(img->filename));
489
490     if (!*in)
491       return false;
492
493     ImageSpec spec = ImageSpec();
494     ImageSpec config = ImageSpec();
495
496     if (img->use_alpha == false)
497       config.attribute("oiio:UnassociatedAlpha", 1);
498
499     if (!(*in)->open(img->filename, spec, config)) {
500       return false;
501     }
502   }
503   else {
504     /* load image using builtin images callbacks */
505     if (!builtin_image_info_cb || !builtin_image_pixels_cb)
506       return false;
507   }
508
509   /* we only handle certain number of components */
510   if (!(img->metadata.channels >= 1 && img->metadata.channels <= 4)) {
511     if (*in) {
512       (*in)->close();
513     }
514     return false;
515   }
516
517   return true;
518 }
519
520 template<TypeDesc::BASETYPE FileFormat, typename StorageType, typename DeviceType>
521 bool ImageManager::file_load_image(Image *img,
522                                    ImageDataType type,
523                                    int texture_limit,
524                                    device_vector<DeviceType> &tex_img)
525 {
526   unique_ptr<ImageInput> in = NULL;
527   if (!file_load_image_generic(img, &in)) {
528     return false;
529   }
530
531   /* Get metadata. */
532   int width = img->metadata.width;
533   int height = img->metadata.height;
534   int depth = img->metadata.depth;
535   int components = img->metadata.channels;
536
537   /* Read pixels. */
538   vector<StorageType> pixels_storage;
539   StorageType *pixels;
540   const size_t max_size = max(max(width, height), depth);
541   if (max_size == 0) {
542     /* Don't bother with empty images. */
543     return false;
544   }
545
546   /* Allocate memory as needed, may be smaller to resize down. */
547   if (texture_limit > 0 && max_size > texture_limit) {
548     pixels_storage.resize(((size_t)width) * height * depth * 4);
549     pixels = &pixels_storage[0];
550   }
551   else {
552     thread_scoped_lock device_lock(device_mutex);
553     pixels = (StorageType *)tex_img.alloc(width, height, depth);
554   }
555
556   if (pixels == NULL) {
557     /* Could be that we've run out of memory. */
558     return false;
559   }
560
561   bool cmyk = false;
562   const size_t num_pixels = ((size_t)width) * height * depth;
563   if (in) {
564     /* Read pixels through OpenImageIO. */
565     StorageType *readpixels = pixels;
566     vector<StorageType> tmppixels;
567     if (components > 4) {
568       tmppixels.resize(((size_t)width) * height * components);
569       readpixels = &tmppixels[0];
570     }
571
572     if (depth <= 1) {
573       size_t scanlinesize = ((size_t)width) * components * sizeof(StorageType);
574       in->read_image(FileFormat,
575                      (uchar *)readpixels + (height - 1) * scanlinesize,
576                      AutoStride,
577                      -scanlinesize,
578                      AutoStride);
579     }
580     else {
581       in->read_image(FileFormat, (uchar *)readpixels);
582     }
583
584     if (components > 4) {
585       size_t dimensions = ((size_t)width) * height;
586       for (size_t i = dimensions - 1, pixel = 0; pixel < dimensions; pixel++, i--) {
587         pixels[i * 4 + 3] = tmppixels[i * components + 3];
588         pixels[i * 4 + 2] = tmppixels[i * components + 2];
589         pixels[i * 4 + 1] = tmppixels[i * components + 1];
590         pixels[i * 4 + 0] = tmppixels[i * components + 0];
591       }
592       tmppixels.clear();
593     }
594
595     cmyk = strcmp(in->format_name(), "jpeg") == 0 && components == 4;
596     in->close();
597   }
598   else {
599     /* Read pixels through callback. */
600     if (FileFormat == TypeDesc::FLOAT) {
601       builtin_image_float_pixels_cb(img->filename,
602                                     img->builtin_data,
603                                     (float *)&pixels[0],
604                                     num_pixels * components,
605                                     img->metadata.builtin_free_cache);
606     }
607     else if (FileFormat == TypeDesc::UINT8) {
608       builtin_image_pixels_cb(img->filename,
609                               img->builtin_data,
610                               (uchar *)&pixels[0],
611                               num_pixels * components,
612                               img->metadata.builtin_free_cache);
613     }
614     else {
615       /* TODO(dingto): Support half for ImBuf. */
616     }
617   }
618
619   /* The kernel can handle 1 and 4 channel images. Anything that is not a single
620    * channel image is converted to RGBA format. */
621   bool is_rgba = (type == IMAGE_DATA_TYPE_FLOAT4 || type == IMAGE_DATA_TYPE_HALF4 ||
622                   type == IMAGE_DATA_TYPE_BYTE4 || type == IMAGE_DATA_TYPE_USHORT4);
623
624   if (is_rgba) {
625     const StorageType one = util_image_cast_from_float<StorageType>(1.0f);
626
627     if (cmyk) {
628       /* CMYK to RGBA. */
629       for (size_t i = num_pixels - 1, pixel = 0; pixel < num_pixels; pixel++, i--) {
630         float c = util_image_cast_to_float(pixels[i * 4 + 0]);
631         float m = util_image_cast_to_float(pixels[i * 4 + 1]);
632         float y = util_image_cast_to_float(pixels[i * 4 + 2]);
633         float k = util_image_cast_to_float(pixels[i * 4 + 3]);
634         pixels[i * 4 + 0] = util_image_cast_from_float<StorageType>((1.0f - c) * (1.0f - k));
635         pixels[i * 4 + 1] = util_image_cast_from_float<StorageType>((1.0f - m) * (1.0f - k));
636         pixels[i * 4 + 2] = util_image_cast_from_float<StorageType>((1.0f - y) * (1.0f - k));
637         pixels[i * 4 + 3] = one;
638       }
639     }
640     else if (components == 2) {
641       /* Grayscale + alpha to RGBA. */
642       for (size_t i = num_pixels - 1, pixel = 0; pixel < num_pixels; pixel++, i--) {
643         pixels[i * 4 + 3] = pixels[i * 2 + 1];
644         pixels[i * 4 + 2] = pixels[i * 2 + 0];
645         pixels[i * 4 + 1] = pixels[i * 2 + 0];
646         pixels[i * 4 + 0] = pixels[i * 2 + 0];
647       }
648     }
649     else if (components == 3) {
650       /* RGB to RGBA. */
651       for (size_t i = num_pixels - 1, pixel = 0; pixel < num_pixels; pixel++, i--) {
652         pixels[i * 4 + 3] = one;
653         pixels[i * 4 + 2] = pixels[i * 3 + 2];
654         pixels[i * 4 + 1] = pixels[i * 3 + 1];
655         pixels[i * 4 + 0] = pixels[i * 3 + 0];
656       }
657     }
658     else if (components == 1) {
659       /* Grayscale to RGBA. */
660       for (size_t i = num_pixels - 1, pixel = 0; pixel < num_pixels; pixel++, i--) {
661         pixels[i * 4 + 3] = one;
662         pixels[i * 4 + 2] = pixels[i];
663         pixels[i * 4 + 1] = pixels[i];
664         pixels[i * 4 + 0] = pixels[i];
665       }
666     }
667
668     /* Disable alpha if requested by the user. */
669     if (img->use_alpha == false) {
670       for (size_t i = num_pixels - 1, pixel = 0; pixel < num_pixels; pixel++, i--) {
671         pixels[i * 4 + 3] = one;
672       }
673     }
674
675     if (img->metadata.colorspace != u_colorspace_raw &&
676         img->metadata.colorspace != u_colorspace_srgb) {
677       /* Convert to scene linear. */
678       ColorSpaceManager::to_scene_linear(
679           img->metadata.colorspace, pixels, width, height, depth, img->metadata.compress_as_srgb);
680     }
681   }
682
683   /* Make sure we don't have buggy values. */
684   if (FileFormat == TypeDesc::FLOAT) {
685     /* For RGBA buffers we put all channels to 0 if either of them is not
686      * finite. This way we avoid possible artifacts caused by fully changed
687      * hue. */
688     if (is_rgba) {
689       for (size_t i = 0; i < num_pixels; i += 4) {
690         StorageType *pixel = &pixels[i * 4];
691         if (!isfinite(pixel[0]) || !isfinite(pixel[1]) || !isfinite(pixel[2]) ||
692             !isfinite(pixel[3])) {
693           pixel[0] = 0;
694           pixel[1] = 0;
695           pixel[2] = 0;
696           pixel[3] = 0;
697         }
698       }
699     }
700     else {
701       for (size_t i = 0; i < num_pixels; ++i) {
702         StorageType *pixel = &pixels[i];
703         if (!isfinite(pixel[0])) {
704           pixel[0] = 0;
705         }
706       }
707     }
708   }
709
710   /* Scale image down if needed. */
711   if (pixels_storage.size() > 0) {
712     float scale_factor = 1.0f;
713     while (max_size * scale_factor > texture_limit) {
714       scale_factor *= 0.5f;
715     }
716     VLOG(1) << "Scaling image " << img->filename << " by a factor of " << scale_factor << ".";
717     vector<StorageType> scaled_pixels;
718     size_t scaled_width, scaled_height, scaled_depth;
719     util_image_resize_pixels(pixels_storage,
720                              width,
721                              height,
722                              depth,
723                              is_rgba ? 4 : 1,
724                              scale_factor,
725                              &scaled_pixels,
726                              &scaled_width,
727                              &scaled_height,
728                              &scaled_depth);
729
730     StorageType *texture_pixels;
731
732     {
733       thread_scoped_lock device_lock(device_mutex);
734       texture_pixels = (StorageType *)tex_img.alloc(scaled_width, scaled_height, scaled_depth);
735     }
736
737     memcpy(texture_pixels, &scaled_pixels[0], scaled_pixels.size() * sizeof(StorageType));
738   }
739
740   return true;
741 }
742
743 void ImageManager::device_load_image(
744     Device *device, Scene *scene, ImageDataType type, int slot, Progress *progress)
745 {
746   if (progress->get_cancel())
747     return;
748
749   Image *img = images[type][slot];
750
751   if (osl_texture_system && !img->builtin_data)
752     return;
753
754   string filename = path_filename(images[type][slot]->filename);
755   progress->set_status("Updating Images", "Loading " + filename);
756
757   const int texture_limit = scene->params.texture_limit;
758
759   /* Slot assignment */
760   int flat_slot = type_index_to_flattened_slot(slot, type);
761   img->mem_name = string_printf("__tex_image_%s_%03d", name_from_type(type), flat_slot);
762
763   /* Free previous texture in slot. */
764   if (img->mem) {
765     thread_scoped_lock device_lock(device_mutex);
766     delete img->mem;
767     img->mem = NULL;
768   }
769
770   /* Create new texture. */
771   if (type == IMAGE_DATA_TYPE_FLOAT4) {
772     device_vector<float4> *tex_img = new device_vector<float4>(
773         device, img->mem_name.c_str(), MEM_TEXTURE);
774
775     if (!file_load_image<TypeDesc::FLOAT, float>(img, type, texture_limit, *tex_img)) {
776       /* on failure to load, we set a 1x1 pixels pink image */
777       thread_scoped_lock device_lock(device_mutex);
778       float *pixels = (float *)tex_img->alloc(1, 1);
779
780       pixels[0] = TEX_IMAGE_MISSING_R;
781       pixels[1] = TEX_IMAGE_MISSING_G;
782       pixels[2] = TEX_IMAGE_MISSING_B;
783       pixels[3] = TEX_IMAGE_MISSING_A;
784     }
785
786     img->mem = tex_img;
787     img->mem->interpolation = img->interpolation;
788     img->mem->extension = img->extension;
789
790     thread_scoped_lock device_lock(device_mutex);
791     tex_img->copy_to_device();
792   }
793   else if (type == IMAGE_DATA_TYPE_FLOAT) {
794     device_vector<float> *tex_img = new device_vector<float>(
795         device, img->mem_name.c_str(), MEM_TEXTURE);
796
797     if (!file_load_image<TypeDesc::FLOAT, float>(img, type, texture_limit, *tex_img)) {
798       /* on failure to load, we set a 1x1 pixels pink image */
799       thread_scoped_lock device_lock(device_mutex);
800       float *pixels = (float *)tex_img->alloc(1, 1);
801
802       pixels[0] = TEX_IMAGE_MISSING_R;
803     }
804
805     img->mem = tex_img;
806     img->mem->interpolation = img->interpolation;
807     img->mem->extension = img->extension;
808
809     thread_scoped_lock device_lock(device_mutex);
810     tex_img->copy_to_device();
811   }
812   else if (type == IMAGE_DATA_TYPE_BYTE4) {
813     device_vector<uchar4> *tex_img = new device_vector<uchar4>(
814         device, img->mem_name.c_str(), MEM_TEXTURE);
815
816     if (!file_load_image<TypeDesc::UINT8, uchar>(img, type, texture_limit, *tex_img)) {
817       /* on failure to load, we set a 1x1 pixels pink image */
818       thread_scoped_lock device_lock(device_mutex);
819       uchar *pixels = (uchar *)tex_img->alloc(1, 1);
820
821       pixels[0] = (TEX_IMAGE_MISSING_R * 255);
822       pixels[1] = (TEX_IMAGE_MISSING_G * 255);
823       pixels[2] = (TEX_IMAGE_MISSING_B * 255);
824       pixels[3] = (TEX_IMAGE_MISSING_A * 255);
825     }
826
827     img->mem = tex_img;
828     img->mem->interpolation = img->interpolation;
829     img->mem->extension = img->extension;
830
831     thread_scoped_lock device_lock(device_mutex);
832     tex_img->copy_to_device();
833   }
834   else if (type == IMAGE_DATA_TYPE_BYTE) {
835     device_vector<uchar> *tex_img = new device_vector<uchar>(
836         device, img->mem_name.c_str(), MEM_TEXTURE);
837
838     if (!file_load_image<TypeDesc::UINT8, uchar>(img, type, texture_limit, *tex_img)) {
839       /* on failure to load, we set a 1x1 pixels pink image */
840       thread_scoped_lock device_lock(device_mutex);
841       uchar *pixels = (uchar *)tex_img->alloc(1, 1);
842
843       pixels[0] = (TEX_IMAGE_MISSING_R * 255);
844     }
845
846     img->mem = tex_img;
847     img->mem->interpolation = img->interpolation;
848     img->mem->extension = img->extension;
849
850     thread_scoped_lock device_lock(device_mutex);
851     tex_img->copy_to_device();
852   }
853   else if (type == IMAGE_DATA_TYPE_HALF4) {
854     device_vector<half4> *tex_img = new device_vector<half4>(
855         device, img->mem_name.c_str(), MEM_TEXTURE);
856
857     if (!file_load_image<TypeDesc::HALF, half>(img, type, texture_limit, *tex_img)) {
858       /* on failure to load, we set a 1x1 pixels pink image */
859       thread_scoped_lock device_lock(device_mutex);
860       half *pixels = (half *)tex_img->alloc(1, 1);
861
862       pixels[0] = TEX_IMAGE_MISSING_R;
863       pixels[1] = TEX_IMAGE_MISSING_G;
864       pixels[2] = TEX_IMAGE_MISSING_B;
865       pixels[3] = TEX_IMAGE_MISSING_A;
866     }
867
868     img->mem = tex_img;
869     img->mem->interpolation = img->interpolation;
870     img->mem->extension = img->extension;
871
872     thread_scoped_lock device_lock(device_mutex);
873     tex_img->copy_to_device();
874   }
875   else if (type == IMAGE_DATA_TYPE_USHORT) {
876     device_vector<uint16_t> *tex_img = new device_vector<uint16_t>(
877         device, img->mem_name.c_str(), MEM_TEXTURE);
878
879     if (!file_load_image<TypeDesc::USHORT, uint16_t>(img, type, texture_limit, *tex_img)) {
880       /* on failure to load, we set a 1x1 pixels pink image */
881       thread_scoped_lock device_lock(device_mutex);
882       uint16_t *pixels = (uint16_t *)tex_img->alloc(1, 1);
883
884       pixels[0] = (TEX_IMAGE_MISSING_R * 65535);
885     }
886
887     img->mem = tex_img;
888     img->mem->interpolation = img->interpolation;
889     img->mem->extension = img->extension;
890
891     thread_scoped_lock device_lock(device_mutex);
892     tex_img->copy_to_device();
893   }
894   else if (type == IMAGE_DATA_TYPE_USHORT4) {
895     device_vector<ushort4> *tex_img = new device_vector<ushort4>(
896         device, img->mem_name.c_str(), MEM_TEXTURE);
897
898     if (!file_load_image<TypeDesc::USHORT, uint16_t>(img, type, texture_limit, *tex_img)) {
899       /* on failure to load, we set a 1x1 pixels pink image */
900       thread_scoped_lock device_lock(device_mutex);
901       uint16_t *pixels = (uint16_t *)tex_img->alloc(1, 1);
902
903       pixels[0] = (TEX_IMAGE_MISSING_R * 65535);
904       pixels[1] = (TEX_IMAGE_MISSING_G * 65535);
905       pixels[2] = (TEX_IMAGE_MISSING_B * 65535);
906       pixels[3] = (TEX_IMAGE_MISSING_A * 65535);
907     }
908
909     img->mem = tex_img;
910     img->mem->interpolation = img->interpolation;
911     img->mem->extension = img->extension;
912
913     thread_scoped_lock device_lock(device_mutex);
914     tex_img->copy_to_device();
915   }
916   else if (type == IMAGE_DATA_TYPE_HALF) {
917     device_vector<half> *tex_img = new device_vector<half>(
918         device, img->mem_name.c_str(), MEM_TEXTURE);
919
920     if (!file_load_image<TypeDesc::HALF, half>(img, type, texture_limit, *tex_img)) {
921       /* on failure to load, we set a 1x1 pixels pink image */
922       thread_scoped_lock device_lock(device_mutex);
923       half *pixels = (half *)tex_img->alloc(1, 1);
924
925       pixels[0] = TEX_IMAGE_MISSING_R;
926     }
927
928     img->mem = tex_img;
929     img->mem->interpolation = img->interpolation;
930     img->mem->extension = img->extension;
931
932     thread_scoped_lock device_lock(device_mutex);
933     tex_img->copy_to_device();
934   }
935   img->need_load = false;
936 }
937
938 void ImageManager::device_free_image(Device *, ImageDataType type, int slot)
939 {
940   Image *img = images[type][slot];
941
942   if (img) {
943     if (osl_texture_system && !img->builtin_data) {
944 #ifdef WITH_OSL
945       ustring filename(images[type][slot]->filename);
946       ((OSL::TextureSystem *)osl_texture_system)->invalidate(filename);
947 #endif
948     }
949
950     if (img->mem) {
951       thread_scoped_lock device_lock(device_mutex);
952       delete img->mem;
953     }
954
955     delete img;
956     images[type][slot] = NULL;
957     --tex_num_images[type];
958   }
959 }
960
961 void ImageManager::device_update(Device *device, Scene *scene, Progress &progress)
962 {
963   if (!need_update) {
964     return;
965   }
966
967   TaskPool pool;
968   for (int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
969     for (size_t slot = 0; slot < images[type].size(); slot++) {
970       if (!images[type][slot])
971         continue;
972
973       if (images[type][slot]->users == 0) {
974         device_free_image(device, (ImageDataType)type, slot);
975       }
976       else if (images[type][slot]->need_load) {
977         if (!osl_texture_system || images[type][slot]->builtin_data)
978           pool.push(function_bind(&ImageManager::device_load_image,
979                                   this,
980                                   device,
981                                   scene,
982                                   (ImageDataType)type,
983                                   slot,
984                                   &progress));
985       }
986     }
987   }
988
989   pool.wait_work();
990
991   need_update = false;
992 }
993
994 void ImageManager::device_update_slot(Device *device,
995                                       Scene *scene,
996                                       int flat_slot,
997                                       Progress *progress)
998 {
999   ImageDataType type;
1000   int slot = flattened_slot_to_type_index(flat_slot, &type);
1001
1002   Image *image = images[type][slot];
1003   assert(image != NULL);
1004
1005   if (image->users == 0) {
1006     device_free_image(device, type, slot);
1007   }
1008   else if (image->need_load) {
1009     if (!osl_texture_system || image->builtin_data)
1010       device_load_image(device, scene, type, slot, progress);
1011   }
1012 }
1013
1014 void ImageManager::device_load_builtin(Device *device, Scene *scene, Progress &progress)
1015 {
1016   /* Load only builtin images, Blender needs this to load evaluated
1017    * scene data from depsgraph before it is freed. */
1018   if (!need_update) {
1019     return;
1020   }
1021
1022   TaskPool pool;
1023   for (int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
1024     for (size_t slot = 0; slot < images[type].size(); slot++) {
1025       if (!images[type][slot])
1026         continue;
1027
1028       if (images[type][slot]->need_load) {
1029         if (images[type][slot]->builtin_data) {
1030           pool.push(function_bind(&ImageManager::device_load_image,
1031                                   this,
1032                                   device,
1033                                   scene,
1034                                   (ImageDataType)type,
1035                                   slot,
1036                                   &progress));
1037         }
1038       }
1039     }
1040   }
1041
1042   pool.wait_work();
1043 }
1044
1045 void ImageManager::device_free_builtin(Device *device)
1046 {
1047   for (int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
1048     for (size_t slot = 0; slot < images[type].size(); slot++) {
1049       if (images[type][slot] && images[type][slot]->builtin_data)
1050         device_free_image(device, (ImageDataType)type, slot);
1051     }
1052   }
1053 }
1054
1055 void ImageManager::device_free(Device *device)
1056 {
1057   for (int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
1058     for (size_t slot = 0; slot < images[type].size(); slot++) {
1059       device_free_image(device, (ImageDataType)type, slot);
1060     }
1061     images[type].clear();
1062   }
1063 }
1064
1065 void ImageManager::collect_statistics(RenderStats *stats)
1066 {
1067   for (int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
1068     foreach (const Image *image, images[type]) {
1069       stats->image.textures.add_entry(
1070           NamedSizeEntry(path_filename(image->filename), image->mem->memory_size()));
1071     }
1072   }
1073 }
1074
1075 CCL_NAMESPACE_END