output2dpng.c

Go to the documentation of this file.

/***************************************************************************
 *   stick2xyz - Can create and convert stick figure animations for CG.    *
 *   Copyright (C) 2021 by Kevin McBride <dolphindddd@aol.com>             *
 *                                                                         *
 *  This program is free software: you can redistribute it and/or modify   *
 *  it under the terms of the GNU General Public License as published by   *
 *  the Free Software Foundation, either version 3 of the License, or      *
 *  (at your option) any later version.                                    *
 *                                                                         *
 *  This program is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *  GNU General Public License for more details.                           *
 *                                                                         *
 *  You should have received a copy of the GNU General Public License      *
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
 
 
#include "output2dpngpriv.h"
 
 
#ifdef      DOXYGEN_BUILD
#include "output2dpng.h"
#include "output2djpeg.h"
#include "output2dbmp.h"
#else /* not DOXYGEN_BUILD */
 
/* This array contains the version of the module. */
static int modversion[] = 
      {STICK2XYZ_VER_MAJOR, STICK2XYZ_VER_MINOR, STICK2XYZ_VER_REVISION};
/* The file descriptors we are outputting tty information to. */
static FILE * modttyout = NULL;
static FILE * modttyerr = NULL;
#if   defined(HAVE_THREADS_H) | defined(__WINDOWS__)
static int canmultithread = 0;
#else /* defined(HAVE_THREADS_H) | defined(__WINDOWS__) */
static const int canmultithread = 0;
#endif      /* defined(HAVE_THREADS_H) | defined(__WINDOWS__) */
static volatile int modreferences = 0;
 
#ifndef     STICK2XYZ_NO_MODLANGPACKS
/* Used for dynamically accessing the language libraries. */
stick2xyz_print_ptr stick2xyz_lang_lib_output2dpng = NULL;
 
void output2dpng_lang ( stick2xyz_print_ptr newval )
{
      stick2xyz_lang_lib_output2dpng = newval;
}
#endif      /* not STICK2XYZ_NO_MODLANGPACKS */
 
 
/* PNGWrite Module Info Functions */
stick2xyz_pctchar output2dpng_name ( void )
{
      return stick2xyz_output2dpng_modname();
}
 
stick2xyz_pctchar output2dpng_desc ( void )
{
      return stick2xyz_output2dpng_moddesc();
}
 
void output2dpng_version ( int * dest )
{
      dest[0] = modversion[0];
      dest[1] = modversion[1];
      dest[2] = modversion[2];
}
 
int output2dpng_type ( void )
{
#ifdef      UNICODE
#ifdef      DEBUG
      return STICK2XYZ_MODTYPE_OUTPUT2D_UNICODE_DEBUG;
#else /* not DEBUG */
      return STICK2XYZ_MODTYPE_OUTPUT2D_UNICODE;
#endif      /* not DEBUG */
#else /* not UNICODE */
#ifdef      DEBUG
      return STICK2XYZ_MODTYPE_OUTPUT2D_DEBUG;
#else /* not DEBUG */
      return STICK2XYZ_MODTYPE_OUTPUT2D;
#endif      /* not DEBUG */
#endif      /* not UNICODE */
}
 
 
int output2dpng_init ( int multithread )
{
#if   defined(HAVE_THREADS_H) | defined(__WINDOWS__)
      /* Check reference count. */
      if ( ( multithread ) && ( modreferences == 0 ) )
      {
            /* Initialize the mutex. */
            if ( output2dpng_enablemultithread() )
            {
                  /* We can now multithread. */
                  canmultithread = 1;
            } else {
                  /* Call failed. */
                  return 0;
            }
      }
#endif      /* defined(HAVE_THREADS_H) | defined(__WINDOWS__) */
 
      /* Increment modreferences. */
      modreferences++;
      /* Return reference count to caller. */
      return modreferences;
}
 
