Où est ce #!?\ de bug ? (projet MFC)

CPathDialog::CPathDialog(LPCTSTR lpszCaption,
       LPCTSTR lpszTitle,
       LPCTSTR lpszInitialPath,
       CWnd* pParent)
{
 m_hWnd=NULL;
 m_PathDialogSub.m_pPathDialog= this;
    m_bParentDisabled = FALSE;

    // Get the true parent of the dialog
    m_pParentWnd = CWnd::GetSafeOwner(pParent);

 m_lpszCaption = lpszCaption;
 m_lpszInitialPath = lpszInitialPath;

 memset(&m_bi, 0, sizeof(BROWSEINFO) );
 m_bi.hwndOwner = (m_pParentWnd==NULL)?NULL:m_pParentWnd->GetSafeHwnd();
 m_bi.pszDisplayName = 0;
 m_bi.pidlRoot = 0;
 m_bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
 m_bi.lpfn = BrowseCallbackProc;
 m_bi.lpszTitle = lpszTitle;
}

/////////////////////////////////////////////////////////////////////////////
// CPathDialog message handlers

CString CPathDialog::GetPathName()
{
 return CString(m_szPathName);
}

int CALLBACK CPathDialog::BrowseCallbackProc(HWND hwnd,UINT uMsg,LPARAM lParam, LPARAM pData)
{
 CPathDialog* pDlg = (CPathDialog*)pData;

 switch(uMsg)
 {
 case BFFM_INITIALIZED:
  {
   RECT rc;
   HWND hEdit;
   HFONT hFont;

   pDlg->m_hWnd = hwnd;

   if(pDlg->m_lpszCaption!=NULL)
   {
    ::SetWindowText(hwnd, pDlg->m_lpszCaption);
   }

   VERIFY(pDlg->m_PathDialogSub.SubclassWindow(hwnd));
   ::ShowWindow(::GetDlgItem(hwnd, IDC_STATUSTEXT), SW_HIDE);
   ::GetWindowRect(::GetDlgItem(hwnd, IDC_FOLDERTREE), &rc);
   rc.bottom = rc.top - 4;
   rc.top = rc.bottom - 23;
   ::ScreenToClient(hwnd, (LPPOINT)&rc);
   ::ScreenToClient(hwnd, ((LPPOINT)&rc)+1);
   hEdit = ::CreateWindowEx(WS_EX_CLIENTEDGE, _T("EDIT"), _T(""),
    WS_CHILD|WS_TABSTOP|WS_VISIBLE|ES_AUTOHSCROLL,
    rc.left, rc.top,
    rc.right-rc.left, rc.bottom-rc.top,
    hwnd, NULL, NULL, NULL);
   ::SetWindowLong(hEdit, GWL_ID, IDC_NEW_EDIT_PATH);
   ::ShowWindow(hEdit, SW_SHOW);

   hFont = (HFONT)::SendMessage(hwnd, WM_GETFONT, 0, 0);
   ::SendMessage(hEdit, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));

   LPCTSTR lpszPath = pDlg->m_lpszInitialPath;
   TCHAR szTemp[MAX_PATH];
   if(lpszPath==NULL)
   {
    ::GetCurrentDirectory(MAX_PATH, szTemp );
    lpszPath = szTemp;
   }
   // WParam is TRUE since you are passing a path.
   // It would be FALSE if you were passing a pidl.
   ::SendMessage(hwnd,BFFM_SETSELECTION,TRUE,
    (LPARAM)lpszPath);
   break;
  }
 case BFFM_SELCHANGED:
  {
   char szSelection[MAX_PATH];
   if(!::SHGetPathFromIDList((LPITEMIDLIST)lParam, szSelection) ||
    szSelection[1]!=':')
   {
    szSelection[0] = '\0';
    ::SendMessage(hwnd, BFFM_ENABLEOK, 0, FALSE);
   }
   else
   {
    ::SendMessage(hwnd, BFFM_ENABLEOK, 0, TRUE);
   }
   ::SendMessage(hwnd,BFFM_SETSTATUSTEXT,0,(LPARAM)szSelection);
   ::SetWindowText(::GetDlgItem(hwnd, IDC_NEW_EDIT_PATH), szSelection);
   break;
  }
 default:
  break;
 }
 return 0;
}

