dctwaterdoc.cpp

站长！这是DCT域的图像数字水印嵌入及提取程序！请查收！暂归入加密解密类别！

// DCTWaterDoc.cpp : implementation of the CDCTWaterDoc class
//

#include "stdafx.h"
#include "DCTWater.h"

#include "DCTWaterDoc.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CDCTWaterDoc

IMPLEMENT_DYNCREATE(CDCTWaterDoc, CDocument)

BEGIN_MESSAGE_MAP(CDCTWaterDoc, CDocument)
	//{{AFX_MSG_MAP(CDCTWaterDoc)
    ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_AS, OnUpdateFileSaveAs)
	ON_UPDATE_COMMAND_UI(ID_FILE_PRINT, OnUpdateFilePrint)
	ON_UPDATE_COMMAND_UI(ID_FILE_PRINT_PREVIEW, OnUpdateFilePrintPreview)
	ON_UPDATE_COMMAND_UI(ID_FILE_PRINT_SETUP, OnUpdateFilePrintSetup)
	ON_UPDATE_COMMAND_UI(ID_EMBED_EMBED, OnUpdateEmbedEmbed)
	ON_UPDATE_COMMAND_UI(ID_EXTRACT_EXTRACT, OnUpdateExtractExtract)
	ON_COMMAND(ID_EMBED_MEHOD1, OnEmbedMehod1)
	ON_COMMAND(ID_EMBED_MEHOD2, OnEmbedMehod2)
	ON_COMMAND(ID_EMBED_MEHOD3, OnEmbedMehod3)
	ON_COMMAND(ID_EMBED_MEHOD4, OnEmbedMehod4)
	ON_UPDATE_COMMAND_UI(ID_EMBED_MEHOD1, OnUpdateEmbedMehod1)
	ON_UPDATE_COMMAND_UI(ID_EMBED_MEHOD2, OnUpdateEmbedMehod2)
	ON_UPDATE_COMMAND_UI(ID_EMBED_MEHOD3, OnUpdateEmbedMehod3)
	ON_UPDATE_COMMAND_UI(ID_EMBED_MEHOD4, OnUpdateEmbedMehod4)
	ON_COMMAND(ID_EMBED_MEHOD5, OnEmbedMehod5)
	ON_UPDATE_COMMAND_UI(ID_EMBED_MEHOD5, OnUpdateEmbedMehod5)
	ON_COMMAND(ID_EMBED_MEHOD6, OnEmbedMehod6)
	ON_UPDATE_COMMAND_UI(ID_EMBED_MEHOD6, OnUpdateEmbedMehod6)
	ON_UPDATE_COMMAND_UI(ID_EMBED_EMBED, OnUpdateEmbedEmbed)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDCTWaterDoc construction/destruction

CDCTWaterDoc::CDCTWaterDoc()
{
	// TODO: add one-time construction code here
///////////My code begins:to initialize the member/////////
    Success=TRUE;
	long int fh;
    LPBITMAPFILEHEADER bitfile;
    LPBITMAPINFOHEADER bitinfo;
    //open the standard file
	fh=_open("standard.dat",_O_RDONLY|_O_BINARY);
	if(fh==-1)
	{
		MessageBox(NULL,"Can not Find or Open the Standard [standard.dat]!","Initialize the Program",MB_ICONSTOP|MB_OK);
		Success=FALSE;
	}
    //Read file
    if(_read(fh,m_StandardBmpInfo,1078)==-1)
    {
	  _close(fh);   
      MessageBox(NULL,"Failure in Reading Standard [standard.dat]!","Initialize the Program",MB_ICONSTOP|MB_OK);
	  Success=FALSE;
    }
    _close(fh);   
    //Read Infomation
	bitfile=(LPBITMAPFILEHEADER)m_StandardBmpInfo;
    bitinfo=(LPBITMAPINFOHEADER)(m_StandardBmpInfo+sizeof(BITMAPFILEHEADER));
    //Judge the information of the standard file
	if(bitfile->bfType!=0x4d42||bitfile->bfOffBits!=1078||bitinfo->biBitCount!=8||bitinfo->biCompression!=0)
	{
		MessageBox(NULL,"Pattern Error in Standard File [standard.dat]!","Initialize the Program",MB_ICONSTOP|MB_OK);
		Success=FALSE;
	}
    //Get the current working directory
	GetCurrentDirectory(_MAX_PATH,m_CurrentDirectory);	
//////=====Inital Variables for watermark preprocessing=====/////////////  	
    //clear the original watermark opened flag
	m_OriginalWatermarkOpened=FALSE;
	m_OriginalWatermarkOpened1=FALSE;
	//clear the watermark permuted flag
	m_Permuted=FALSE;
	m_Permuted1=FALSE;
//////=====Inital Variables for encode&embed======/////////////  	
	//The method
	m_EmbedMethod=2;
	//The image size to be encoded to be initialized as 0
	m_OriginalImageSize=0;
	//The image width to be encoded to be initialized as 0
	m_OriginalImageWidth=0;
	//The image height to be encoded to be initialized as 0
	m_OriginalImageHeight=0;
	//clear the encode finished flag
	m_Embeded0=FALSE;
	m_Embeded1=FALSE;

//////=====Inital Variables for extraction======/////////////  	
	//clear the extraction finished flag
	m_Extracted=FALSE;
//////=====Inital Variables for attacking======/////////////  	
	//clear the attacked watermark extracted flag
	m_AttackExtracked=FALSE;
	//clear the attacked image opened flag
	m_AttackedImageOpened=FALSE;
////////////My code ends:to initialize the member/////////
    Keymem=GlobalAlloc(GMEM_FIXED,16384*2*sizeof(long int));//Apply the required memory
    ////If memory is not enough, return directly
    if(Keymem==NULL)
	{ 
      MessageBox(NULL,"Sorry！Not Enough Memory!","Intial",MB_ICONSTOP|MB_OK);//Display the information
	  return;
    }
   keyA=(long int *)Keymem;//Give the memory pointer to the file data pointer
   keyB=keyA+16384;
}