int output2dpng_release ( void )
{
#if   defined(HAVE_THREADS_H) | defined(__WINDOWS__)
      /* Check reference count. */
      if ( modreferences == 1 )
      {
            /* Destroy the mutex. */
            if ( output2dpng_disablemultithread() )
            {
                  /* We can no longer multithread. */
                  canmultithread = 0;
            } else {
                  /* The function failed. */
                  return -1;
            }
      }
#endif      /* defined(HAVE_THREADS_H) | defined(__WINDOWS__) */
 
      /* Check reference count. */
      if ( modreferences == 0 )
      {
            /* Set errno. */
            stick2xyz_set_errno(EAGAIN);
            /* Nothing to do when ref is zero. */
            return 0;
      }
 
      /* Decrement references. */
      modreferences--;
 
      /* Return reference count to caller. */
      return modreferences;
}
 
 
void output2dpng_set_tty ( void * fildescout, void * fildescerr )
{
      modttyout = (FILE *)fildescout;
      modttyerr = (FILE *)fildescerr;
}
 
FILE * output2dpng_get_ttyout ( void )
{
      if ( modttyout == NULL )
            return stdout;
      else
            return modttyout;
}
 
FILE * output2dpng_get_ttyerr ( void )
{
      if ( modttyerr == NULL )
            return stderr;
      else
            return modttyerr;
}
 
 
/* PNG Allocation Functions */
output2d_handle output2dpng_to_png (
      pane2d_handle pane,
      pane2d_dupdata dupdata,
      pane2d_dupxy dupxy,
      int use_rgb
)
{
      stick2xyz_image_data image;
      int x;
      int y;
 
      /* Determine if padding should be used. */
      if ( use_rgb )
            use_rgb = 3;
      else
            use_rgb = 1;
 
      /* Get the raw image data. */
      image = dupdata(pane, use_rgb);
      if ( image == NULL )
            return NULL;
 
      /* Get the x and y coordinates. */
      dupxy(pane, &x, &y);
 
      /* Pass all this information onto the allocator. */
      return output2dpng_to_png_internal(image, use_rgb, x, y);
}
 
output2d_handle output2dpng_image_to_png (
      pane2d_handle pane,
      pane2d_dupimage dupimage,
      pane2d_freeimage freedata,
      pane2d_dupxy dupxy,
      int use_rgb
)
{
      stick2xyz_image_data image;
      int x;
      int y;
 
      /* Determine if padding should be used. */
      if ( use_rgb )
            use_rgb = 3;
      else
            use_rgb = 1;
 
      /* Get the raw image data. */
      image = dupimage(pane, use_rgb);
      if ( image == NULL )
            return NULL;
 
      /* Get the x and y coordinates. */
      dupxy(pane, &x, &y);
 
      /* Pass all this information onto the allocator. */
      return output2dpng_image_to_png_internal(
            image, use_rgb, x, y, pane,
            NULL,
            freedata,
            STICK2XYZ_PANE2D_COLORTYPE_GRAY,
            0,
            NULL
      );
}
 
