DxLibFanに戻る

#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <LIMITS.H>


//**********************************************************
//dKingyoUtility2のソースの一部をドーンと掲載!!!
//BSDライセンスってことにすればいいかな?うん。そーしよ〜
//(BSDライセンスはつまり、バリバリコピペしてOKよ!ってライセンス。
//GPLみたいに再配布のさい、ソース公開しろとかは言わないから凄くGoodなライセンスだと思う。
//(でも説明書に私の名前を書かなくてはいけない・・・とライセンスには書いていたと思った。
//NYSLはパブリックドメインに近い。GoogleでNYSLと検索すれば簡単に見つかる。
//
//説明書等に以下をコピペすればOK
//dKingyoUtility2のソースの一部 2003/09/11 Version
//Licence:BSD Licence かNYSLで。
//auther:d金魚(D.Kingyo)
//hp:http://www3.to/shisui/
//**********************************************************


//**********************************************
//画像関連 
//(注意!まだ不具合があるかも知れません!
//バグが出たら知らせてください。お願いします。
//****************************************


namespace dkutil{

#define DKUTIL_SAFETY_FREE(a) if(a){::free(a);a=NULL;}


/// MessageBoxを表示
#define MB(str) MessageBox(NULL,str,"Message",MB_OK)//MessageBox
///OutputDebugStringを使用
#define ODS(str) OutputDebugString(str)//OutputDebugString

#ifdef _DEBUG
///デバッグ時のみのメッセージボックス
#  define DEBUGMB(s) ::MessageBox(NULL,s,"DEBUG MESSAGE BOX",MB_OK)
///デバッグ時のみのOutputDebugString
#  define DEBUGODS(s) ::OutputDebugString(s)
///デバッグ時のみのassart
#  include <assert.h>
#  define DEBUGASSART(s) assert(s)
#else
#  define DEBUGMB(s)
#  define DEBUGODS(s)
#  define DEBUGASSART(s)
#endif

///GetLastError 可視化
#define VISUAL_LASTERROR() \
{\
  LPVOID lpMsgBuf;\
  FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,\
         NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL );\
  ::MessageBox( NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION );\
  LocalFree( lpMsgBuf );\
}

///画像ファイルを解析する時に使う^^
enum{
  enuDKINGYO_BMPFILEHEADER_ADR = 1,
  enuDKINGYO_BMPCOREHEADER_ADR,
  enuDKINGYO_BMPINFOHEADER_ADR,
  enuDKINGYO_BMPPALLETE_ADR,
  enuDKINGYO_BMPGRAPH_ADR,
  ///isBmpFile()でのflagにぶち込む識別子 Bitmapファイルかどうか正確なチェックを行う。
  enuDKINGYO_ISBMPFILE_EXACT_CHECK,
  ///isBmpFile()でのflagにぶち込む識別子 偽装ビットマップかどうか調べる。
  enuDKINGYO_ISBMPFILE_CAMOUFLAGE_CHECK,
};

//dOpenDialog関数用のフラグ。DialogTypeFlagにぶち込む奴
enum{
  enu_dDialogOpen = 1,
  enu_dDialogSave,
  enu_dDialogTextSave,
};


