text: #include "tenv.h"
  #include "tsystem.h"
  
  #include "ino_common.h"
  
  /* copy and paste from
   igs_ifx_common.h */
  namespace igs {
  namespace image {
  namespace rgba {
  enum num { blu = 0, gre, red, alp, siz };
  }
  }
  }
  //------------------------------------------------------------
  namespace {
  // T is TPixel32 or TPixel64
  // U is unsigned char or unsigned short
  template <class T, class U>
  void ras_to_arr_(const TRasterPT<T> ras, U *arr, const int channels) {
    using namespace igs::image::rgba;
  
    for (int yy = 0; yy < ras->getLy(); ++yy) {
      const T *ras_sl = ras->pixels(yy);
      for (int xx = 0; xx < ras->getLx(); ++xx, arr += channels) {
        if (red < channels) {
          arr[red] = ras_sl[xx].r;
        }
        if (gre < channels) {
          arr[gre] = ras_sl[xx].g;
        }
        if (blu < channels) {
          arr[blu] = ras_sl[xx].b;
        }
        if (alp < channels) {
          arr[alp] = ras_sl[xx].m;
        }
      }
    }
  }
  template <class U, class T>
  void arr_to_ras_(const U *arr, const int channels, TRasterPT<T> ras,
                   const int margin  // default is 0
                   ) {
    arr +=
        (ras->getLx() + margin + margin) * margin * channels + margin * channels;
  
    using namespace igs::image::rgba;
  
    for (int yy = 0; yy < ras->getLy();
         ++yy, arr += (ras->getLx() + margin + margin) * channels) {
      const U *arrx = arr;
      T *ras_sl     = ras->pixels(yy);
      for (int xx = 0; xx < ras->getLx(); ++xx, arrx += channels) {
        if (red < channels) {
          ras_sl[xx].r = arrx[red];
        }
        if (gre < channels) {
          ras_sl[xx].g = arrx[gre];
        }
        if (blu < channels) {
          ras_sl[xx].b = arrx[blu];
        }
        if (alp < channels) {
          ras_sl[xx].m = arrx[alp];
        }
      }
    }
  }
  }
  //--------------------
  void ino::ras_to_arr(const TRasterP in_ras, const int channels,
                       unsigned char *out_arr) {
    if ((TRaster32P)in_ras) {
      ras_to_arr_<TPixel32, unsigned char>(in_ras, out_arr, channels);
    } else if ((TRaster64P)in_ras) {
      ras_to_arr_<TPixel64, unsigned short>(
          in_ras, reinterpret_cast<unsigned short *>(out_arr), channels);
    }
  }
  void ino::arr_to_ras(const unsigned char *in_arr, const int channels,
                       TRasterP out_ras, const int margin) {
    if ((TRaster32P)out_ras) {
      arr_to_ras_<unsigned char, TPixel32>(in_arr, channels, out_ras, margin);
    } else if ((TRaster64P)out_ras) {
      arr_to_ras_<unsigned short, TPixel64>(
          reinterpret_cast<const unsigned short *>(in_arr), channels, out_ras,
          margin);
    }
  }
  //--------------------
  void ino::ras_to_vec(const TRasterP in_ras, const int channels,
                       std::vector<unsigned char> &out_vec) {
    out_vec.resize(
        in_ras->getLy() * in_ras->getLx() * channels *
        (((TRaster64P)in_ras) ? sizeof(unsigned short) : sizeof(unsigned char)));
    ino::ras_to_arr(in_ras, channels, &out_vec.at(0));
  }
  void ino::vec_to_ras(std::vector<unsigned char> &in_vec, const int channels,
                       TRasterP out_ras, const int margin  // default is 0
                       ) {
    ino::arr_to_ras(&in_vec.at(0), channels, out_ras, margin);
    in_vec.clear();
  }
  //--------------------
  #if 0   //---
  void ino::Lx_to_wrap( TRasterP ras ) {
  	/*
  	ras->getLx()   : 描画の幅
  	ras->getWrap() : データの存在幅
  	描画幅よりデータの存在幅の方が大きい場合、
  	存在幅位置に置き直し、残りをゼロクリア
  	*/
  	if ( ras->getWrap() <= ras->getLx() ) { return; }
  
  	const int rowSize  = ras->getLx()   * ras->getPixelSize();
  	const int wrapSize = ras->getWrap() * ras->getPixelSize();
  	const int restSize = wrapSize - rowSize;
  	const UCHAR *rowImg  = ras->getRawData()+rowSize *(ras->getLy()-1);
  	      UCHAR *wrapImg = ras->getRawData()+wrapSize*(ras->getLy()-1);
  	for (int yy = 0; yy < ras->getLy(); ++yy) {
  		::memcpy(wrapImg, rowImg, rowSize);
  		::memset(wrapImg+rowSize, 0, restSize); /* 上下にはみ出すとここで落ちる */
  		rowImg  -= rowSize;
  		wrapImg -= wrapSize;
  	}
  }
  #endif  //---
  
  //------------------------------------------------------------
  namespace {
  bool enable_sw_ = true;
  bool check_sw_  = true;
  }
  bool ino::log_enable_sw(void) {
    if (check_sw_) {
      TFileStatus file(
          // ToonzFolder::getProfileFolder()
          TEnv::getConfigDir() + "fx_ino_no_log.setup");
      if (file.doesExist()) {
        enable_sw_ = false;
      }
  
      check_sw_ = false;
    }
    return enable_sw_;
  }
  