output2d_handle output2dpng_bypng16type (
      pane2d_handle pane,
      pane2d_dupfunc_getlist duplist,
      int use_rgb,
      unsigned int filnum
)
{
      struct pane2d_image16_funcs funclist;
      stick2xyz_image16_data image;
#ifdef      __WINDOWS__
      HANDLE eventreleased = NULL;
#endif      /* __WINDOWS__ */
#ifdef      HAVE_EVENTFD
      int eventreleased;
#endif      /* HAVE_EVENTFD */
      int multithreading;
      int res;
      int x;
      int y;
 
      /* Determine if padding should be used. */
      if ( use_rgb )
            use_rgb = 3;
      else
            use_rgb = 1;
 
      /* Get sizeof structure. */
      funclist.len = sizeof(struct pane2d_image16_funcs);
      /* Get list of functions. */
      res = duplist(
            STICK2XYZ_PANE2D_REQUEST_UINT16PP,
            (struct pane2d_dupgen_funcs *)&funclist
      );
      /* If duplist() failed, we can't continue. */
      if ( !res )
            return NULL;
      /* If our sizeof() is less than len, we need to assume a variable. */
      if ( funclist.len < sizeof(struct pane2d_dupgen_funcs_v3) )
      {
            /* If our v2 sizeof() is less than len, we can't continue. */
            if ( funclist.len < sizeof(struct pane2d_dupgen_funcs_v2) )
                  return NULL;
 
            /* Assume multithreading is zero. */
            multithreading = 0;
      } else {
            /* Get the multithreading boolean value. */
            multithreading = funclist.multithreading(pane);
      }
#if   defined(HAVE_EVENTFD) | defined(__WINDOWS__)
      /* If our sizeof() at least v4, we can get the eventreleased handle. */
      if ( funclist.len >= sizeof(struct pane2d_image16_funcs) )
      {
            eventreleased = funclist.eventreleased(pane);
      }
#endif      /* defined(HAVE_EVENTFD) | defined(__WINDOWS__) */
 
      /* Get the raw image data. */
      image = funclist.dupimage(pane, use_rgb);
      if ( image == NULL )
            return NULL;
 
      /* Get the x and y coordinates. */
      funclist.dupxy(pane, &x, &y);
 
      return output2dpng_image16_to_png_internal(
            image, use_rgb, x, y, pane,
            funclist.dupimage,
            funclist.freeimage,
            funclist.colorinfo(),
            multithreading,
#ifdef      __WINDOWS__
            eventreleased
#else /* not __WINDOWS__ */
#ifdef      HAVE_EVENTFD
            &eventreleased
#else /* not HAVE_EVENTFD */
            NULL
#endif      /* not HAVE_EVENTFD */
#endif      /* not __WINDOWS__ */
      );
}
 
output2d_handle output2dpng_bypngtype (
      pane2d_handle pane,
      pane2d_dupfunc_getlist duplist,
      int use_rgb,
      unsigned int filnum
)
{
      struct pane2d_image_funcs funclist;
#ifdef      __WINDOWS__
      HANDLE eventreleased = NULL;
#endif      /* __WINDOWS__ */
#ifdef      HAVE_EVENTFD
      int eventreleased;
#endif      /* HAVE_EVENTFD */
      stick2xyz_image_data image;
      int multithreading;
      int res;
      int x;
      int y;
 
      /* Determine if padding should be used. */
      if ( use_rgb )
            use_rgb = 3;
      else
            use_rgb = 1;
 
      /* Get sizeof structure. */
      funclist.len = sizeof(struct pane2d_image_funcs);
      /* Get list of functions. */
      res = duplist(
            STICK2XYZ_PANE2D_REQUEST_UINT8PP,
            (struct pane2d_dupgen_funcs *)&funclist
      );
      /* If duplist() failed, we can't continue. */
      if ( !res )
            return NULL;
      /* If our sizeof() is less than len, we need to assume a variable. */
      if ( funclist.len < sizeof(struct pane2d_dupgen_funcs_v3) )
      {
            /* If our v2 sizeof() is less than len, we can't continue. */
            if ( funclist.len < sizeof(struct pane2d_dupgen_funcs_v2) )
                  return NULL;
 
            /* Assume multithreading is zero. */
            multithreading = 0;
      } else {
            /* Get the multithreading boolean value. */
            multithreading = funclist.multithreading(pane);
      }
#if   defined(HAVE_EVENTFD) | defined(__WINDOWS__)
      /* If our sizeof() at least v4, we can get the eventreleased handle. */
      if ( funclist.len >= sizeof(struct pane2d_image_funcs) )
      {
            eventreleased = funclist.eventreleased(pane);
      }
#endif      /* defined(HAVE_EVENTFD) | defined(__WINDOWS__) */
 
      /* Get the raw image data. */
      image = funclist.dupimage(pane, use_rgb);
      if ( image == NULL )
            return NULL;
 
      /* Get the x and y coordinates. */
      funclist.dupxy(pane, &x, &y);
 
      return output2dpng_image_to_png_internal(
            image, use_rgb, x, y, pane,
            funclist.dupimage,
            funclist.freeimage,
            funclist.colorinfo(),
            multithreading,
#ifdef      __WINDOWS__
            eventreleased
#else /* not __WINDOWS__ */
#ifdef      HAVE_EVENTFD
            &eventreleased
#else /* not HAVE_EVENTFD */
            NULL
#endif      /* not HAVE_EVENTFD */
#endif      /* not __WINDOWS__ */
      );
}
 
 
int output2dpng_multithread_safe ( void )
{
      return canmultithread;
}
 