//汎用??かなぁ?
int LoadWin32APIFile_Proto(char *filename,void *Buff,size_t BuffSize,DWORD *GetReadSize)
{
  HANDLE hFile;
  DWORD dwSize;//ファイルサイズ
    DWORD dwAccBytes;//実際に読み込んだバイトサイズ?

  hFile = CreateFile(filename, GENERIC_READ, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  if(INVALID_HANDLE_VALUE==hFile){
    VISUAL_LASTERROR();
    return -1;
  }
  dwSize = GetFileSize(hFile, NULL);
    
    SetFilePointer(hFile, 0, 0, FILE_BEGIN);

    ReadFile(hFile, Buff, dwSize, &dwAccBytes, NULL);
  *GetReadSize = dwAccBytes;
    if(CloseHandle(hFile) == 0){
     ODS("CloseHandle FAILED");
     VISUAL_LASTERROR();
    return -1;
  }
  return 0;
}
DWORD LoadWin32APIFile(char *filename,void *Buffer,size_t size/*=0*/)
{
  DWORD r_size=0;

  if(0 !=LoadWin32APIFile_Proto(filename,Buffer,size,&r_size))
  {
    return NULL;
  }
  return r_size;
}

bool dGetFileSizeHighLow(char *str,DWORD *high,DWORD *low){
  WIN32_FIND_DATA findData={0};
  HANDLE hFind=NULL;
  // ファイルサイズ取得
  if((hFind = FindFirstFile(str,&findData)) == INVALID_HANDLE_VALUE){
    return false;
  }

  //ファイルのサイズをヴちこむ
  *high = findData.nFileSizeHigh;
  *low = findData.nFileSizeLow;
  FindClose(hFind);
  return true;
}
//ファイルサイズを得る。ロックされたファイルでも得ることが出来るので便利^^;
bool dGetFileSize(char *str,ULONGLONG *GetSize){
  DWORD High=0,Low=0;
  bool result=false;
  result=dGetFileSizeHighLow(str,&High,&Low);
  *GetSize = High*MAXDWORD + Low;
  return result;
}

//ULONG_MAX byte以下のファイルサイズを得る
DWORD dGetFileSizeMini(char *str){
  ULONGLONG Get;
  if(false==dGetFileSize(str,&Get)) return 0;
  if(ULONG_MAX < Get) return 0;
  return static_cast< DWORD >(Get);
}

//汎用?Win32API用保存関数。
int SaveWin32APIFile(char *filename,void *filedata,size_t size){
  HANDLE hFile;
  hFile = CreateFile(filename, GENERIC_WRITE, 0, 0, 
          OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  if(hFile==INVALID_HANDLE_VALUE){
    MB("CreateFile FAILED");
    VISUAL_LASTERROR();//エラー表示マクロ
    return -1;
  }
  SetFilePointer(
    hFile,    // ファイルハンドル 
    0,    // ファイルポインタを移動する距離
    0,    // 距離64ビット分の上位32ビット 
    FILE_BEGIN     // 移動の仕方 
     );
  DWORD dwAccBytes;
  WriteFile(hFile, filedata, size , &dwAccBytes, NULL);
  SetFilePointer(hFile,size,0,FILE_BEGIN);
  SetEndOfFile(hFile);
  FlushFileBuffers(hFile);
  //wsprintf(szTitle, szTitle_org, szFile);
  //SetWindowText(hEdit, szTitle);
  if(CloseHandle(hFile) == 0){
    MB("CloseHandle FAILED");
     VISUAL_LASTERROR();
     return -1;
  }
  return 0;
}


class EasyLoadSaveFile{
private:
  char *buff;
  size_t msize;
public:
  EasyLoadSaveFile(){
    buff=NULL;
    msize=0;
  }
  virtual ~EasyLoadSaveFile(){
    Release();  
  }
  void Release(){
    if(buff){::free(buff);buff=NULL;}
    msize=0;
  }
  int Load(char *filename){
    size_t size = dGetFileSizeMini(filename);
    char *p = (char *)::malloc(size + 1);
    if(!p) return -1;
    ::memset(p,0,size);
    buff = p;
    msize = LoadWin32APIFile(filename,buff,size);
    buff[msize] = NULL;//最後のしるし
  }
  bool isValid(){
    if(!buff){return false;}
    return true;
  }
  int Save(char *filename){
    if(!isValid()){return -1;}
    return SaveWin32APIFile(filename,buff,msize);
  }
  char *GetBuff(){return buff;}
  size_t GetSize(){return msize;}
};
    

/*!
BITMAP構造体についてはMSDNで調べてください。すぐに見つかります。<br>
@param filename ファイルの名前
@param *bm BITMAP構造体のアドレス
*/
///ビットマップの情報を取得します。
extern int dGetBmpInfo(char *filename,BITMAP *bm);

/*!
@param array[in] LoadWin32APIFile等で読み出したビットマップのデータが入っている配列。
@return TRUE = Windows Bitmap FALSE= OS/2 Bitmap -1 = Unknown bitmap
*/
///Windows Bitmapかどうか調べる。
extern int isWindowsBmp(char *array);

/*!
@param array[in] LoadWin32APIFile等で読み出したビットマップのデータが入っている配列。
@return ビットカウント(256色なら8 HighColorなら16等々)を返す
*/
///ビットマップのビットカウント(256色なら8 HighColorなら16等々)を調べる
extern WORD GetBmpBitCount(char *array);

/*!
@param array[in] LoadWin32APIFile等で読み出したビットマップのデータが入っている配列。
@return パレットが含まれていたらtrue 違うならfalse
*/
///パレットが含まれているかどうか調べる
extern bool isBmpPalette(char *array);
/*!
@param array[in] LoadWin32APIFile等で読み出したビットマップのデータが入っている配列。
@return パレットのアドレス。パレットが無かったらNULL
*/
///パレットのアドレスを得る。
extern char *GetBmpPalleteAddress(char *array);
/*!
@param array[in] LoadWin32APIFile等で読み出したビットマップのデータが入っている配列。
@param ets[in] enuDKINGYO_BMPFILEHEADER_ADR等を入れる。詳しくはdkutil_DataStruct.hに書いている。etsに入れたデータが無かったり、Userがアホな値をetsに入れたらNULL
@return etsで指定したUserが欲しがっていたアドレス
*/
///欲しいアドレスを得る
extern char *GetBmpDataAddress(char *array,int ets);
/*!
@param array[in] LoadWin32APIFile等で読み出したビットマップのデータが入っている配列。
@return BITMAPINFOHEADERのアドレスを得る。OS/2でもBITMAPCOREHEADER*に強制型キャストすれば大丈夫かもしれない。
*/
///BITMAPINFOHEADER部を得る
extern BITMAPINFOHEADER *GetBmpInfoHeader(char *array);


///大馬鹿な方法で配列を分からなくする。(プログラマがソースを見れば一撃で分かる!説明はしない。使って欲しくないから。
extern void IdioticalTransform1(int width,int height,int inc,void *point,bool flag,ULONG *seed);
/*!
@param width[in] ビットマップの幅
@param height[in] ビットマップの高さ
@param bmp[in] ビットマップのドット部分のアドレスを入れる
@param *seed[in][out] 種値への変数を入れる。
Bitmapのファイルの最初の"BM"を変えるのではなく、ドットを完全に分からなくして素人では解析できないようにします。<br>

<font color=red>注意:</font><br>
seedに入れた値は変わってしまいます。なので元のseed値はしっかり保存していてください。<br>
また、seedに無理やり定数を入れないで下さい。<br>
*/
///大馬鹿な方法でBitmapを偽装暗号化する。
extern int BmpIdioticalEncode1(int width,int height,int bit,char *bmp,ULONG *seed);

/*!
@param width[in] ビットマップの幅
@param height[in] ビットマップの高さ
@param bmp[in] ビットマップのドット部分のアドレスを入れる
@param *seed[in][out] 種値への変数を入れる。
注意事項はBmpIdioticalEncode1での解説を見てください。
*/
///大馬鹿な方法でBitmapを偽装複合化する。 BmpIdioticalEncode1で暗号化したbitmapを複合化するのに必要。
extern int BmpIdioticalDecode1(int width,int height,int bit,char *bmp,ULONG *seed);



/*!
@param bmpadr[in] Bitmapのメモリアドレス(ファイルから読み込んだ全体であること)
@param bmpadrsize[in] bmpadrのサイズ
@param array[in] 偽装化(多分バーナム暗号)に使う数列
@param arraysize[in] arrayのサイズ
@param WBMPSig[in] WindowsBitmapの時のシグネチャ(識別ID)
@param OS2Sig[in] OS/2だった時のシグネチャ(識別ID)
@return -1==ERROR / 0 == SUCCEEDED
*/

extern int BmpToYourFormat(char *bmpadr,size_t bmpadrsize,char *array,size_t arraysize,
                    short WBMPSig,short OS2Sig);

/*!
@param yourptr[in] あなた式のフォーマットファイルのメモリアドレス(ファイルから読み込んだ全体であること)
@param yourptrsize[in] yourptrのサイズ
@param array[in] 偽装化(多分バーナム暗号)を解除に使う数列(BmpToYourFormat()に使ったものと同じ物を入れること
@param arraysize[in] arrayのサイズ
@param WBMPSig[in] WindowsBitmapの時のシグネチャ(識別ID)(BmpToYourFormat()に使った時のと同じ物にすること
@param OS2Sig[in] OS/2だった時のシグネチャ(識別ID)(BmpToYourFormat()に使った時のと同じ物にすること
@return BmpToYourFormat()を見てクレイ!
@note
BmpToYourFormat()の逆のことをするということを知っていてクレイ!
*/
extern int YourFormatToBmp(char *yourptr,size_t yourptrsize,char *array,size_t arraysize,
                        short WBMPSig,short OS2Sig);

/*!
@param bmpname[in] Bitmapのファイル名
@param wfilename[in] 書き出す時のファイル名
@note
後はBmpToYourFormat()を見てください。(手抜き!?
*/
extern int BmpFileToYourFormatFile(char *bmpname,char *wfilename,char *array,size_t arraysize,
                      short WBMPSig,short OS2Sig);

/*!
@param yourfilename[in] あなた専用のフォーマットのファイル名
@param wbmpfilename[in] ビットマップに書き出す時のファイル名
*/
extern int YourFormatFileToBmpFile(char *yourfilename,char *wbmpfilename,
                            char *array,size_t arraysize,
                            short WBMPSig,short OS2Sig);


///テストです。この関数の中身を見れば偽装暗号化をどのように使うかが分かります。
extern int TestIdioticalEncodeDecode(char *fname);
extern int TestUsefulEncodeDecode(char *bmpname);


}//end of dkutil


namespace dkutil{


template<typename SEED>
inline int arg_rand(SEED *seed)
{
    (*seed) = (*seed) * 1103515245L + 12345;
    return (unsigned)((*seed) / 65536L) % 32768U;
}
inline int arg_random(ULONG *seed,ULONG Max){
  return arg_rand<ULONG>(seed) * Max / SHRT_MAX;
}

int dKingyoOpenFileDialog_Proto(
          LPSTR lpFileName,LPSTR lpPath,LPCTSTR lpstrFilter,
          LPCTSTR lpstrDefExt,HWND hDlg,int DialogTypeFlag)
{
  //UNICODEで便利なようにTCHARって事で^^;
    static TCHAR strFileName[MAX_PATH] = TEXT("");
    static TCHAR strPath[MAX_PATH] = TEXT("");

    if( '\0' == strPath[0] )
    {
      //TCHAR currentdirectorypath[MAX_PATH];
      //::GetCurrentDirectory(MAX_PATH,currentdirectorypath);
      //strncpy( strPath, currentdirectorypath ,MAX_PATH);
      ::GetCurrentDirectory(MAX_PATH,strPath);
    }

    // Setup the OPENFILENAME structur
  OPENFILENAME ofn;
    
  memset(&ofn, 0, sizeof(OPENFILENAME));

  ofn.lStructSize=sizeof(OPENFILENAME);
  ofn.hwndOwner=hDlg;
  ofn.hInstance=NULL; 
  ofn.lpstrCustomFilter=NULL; 
  ofn.nMaxCustFilter=0; 
  ofn.nFilterIndex=1; 
  ofn.nMaxFile=MAX_PATH; 

  ofn.lpstrFileTitle=NULL; 
  ofn.nMaxFileTitle=0; 
  
  
  ofn.nFileOffset=0; 
  ofn.nFileExtension=0; 
  ofn.lCustData=0; 
  ofn.lpfnHook=NULL; 
  ofn.lpTemplateName=NULL; 

  ofn.lpstrFilter=lpstrFilter;
  ofn.lpstrDefExt=lpstrDefExt;
  ofn.lpstrInitialDir=TEXT(strPath); 
  ofn.lpstrFile=TEXT(strFileName);
  
    // Display the OpenFileName dialog. Then, try to load the specified file
  switch(DialogTypeFlag){
  case enu_dDialogOpen:
    ofn.lpstrTitle=TEXT("Open Contents File"); 
    ofn.Flags=OFN_FILEMUSTEXIST|OFN_HIDEREADONLY; 
    if( TRUE != GetOpenFileName( &ofn ) )
    {
      //ファイルが選択されなかった
      return 1;
    }
    break;
  case enu_dDialogSave:
    ofn.lpstrTitle=TEXT("Save Contents File"); 
    ofn.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;
    
    if( TRUE != GetSaveFileName( &ofn ) )
    {
      //案の定選択されなかった^^;
      return 1;
    }
    break;
  case enu_dDialogTextSave:
    char szFile[60*2];
    memset(szFile,0,sizeof(szFile));
    memset(&ofn, 0, sizeof(OPENFILENAME));
    ofn.lStructSize = sizeof(OPENFILENAME);
    ofn.hwndOwner = hDlg;
    ofn.lpstrFilter = "text(*.txt)\0*.txt\0All files(*.*)\0*.*\0\0";
    ofn.lpstrFile = strFileName;
    ofn.lpstrFileTitle = szFile;
    ofn.nFilterIndex = 1;
    ofn.nMaxFile = MAX_PATH;//sizeof(szFileName);
    ofn.nMaxFileTitle = sizeof(szFile);
    ofn.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;
    ofn.lpstrDefExt = "txt";
    ofn.lpstrTitle = "名前を付けてテキストを保存";

    if(GetSaveFileName(&ofn) == 0)//ダイアログ表示
      return -1;//選択されてない。
    break;
  default:
    char *fhfh;
    fhfh="dKingyoOpenFileDialog_Proto Function value of a DialogTypeFlag variable is inaccurate.";
    MB(fhfh);
    return -2;
  }

  //最後に選択したやつは取っておく
  char* strLastSlash = strrchr( strPath, '\\' );
  if(strLastSlash){
    (*strLastSlash) = '\0';
  }
  strncpy( strPath, strFileName ,MAX_PATH);
  
  
  //しっかりコピー
  strncpy(lpFileName,strFileName,MAX_PATH);
  strncpy(lpPath,strPath,MAX_PATH);

  return 0;
}

int dSaveTextFileDialog( LPSTR lpFileName,LPSTR lpPath,HWND hDlg)
{
  return dKingyoOpenFileDialog_Proto(lpFileName,lpPath,
    "text(*.txt)\0*.txt\0All files(*.*)\0*.*\0\0","txt",hDlg,enu_dDialogTextSave);
}

int dOpenFileDialog( LPSTR lpFileName,LPSTR lpPath,LPCTSTR lpstrFilter,LPCTSTR lpstrDefExt,HWND hDlg) 
{
  return dKingyoOpenFileDialog_Proto(lpFileName,lpPath,lpstrFilter,lpstrDefExt,hDlg,enu_dDialogOpen);
}

int dSaveFileDialog( LPSTR lpFileName,LPSTR lpPath,LPCTSTR lpstrFilter,LPCTSTR lpstrDefExt,HWND hDlg)
{
  return dKingyoOpenFileDialog_Proto(lpFileName,lpPath,lpstrFilter,lpstrDefExt,hDlg,enu_dDialogSave);
}

int dGetBmpInfo(char *filename,BITMAP *bm){
//Begin Load BitMap
  HBITMAP hbmp;
  //BITMAP bm;
  //まずリソースからビットマップを読んでみる
  hbmp = (HBITMAP)LoadImage(GetModuleHandle(NULL),filename,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION);

  //なければファイルから
  if(hbmp == NULL){
    hbmp = (HBITMAP)LoadImage(NULL,filename,IMAGE_BITMAP,0,0,LR_LOADFROMFILE|LR_CREATEDIBSECTION);
    if(hbmp == NULL){
      //JPEGやPNGらしい
      return -2;      
    }
  }
  //LoadしたBITMAPの情報を取得するらしい
  GetObject(hbmp,sizeof(*bm),bm);

  //SelectObject(hdcm,dcbmp);
    //DeleteDC(hdcm);
  DeleteObject(hbmp);
  return 0;
}

int isWindowsBmp(char *array){
  long *ptr=(long *)&array[sizeof(BITMAPFILEHEADER)];
  switch(*ptr){
  case 16://OS/2
    return FALSE;
  case 40://Window BITMAP
    return TRUE;
  default://Unknown format
    break;
  }
  return -1;
}

WORD GetBmpBitCount(char *array){
  BITMAPCOREHEADER *ptr=(BITMAPCOREHEADER *)&array[sizeof(BITMAPFILEHEADER)];
  return ptr->bcBitCount;
}

bool isBmpPalette(char *array){
  if(GetBmpBitCount(array) <= 8){
     return false;
  }
  return true;
}

char *GetBmpPalleteAddress(char *array){
  long *ptr=(long *)&array[sizeof(BITMAPFILEHEADER)];
  switch(*ptr){
  case 16://OS/2
    BITMAPCOREHEADER *os2h;
    os2h=(BITMAPCOREHEADER *)ptr;
    if(os2h->bcBitCount <= 8){
      return &array[sizeof(BITMAPFILEHEADER) + sizeof(BITMAPCOREHEADER)];
    }
    break;
  case 40://Window BITMAP
    BITMAPINFOHEADER *bm;
    bm=(BITMAPINFOHEADER *) ptr;
    if(bm->biBitCount >= 8){
      return &array[sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)];
    }
    break;
  default://Unknown format
    break;
  }
  return NULL;
}

char *GetBmpDataAddress(char *array,int ets){
  switch(ets){
  case enuDKINGYO_BMPFILEHEADER_ADR:
    return array;
  case enuDKINGYO_BMPCOREHEADER_ADR:
  case enuDKINGYO_BMPINFOHEADER_ADR:
    return &array[sizeof(BITMAPFILEHEADER)];
  case enuDKINGYO_BMPPALLETE_ADR:
    return GetBmpPalleteAddress(array);
  case enuDKINGYO_BMPGRAPH_ADR:
    //Windows BMP
    if(TRUE==isWindowsBmp(array)){
      DWORD offset=sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) ;
      if(true == isBmpPalette(array)){
        
        switch(GetBmpBitCount(array)){
        case 8:
          offset +=  sizeof(RGBQUAD) * 256;
          break;
        case 4:
          offset += sizeof(RGBQUAD) * 16;
          break;
        case 1:
          offset += sizeof(RGBQUAD) * 2;
          break;
        default:
          return NULL;
        }
      }
      return &array[offset];
    }
    // OS /2
    if(FALSE==isWindowsBmp(array)){
      DWORD offset=sizeof(BITMAPFILEHEADER) + sizeof(BITMAPCOREHEADER) ;
      if(true==isBmpPalette(array)){
        switch(GetBmpBitCount(array)){
        case 8:
          offset +=  sizeof(RGBTRIPLE) * 256;
          break;
        case 4:
          offset += sizeof(RGBTRIPLE) * 16;
          break;
        case 1:
          offset += sizeof(RGBTRIPLE) * 2;
          break;
        default:
          return NULL;
        }
      }
      return &array[offset];
    }
    break;
  default:
    break;
      
  }
  return NULL;
}

