buffer.cpp

/* Mondschein Engine is a fast, powerful, and easy-to-use 3D realtime rendering engine.
 *
 * Copyright (C) 2009-2013 by Andreas Amereller
 * E-Mail: andreas.amereller.dev@googlemail.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, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "freeimage/buffer.h"
#include "core/texture.h"

using namespace mondschein;
using namespace io;

void FreeImageErrorHandler(FREE_IMAGE_FORMAT fif, const char *message)
{
  std::cerr<<"FreeImage ERROR: "<<message<<std::endl;
  return;
}

FI_Buffer::FI_Buffer() : Buffer(), format(FIF_UNKNOWN)
{
  return;
}

FI_Buffer::FI_Buffer(FI_Buffer_c _b) : Buffer(_b), format(_b->format)
{
  FreeImage_SetOutputMessage(FreeImageErrorHandler);
  return;
}

FI_Buffer::FI_Buffer(FREE_IMAGE_FORMAT _format) : Buffer(), format(_format)
{
  FreeImage_SetOutputMessage(FreeImageErrorHandler);
  return;
}

FI_Buffer::~FI_Buffer()
{
  return;
}

FI_Buffer &FI_Buffer::operator=(FI_Buffer_c _b)
{
  Buffer::operator=(_b);
  format=_b->format;
  return *this;
}

void FI_Buffer::parse_istream(std::istream &_in)
{
  std::string content;
  while (_in.good())
  {
    content+=_in.get();
  }
  if (content.empty()) return;
  try
  {
    parse_string(content);
  }
  catch (exception &e)
  {
    std::string err(*boost::get_error_info<exception_error>(e));
    err+=", called in function\n\tvoid mondschein::io::FI_Buffer::parse_istream(const std::istream& _in)";
    throw boost::enable_current_exception(e) << exception_error(err);
  }
  return;
}

void FI_Buffer::parse_string(const std::string &_in)
{
  // Load the image
  #ifdef DEBUG_0_3
  std::cout<<"Mondschein Engine DEBUG: Loading image \"FI_Texture\"...\nParameter info:\nLength: "<<_in.size()<<std::endl;
  #ifdef DEBUG_LONG
  std::cout<<"Data: "<<_in<<std::endl;
  #else
  std::cout<<"Data: <shorted out>"<<std::endl;
  #endif // DEBUG_LONG
  #endif // DEBUG_0_3
  BYTE *str=new BYTE[_in.size()];
  for (uint i=0;i<_in.size();++i) str[i]=_in.at(i);
  FIMEMORY *buffer=FreeImage_OpenMemory(str,_in.size());
  if (buffer==nullptr)
  {
    std::string err("Mondschein Engine ERROR: Error while opening memory buffer. Exception raised in function\n\t");
    err+="void mondschein::io::FI_Buffer::parse_string(const std::string& _in)";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
  FIBITMAP *image=nullptr;
  if (format == FIF_UNKNOWN) format=FreeImage_GetFileTypeFromMemory(buffer,_in.size());
  if (format == FIF_UNKNOWN)
  {
    std::string err("Mondschein Engine ERROR: Could not detect any valid file format. ");
    err+="Exception raised in function\n\t";
    err+="void mondschein::io::FI_Buffer::parse_string(const std::string& _in)";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
  if (FreeImage_FIFSupportsReading(format))
  {
    image=FreeImage_LoadFromMemory(format,buffer);
    if (image==nullptr)
    {
      std::string err("Mondschein Engine ERROR: Error while loading image. Exception raised in function\n\t");
      err+="void mondschein::io::FI_Buffer::parse_string(const std::string& _in)";
      throw boost::enable_current_exception(exception()) << exception_error(err);
    }
  }
  else
  {
    std::string err("Mondschein Engine ERROR: File format plugin <");
    err+=FreeImage_GetFormatFromFIF(format);
    err+="> does not support reading. ";
    err+="Exception raised in function\n\t";
    err+="void mondschein::io::FI_Buffer::parse_string(const std::string& _in)";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
  FreeImage_CloseMemory(buffer);
  delete[] str;

  // Convert FreeImage bitmap to texture object
  if (FreeImage_GetImageType(image)!=FIT_BITMAP) image=FreeImage_ConvertToStandardType(image,true);
  uint8 *tmp=static_cast<uint8 *>(FreeImage_GetBits(image));
  uint32 s=FreeImage_GetWidth(image)*FreeImage_GetHeight(image)*FreeImage_GetBPP(image)/8;
  std::vector<uint8> data(s);
  for (uint32 i=0; i<s; ++i)
  {
    data.at(i)=tmp[i];
  }
  scene::texture_attribs_t texture(FreeImage_GetWidth(image),FreeImage_GetHeight(image),FreeImage_GetBPP(image),
                    !FreeImage_IsLittleEndian(),ONN,0,0,data);

  #ifdef DEBUG_0_3
  std::cout<<"Mondschein Engine DEBUG: Loaded texture \"FI_Texture\":\nWidth: "<<texture.width;
  std::cout<<"\nHeight: "<<texture.height<<"\nBPP: "<<(int)texture.bpp<<"\nRGB: "<<texture.rgb<<"\nTexture filter: ";
  std::cout<<texture.texture_filter<<"\nAnisotrpic filter: "<<(int)texture.anisotropic_filter<<std::endl;
  #ifdef DEBUG_LONG
  std::cout<<"Data: ";
  for (uint i=0;i<texture.data.size();++i) std::cout<<texture.data.at(i);
  std::cout<<std::endl;
  #else
  std::cout<<"<shorted out>"<<std::endl;
  #endif // DEBUG_LONG
  #endif // DEBUG_0_3

  FreeImage_Unload(image);
  io_objects_t result=get_io_objects();
  result.nodes.insert(std::make_pair("ID_FI_TEXTURE",scene::Texture_p(new scene::Texture("ID_FI_TEXTURE",texture))));
  set_io_objects(result);
  return;
}

void FI_Buffer::serialize_ostream(std::ostream &_out) const
{
  std::string content;
  try
  {
    serialize_string(content);
  }
  catch (exception &e)
  {
    std::string err(*boost::get_error_info<exception_error>(e));
    err+=", called in function\n\tvoid mondschein::io::FI_Buffer::parse_istream(const std::istream& _in)";
    throw boost::enable_current_exception(e) << exception_error(err);
  }
  _out<<content;
  return;
}

void FI_Buffer::serialize_string(std::string &_out) const
{
  // Convert texture object into FreeImage bitmap
  scene::Texture_p tmp=boost::dynamic_pointer_cast<scene::Texture>(get_io_objects().nodes.at("FI_Texture"));
  if (tmp.get()==NULL)
  {
    std::string err("Mondschein Engine ERROR: No Element \"FI_Texture\" or \"FI_Texture\" is not a texture node. ");
    err+="Exception raised in function\n\t";
    err+="void mondschein::io::FI_Buffer::serialize_string(std::string &_out) const";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
  scene::texture_attribs_t texture=tmp->get_texture_attribs();
  FIBITMAP *image=FreeImage_Allocate(texture.width,texture.height,texture.bpp);
  uint8 *data=static_cast<uint8 *>(FreeImage_GetBits(image));
  uint32 s=texture.width*texture.height*texture.bpp;
  for (uint32 i=0; i<s; ++i)
  {
    data[i]=texture.data.at(i);
  }

  // Write image data to memory buffer
  char str[FreeImage_GetDIBSize(image)];
  FIMEMORY *buffer=FreeImage_OpenMemory(reinterpret_cast<BYTE *>(data),FreeImage_GetDIBSize(image));
  if (format == FIF_UNKNOWN)
  {
    if (FreeImage_FIFSupportsWriting(FIF_JPEG)) FreeImage_SaveToMemory(FIF_JPEG,image,buffer);
  }
  else
  {
    if (FreeImage_FIFSupportsWriting(format)) FreeImage_SaveToMemory(format,image,buffer);
  }
  FreeImage_CloseMemory(buffer);
  _out=str;
  return;
}

void FI_Buffer::set_format(FREE_IMAGE_FORMAT _format)
{
  format=_format;
  return;
}

FREE_IMAGE_FORMAT FI_Buffer::get_format() const
{
  return format;
}