WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-png.c

  */
 #include "cairoint.h"
 #include "cairo-error-private.h"
-#include "cairo-error-private.h"
+#include "cairo-image-surface-private.h"
 #include "cairo-output-stream-private.h"
  * @Short_Description: Reading and writing PNG images
  * @See_Also: #cairo_surface_t
+ *
  * The PNG functions allow reading PNG images into image surfaces, and writing
  * any surface to a PNG file.
+ *
+ * It is a toy API. It only offers very simple support for reading and
+ * writing PNG files, which is sufficient for testing and
+ * demonstration purposes. Applications which need more control over
+ * the generated PNG file should access the pixel data directly, using
+ * cairo_image_surface_get_data() or a backend-specific access
+ * function, and process it with another library, e.g. gdk-pixbuf or
+ * libpng.
- */
+ **/
 /**
  * CAIRO_HAS_PNG_FUNCTIONS:
+ *
  * Defined if the PNG functions are available.
  * This macro can be used to conditionally compile code using the cairo
+ * PNG functions.
+ *
- * PNG functions.
+ * Since: 1.0
- */
+ **/
 struct png_read_closure_t {
     cairo_read_func_t		 read_func;
 static void
 png_simple_warning_callback (png_structp png,
 	                     png_const_charp error_msg)
 {
-    cairo_status_t *error = png_get_error_ptr (png);
+    /* png does not expect to abort and will try to tidy up and continue
-    /* default to the most likely error */
+     * loading the image after a warning. So we also want to return the
+     * (incorrect?) surface.
-    if (*error == CAIRO_STATUS_SUCCESS)
+     *
-	*error = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+     * We use our own warning callback to squelch any attempts by libpng
+     * to write to stderr as we may not be in control of that output.
-    /* png does not expect to abort and will try to tidy up after a warning */
+     */
+}
 write_png (cairo_surface_t	*surface,
 	   png_rw_ptr		write_func,
 	   void			*closure)
+{
     int i;
-    cairo_status_t status;
+    cairo_int_status_t status;
     cairo_image_surface_t *image;
     cairo_image_surface_t * volatile clone;
     void *image_extra;
     png_struct *png;
     png_info *info;
     png_byte **volatile rows = NULL;
     png_color_16 white;
     int png_color_type;
-    int depth;
+    int bpc;
     status = _cairo_surface_acquire_source_image (surface,
 						  &image,
     png_set_write_fn (png, closure, write_func, png_simple_output_flush_fn);
     switch (clone->format) {
     case CAIRO_FORMAT_ARGB32:
-	depth = 8;
+	bpc = 8;
 	if (_cairo_image_analyze_transparency (clone) == CAIRO_IMAGE_IS_OPAQUE)
 	    png_color_type = PNG_COLOR_TYPE_RGB;
 	else
+	    png_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+	break;
+    case CAIRO_FORMAT_RGB30:
+	bpc = 10;
-	    png_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+	png_color_type = PNG_COLOR_TYPE_RGB;
 	break;
     case CAIRO_FORMAT_RGB24:
-	depth = 8;
+	bpc = 8;
 	png_color_type = PNG_COLOR_TYPE_RGB;
 	break;
     case CAIRO_FORMAT_A8:
-	depth = 8;
+	bpc = 8;
 	png_color_type = PNG_COLOR_TYPE_GRAY;
 	break;
     case CAIRO_FORMAT_A1:
-	depth = 1;
+	bpc = 1;
 	png_color_type = PNG_COLOR_TYPE_GRAY;
 #ifndef WORDS_BIGENDIAN
 	png_set_packswap (png);
 	goto BAIL4;
+    }
     png_set_IHDR (png, info,
 		  clone->width,
-		  clone->height, depth,
+		  clone->height, bpc,
 		  png_color_type,
 		  PNG_INTERLACE_NONE,
 		  PNG_COMPRESSION_TYPE_DEFAULT,
 		  PNG_FILTER_TYPE_DEFAULT);
-    white.gray = (1 << depth) - 1;
+    white.gray = (1 << bpc) - 1;
     white.red = white.blue = white.green = white.gray;
     png_set_bKGD (png, info, &white);
  * successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY if memory could not
  * be allocated for the operation or
  * %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have
  * pixel contents, or %CAIRO_STATUS_WRITE_ERROR if an I/O error occurs
  * while attempting to write the file.
+ *
+ * Since: 1.0
  **/
 cairo_status_t
 cairo_surface_write_to_png (cairo_surface_t	*surface,
 			    const char		*filename)
+{
  * Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written
  * successfully.  Otherwise, %CAIRO_STATUS_NO_MEMORY is returned if
  * memory could not be allocated for the operation,
  * %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have
  * pixel contents.
+ *
+ * Since: 1.0
  **/
 cairo_status_t
 cairo_surface_write_to_png_stream (cairo_surface_t	*surface,
 				   cairo_write_func_t	write_func,
 				   void			*closure)
 	surface = _cairo_surface_create_in_error (status);
 	goto BAIL;
+    }
- BAIL:
-    if (row_pointers != NULL)
+ BAIL:
-	free (row_pointers);
-    if (data != NULL)
+    free (row_pointers);
-	free (data);
+    free (data);
     if (png != NULL)
 	png_destroy_read_struct (&png, &info, NULL);
     if (png_closure->png_data != NULL) {
  *	%CAIRO_STATUS_READ_ERROR
+ *
  * Alternatively, you can allow errors to propagate through the drawing
  * operations and check the status on the context upon completion
  * using cairo_status().
+ *
+ * Since: 1.0
  **/
 cairo_surface_t *
 cairo_image_surface_create_from_png (const char *filename)
+{
     struct png_read_closure_t png_closure;
  *	%CAIRO_STATUS_READ_ERROR
+ *
  * Alternatively, you can allow errors to propagate through the drawing
  * operations and check the status on the context upon completion
  * using cairo_status().
+ *
+ * Since: 1.0
  **/
 cairo_surface_t *
 cairo_image_surface_create_from_png_stream (cairo_read_func_t	read_func,
 					    void		*closure)
+{

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-png.c – Rev 1897 → 3959