BITMAPINFOHEADER *GetBmpInfoHeader(char *array){
  return (BITMAPINFOHEADER *)
    (GetBmpDataAddress(array,enuDKINGYO_BMPINFOHEADER_ADR));
}


void IdioticalTransform1(int width,int height,int inc,void *point,bool flag,ULONG *seed){
  char *cb=(char *)point;
  UINT endc = inc * (width * height);
  for(UINT i=0;i<endc;i++){
    cb[i] += (flag) ? arg_random(seed,UCHAR_MAX) : - arg_random(seed,UCHAR_MAX);
  }
}

int BmpIdioticalEncode1(int width,int height,int bit,char *bmp,ULONG *seed){
  if(!(bit==8 || bit==16 || bit==24 || bit==32))
    return -1;//知るか!ヴぉけ!
  int inc=0;
  char *cb=(char *)bmp;

  //もっとエレガントな方法はないかな〜。ビット演算苦手なんです(TT
  /*switch(bit){
  case 32:
    inc=4;
    break;
  case 16:
    inc=2;
    break;
  case 8:
  default:
    inc=1;
    break;
  }*/
  //inc=GetIncByte<bit>::value;
  inc=bit/8;//これがまぁまぁ^^;ってとこか。
  IdioticalTransform1(width,height,inc,bmp,true,seed);

  return 0;

}


