simage.h

Go to the documentation of this file.

#ifndef SIMAGE_H
#define SIMAGE_H
 
/*
 * Copyright (c) Kongsberg Oil & Gas Technologies
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
/***************************************************************************/
 
#define __SIMAGE__
 
#define SIMAGE_VERSION_1_1
 
#define SIMAGE_VERSION_1_2
 
#define SIMAGE_VERSION_1_3
 
#define SIMAGE_VERSION_1_4
 
#define SIMAGE_VERSION_1_5
 
#define SIMAGE_VERSION_1_6
 
#if !defined(SIMAGE_MAJOR_VERSION)
#undef SIMAGE_MAJOR_VERSION
#endif /* !SIMAGE_MAJOR_VERSION */
#if !defined(SIMAGE_MINOR_VERSION)
#undef SIMAGE_MINOR_VERSION
#endif /* !SIMAGE_MINOR_VERSION */
#if !defined(SIMAGE_MICRO_VERSION)
#undef SIMAGE_MICRO_VERSION
#endif /* !SIMAGE_MICRO_VERSION */
#if !defined(SIMAGE_VERSION)
#undef SIMAGE_VERSION
#endif /* !SIMAGE_VERSION */
 
/***************************************************************************/
 
/* Precaution to avoid an error easily made by the application programmer. */
#ifdef SIMAGE_DLL_API
# error Leave the internal SIMAGE_DLL_API define alone.
#endif /* SIMAGE_DLL_API */
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
# ifdef SIMAGE_INTERNAL
#  ifdef SIMAGE_MAKE_DLL
#   define SIMAGE_DLL_API __declspec(dllexport)
#  endif /* SIMAGE_MAKE_DLL */
# else /* !SIMAGE_INTERNAL */
#  ifdef SIMAGE_DLL
#   define SIMAGE_DLL_API __declspec(dllimport)
#  else /* !SIMAGE_DLL */
#   ifndef SIMAGE_NOT_DLL
#    error Define either SIMAGE_DLL or SIMAGE_NOT_DLL as appropriate for your linkage!
#   endif /* SIMAGE_NOT_DLL */
#  endif /* !SIMAGE_DLL */
# endif /* !SIMAGE_INTERNAL */
#endif /* Microsoft Windows */
 
/* Empty define to avoid errors when _not_ compiling an Microsoft Windows DLL. */
#ifndef SIMAGE_DLL_API
# define SIMAGE_DLL_API
#endif /* !SIMAGE_DLL_API */
 
/***************************************************************************/
 