int CPathDialog::DoModal()
{

 /////////////////////////////////////////////////////////
 TCHAR szPathTemp[MAX_PATH];
    m_bi.lpfn = BrowseCallbackProc;  // address of callback function
    m_bi.lParam = (LPARAM)this;      // pass address of object to callback function
 m_bi.pszDisplayName = szPathTemp;

 LPITEMIDLIST pidl;
 LPMALLOC pMalloc;

 int iResult=-1;
 if(SUCCEEDED(SHGetMalloc(&pMalloc)))
 {
//  if((m_pParentWnd!=NULL) && m_pParentWnd->IsWindowEnabled())
//  {
//    m_pParentWnd->EnableWindow(FALSE);
//    m_bParentDisabled = TRUE;
//  }
  m_bGetSuccess = FALSE;
  pidl = SHBrowseForFolder(&m_bi);
  if (pidl!=NULL)
  {
   //not need do this because OnOK function did
   //bSucceeded = SHGetPathFromIDList(pidl, m_szPathName);
   // In C++:
   pMalloc->Free(pidl);
   //In C:
   //pMalloc->lpVtbl->Free(pMalloc,pidl);
   //pMalloc->lpVtbl->Release(pMalloc);
  }
  if(m_bGetSuccess)
  {
   iResult = IDOK;
  }
  pMalloc->Release();
 }

    if(m_bParentDisabled && (m_pParentWnd!=NULL))
 {
  m_pParentWnd->EnableWindow(TRUE);
 }
    m_bParentDisabled=FALSE;

 return iResult;
}

BOOL CPathDialog::IsFileNameValid(LPCTSTR lpFileName)
{
 if(lpFileName==NULL)
 {
  return FALSE;
 }

 int nLen = _tcslen(lpFileName);
 if(nLen<=0)
 {
  return FALSE;
 }

 //check first char
 switch(lpFileName[0])
 {
 case _T('.'):
 case _T(' '):
 case _T('\t'):
  return FALSE;
 }

 //check last char
 switch(lpFileName[nLen-1])
 {
 case _T('.'):
 case _T(' '):
 case _T('\t'):
  return FALSE;
 }

 //check all
 int i=0;
 while(lpFileName[i]!=0)
 {
  switch(lpFileName[i])
  {
  case _T('\\'):
  case _T('/'):
  case _T(':'):
  case _T('*'):
  case _T('?'):
  case _T('\"'):
  case _T('<'):
  case _T('>'):
  case _T('|'):
   return FALSE;
  }
  i++;
 }

 return TRUE;
}

const TCHAR c_FolderDoesNotExist[] = _T(
  "Le répertoire:\n\n"
  "%s\n\n"
  "n'existe pas. Voulez vous le créer ?");
const TCHAR c_szErrInvalidPath[] = _T(
  "Le répertoire:"
  "\n\n"
  "%s\n\n"
  "est invalide. Recommencez.");
const TCHAR c_szErrCreatePath[] = _T(
  "Le répertoire:"
  "\n\n"
  "%s"
  "\n\nne peut être créer.");

//return -1: user break;
//return 0: no error
//return 1: lpPath is invalid
//return 2: can not create lpPath
int CPathDialog::MakeSurePathExists(LPCTSTR lpPath)
{
 CString strMsg;
 int iRet;
 try
 {
  //validate path
  iRet=Touch(lpPath, TRUE);
  if(iRet!=0)
  {
   throw iRet;
  }

  if(_taccess(lpPath, 0)==0)
  {
   return (int)0;
  }

  strMsg.Format(c_FolderDoesNotExist, lpPath);
  if(AfxMessageBox(strMsg, MB_YESNO|MB_ICONQUESTION) != IDYES)
  {
   return (int)-1;
  }

  //create path
  iRet=Touch(lpPath, FALSE);
  if(iRet!=0)
  {
   throw iRet;
  }

  return 0;
 }
 catch(int nErrCode)
 {
  switch(nErrCode)
  {
  case 1:
   strMsg.Format(c_szErrInvalidPath, lpPath);
   break;
  case 2:
  default:
   strMsg.Format(c_szErrCreatePath, lpPath);
   break;
  }

  AfxMessageBox(strMsg, MB_OK|MB_ICONEXCLAMATION);

 }

 return iRet;
}

