platform-abstractions: png: use C++ headers for stdlib
[platform/core/uifw/dali-adaptor.git] / platform-abstractions / slp / image-loaders / loader-png.cpp
1 /*
2  * Copyright (c) 2014 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 <png.h>
24
25 #include <dali/integration-api/bitmap.h>
26 #include <dali/integration-api/debug.h>
27 #include <dali/public-api/images/image.h>
28 #include <dali/public-api/images/image-attributes.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 SlpPlatform
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(FILE *fp, const ImageAttributes& attributes, 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(fp, width, height, png, info);
127
128   return success;
129 }
130
131 bool LoadBitmapFromPng( FILE *fp, Bitmap& bitmap, ImageAttributes& attributes, const ResourceLoadingClient& client )
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(fp, 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   // set the attributes
312   attributes.SetSize( width, height );
313   attributes.SetPixelFormat( pixelFormat );
314
315   free(rows);
316
317   return true;
318 }
319
320 // simple class to enforce clean-up of PNG structures
321 struct AutoPngWrite
322 {
323   AutoPngWrite(png_structp& _png, png_infop& _info)
324   : png(_png),
325     info(_info)
326   {
327     DALI_ASSERT_DEBUG(&_png != 0 && &_info != 0);
328   }
329
330   ~AutoPngWrite()
331   {
332     if(NULL != png)
333     {
334       png_destroy_write_struct(&png, &info);
335     }
336   }
337
338   png_structp& png;
339   png_infop& info;
340 }; // struct AutoPngWrite;
341
342 namespace
343 {
344   // Custom libpng write callbacks that buffer to a vector instead of a file:
345
346   /**
347    * extern "C" linkage is used because this is a callback that we pass to a C
348    * library which is part of the underlying platform and so potentially compiled
349    * as C rather than C++.
350    * @see http://stackoverflow.com/a/2594222
351    * */
352   extern "C" void WriteData(png_structp png_ptr, png_bytep data, png_size_t length)
353   {
354     using Dali::SlpPlatform::PngBuffer;
355     DALI_ASSERT_DEBUG(png_ptr && data);
356     if(!png_ptr || !data)
357     {
358       return;
359     }
360     // Make sure we don't try to propagate a C++ exception up the call stack of a pure C library:
361     try {
362       // Recover our buffer for writing into:
363       PngBuffer* const encoded_img = (PngBuffer*) png_get_io_ptr(png_ptr);
364       if(encoded_img)
365       {
366         const PngBuffer::size_type bufferSize = encoded_img->size();
367         encoded_img->resize(encoded_img->size() + length); //< Can throw OOM.
368         PngBuffer::value_type* const bufferBack = &((*encoded_img)[bufferSize]);
369         memcpy(bufferBack, data, length);
370       }
371       else
372       {
373         DALI_LOG_ERROR("PNG buffer for write to memory was passed from libpng as null.");
374       }
375     } catch(...)
376     {
377       DALI_LOG_ERROR("C++ Exception caught");
378     }
379   }
380
381   /** Override the flush with a NOP to prevent libpng trying cstdlib file io. */
382   extern "C" void FlushData(png_structp png_ptr)
383   {
384 #ifdef DEBUG_ENABLED
385     Debug::LogMessage(Debug::DebugInfo, "PNG Flush");
386 #endif // DEBUG_ENABLED
387   }
388 }
389
390 /**
391  * Potential improvements:
392  * 1. Detect <= 256 colours and write in palette mode.
393  * 2. Detect grayscale (will early-out quickly for colour images).
394  * 3. Store colour space / gamma correction info related to the device screen?
395  *    http://www.libpng.org/pub/png/book/chapter10.html
396  * 4. Refactor with callers to write straight through to disk and save keeping a big buffer around.
397  * 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)>.
398  * 6. Set the modification time with png_set_tIME(png_ptr, info_ptr, mod_time);
399  * 7. If caller asks for no compression, bypass libpng and blat raw data to
400  *    disk, topped and tailed with header/tail blocks.
401  */
402 bool EncodeToPng( const unsigned char* const pixelBuffer, PngBuffer& encodedPixels, std::size_t width, std::size_t height, Pixel::Format pixelFormat )
403 {
404   // Translate pixel format enum:
405   int pngPixelFormat = -1;
406   unsigned pixelBytes = 0;
407   bool rgbaOrder = true;
408
409   // Account for RGB versus BGR and presence of alpha in input pixels:
410   switch( pixelFormat )
411   {
412     case Pixel::RGB888:
413     {
414       pngPixelFormat = PNG_COLOR_TYPE_RGB;
415       pixelBytes = 3;
416       break;
417     }
418     case Pixel::BGRA8888:
419     {
420       rgbaOrder = false;
421       ///! No break: fall through:
422     }
423     case Pixel::RGBA8888:
424     {
425       pngPixelFormat = PNG_COLOR_TYPE_RGB_ALPHA;
426       pixelBytes = 4;
427       break;
428     }
429     default:
430     {
431       DALI_LOG_ERROR( "Unsupported pixel format for encoding to PNG." );
432       return false;
433     }
434   }
435
436   const int interlace = PNG_INTERLACE_NONE;
437
438   png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
439   if(!png_ptr)
440   {
441     return false;
442   }
443   /* Allocate/initialize the image information data.  REQUIRED */
444   png_infop info_ptr = png_create_info_struct( png_ptr );
445   if(!info_ptr)
446   {
447     png_destroy_write_struct(&png_ptr, NULL);
448     return false;
449   }
450
451   /* Set error handling.  REQUIRED if you aren't supplying your own
452    * error handling functions in the png_create_write_struct() call.
453    */
454   if(setjmp(png_jmpbuf(png_ptr)))
455   {
456     png_destroy_write_struct(&png_ptr, &info_ptr);
457     return false;
458   }
459
460   // Since we are going to write to memory instead of a file, lets provide
461   // libpng with a custom write function and ask it to pass back our
462   // std::vector buffer each time it calls back to flush data to "file":
463   png_set_write_fn(png_ptr, &encodedPixels, WriteData, FlushData);
464
465   // png_set_compression_level( png_ptr, Z_BEST_COMPRESSION);
466   png_set_compression_level(png_ptr, Z_BEST_SPEED);
467   // png_set_compression_level( png_ptr, Z_NO_COMPRESSION); //! We could just generate png directly without libpng in this case.
468
469   // Explicitly limit the number of filters used per scanline to speed us up:
470   // png_set_filter(png_ptr, 0, PNG_FILTER_NONE); ///!ToDo: Try this once baseline profile is in place.
471        // PNG_FILTER_SUB   |
472        // PNG_FILTER_UP    |
473        // PNG_FILTER_AVE   |
474        // PNG_FILTER_PAETH |
475        // PNG_ALL_FILTERS);
476   // Play with Zlib parameters in optimisation phase:
477     // png_set_compression_mem_level(png_ptr, 8);
478     // png_set_compression_strategy(png_ptr,
479         // Z_DEFAULT_STRATEGY);
480     // png_set_compression_window_bits(png_ptr, 15);
481     // png_set_compression_method(png_ptr, 8);
482     // png_set_compression_buffer_size(png_ptr, 8192)
483
484   // Let lib_png know if the pixel bytes are in BGR(A) order:
485   if(!rgbaOrder)
486   {
487     png_set_bgr( png_ptr );
488   }
489
490   // Set the image information:
491   png_set_IHDR(png_ptr, info_ptr, width, height, 8,
492      pngPixelFormat, interlace,
493      PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
494
495   // Start to output the PNG data to our buffer:
496   png_write_info(png_ptr, info_ptr);
497
498   // Walk the rows:
499   const unsigned row_step = width * pixelBytes;
500   png_bytep row_ptr = const_cast<png_bytep>(pixelBuffer);
501   const png_bytep row_end = row_ptr + height * row_step;
502   for(; row_ptr < row_end; row_ptr += row_step)
503   {
504     png_write_row(png_ptr, row_ptr);
505   }
506
507   /* It is REQUIRED to call this to finish writing the rest of the file */
508   png_write_end(png_ptr, info_ptr);
509   /* Clean up after the write, and free any memory allocated */
510   png_destroy_write_struct(&png_ptr, &info_ptr);
511   return true;
512 }
513
514 } // namespace SlpPlatform
515
516 } // namespace Dali