mg_png.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2008 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include <stdlib.h>
#include <string.h>  /* memset */
#include <stdio.h>

/* third party header files */
#include <png.h>

/* OBS header files */
#include "decoder.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "mg_ctxt.h"
#include "osd_utils.h"
#include "glue_assert.h"

/*---constant definitions for this file--------------------------------------*/

#define MAX_HEADER 8

#ifdef OSD_8_BIT
#define GetColourIndex(r, g, b, a) \
   OSD_FindNearestColourIndex((a << 24) | (r << 16) | (g << 8) | b )
#endif

/*---local typedef structs for this file-------------------------------------*/

typedef struct buffer
{
   void *data;
   S32BIT len;
   S32BIT offset;
} S_BUFFER;

typedef struct info
{
   /* Palette info */
   BOOLEAN has_palette;
   png_colorp palette;
   int num_palette;

   /* Transparency info */
   BOOLEAN has_trans;
   png_bytep trans;
   int num_trans;
   png_color_16p trans_values;
} S_INFO;

/*---local (static) variable declarations for this file----------------------*/
static void ErrorFunction(png_structp png_ptr,
   png_const_charp error_msg);
static void WarningFunction(png_structp png_ptr,
   png_const_charp warning_msg);
/*---local function definitions----------------------------------------------*/

static void PNG_ReadDataFunc(png_structp png_ptr, png_bytep data,
   png_size_t length)
{
   S_BUFFER *buffer = png_get_io_ptr(png_ptr);
   if (length > (png_size_t)(buffer->len - buffer->offset))
   {
      length = (png_size_t)(buffer->len - buffer->offset);
   }
   if (length > 0)
   {
      memcpy(data, (char *)buffer->data + buffer->offset, length);
      buffer->offset += length;
   }
}

static png_voidp PNG_AllocFunc(png_structp png_ptr, png_size_t size)
{
   return OSD_MemAlloc(size);
}

static void PNG_FreeFunc(png_structp png_ptr, png_voidp ptr)
{
   OSD_MemFree(ptr);
}

#ifdef OSD_8_BIT

static void ReadGrayFunc(png_structp png_ptr, png_row_infop row_info,
   png_bytep data)
{
   unsigned int i;

   FUNCTION_START(ReadGrayFunc);

   for (i = 0; i < row_info->rowbytes; ++i)
   {
      data[i] = GetColourIndex(data[i], data[i], data[i], 0xff);
   }

   FUNCTION_FINISH(ReadGrayFunc);
}

static void ReadPaletteFunc(png_structp png_ptr, png_row_infop row_info,
   png_bytep data)
{
   S_INFO *info = png_get_user_transform_ptr(png_ptr);
   unsigned int i;

   FUNCTION_START(ReadPaletteFunc);

   if (info->has_trans)
   {
      png_colorp col;
      png_byte idx;
      for (i = 0; i < row_info->rowbytes; ++i)
      {
         idx = data[i];
         col = &info->palette[idx];
         if (idx >= info->num_trans)
         {
            data[i] = GetColourIndex(col->red, col->green, col->blue, 0xff);
         }
         else
         {
            data[i] = GetColourIndex(col->red, col->green, col->blue,
                  info->trans[idx]);
         }
      }
   }
   else
   {
      png_colorp col;
      for (i = 0; i < row_info->rowbytes; ++i)
      {
         col = &info->palette[data[i]];
         data[i] = GetColourIndex(col->red, col->green, col->blue, 0xff);
      }
   }

   FUNCTION_FINISH(ReadPaletteFunc);
}

static void ReadRGBFunc(png_structp png_ptr, png_row_infop row_info,
   png_bytep data)
{
   int i, j;

   for (i = 0, j = 0; j != row_info->rowbytes; j += 3, ++i)
   {
      data[i] = GetColourIndex(data[j], data[j + 1], data[j + 2], 0xff);
   }
}

static void ReadRGBAlphaFunc(png_structp png_ptr, png_row_infop row_info,
   png_bytep data)
{
   unsigned int i, j;

   for (i = 0, j = 0; j < row_info->rowbytes; j += 4, ++i)
   {
      data[i] = GetColourIndex(data[j], data[j + 1], data[j + 2], data[j + 3]);
   }
}