CDCTWaterDoc::~CDCTWaterDoc()
{
  GlobalFree(Keymem);
}

BOOL CDCTWaterDoc::OnNewDocument()
{
    if (!CDocument::OnNewDocument()||Success==FALSE)
		return FALSE;
	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)
	return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
// CDCTWaterDoc serialization

void CDCTWaterDoc::Serialize(CArchive& ar)
{
	
    unsigned long int i;
	if (ar.IsStoring())
	{
		// TODO: add storing code here	

///////////My code begins////////////////////		
		//save the file according to the length
		i=m_OriginalImageSize;
		if((i==512*512)||(i==256*256)||(i==320*240)||(i==MAXIMAGESIZE))
           ar.Write(m_OriginalImageBytes,i);
		//If the length is not suitable, set the image size as 0
		else
		{
		   m_OriginalImageSize=0;
		   MessageBox(NULL,"The File You Saved Is Invalid","Save As",MB_OK|MB_ICONINFORMATION);
		}
///////////My code ends////////////////////
	}
	else
	{
		// TODO: add loading code here
        
///////////My code begins////////////////////		
		//Clear the encode/decode finished flag
		m_Embeded0=0;
    	m_Embeded1=0;

		m_Extracted=FALSE;
		CFile *fp;
		LPBITMAPFILEHEADER bitfile;
	    LPBITMAPINFOHEADER bitinfo;
	    //Get the file pointer
		fp=ar.GetFile();
		//Get the Image Size
		m_OriginalImageSize=fp->GetLength();
		//Get the width and height of the opened image
		switch(m_OriginalImageSize)
		{
		   case 512*512:
			   m_OriginalImageWidth=512;
			   m_OriginalImageHeight=512;
			   break;
		   case 256*256:
			   m_OriginalImageWidth=256;
			   m_OriginalImageHeight=256;
			   break;
		   case 640*480:
		  	   m_OriginalImageWidth=640;
			   m_OriginalImageHeight=480;
			   break;
		   case 320*240:
			   m_OriginalImageWidth=320;
			   m_OriginalImageHeight=240;
			   break;
		   default:
			   //If image length is not suitable, set the length to be 0
			   m_OriginalImageSize=0;
			   MessageBox(NULL,"The File You Opened Is Not Compatible With The Program，System Would Recognize It As 0-length File","Open the File",MB_OK|MB_ICONINFORMATION);
			   return;
			   break;
		}
		if(m_OriginalImageSize!=512*512)
		{
		  m_OriginalImageSize=0;
		  MessageBox(NULL,"The File You Opened Is Not Compatible With The Program，System Would Recognize It As 0-length File","Open the File",MB_OK|MB_ICONINFORMATION);
		  return;	   
		}
		//Read the image according to the image length
		ar.Read(m_OriginalImageBytes,m_OriginalImageSize);
		bitfile=(LPBITMAPFILEHEADER)m_StandardBmpInfo;
        bitinfo=(LPBITMAPINFOHEADER)(m_StandardBmpInfo+sizeof(BITMAPFILEHEADER));
        bitfile->bfSize=m_OriginalImageSize+1078;
        bitinfo->biHeight=m_OriginalImageHeight;
        bitinfo->biWidth=m_OriginalImageWidth;
		//Copy the 256 gray bmp image header information
		memcpy(m_DisplayImageBytes,m_StandardBmpInfo,1078);
		for(i=0;i<m_OriginalImageHeight;i++)
			memcpy(m_DisplayImageBytes+1078+i*m_OriginalImageWidth,
			m_OriginalImageBytes+(m_OriginalImageHeight-i-1)*m_OriginalImageWidth,m_OriginalImageWidth);
		//copy the imagesize information
		/////////My code ends////////////////////		
	}
}

/////////////////////////////////////////////////////////////////////////////
// CDCTWaterDoc diagnostics

