Cleanup dead abstraction code, remove boost dependency from resource loader
[platform/core/uifw/dali-adaptor.git] / platform-abstractions / tizen / image-loaders / loader-png.cpp
1 /*
2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
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
18 #include "loader-png.h"
19
20 #include <cstring>
21 #include <cstdlib>
22
23 #include <zlib.h>
24 #include <png.h>
25
26 #include <dali/integration-api/bitmap.h>
27 #include <dali/integration-api/debug.h>
28 #include <dali/public-api/images/image.h>
29 #include "dali/public-api/math/math-utils.h"
30 #include "dali/public-api/math/vector2.h"
31 #include "platform-capabilities.h"
32
33 namespace Dali
34 {
35
36 using Integration::Bitmap;
37 using Dali::Integration::PixelBuffer;
38
39 namespace TizenPlatform
40 {
41
42 namespace
43 {
44
45 // simple class to enforce clean-up of PNG structures
46 struct auto_png
47 {
48   auto_png(png_structp& _png, png_infop& _info)
49   : png(_png),
50     info(_info)
51   {
52   }
53
54   ~auto_png()
55   {
56     if(NULL != png)
57     {
58       png_destroy_read_struct(&png, &info, NULL);
59     }
60   }
61
62   png_structp& png;
63   png_infop& info;
64 }; // struct auto_png;
65
66 bool LoadPngHeader(FILE *fp, unsigned int &width, unsigned int &height, png_structp &png, png_infop &info)
67 {
68   png_byte header[8] = { 0 };
69
70   // Check header to see if it is a PNG file
71   size_t size = fread(header, 1, 8, fp);
72   if(size != 8)
73   {
74     return false;
75   }
76
77   if(png_sig_cmp(header, 0, 8))
78   {
79     return false;
80   }
81
82   png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
83
84   if(!png)
85   {
86     DALI_LOG_WARNING("Can't create PNG read structure\n");
87     return false;
88   }
89
90   info = png_create_info_struct(png);
91   if(!info)
92   {
93     DALI_LOG_WARNING("png_create_info_struct failed\n");
94     return false;
95   }
96
97   png_set_expand(png);
98
99   if(setjmp(png_jmpbuf(png)))
100   {
101     DALI_LOG_WARNING("error during png_init_io\n");
102     return false;
103   }
104
105   png_init_io(png, fp);
106   png_set_sig_bytes(png, 8);
107
108   // read image info
109   png_read_info(png, info);
110
111   // dimensions
112   width = png_get_image_width(png, info);
113   height = png_get_image_height(png, info);
114
115   return true;
116 }
117
118 } // namespace - anonymous
119
120 bool LoadPngHeader( const ImageLoader::Input& input, unsigned int& width, unsigned int& height )
121 {
122   png_structp png = NULL;
123   png_infop info = NULL;
124   auto_png autoPng(png, info);
125
126   bool success = LoadPngHeader( input.file, width, height, png, info );
127
128   return success;
129 }
130
131 bool LoadBitmapFromPng( const ResourceLoadingClient& client, const ImageLoader::Input& input, Integration::Bitmap& bitmap )
132 {
133   png_structp png = NULL;
134   png_infop info = NULL;
135   auto_png autoPng(png, info);
136
137   /// @todo: consider parameters
138   unsigned int y;
139   unsigned int width, height;
140   unsigned char *pixels;
141   png_bytep *rows;
142   unsigned int bpp = 0; // bytes per pixel
143   bool valid = false;
144
145   // Load info from the header
146   if( !LoadPngHeader( input.file, width, height, png, info ) )
147   {
148     return false;
149   }
150
151   Pixel::Format pixelFormat = Pixel::RGBA8888;
152
153   // decide pixel format
154   unsigned int colordepth = png_get_bit_depth(png, info);
155
156   // Ask PNGLib to convert high precision images into something we can use:
157   if (colordepth == 16)
158   {
159     png_set_strip_16(png);
160     colordepth = 8;
161   }
162
163   png_byte colortype = png_get_color_type(png, info);
164
165   if(colortype == PNG_COLOR_TYPE_GRAY)
166   {
167     switch( colordepth )
168     {
169       case 8:
170       {
171         pixelFormat = Pixel::L8;
172         valid = true;
173         break;
174       }
175       default:
176       {
177         break;
178       }
179     }
180   }
181   else if(colortype == PNG_COLOR_TYPE_GRAY_ALPHA)
182   {
183     switch(colordepth)
184     {
185       case 8:
186       {
187         pixelFormat = Pixel::LA88;
188         valid = true;
189         break;
190       }
191       default:
192       {
193         break;
194       }
195     }
196   }
197   else if(colortype == PNG_COLOR_TYPE_RGB )
198   {
199     switch(colordepth)
200     {
201       case 8:
202       {
203         pixelFormat = Pixel::RGB888;
204         valid = true;
205         break;
206       }
207       case 5:      /// @todo is this correct for RGB16 5-6-5 ?
208       {
209         pixelFormat = Pixel::RGB565;
210         valid = true;
211         break;
212       }
213       default:
214       {
215         break;
216       }
217     }
218   }
219   else if(colortype == PNG_COLOR_TYPE_RGBA)
220   {
221     switch(colordepth)
222     {
223       case 8:
224       {
225         pixelFormat = Pixel::RGBA8888;
226         valid = true;
227         break;
228       }
229       default:
230       {
231         break;
232       }
233     }
234   }
235   else if(colortype == PNG_COLOR_TYPE_PALETTE)
236   {
237     switch(colordepth)
238     {
239       case 2:
240       case 4:
241       case 8:
242       {
243         /* Expand paletted or RGB images with transparency to full alpha channels
244          * so the data will be available as RGBA quartets. PNG_INFO_tRNS = 0x10
245          */
246         if(png_get_valid(png, info, PNG_INFO_tRNS) == 0x10)
247         {
248           pixelFormat = Pixel::RGBA8888;
249           valid = true;
250         }
251         else
252         {
253           pixelFormat = Pixel::RGB888;
254           png_set_packing(png);
255           png_set_packswap(png);
256           png_set_palette_to_rgb(png);
257           valid = true;
258         }
259         break;
260       }
261       default:
262       {
263         break;
264       }
265     }
266   }
267
268   if( !valid )
269   {
270     DALI_LOG_WARNING( "Unsupported png format\n" );
271     return false;
272   }
273
274   // bytes per pixel
275   bpp = Pixel::GetBytesPerPixel(pixelFormat);
276
277   png_read_update_info(png, info);
278
279   if(setjmp(png_jmpbuf(png)))
280   {
281     DALI_LOG_WARNING("error during png_read_image\n");
282     return false;
283   }
284
285   unsigned int rowBytes = png_get_rowbytes(png, info);
286
287   unsigned int bufferWidth   = GetTextureDimension(width);
288   unsigned int bufferHeight  = GetTextureDimension(height);
289   unsigned int stride        = bufferWidth*bpp;
290
291   // not sure if this ever happens
292   if( rowBytes > stride )
293   {
294     stride = GetTextureDimension(rowBytes);
295     bufferWidth = stride / bpp;
296   }
297
298   // decode the whole image into bitmap buffer
299   pixels = bitmap.GetPackedPixelsProfile()->ReserveBuffer(pixelFormat, width, height, bufferWidth, bufferHeight);
300
301   DALI_ASSERT_DEBUG(pixels);
302   rows = (png_bytep*) malloc(sizeof(png_bytep) * height);
303   for(y=0; y<height; y++)
304   {
305     rows[y] = (png_byte*) (pixels + y * stride);
306   }
307
308   // decode image
309   png_read_image(png, rows);
310
311   free(rows);
312
313   return true;
314 }
315
316 // simple class to enforce clean-up of PNG structures
317 struct AutoPngWrite
318 {
319   AutoPngWrite(png_structp& _png, png_infop& _info)
320   : png(_png),
321     info(_info)
322   {
323     DALI_ASSERT_DEBUG(&_png != 0 && &_info != 0);
324   }
325
326   ~AutoPngWrite()
327   {
328     if(NULL != png)
329     {
330       png_destroy_write_struct(&png, &info);
331     }
332   }
333
334   png_structp& png;
335   png_infop& info;
336 }; // struct AutoPngWrite;
337
338 namespace
339 {
340   // Custom libpng write callbacks that buffer to a vector instead of a file:
341
342   /**
343    * extern "C" linkage is used because this is a callback that we pass to a C
344    * library which is part of the underlying platform and so potentially compiled
345    * as C rather than C++.
346    * @see http://stackoverflow.com/a/2594222
347    * */
348   extern "C" void WriteData(png_structp png_ptr, png_bytep data, png_size_t length)
349   {
350     DALI_ASSERT_DEBUG(png_ptr && data);
351     if(!png_ptr || !data)
352     {
353       return;
354     }
355     // Make sure we don't try to propagate a C++ exception up the call stack of a pure C library:
356     try
357     {
358       // Recover our buffer for writing into:
359       Vector<unsigned char>* const encoded_img = static_cast< Vector<unsigned char>* >( png_get_io_ptr(png_ptr) );
360       if(encoded_img)
361       {
362         const Vector<unsigned char>::SizeType bufferSize = encoded_img->Count();
363         encoded_img->Reserve( bufferSize + length ); //< Can throw OOM.
364         unsigned char* const bufferBack = encoded_img->Begin() + bufferSize;
365         memcpy(bufferBack, data, length);
366       }
367       else
368       {
369         DALI_LOG_ERROR("PNG buffer for write to memory was passed from libpng as null.");
370       }
371     }
372     catch(...)
373     {
374       DALI_LOG_ERROR("C++ Exception caught");
375     }
376   }
377
378   /** Override the flush with a NOP to prevent libpng trying cstdlib file io. */
379   extern "C" void FlushData(png_structp png_ptr)
380   {
381 #ifdef DEBUG_ENABLED
382     Debug::LogMessage(Debug::DebugInfo, "PNG Flush");
383 #endif // DEBUG_ENABLED
384   }
385 }
386
387 /**
388  * Potential improvements:
389  * 1. Detect <= 256 colours and write in palette mode.
390  * 2. Detect grayscale (will early-out quickly for colour images).
391  * 3. Store colour space / gamma correction info related to the device screen?
392  *    http://www.libpng.org/pub/png/book/chapter10.html
393  * 4. Refactor with callers to write straight through to disk and save keeping a big buffer around.
394  * 5. Prealloc buffer (reserve) to input size / <A number greater than 2 (expexcted few realloc but without using lots of memory) | 1 (expected zero reallocs but using a lot of memory)>.
395  * 6. Set the modification time with png_set_tIME(png_ptr, info_ptr, mod_time);
396  * 7. If caller asks for no compression, bypass libpng and blat raw data to
397  *    disk, topped and tailed with header/tail blocks.
398  */
399 bool EncodeToPng( const unsigned char* const pixelBuffer, Vector<unsigned char>& encodedPixels, std::size_t width, std::size_t height, Pixel::Format pixelFormat )
400 {
401   // Translate pixel format enum:
402   int pngPixelFormat = -1;
403   unsigned pixelBytes = 0;
404   bool rgbaOrder = true;
405
406   // Account for RGB versus BGR and presence of alpha in input pixels:
407   switch( pixelFormat )
408   {
409     case Pixel::RGB888:
410     {
411       pngPixelFormat = PNG_COLOR_TYPE_RGB;
412       pixelBytes = 3;
413       break;
414     }
415     case Pixel::BGRA8888:
416     {
417       rgbaOrder = false;
418       ///! No break: fall through:
419     }
420     case Pixel::RGBA8888:
421     {
422       pngPixelFormat = PNG_COLOR_TYPE_RGB_ALPHA;
423       pixelBytes = 4;
424       break;
425     }
426     default:
427     {
428       DALI_LOG_ERROR( "Unsupported pixel format for encoding to PNG." );
429       return false;
430     }
431   }
432
433   const int interlace = PNG_INTERLACE_NONE;
434
435   png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
436   if(!png_ptr)
437   {
438     return false;
439   }
440   /* Allocate/initialize the image information data.  REQUIRED */
441   png_infop info_ptr = png_create_info_struct( png_ptr );
442   if(!info_ptr)
443   {
444     png_destroy_write_struct(&png_ptr, NULL);
445     return false;
446   }
447
448   /* Set error handling.  REQUIRED if you aren't supplying your own
449    * error handling functions in the png_create_write_struct() call.
450    */
451   if(setjmp(png_jmpbuf(png_ptr)))
452   {
453     png_destroy_write_struct(&png_ptr, &info_ptr);
454     return false;
455   }
456
457   // Since we are going to write to memory instead of a file, lets provide
458   // libpng with a custom write function and ask it to pass back our
459   // Vector buffer each time it calls back to flush data to "file":
460   png_set_write_fn(png_ptr, &encodedPixels, WriteData, FlushData);
461
462   // png_set_compression_level( png_ptr, Z_BEST_COMPRESSION);
463   png_set_compression_level(png_ptr, Z_BEST_SPEED);
464   // png_set_compression_level( png_ptr, Z_NO_COMPRESSION); //! We could just generate png directly without libpng in this case.
465
466   // Explicitly limit the number of filters used per scanline to speed us up:
467   // png_set_filter(png_ptr, 0, PNG_FILTER_NONE); ///!ToDo: Try this once baseline profile is in place.
468        // PNG_FILTER_SUB   |
469        // PNG_FILTER_UP    |
470        // PNG_FILTER_AVE   |
471        // PNG_FILTER_PAETH |
472        // PNG_ALL_FILTERS);
473   // Play with Zlib parameters in optimisation phase:
474     // png_set_compression_mem_level(png_ptr, 8);
475     // png_set_compression_strategy(png_ptr,
476         // Z_DEFAULT_STRATEGY);
477     // png_set_compression_window_bits(png_ptr, 15);
478     // png_set_compression_method(png_ptr, 8);
479     // png_set_compression_buffer_size(png_ptr, 8192)
480
481   // Let lib_png know if the pixel bytes are in BGR(A) order:
482   if(!rgbaOrder)
483   {
484     png_set_bgr( png_ptr );
485   }
486
487   // Set the image information:
488   png_set_IHDR(png_ptr, info_ptr, width, height, 8,
489      pngPixelFormat, interlace,
490      PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
491
492   // Start to output the PNG data to our buffer:
493   png_write_info(png_ptr, info_ptr);
494
495   // Walk the rows:
496   const unsigned row_step = width * pixelBytes;
497   png_bytep row_ptr = const_cast<png_bytep>(pixelBuffer);
498   const png_bytep row_end = row_ptr + height * row_step;
499   for(; row_ptr < row_end; row_ptr += row_step)
500   {
501     png_write_row(png_ptr, row_ptr);
502   }
503
504   /* It is REQUIRED to call this to finish writing the rest of the file */
505   png_write_end(png_ptr, info_ptr);
506   /* Clean up after the write, and free any memory allocated */
507   png_destroy_write_struct(&png_ptr, &info_ptr);
508   return true;
509 }
510
511 } // namespace TizenPlatform
512
513 } // namespace Dali