//return 0: no error
//return 1: lpPath is invalid
//return 2: lpPath can not be created(bValidate==FALSE)
int CPathDialog::Touch(LPCTSTR lpPath, BOOL bValidate)
{
 if(lpPath==NULL)
 {
  return 1;
 }

 TCHAR szPath[MAX_PATH];
 _tcscpy(szPath, lpPath);
 int nLen = _tcslen(szPath);

 //path must be "x:\..."
 if( ( nLen<3 ) ||
  ( ( szPath[0]<_T('A') || _T('Z')<szPath[0] ) &&
    ( szPath[0]<_T('a') || _T('z')<szPath[0] ) ||
  ( szPath[1]!=_T(':') )||
  ( szPath[2]!=_T('\\') )
  )
   )
 {
  return 1;
 }

 int i;
 if(nLen==3)
 {
  if(!bValidate)
  {
   if(_access(szPath, 0)!=0)
   {
    return 2;
   }
  }
  return 0;
 }

 i = 3;
 BOOL bLastOne=TRUE;
 LPTSTR lpCurrentName;
 while(szPath[i]!=0)
 {
  lpCurrentName = &szPath[i];
  while( (szPath[i]!=0) && (szPath[i]!=_T('\\')) )
  {
   i++;
  }

  bLastOne =(szPath[i]==0);
  szPath[i] = 0;

  if( !IsFileNameValid(lpCurrentName) )
  {
   return 1;
  }

  if(!bValidate)
  {
   CreateDirectory(szPath, NULL);
   if(_taccess(szPath, 0)!=0)
   {
    return 2;
   }
  }

  if(bLastOne)
  {
   break; //it's done
  }
  else
  {
   szPath[i] = _T('\\');
  }

  i++;
 }

 return (bLastOne?0:1);
}

//return 0: ok
//return 1: error
int CPathDialog::ConcatPath(LPTSTR lpRoot, LPCTSTR lpMorePath)
{
 if(lpRoot==NULL)
 {
  return 1;
 }

 int nLen = _tcslen(lpRoot);

 if(nLen<3)
 {
  return 1;
 }

 if(lpMorePath==NULL)
 {
  return 0;
 }

 if(nLen==3)
 {
  _tcscat(lpRoot, lpMorePath);
  return 0;
 }

 _tcscat(lpRoot, _T("\\"));
 _tcscat(lpRoot, lpMorePath);

 return 0;
}

Ficher Film2Frames.h

#pragma once

#include <vfw.h>

#pragma comment(lib, "vfw32.lib")

#pragma warning(disable : 4996)

// CFilm2Frames dialog

class CFilm2Frames : public CDialog
{
 DECLARE_DYNAMIC(CFilm2Frames)

public:
 CFilm2Frames(CWnd* pParent = NULL);   // standard constructor
 virtual ~CFilm2Frames();

// Dialog Data
 enum { IDD = IDD_FILM_TO_FRAMES };
 
 bool ExtractAVIFrames(CString m_sFileName);
 bool CreateBMPFromDIBPointer(LPBYTE pDIB, int iImg);

 CBrush m_whitebrush;

 CString m_sFilm_a_Decompiler;
 CString m_sFolderFrames;
 CString m_info;

 CStatic m_sLargeur;
 CStatic m_sHauteur;
 CStatic m_sNbImages;
 CStatic m_sTauxTransfert;
 CStatic m_sImageParSec;
 CStatic m_sFluxVideo;
 CStatic m_sTypeFichier;
 CEdit m_sEditFrames;

protected:
 virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