int output2dpng_getnewdata (
      output2d_handle handle,
      unsigned int filnum
)
{
#if   defined(HAVE_THREADS_H) | defined(__WINDOWS__)
      /* If multithreading is not enabled, we can't do anything. */
      if ( !canmultithread )
      {
            stick2xyz_set_errno(ENOSYS);
            return 0;
      }
 
      /* Call our internal function. */
      return output2dpng_getnewdata_internal(handle, filnum);
#else /* not defined(HAVE_THREADS_H) | defined(__WINDOWS__) */
      stick2xyz_set_errno(ENOSYS);
      return 0;
#endif      /* not defined(HAVE_THREADS_H) | defined(__WINDOWS__) */
}
 
 
int output2dpng_quality_range ( struct output2d_qualityinfo * dest )
{
      /* If dest is NULL, we can't do anything. */
      if ( dest == NULL )
            return 0;
 
      /* If version of structure is less than we coded,
         return failure to caller. */
      if ( dest->quality_version < sizeof(struct output2d_qualityinfo) )
            return 0;
 
      /* Set our version of the structure. */
      dest->quality_version = sizeof(struct output2d_qualityinfo);
 
      /* Set up the values. */
      dest->quality_min = STICK2XYZ_PNG_QUALITY_LOWEST;
      dest->quality_max = STICK2XYZ_PNG_QUALITY_HIGHEST;
      dest->quality_best = Z_BEST_COMPRESSION;
      dest->quality_fast = Z_BEST_SPEED;
      dest->quality_default = STICK2XYZ_PNG_COMPRESSION;
 
      /* Return success to caller. */
      return 1;
}
 
uint32_t output2dpng_quality_valid ( const int value )
{
      /* See if the value is too low. */
      if ( value < 0 )
            return STICK2XYZ_OUTPUT2D_QUALITY_TOOLOW;
 
      /* See if the value is too high. */
      if ( value > 9 )
            return STICK2XYZ_OUTPUT2D_QUALITY_TOOHIGH;
 
      /* value is in the correct range. */
      return STICK2XYZ_OUTPUT2D_QUALITY_VALID;
}
 
size_t output2dpng_bpp_list ( int * array )
{
      /* If array is NULL, return amount of elements to write. */
      if ( array == NULL )
            return 4;
 
      /* Set up the bpp list array. */
      array[0] = 8;
      array[1] = 16;
      array[2] = 24;
      array[3] = 48;
 
      /* Return to caller. */
      return 4;
}
 
int output2dpng_bpp_supported ( const int value )
{
      if ( ( value == 8 ) | ( value == 16 ) )
            return 1; /* Value is valid. */
      if ( ( value == 24 ) | ( value == 48 ) )
            return 1; /* Value is valid. */
      return 0; /* Value is not valid. */
}
 
int output2dpng_bpp_default ( void )
{
      return 8;
}
 
#endif      /* not DOXYGEN_BUILD */
 
 
#ifndef     STICK2XYZ_STATIC
/* PNGWrite Module Info Functions */
stick2xyz_pctchar mod_output2d_name ( void )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_name();
      output2djpeg_name();
#endif      /* DOXYGEN_BUILD */
      return output2dpng_name();
}
 
stick2xyz_pctchar mod_output2d_desc ( void )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_desc();
      output2djpeg_desc();
#endif      /* DOXYGEN_BUILD */
      return output2dpng_desc();
}
 
 
void mod_output2d_version ( int * dest )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_version(dest);
      output2djpeg_version(dest);