int BmpToYourFormat(char *bmpadr,size_t bmpadrsize,char *array,size_t arraysize,
                    short WBMPSig,short OS2Sig)
{
  size_t bmphsize;
  short sig = 0;
  int isWB = isWindowsBmp(bmpadr);
  if(isWB==TRUE)
  {//Windows Bitmapなら
    bmphsize = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);
    sig = WBMPSig;
  }else if(isWB == FALSE)
  {//OS/2なら
    bmphsize = sizeof(BITMAPCOREHEADER) + sizeof(BITMAPFILEHEADER);
    sig = OS2Sig;
  }else if(isWB == -1)
  {//ERROR
    return -1;
  }
  //まぁ、こんなバカはいないと思いますが・・・
  if(arraysize==0 || array == NULL || bmpadrsize < bmphsize || bmpadr==NULL){
    return -1;
  }
  //シグネチャ分をちょっと引く
  bmphsize -= sizeof(short);
  short *sigset = (short *)bmpadr;
  (*sigset) = sig;//シグネチャを入れる。
  //偽装化
    //ポイントを保存。
  char *point = bmpadr + sizeof(short);
  size_t array_count = 0;
  for(int i=0;i<bmphsize;i++)
  {
    point[i] += array[array_count];
    if(array_count >= arraysize){
      array_count = 0;
    }
    array_count++;
  }
  //成功
  return 0;
}