 //{{AFX_MSG(CFilm2Frames)
 afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);
 virtual BOOL OnInitDialog();
 afx_msg void OnParcourirFilmADecompiler();
 afx_msg bool OnRecuperationInfoVideo(CString m_sFileName);
 afx_msg void OnParcourirFolderFrames();
 afx_msg void OnExtractAVIFrames();
 //}}AFX_MSG

 DECLARE_MESSAGE_MAP()
};

Fichier Film2Frames.cpp

// Film2Frames.cpp : implementation file
//

#include "stdafx.h"
#include "Cinema Movie Maker.h"
#include "Film2Frames.h"

// CFilm2Frames dialog

IMPLEMENT_DYNAMIC(CFilm2Frames, CDialog)

CFilm2Frames::CFilm2Frames(CWnd* pParent /*=NULL*/)
 : CDialog(CFilm2Frames::IDD, pParent)
{
 m_sFolderFrames = _T("Répertoire de destination des Images.");
 m_sFilm_a_Decompiler = _T("Film dont les images seront extraites.");
}

CFilm2Frames::~CFilm2Frames()
{
}

void CFilm2Frames::DoDataExchange(CDataExchange* pDX)
{
 CDialog::DoDataExchange(pDX);

 DDX_Text(pDX, IDC_EDIT_FILM_A_DECOMPILER, m_sFilm_a_Decompiler);
 DDX_Control(pDX, IDC_LARGEUR_VIDEO, m_sLargeur);
 DDX_Control(pDX, IDC_HAUTEUR_VIDEO, m_sHauteur);
 DDX_Control(pDX, IDC_NOMBRE_IMAGES, m_sNbImages);
 DDX_Control(pDX, IDC_TAUX_TRANSFERT, m_sTauxTransfert);
 DDX_Control(pDX, IDC_IMAGES_PAR_SECONDE, m_sImageParSec);
 DDX_Control(pDX, IDC_FLUX_VIDEO, m_sFluxVideo);
 DDX_Control(pDX, IDC_TYPE_FICHIER, m_sTypeFichier);
 DDX_Text(pDX, IDC_EDIT_DEST_IMAGES, m_sFolderFrames);
 DDX_Control(pDX, IDC_EDIT_DEST_IMAGES, m_sEditFrames);
}

BEGIN_MESSAGE_MAP(CFilm2Frames, CDialog)
 ON_WM_CTLCOLOR()
 ON_BN_CLICKED(IDC_PARCOURIR_FILM_A_DECOMPILER, OnParcourirFilmADecompiler)
 ON_BN_CLICKED(IDC_PARCOURIR_DEST_IMAGES, OnParcourirFolderFrames)
 ON_BN_CLICKED(IDC_EXTRAIRE_IMAGES, OnExtractAVIFrames)
END_MESSAGE_MAP()

// CFilm2Frames message handlers

BOOL CFilm2Frames::OnInitDialog()
{
 CDialog::OnInitDialog();

 m_whitebrush.CreateSolidBrush(RGB(255,255,255));

 return TRUE;
}

HBRUSH CFilm2Frames::OnCtlColor(CDC *pDC, CWnd *pWnd, UINT nCtlColor)
{
 HBRUSH hbr;

 switch(nCtlColor)
 {
  case CTLCOLOR_DLG:
   return m_whitebrush;

  case CTLCOLOR_STATIC:
  {
   switch(pWnd->GetDlgCtrlID())
   {
    case IDC_STATIC14:
    case IDC_STATIC15:
    case IDC_STATIC16:
    case IDC_STATIC17:
    case IDC_STATIC18:
    case IDC_STATIC19:
    case IDC_STATIC20:
    case IDC_STATIC21:
    case IDC_STATIC22:
    case IDC_STATIC23:
    case IDC_STATIC24:
    {
     pDC->SetTextColor(RGB(0,255,255));
     hbr = (HBRUSH)m_whitebrush;
    }
    break;

    case IDC_LARGEUR_VIDEO:
    case IDC_HAUTEUR_VIDEO:
    case IDC_TAUX_TRANSFERT:
    case IDC_FLUX_VIDEO:
    case IDC_TYPE_FICHIER:
    case IDC_NOMBRE_IMAGES:
    case IDC_IMAGES_PAR_SECONDE:
    {
     pDC->SetTextColor(RGB(255,0,0));
     hbr = (HBRUSH)m_whitebrush;
    }
    break;

    default:
     hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
   }
  }
  break;

  default:
   hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
 }

 return hbr;
}