#ifdef _DEBUG
void CDCTWaterDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CDCTWaterDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

//Function to change the document title
void CDCTWaterDoc::SetTitle(LPCTSTR lpszTitle) 
{
	// TODO: Add your specialized code here and/or call the base class
	CString title;
	if(m_OriginalImageSize==0)
	  lpszTitle="No Compatible Image Opened";
	else
	{
	  title=lpszTitle;
	  title+="Image";
	  lpszTitle=(LPCTSTR)title;
	}
	CDocument::SetTitle(lpszTitle);
}

/////////////////////////////////////////////////////////////////////////////
// CDCTWaterDoc commands

////////////////My code begins to handle the menu items////////////////


void CDCTWaterDoc::OnUpdateExtractExtract(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    pCmdUI->Enable(m_Embeded0||m_Embeded1);
}

void CDCTWaterDoc::OnUpdateEmbedEmbed(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    if(((m_Permuted==TRUE&&m_Permuted1==TRUE&&m_EmbedMethod==2)||(m_Permuted==TRUE&&m_EmbedMethod!=2))&&(m_OriginalImageSize!=0))
//	if((m_Permuted==TRUE)&&(m_OriginalImageSize!=0))  
	  pCmdUI->Enable(TRUE);
	else
      pCmdUI->Enable(FALSE);  
}


void CDCTWaterDoc::OnUpdateFileSaveAs(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    unsigned long int i;
	i=m_OriginalImageSize;
	if((i!=512*512)&&(i!=256*256)&&(i!=640*480)&&(i!=320*240))
	  pCmdUI->Enable(FALSE);
	else
	  pCmdUI->Enable(TRUE);
}
void CDCTWaterDoc::OnUpdateFilePrint(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    unsigned long int i;
	i=m_OriginalImageSize;
	if((i!=512*512)&&(i!=256*256)&&(i!=640*480)&&(i!=320*240))
	  pCmdUI->Enable(FALSE);
	else
	  pCmdUI->Enable(TRUE);
}

void CDCTWaterDoc::OnUpdateFilePrintPreview(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    unsigned long int i;
	i=m_OriginalImageSize;
	if((i!=512*512)&&(i!=256*256)&&(i!=640*480)&&(i!=320*240))
	  pCmdUI->Enable(FALSE);
	else
	  pCmdUI->Enable(TRUE);
}
void CDCTWaterDoc::OnUpdateFilePrintSetup(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    unsigned long int i;
	i=m_OriginalImageSize;
	if((i!=512*512)&&(i!=256*256)&&(i!=640*480)&&(i!=320*240))
	  pCmdUI->Enable(FALSE);
	else
	  pCmdUI->Enable(TRUE);
}
void CDCTWaterDoc::OnEmbedMehod1() 
{
	// TODO: Add your command handler code here
    m_EmbedMethod=0;	
}

void CDCTWaterDoc::OnEmbedMehod2() 
{
	// TODO: Add your command handler code here
	m_EmbedMethod=1;	
}

void CDCTWaterDoc::OnEmbedMehod3() 
{
	// TODO: Add your command handler code here
	m_EmbedMethod=2;	
}

void CDCTWaterDoc::OnEmbedMehod4() 
{
	// TODO: Add your command handler code here
	m_EmbedMethod=3;	
}
void CDCTWaterDoc::OnEmbedMehod5() 
{
	// TODO: Add your command handler code here
	m_EmbedMethod=4;	
}

void CDCTWaterDoc::OnEmbedMehod6() 
{
	// TODO: Add your command handler code here
    m_EmbedMethod=5;	
}

void CDCTWaterDoc::OnUpdateEmbedMehod1(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if(m_EmbedMethod==0)
	   pCmdUI->SetCheck(1);
	else
	   pCmdUI->SetCheck(0);
}

void CDCTWaterDoc::OnUpdateEmbedMehod2(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if(m_EmbedMethod==1)
	   pCmdUI->SetCheck(1);
	else
	   pCmdUI->SetCheck(0);
}

void CDCTWaterDoc::OnUpdateEmbedMehod3(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if(m_EmbedMethod==2)
	   pCmdUI->SetCheck(1);
	else
	   pCmdUI->SetCheck(0);
}

void CDCTWaterDoc::OnUpdateEmbedMehod4(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if(m_EmbedMethod==3)
	   pCmdUI->SetCheck(1);
	else
	   pCmdUI->SetCheck(0);
}
void CDCTWaterDoc::OnUpdateEmbedMehod5(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if(m_EmbedMethod==4)
	   pCmdUI->SetCheck(1);
	else
	   pCmdUI->SetCheck(0);
	
}
void CDCTWaterDoc::OnUpdateEmbedMehod6(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if(m_EmbedMethod==5)
	   pCmdUI->SetCheck(1);
	else
	   pCmdUI->SetCheck(0);
}

////////////////My code ends to handle the menu items////////////////