int YourFormatToBmp(char *yourptr,size_t yourptrsize,char *array,size_t arraysize,
                        short WBMPSig,short OS2Sig)
{
  size_t bmphsize;
  short *sigset = (short *)yourptr;
  if(*sigset==WBMPSig){
    bmphsize = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);
  }else if(*sigset==OS2Sig){
    bmphsize = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);
    
  }else{
    return -1;
  }
  //error check
  if(arraysize==0 || array == NULL || yourptrsize < bmphsize || yourptr==NULL){
    return -1;
  }
  //元のシグネチャに戻す
  *sigset = 0x4D42;//BM
  //シグネチャ分をちょっと引く
  bmphsize -= sizeof(short);
  //シグネチャ分移動
  char *point = yourptr + sizeof(short);
  size_t array_count = 0;
  //ッてことで復元
  for(int i=0;i<bmphsize;i++)
  {
    point[i] -= array[array_count];
    if(array_count >= arraysize){
      array_count = 0;
    }
    array_count++;
  }
  return 0;
}



int BmpFileToYourFormatFile(char *bmpname,char *wfilename,char *array,size_t arraysize,
                      short WBMPSig,short OS2Sig)
{
  EasyLoadSaveFile f;
  f.Load(bmpname);
  int r = BmpToYourFormat(f.GetBuff(),f.GetSize(),array,arraysize,WBMPSig,OS2Sig);
  if(r == -1) return -1;
  f.Save(wfilename);  
  return 0;
}