#ifdef __cplusplus
extern "C" {
#endif
 
  SIMAGE_DLL_API void simage_version(int * major, int * minor, int * micro);
 
  SIMAGE_DLL_API int simage_check_supported(const char * filename);
 
  SIMAGE_DLL_API unsigned char * simage_read_image(const char * filename,
                                                   int * width, int * height,
                                                   int * numcomponents);
 
  SIMAGE_DLL_API const char * simage_get_last_error(void);
 
  SIMAGE_DLL_API void simage_free_image(unsigned char * imagedata);
 
  SIMAGE_DLL_API int simage_next_power_of_two(int val);
 
  SIMAGE_DLL_API unsigned char * simage_resize(unsigned char * imagedata,
                                               int width, int height,
                                               int numcomponents,
                                               int newwidth, int newheight);
 
  struct simage_plugin
  {
    unsigned char *(*load_func)(const char * name, int * width, int * height,
                                int * numcomponents);
    int (*identify_func)(const char * filename,
                         const unsigned char * header, int headerlen);
    int (*error_func)(char * textbuffer, int bufferlen);
  };
 
  SIMAGE_DLL_API void * simage_add_loader(const struct simage_plugin * l,
                                          int addbefore);
  SIMAGE_DLL_API void simage_remove_loader(void * handle);
 
 
  /*****************************************************************/
  /**** NOTE: new methods for simage version 1.1 *******************/
  /*****************************************************************/
 
  SIMAGE_DLL_API int simage_check_save_supported(const char * filenameextension);
 
  SIMAGE_DLL_API int simage_save_image(const char * filename,
                                       const unsigned char * bytes,
                                       int w, int h, int numcomponents,
                                       const char * filenameextension);
 
  SIMAGE_DLL_API void * simage_add_saver(int (*save_func)(const char * name,
                                                          const unsigned char * bytes,
                                                          int width, int height, int nc),
                                         int (*error_func)(char * textbuffer, int bufferlen),
                                         const char * extensions,
                                         const char * fullname,
                                         const char * description,
                                         int addbefore);
 
  SIMAGE_DLL_API void simage_remove_saver(void * handle);
  SIMAGE_DLL_API int simage_get_num_savers(void);
  SIMAGE_DLL_API void * simage_get_saver_handle(int idx);
  SIMAGE_DLL_API const char * simage_get_saver_extensions(void * handle);
  SIMAGE_DLL_API const char * simage_get_saver_fullname(void * handle);
  SIMAGE_DLL_API const char * simage_get_saver_description(void * handle);
 
 
  /*****************************************************************/
  /**** NOTE: new methods for simage version 1.2 *******************/
  /*****************************************************************/
 
  typedef struct simage_image_s s_image;
  typedef struct simage_movie_s s_movie;
  typedef struct simage_parameters_s s_params;
  typedef int s_movie_open_func(const char *, s_movie *);
  typedef int s_movie_create_func(const char *, s_movie *, s_params *);
  typedef s_image * s_movie_get_func(s_movie *, s_image *, s_params *);
  typedef int s_movie_put_func(s_movie *, s_image *, s_params *);
  typedef void s_movie_close_func(s_movie *);
 
  SIMAGE_DLL_API s_image * s_image_create(int w, int h, int components,
                                          unsigned char * prealloc /* | NULL */);
  SIMAGE_DLL_API void s_image_destroy(s_image * image);
 
  SIMAGE_DLL_API int s_image_width(s_image * image);
  SIMAGE_DLL_API int s_image_height(s_image * image);
  SIMAGE_DLL_API int s_image_components(s_image * image);
  SIMAGE_DLL_API unsigned char * s_image_data(s_image * image);
  SIMAGE_DLL_API void s_image_set(s_image * image, int w, int h, int components,
                                  unsigned char * data, int copydata);
 
  SIMAGE_DLL_API s_image * s_image_load(const char * filename, s_image * prealloc /* | NULL */);
  SIMAGE_DLL_API int s_image_save(const char * filename, s_image * image,
                                  s_params * params /* | NULL */);
 
  SIMAGE_DLL_API s_movie * s_movie_open(const char * filename);
 
  SIMAGE_DLL_API s_movie * s_movie_create(const char * filename, s_params * params /* | NULL */);
 
  SIMAGE_DLL_API s_image * s_movie_get_image(s_movie * movie, s_image * prealloc /* | NULL */,
                                             s_params * params /* | NULL */);
 
  SIMAGE_DLL_API int s_movie_put_image(s_movie * movie, s_image * image,
                                       s_params * params /* | NULL */);
 
  SIMAGE_DLL_API void s_movie_close(s_movie * movie);
 
  SIMAGE_DLL_API void s_movie_destroy(s_movie * movie);
 
  SIMAGE_DLL_API void s_movie_importer_add(s_movie_open_func * open,
                                           s_movie_get_func * get,
                                           s_movie_close_func * close);
 
  SIMAGE_DLL_API void s_movie_exporter_add(s_movie_create_func * create,
                                           s_movie_put_func * put,
                                           s_movie_close_func * close);
 
  enum {
    S_INTEGER_PARAM_TYPE,
    S_BOOL_PARAM_TYPE = S_INTEGER_PARAM_TYPE,
    S_FLOAT_PARAM_TYPE,
    S_DOUBLE_PARAM_TYPE,
    S_STRING_PARAM_TYPE,
    S_POINTER_PARAM_TYPE,
    S_FUNCTION_PARAM_TYPE
  };
 
  SIMAGE_DLL_API s_params * s_params_create(void);
  SIMAGE_DLL_API s_params * s_params_copy(s_params * params);
  SIMAGE_DLL_API void s_params_destroy(s_params * params);
 
  SIMAGE_DLL_API void s_params_set(s_params * params, ...);
  SIMAGE_DLL_API int s_params_get(s_params * params, ...);
 
  /*****************************************************************/
  /**** NOTE: new methods for simage version 1.3 *******************/
  /*****************************************************************/
 
  SIMAGE_DLL_API unsigned char * simage_resize3d(unsigned char * imagedata,
                                                 int width, int height,
                                                 int numcomponents,
                                                 int layers,
                                                 int newwidth, int newheight,
                                                 int newlayers);
 
  /*****************************************************************/
  /**** NOTE: new methods for simage version 1.4 *******************/
  /*****************************************************************/
 
  typedef struct simage_stream_s s_stream;
  typedef int s_stream_open_func(const char *, s_stream *, s_params *);
  typedef int s_stream_create_func(const char *, s_stream *, s_params *);
  typedef void * s_stream_get_func(s_stream *, void *, int *, s_params *);
  typedef int s_stream_put_func(s_stream *, void *, int, s_params *);
  typedef void s_stream_close_func(s_stream *);
 
  SIMAGE_DLL_API s_stream * s_stream_open(const char * filename,
                                          s_params * params /* | NULL */);
  SIMAGE_DLL_API s_stream * s_stream_create(const char * filename,
                                            s_params * params /* | NULL */);
  SIMAGE_DLL_API void * s_stream_get_buffer(s_stream * stream,
                                            void * prealloc /* | NULL */,
                                            int *size /* | NULL */,
                                            s_params * params /* | NULL */);
  SIMAGE_DLL_API int s_stream_put_buffer(s_stream * stream, void * buffer,
                                         int size,
                                         s_params * params /* | NULL */);
  SIMAGE_DLL_API void s_stream_close(s_stream * stream);
  SIMAGE_DLL_API void s_stream_destroy(s_stream * stream);
  SIMAGE_DLL_API s_params * s_stream_params(s_stream * stream);
 
  SIMAGE_DLL_API void s_stream_importer_add(s_stream_open_func * open,
                                            s_stream_get_func * get,
                                            s_stream_close_func * close);
 
  SIMAGE_DLL_API void s_stream_exporter_add(s_stream_create_func * create,
                                            s_stream_put_func * put,
                                            s_stream_close_func * close);
 
  /*****************************************************************/
  /**** NOTE: new methods for simage version 1.5 *******************/
  /*****************************************************************/
 
  typedef int s_stream_seek_func(s_stream *, int, int, s_params *);
  typedef int s_stream_tell_func(s_stream *, s_params *);
 
  enum {
    SIMAGE_SEEK_SET = 0,
    SIMAGE_SEEK_CUR = 1,
    SIMAGE_SEEK_END = 2
  };
 
 
  SIMAGE_DLL_API int s_stream_seek(s_stream * stream, int offset, int whence,
                                   s_params * params /* | NULL */);
  SIMAGE_DLL_API int s_stream_tell(s_stream *stream,
                                   s_params * params /* | NULL */);
 
  SIMAGE_DLL_API void s_stream_importer_add_ex(s_stream_open_func * open,
                                               s_stream_get_func * get,
                                               s_stream_seek_func * seek,
                                               s_stream_tell_func * tell,
                                               s_stream_close_func * close);
 
  SIMAGE_DLL_API void s_stream_exporter_add_ex(s_stream_create_func * create,
                                               s_stream_put_func * put,
                                               s_stream_seek_func * seek,
                                               s_stream_tell_func * tell,
                                               s_stream_close_func * close);
 
  enum {
    SIMAGE_ORDER_RGB = 0,
    SIMAGE_ORDER_BGR
  };
  SIMAGE_DLL_API int s_image_set_component_order(s_image * image, int order);
  SIMAGE_DLL_API int s_image_get_component_order(s_image * image);
 
  /*****************************************************************/
  /**** NOTE: new methods for simage version 1.6 *******************/
  /*****************************************************************/
 
  SIMAGE_DLL_API s_image * s_image_open(const char * file, int oktoreadall);
  SIMAGE_DLL_API int s_image_read_line(s_image * image,
                                       int line,
                                       unsigned char * buf);
 
  typedef void * s_dlopen_func(const char * filename);
  typedef void * s_dlsym_func(void * handle, const char * symbolname);
  typedef void s_dlclose_func(void * handle);
 
  SIMAGE_DLL_API void s_set_dynamic_loader_interface(s_dlopen_func *dlopen,
                                                     s_dlsym_func *dlsym,
                                                     s_dlclose_func *dlclose);
 
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* ! SIMAGE_H */