#endif      /* DOXYGEN_BUILD */
      output2dpng_version(dest);
}
 
int mod_output2d_type ( void )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_type();
      output2djpeg_type();
#endif      /* DOXYGEN_BUILD */
      return output2dpng_type();
}
 
int mod_output2d_multithread_safe ( void )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_multithread_safe();
      output2djpeg_multithread_safe();
#endif      /* DOXYGEN_BUILD */
      return output2dpng_multithread_safe();
}
 
 
void mod_output2d_set_tty ( void * fildescout, void * fildescerr )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_set_tty(fildescout, fildescerr);
      output2djpeg_set_tty(fildescout, fildescerr);
#endif      /* DOXYGEN_BUILD */
      output2dpng_set_tty(fildescout, fildescerr);
}
 
int mod_output2d_quality_range ( struct output2d_qualityinfo * dest )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_qualityrange(dest);
      output2djpeg_qualityrange(dest);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_quality_range(dest);
}
 
uint32_t mod_output2d_quality_valid ( const int value )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_qualityvalid(value);
      output2djpeg_qualityvalid(value);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_quality_valid(value);
}
 
 
size_t mod_output2d_bpp_list ( int * array )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_bpp_list(array);
      output2djpeg_bpp_list(array);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_bpp_list(array);
}
 
int mod_output2d_bpp_supported ( const int value )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_bpp_supported(value);
      output2djpeg_bpp_supported(value);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_bpp_supported(value);
}
 
int mod_output2d_bpp_default ( void )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_bpp_default();
      output2djpeg_bpp_default();
#endif      /* DOXYGEN_BUILD */
      return output2dpng_bpp_default();
}
 
 
output2d_handle mod_pane_to_output2d (
      pane2d_handle pane,
      pane2d_dupdata dupdata,
      pane2d_dupxy dupxy,
      int use_rgb
)
{
      return output2dpng_to_png(pane, dupdata, dupxy, use_rgb);
}
 
output2d_handle mod_paneimage_to_output2d (
      pane2d_handle pane,
      pane2d_dupimage dupimage,
      pane2d_freeimage freedata,
      pane2d_dupxy dupxy,
      int use_rgb
)
{
      return output2dpng_image_to_png(pane, dupimage, freedata, dupxy, use_rgb);
}
 
output2d_handle mod_pane16bytype_to_output2d (
      pane2d_handle pane,
      pane2d_dupfunc_getlist duplist,
      int use_rgb,
      unsigned int filnum
)
{
      return output2dpng_bypng16type(pane, duplist, use_rgb, filnum);
}
 
output2d_handle mod_panebytype_to_output2d (
      pane2d_handle pane,
      pane2d_dupfunc_getlist duplist,
      int use_rgb,
      unsigned int filnum
)
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_bybmptype(pane, duplist, use_rgb, filnum);
      output2djpeg_byjpegtype(pane, duplist, use_rgb, filnum);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_bypngtype(pane, duplist, use_rgb, filnum);
}
 
void mod_output2d_free_handle ( output2d_handle handle )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_free(handle);
      output2djpeg_free(handle);
#endif      /* DOXYGEN_BUILD */
      output2dpng_free(handle);
}
 
int mod_output2d_getnewdata (
      output2d_handle handle,
      unsigned int filnum
)
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_getnewdata(handle, filnum);
      output2djpeg_getnewdata(handle, filnum);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_getnewdata(handle, filnum);
}
 
int mod_output2d_write (
      output2d_handle handle,
      const char * filnam,
      unsigned int filnum,
      int compression
)
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_write(handle, filnam, filnum, compression);
      output2djpeg_write(handle, filnam, filnum, compression);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_write(handle, filnam, filnum, compression);
}
 
#ifdef UNICODE
int mod_output2d_write_w(
      output2d_handle handle,
      const wchar_t * filnam,
      unsigned int filnum,
      int compression
)
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_write_w(handle, filnam, filnum, compression);
      output2djpeg_write_w(handle, filnam, filnum, compression);