int YourFormatFileToBmpFile(char *yourfilename,char *wbmpfilename,
                            char *array,size_t arraysize,
                            short WBMPSig,short OS2Sig)
{
  EasyLoadSaveFile f;
  f.Load(yourfilename);
  int r = YourFormatToBmp(f.GetBuff(),f.GetSize(),array,arraysize,WBMPSig,OS2Sig);
  if(r == -1) return -1;
  f.Save(wbmpfilename);  
  return 0;
}



int BmpIdioticalDecode1(int width,int height,int bit,char *bmp,ULONG *seed){
  if(!(bit==8 || bit==16 || bit==24 || bit==32))
    return -1;//知るか!ヴぉけ!
  int inc=bit/8;
  char *cb=(char *)bmp;

  IdioticalTransform1(width,height,inc,bmp,false,seed);
  return 0;
}

int TestUsefulEncodeDecode(char *bmpname){
  const int keysize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
  char *wname = "TestUsefulEncodeDecode.bin";
  char key[keysize];

  for(int i=0;i<keysize;i++)
  {
    key[i] = rand();//乱数でキーファイルを作成
  }

  //独自シグネチャの指定
  short WBMPSig = 1;
  short OS2Sig = 0;
  //エンコード
  {
    int result;
    
    result = BmpFileToYourFormatFile(
      bmpname,wname,
      key,keysize,WBMPSig,OS2Sig);

    if(result == -1){
      MB("ERROR ENCODE");
      return -1;
    }
  }
  //デコード
  {
    int result;
    
    result = YourFormatFileToBmpFile(
      wname,"ResultTestUsefulEncodeDecode.bmp",
      key,keysize,WBMPSig,OS2Sig);

    if(result == -1){
      MB("ERROR DECODE");
      return -1;
    }
  }
}