static void ReadGrayAlphaFunc(png_structp png_ptr, png_row_infop row_info,
   png_bytep data)
{
   unsigned int i, j;

   for (i = 0, j = 0; j < row_info->rowbytes; j += 2, ++i)
   {
      data[i] = GetColourIndex(data[j], data[j], data[j], data[j + 1]);
   }
}

static void SetTransformations(png_structp png_ptr, png_infop info_ptr,
   S_INFO *info)
{
   png_byte color_type = png_get_color_type(png_ptr, info_ptr);
   png_byte bit_depth = png_get_bit_depth(png_ptr, info_ptr);

   memset( info, 0, sizeof(S_INFO));
   /* Read palette (if possible) */
   if (png_get_PLTE(png_ptr, info_ptr,
          &info->palette, &info->num_palette) == PNG_INFO_PLTE)
   {
      info->has_palette = TRUE;
   }

   /* Read transparency info (if possible) */
   if (png_get_tRNS(png_ptr, info_ptr, &info->trans,
          &info->num_trans, &info->trans_values) == PNG_INFO_tRNS)
   {
      info->has_trans = TRUE;
   }

   png_set_strip_16(png_ptr);
   switch (color_type)
   {
      case PNG_COLOR_TYPE_GRAY:
         png_set_expand(png_ptr);
         if (info->has_trans)
         {
            png_set_read_user_transform_fn(png_ptr, ReadGrayAlphaFunc);
         }
         else
         {
            png_set_read_user_transform_fn(png_ptr, ReadGrayFunc);
         }
         break;
      case PNG_COLOR_TYPE_PALETTE:
         if (bit_depth < 8)
         {
            png_set_packing(png_ptr);
         }
         png_set_read_user_transform_fn(png_ptr, ReadPaletteFunc);
         break;
      case PNG_COLOR_TYPE_RGB:
         if (info->has_trans)
         {
            png_set_expand(png_ptr);
            png_set_read_user_transform_fn(png_ptr, ReadRGBAlphaFunc);
         }
         else
         {
            png_set_read_user_transform_fn(png_ptr, ReadRGBFunc);
         }
         break;
      case PNG_COLOR_TYPE_RGB_ALPHA:
         png_set_read_user_transform_fn(png_ptr, ReadRGBAlphaFunc);
         break;
      case PNG_COLOR_TYPE_GRAY_ALPHA:
         png_set_expand(png_ptr);
         png_set_read_user_transform_fn(png_ptr, ReadGrayAlphaFunc);
         break;
   }
   png_set_user_transform_info( png_ptr, info, 8, 1 /*i.e. mg_ctxt.bytes_per_pixel*/ );
}

#endif /* OSD_8_BIT */