#endif      /* DOXYGEN_BUILD */
      return output2dpng_write_w(handle, filnam, filnum, compression);
}
#endif /* UNICODE */
 
 
#ifndef     STICK2XYZ_NO_MODLANGPACKS
void mod_output2d_lang ( stick2xyz_print_ptr newval )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_lang(newval);
      output2djpeg_lang(newval);
#endif      /* DOXYGEN_BUILD */
      output2dpng_lang(newval);
}
#endif      /* not STICK2XYZ_NO_MODLANGPACKS */
 
#ifdef      DEBUG
void mod_output2d_read ( const char * filetoread )
{
      output2dpng_read(filetoread);
}
#endif      /* DEBUG */
 
 
int mod_output2d_init ( int multithread )
{
      return output2dpng_init(multithread);
}
 
int mod_output2d_release ( void )
{
      return output2dpng_release();
}
 
 
#if   defined(HAVE_THREADS_H) | defined(DOXYGEN_BUILD)
int mod_output2d_sigterm ( output2d_sigterm_ready func, int modnumber )
{
#ifdef      DOXYGEN_BUILD
      output2dbmp_sigterm(func, modnumber);
      output2djpeg_sigterm(func, modnumber);
#endif      /* DOXYGEN_BUILD */
 
      return output2dpng_sigterm(func, modnumber);
}
#endif      /* defined(HAVE_THREADS_H) | defined(DOXYGEN_BUILD) */
 
 
#else /* STICK2XYZ_STATIC */
void output2dpng_funcptrs_setup ( struct output2d_funcptrs * ptr )
{
      ptr->output2d_funcptrs_name = &output2dpng_name;
      ptr->output2d_funcptrs_desc = &output2dpng_desc;
      ptr->output2d_funcptrs_version = &output2dpng_version;
      ptr->output2d_funcptrs_type = &output2dpng_type;
 
      ptr->output2d_funcptrs_init = &output2dpng_init;
      ptr->output2d_funcptrs_release = &output2dpng_release;
#ifdef      HAVE_THREADS_H
      ptr->output2d_funcptrs_sigterm = &output2dpng_sigterm;
#else /* not HAVE_THREADS_H */
      ptr->output2d_funcptrs_sigterm = NULL;
#endif      /* not HAVE_THREADS_H */
      ptr->output2d_funcptrs_multithread_safe = &output2dpng_multithread_safe;
 
      ptr->output2d_funcptrs_pane_to_output2d =
            &output2dpng_to_png;
      ptr->output2d_funcptrs_paneimage_to_output2d =
            &output2dpng_image_to_png;
      ptr->output2d_funcptrs_pane16_to_output2d_bytype =
            &output2dpng_bypng16type;
      ptr->output2d_funcptrs_pane_to_output2d_bytype =
            &output2dpng_bypngtype;
      ptr->output2d_funcptrs_getnewdata = &output2dpng_getnewdata;
      ptr->output2d_funcptrs_free_handle = &output2dpng_free;
      ptr->output2d_funcptrs_set_tty = &output2dpng_set_tty;
 
      ptr->output2d_funcptrs_quality_range = &output2dpng_quality_range;
      ptr->output2d_funcptrs_quality_valid = &output2dpng_quality_valid;
 
      ptr->output2d_funcptrs_bpp_list = &output2dpng_bpp_list;
      ptr->output2d_funcptrs_bpp_supported = &output2dpng_bpp_supported;
      ptr->output2d_funcptrs_bpp_default = &output2dpng_bpp_default;
 
#ifdef      UNICODE
      ptr->output2d_funcptrs_write_w = &output2dpng_write_w;
#endif      /* UNICODE */
      ptr->output2d_funcptrs_write = &output2dpng_write;
 
#ifdef      DEBUG
      ptr->output2d_funcptrs_read = &output2dpng_read;
#else /* DEBUG */
      ptr->output2d_funcptrs_read = NULL;
#endif      /* DEBUG */
}
#endif      /* STICK2XYZ_STATIC */