int TestIdioticalEncodeDecode(char *fname){
  ULONGLONG Size;
  bool br;
  int r=-1;
  //ファイルサイズをゲットする
  br=dGetFileSize(fname,&Size);
  if(br==false) return -1;

  //メモリを確保する
  void *buff = malloc((size_t)Size);
  size_t buffsize = Size;
  if(!buff) return r;

  {
    //BMPファイルをロードする
    LoadWin32APIFile(fname,buff,buffsize);
    
    //OS /2 のBITMAPについては無視する
    BITMAPINFOHEADER *info = GetBmpInfoHeader((char *)buff);
    //乱数の種をセット
    ULONG seed = 100;
    //大馬鹿な暗号化を開始
    char *dotadr = GetBmpDataAddress((char *)buff,enuDKINGYO_BMPGRAPH_ADR);
    if(dotadr==NULL) goto end;
    BmpIdioticalEncode1(info->biWidth,info->biHeight,info->biBitCount,
      dotadr
      ,&seed);

    //そして、セーブ
    SaveWin32APIFile("ok.bmp",buff,buffsize);
  }

  {
    //もっかい読み込んでみる
    LoadWin32APIFile("ok.bmp",buff,buffsize);

    BITMAPINFOHEADER *info = GetBmpInfoHeader((char *)buff);

    //大馬鹿な複合化を開始
    ULONG seed=100;
    char *dotadr = GetBmpDataAddress((char *)buff,enuDKINGYO_BMPGRAPH_ADR);
    if(dotadr==NULL) goto end;
    BmpIdioticalDecode1(info->biWidth,info->biHeight,info->biBitCount,
      dotadr,&seed);

    //保存してみる
    SaveWin32APIFile("ok2.bmp",buff,buffsize);
  }

  r=0;//成功したらしい
end:
  //メモリを開放する
  if(buff){free(buff);buff=NULL;}
  //そして値を返す。−1だとエラー
  return r;
}