S_IMAGE* DEC_DecodePng( U8BIT *data, U32BIT len )
{
   png_structp png_ptr;
   png_infop info_ptr;
   png_infop end_info;
   S_IMAGE *p_bmp = NULL;
   S_BUFFER buffer;
   U16BIT row, pass, num;
   U8BIT *row_ptr;
#ifndef PNG_VERSION_12
   U8BIT **row_pointers;
#endif
   #ifdef OSD_8_BIT
   S_INFO info; /* only relevant for bytes_per_pixel == 1 */
   #endif
   #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
   U8BIT opaque;
   #endif

   TRACE(TGRAPHICS, ("data=%p len=%d", data, len))

   if (len > 0)
   {
      buffer.data = data;
      buffer.len = len;
      buffer.offset = 0;

      do
      {
         /* Check PNG signature */
#ifdef PNG_VERSION_12
         if (!png_check_sig(data, MAX_HEADER > len ? len : MAX_HEADER))
#else
         if (png_sig_cmp(data, 0, (MAX_HEADER > len ? len : MAX_HEADER)) != 0)
#endif
         {
            break;
         }
         /* Create read structure */
         png_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING,
               NULL, NULL, NULL, NULL,
               PNG_AllocFunc, PNG_FreeFunc);
         if (png_ptr == NULL)
         {
            break;
         }
         /* Create info structure */
         info_ptr = png_create_info_struct(png_ptr);
         if (info_ptr == NULL)
         {
            png_destroy_read_struct(&png_ptr, (png_infopp)NULL,
               (png_infopp)NULL);
            break;
         }
         /* Create end-info structure */
         end_info = png_create_info_struct(png_ptr);
         if (end_info == NULL)
         {
            png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
            break;
         }
         png_set_error_fn(png_ptr, NULL, ErrorFunction, WarningFunction);
         if (setjmp(png_jmpbuf(png_ptr)))
         {
            png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
            break;
         }
         /* Initialise I/O */
         png_set_read_fn(png_ptr, &buffer, PNG_ReadDataFunc);

         /* Read info */
         png_read_info(png_ptr, info_ptr);

#ifdef PNG_VERSION_12
         TRACE(TGRAPHICS, ("col_typ=%d vld=%d", info_ptr->color_type, info_ptr->valid))
#endif

         IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
         {
            #ifdef OSD_8_BIT
            SetTransformations(png_ptr, info_ptr, &info);
            pass = png_set_interlace_handling(png_ptr);
            /* Update info */
            png_read_update_info(png_ptr, info_ptr);

            p_bmp = (S_IMAGE *) OSD_MemAlloc( sizeof(S_IMAGE));
            if (p_bmp != NULL)
            {
#ifdef PNG_VERSION_12
               assert((info_ptr->rowbytes % info_ptr->width) == 0 );

               row_ptr = OSD_MemAlloc( info_ptr->width * info_ptr->height );
#else
               assert((png_get_rowbytes(png_ptr, info_ptr) % png_get_image_width(png_ptr, info_ptr)) == 0 );

               row_ptr = OSD_MemAlloc(png_get_image_width(png_ptr, info_ptr) *
                     png_get_image_height(png_ptr, info_ptr));
#endif
               if (row_ptr == NULL)
               {
                  OSD_MemFree( p_bmp );
                  p_bmp = NULL;
               }
               else
               {
                  p_bmp->col_buff = row_ptr;
#ifdef PNG_VERSION_12
                  p_bmp->width = (U16BIT)info_ptr->width;
                  p_bmp->height = (U16BIT)info_ptr->height;
#else
                  p_bmp->width = (U16BIT)png_get_image_width(png_ptr, info_ptr);
                  p_bmp->height = (U16BIT)png_get_image_height(png_ptr, info_ptr);
#endif
                  p_bmp->pix_bytes = 1;
#ifdef PNG_VERSION_12
                  if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) || (info.has_trans))
#else
                  if ((png_get_color_type(png_ptr, info_ptr) & PNG_COLOR_MASK_ALPHA) || (info.has_trans))
#endif
                  {
                     p_bmp->opaque = HAS_TRANSPARENCY;
                  }
                  else
                  {
                     p_bmp->opaque = COMPLETELY_OPAQUE;
                  }

                  /* Read image */
#ifdef PNG_VERSION_12
                  png_ptr->num_rows = p_bmp->height;
                  do
                  {
                     for (row = 0; row != p_bmp->height; row++)
                     {
                        png_read_row(png_ptr, row_ptr, png_bytep_NULL);
                        row_ptr += p_bmp->width;
                     }
                     row_ptr = p_bmp->col_buff;
                  }
                  while (--pass);
#else
                  row_pointers = OSD_MemAlloc(p_bmp->height * sizeof(U8BIT *));
                  if (row_pointers != NULL)
                  {
                     for (row = 0; row != p_bmp->height; row++)
                     {
                        row_pointers[row] = row_ptr + (row * p_bmp->width);
                     }

                     png_read_image(png_ptr, row_pointers);

                     OSD_MemFree(row_pointers);
                  }
                  USE_UNWANTED_PARAM(pass);
#endif

                  if (p_bmp->opaque == COMPLETELY_OPAQUE)
                  {
                     for (row = 0; (p_bmp->opaque == COMPLETELY_OPAQUE) && row != p_bmp->height; ++row)
                     {
                        for (num = 0; num != p_bmp->width; ++num)
                        {
                           if (!OSD_IsColourOpaque(*row_ptr))
                           {
                              p_bmp->opaque = HAS_TRANSPARENCY;
                              break;
                           }
                           row_ptr++;
                        }
                     }
                  }
                  TRACE(TGRAPHICS, ("w=%d h=%d", p_bmp->width, p_bmp->height))
                  /*TRACE_BUFF(TGRAPHICS,p_bmp->col_buff,p_bmp->width*2)*/
               }
            }
            #endif /*OSD_8_BIT*/
         }
         ELSE
         {
            #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
            png_set_strip_16(png_ptr);
#ifdef PNG_VERSION_12
            switch (info_ptr->color_type)
#else
            switch (png_get_color_type(png_ptr, info_ptr))
#endif
            {
               case PNG_COLOR_TYPE_GRAY_ALPHA:
               case PNG_COLOR_TYPE_GRAY:
                  png_set_expand(png_ptr);
                  png_set_gray_to_rgb(png_ptr);
                  break;
               case PNG_COLOR_TYPE_PALETTE:
                  /* for this case, could do "png_set_palette_to_rgb(png_ptr)"
                   * but that is the same as "png_set_expand(png_ptr)"
                   */
                  png_set_expand(png_ptr);
                  break;

               case PNG_COLOR_TYPE_RGB:
#ifdef PNG_VERSION_12
                  if (info_ptr->valid & PNG_INFO_tRNS)
#else
                  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) != 0)