void CFilm2Frames::OnParcourirFilmADecompiler()
{
 CFileDialog dlg(TRUE, 0, 0, OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST,
  "Fichier Audio Vidéo Interleaved (.avi)|*.avi\0\0");

 dlg.m_ofn.lpstrTitle = _T("Nom du Film qui aura l'insigne honneur d'être décompiler...");

 if(dlg.DoModal() == IDOK)
 {
  UpdateData(TRUE);

  m_sFilm_a_Decompiler = dlg.GetPathName();

  UpdateData(FALSE);

  OnRecuperationInfoVideo(m_sFilm_a_Decompiler);
 }
}

bool CFilm2Frames::OnRecuperationInfoVideo(CString m_sFileName)
{
 AVIFileInit();

 PAVIFILE avi;

 int res = AVIFileOpen(&avi, m_sFileName, OF_READ, NULL);

 if(res != AVIERR_OK)
 {
  // Erreur
  if(avi != NULL)
   AVIFileRelease(avi);

  return false;
 }

 // Variable de récupération des données
 AVIFILEINFO m_avi_info;

 AVIFileInfo(avi, &m_avi_info, sizeof(AVIFILEINFO));

 m_info.Format("%d", m_avi_info.dwWidth);
 m_sLargeur.SetWindowText(m_info);

 m_info.Format("%d", m_avi_info.dwHeight);
 m_sHauteur.SetWindowText(m_info);

 m_info.Format("%d", m_avi_info.dwLength);
 m_sNbImages.SetWindowText(m_info);

 m_info.Format("%d", m_avi_info.dwMaxBytesPerSec);
 m_sTauxTransfert.SetWindowText(m_info);

 m_info.Format("%d", ((DWORD)m_avi_info.dwRate / m_avi_info.dwScale));
 m_sImageParSec.SetWindowText(m_info);

 m_info.Format("%d", m_avi_info.dwStreams);
 m_sFluxVideo.SetWindowText(m_info);

 m_info.Format("%s", m_avi_info.szFileType);
 m_sTypeFichier.SetWindowText(m_info);

 return true;
}

#include "PathDialog.h"

void CFilm2Frames::OnParcourirFolderFrames()
{
 CString szPath;
 CString szTitle = _T("Choisissez le dossier de destination qui recevra les images du film.");
 CString szCaption = _T("Répertoire de décompilation du Film");

 CPathDialog dlg(szCaption, szTitle, szPath);

 if(dlg.DoModal() == IDOK)
 {
  UpdateData(TRUE);

  m_sFolderFrames = dlg.GetPathName();

  UpdateData(FALSE);
 }
}

void CFilm2Frames::OnExtractAVIFrames()
{
 ExtractAVIFrames(m_sFilm_a_Decompiler);
}