int BitmapEncodeDecode02(char *key,size_t keysize,
                         short WindowsBitmapSignature,short OS2Signature)
{
  int r=MessageBox(NULL,"暗号化するならば”はい”複合化するなら”いいえ”",
    "StudioKingyo Bitmap Encode Decode Version 02",MB_YESNO);
  char filename[MAX_PATH]="";
  char writefilename[MAX_PATH]="";
  char path[MAX_PATH]="";
  char *all_filter="All files(*.*)\0*.*\0\0";
  char *filter="Windows Bitmap(*.bmp)\0*.bmp\0All files(*.*)\0*.*\0\0";
  char *DefExt="bmp = Bitmap";
  char *AllDefExt="ALL FILE";
  

  if(r==IDYES)
  //エンコード
  {
    int result;
    int opened;
    opened= dOpenFileDialog(filename,path,filter,DefExt,NULL);
    if(opened != 0)
      return 1;//選択されなかった
    opened= dSaveFileDialog(writefilename,path,all_filter,AllDefExt,NULL);
    if(opened != 0)
      return 1;//選択されなかった
    result = BmpFileToYourFormatFile(
      filename,writefilename,
      key,keysize,
      WindowsBitmapSignature,OS2Signature);

    if(result == -1){
      MB("ERROR ENCODE");
      return -1;
    }
  }else
  //デコード
  {
    int result;
    int opened;
    opened= dOpenFileDialog(filename,path,all_filter,AllDefExt,NULL);
    if(opened != 0)
      return 1;//選択されなかった
    opened= dSaveFileDialog(writefilename,path,filter,DefExt,NULL);
    if(opened != 0)
      return 1;//選択されなかった
    result = YourFormatFileToBmpFile(
      filename,writefilename,
      key,keysize,WindowsBitmapSignature,OS2Signature);

    if(result == -1){
      MB("ERROR DECODE");
      return -1;
    }
  }
  return 0;
}


}//end of dkutil namespace


int main(){
  //面倒なので、アルファベットがかぎで・・・(本当は乱数列使うんだよ!
  char *key="ABCDEFGHIJKLMNOPQRSTLVWXYZ";
  short WinSig = 4321;
  short OS2Sig = 1234;
  dkutil::BitmapEncodeDecode02(key,strlen(key),WinSig,OS2Sig);
}
SEO [PR] 爆速!無料ブログ 無料ホームページ開設 無料ライブ放送