#endif
                  {
                     png_set_expand(png_ptr);
                  }
               case PNG_COLOR_TYPE_RGB_ALPHA:
               default:;
            }
            pass = png_set_interlace_handling(png_ptr);

            png_read_update_info(png_ptr, info_ptr);

            num = 3;
            opaque = COMPLETELY_OPAQUE;
#ifdef PNG_VERSION_12
            if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
#else
            if (png_get_color_type(png_ptr, info_ptr) & PNG_COLOR_MASK_ALPHA)
#endif
            {
               png_set_swap_alpha(png_ptr);
               opaque = HAS_TRANSPARENCY;
               num++;
            }
            p_bmp = (S_IMAGE *) OSD_MemAlloc( sizeof(S_IMAGE));
            if (p_bmp != NULL)
            {
#ifdef PNG_VERSION_12
               row_ptr = OSD_MemAlloc((info_ptr->width * info_ptr->height * num));
#else
               row_ptr = OSD_MemAlloc( png_get_image_width(png_ptr, info_ptr) *
                     png_get_image_height(png_ptr, info_ptr) * num );
#endif
               if (row_ptr)
               {
                  p_bmp->col_buff = row_ptr;
                  p_bmp->pix_bytes = (U8BIT)num;
                  p_bmp->opaque = opaque;
#ifdef PNG_VERSION_12
                  p_bmp->width = (U16BIT)info_ptr->width;
                  p_bmp->height = (U16BIT)info_ptr->height;
#else
                  p_bmp->width = (U16BIT)png_get_image_width(png_ptr, info_ptr);
                  p_bmp->height = (U16BIT)png_get_image_height(png_ptr, info_ptr);
#endif
                  p_bmp->y_resolution = (U16BIT)png_get_y_pixels_per_meter( png_ptr, info_ptr );

                  /* Read image */
#ifdef PNG_VERSION_12
                  num *= p_bmp->width;
                  /* Read image */
                  png_ptr->num_rows = p_bmp->height;
                  do
                  {
                     for (row = 0; row != p_bmp->height; row++)
                     {
                        png_read_row(png_ptr, row_ptr, png_bytep_NULL);
                        row_ptr += num;
                     }
                     row_ptr = p_bmp->col_buff;
                  }
                  while (--pass);
#else
                  row_pointers = OSD_MemAlloc(p_bmp->height * sizeof(U8BIT *));
                  if (row_pointers != NULL)
                  {
                     num *= p_bmp->width;

                     for (row = 0; row != p_bmp->height; row++)
                     {
                        row_pointers[row] = row_ptr + (row * num);
                     }

                     png_read_image(png_ptr, row_pointers);

                     OSD_MemFree(row_pointers);
                  }
                  USE_UNWANTED_PARAM(pass);
#endif
                  TRACE(TGRAPHICS, ("w=%d h=%d", p_bmp->width, p_bmp->height))
                  /*TRACE_BUFF(TGRAPHICS,p_bmp->col_buff,num*2)*/
               }
               else
               {
                  OSD_MemFree( p_bmp );
                  p_bmp = NULL;
               }
            }
            #endif
         }

         /* Finish reading */
         png_read_end(png_ptr, end_info);

         /* Clear everything */
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
      }
      while (0);
   }
   return p_bmp;
}

void DEC_FreePng( S_IMAGE *data )
{
   OSD_MemFree(data->col_buff);
   OSD_MemFree(data);
}

static void ErrorFunction(png_structp png_ptr,
   png_const_charp error_msg)
{
   DBG_PRINTF("PNG_ERR: %s\n", error_msg);
}

static void WarningFunction(png_structp png_ptr,
   png_const_charp warning_msg)
{
   DBG_PRINTF("PNG_WARN: %s\n", warning_msg);
}