bool CFilm2Frames::ExtractAVIFrames(CString m_sFileName)
{
 AVIFileInit();

 PAVIFILE avi;

 int res = AVIFileOpen(&avi, m_sFileName, OF_READ, NULL);

 if(res != AVIERR_OK)
 {
  if(avi != NULL)
   AVIFileRelease(avi);

  return false;
 }

 PAVISTREAM pStream;

 res = AVIFileGetStream(avi, &pStream, streamtypeVIDEO, 0);

 if(res != AVIERR_OK)
 {
  if(pStream != NULL)
   AVIStreamRelease(pStream);

  AVIFileExit();

  return false;
 }

 // Variable de récupération d'images;
 // jouons avec le stream
 int iNbImages;
 int iFirstImg;

 iFirstImg = AVIStreamStart(pStream);

 if(iFirstImg == -1)
 {
  // Erreur durant l' "attrapage" de l'image par le stream
  if(pStream != NULL)
   AVIStreamRelease(pStream);

  AVIFileExit();

  return false;
 }

 iNbImages = AVIStreamLength(pStream);

 if(iNbImages == -1)
 {
  // Erreur durant l' "attrapage" du nombre d'images par le stream
  if(pStream != NULL)
   AVIStreamRelease(pStream);

  AVIFileExit();

  return false;
 }

 // Bitmaps à partir de l'image
 BITMAPINFOHEADER bih;
 ZeroMemory(&bih, sizeof(BITMAPINFOHEADER));

 // Paramètres de l'image bitmap
 bih.biBitCount = 24; // 24 bits par pixels
 bih.biClrImportant=0;
    bih.biClrUsed = 0;
    bih.biCompression = BI_RGB;
    bih.biPlanes = 1;
    bih.biSize = 40;
    bih.biXPelsPerMeter = 0;
    bih.biYPelsPerMeter = 0;

 // Calcul de la taille total du RGBQUAD
 bih.biSizeImage = (((bih.biWidth * 3) + 3) & 0xFFFC) * bih.biHeight;

 // Méthode d' "attrapage" d'image
 PGETFRAME pFrame;

 pFrame = AVIStreamGetFrameOpen(pStream, NULL);

 // 1ère Image
 int iIndex = 0;

 for(int i = iFirstImg; i < iNbImages; i++)
 {
  iIndex = i - iFirstImg;

  BYTE* pDIB = static_cast<BYTE*>(AVIStreamGetFrame(pFrame, iIndex));

  CreateBMPFromDIBPointer(pDIB, iIndex);
 }

 AVIStreamGetFrameClose(pFrame);

 // Fermons le stream après la fin de la tâche

 if(pStream != NULL)
  AVIStreamRelease(pStream);

 AVIFileExit();

 return true;
}

bool CFilm2Frames::CreateBMPFromDIBPointer(LPBYTE pDIB, int iImg)
{
 ASSERT(pDIB != NULL); // Il faut impérativement que le pointeur ne soit pas nul.

 BITMAPINFOHEADER bih; // déplaçons le bloc mémoire d'un secteur à un autre
 RtlMoveMemory(&bih.biSize, pDIB, sizeof(BITMAPINFOHEADER));

 // Maintenant, cherchons le nombre de bits de la bitmap
 if(bih.biSizeImage < 1)
 {
  return false;
 }

 BYTE* bits = new BYTE[bih.biSizeImage];

    BYTE memBitmapInfo[40];
    RtlMoveMemory(memBitmapInfo, &bih, sizeof(bih));

    BITMAPFILEHEADER bfh;
    bfh.bfType=19778;    //BM header
    bfh.bfSize=55 + bih.biSizeImage;
    bfh.bfReserved1=0;
    bfh.bfReserved2=0;
    bfh.bfOffBits=sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER); //54

 char szFile[512];
 CString m_sFileName;

 m_sFileName.Format("Image%05d.bmp", iImg);
 m_sEditFrames.GetWindowText(szFile, 512);

 lstrcat(szFile, "\\");
 lstrcat(szFile, m_sFileName);

 FILE* fp;

 fp = fopen(szFile, "wb");

 if(fp != NULL)
 {
  fwrite(&bfh, sizeof(bfh), 1, fp);
  fwrite(&memBitmapInfo, sizeof(memBitmapInfo), 1, fp);
  fwrite(bits, bih.biSizeImage, 1, fp);
  fclose(fp);
 }
 else
 {
  TRACE0("Erreur durant l'écriture du bitmap");
  return false;
 }
 
 delete [] bits;

 return true;
}

Fichier CinemaMovieMakerDlg.h

// Cinema Movie MakerDlg.h : fichier d'en-tête
//

/*#include "Frames2Film.h"
#include "Convertisseur.h"*/
#include "Film2Frames.h"

#pragma once