gui.cpp

DVD转换到AVI的源代码

/* 
 *	Copyright (C) Chia-chen Kuo - Jan 2001
 *
 *  This file is part of DVD2AVI, a free MPEG-2 decoder
 *	
 *  DVD2AVI 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 2, or (at your option)
 *  any later version.
 *   
 *  DVD2AVI 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 GNU Make; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
 *
 */

#define GLOBAL
extern "C"
{
#include "global.h"
#include "AC3Dec\ac3.h"
}

#define TRACK_HEIGHT	30
#define INIT_WIDTH		320
#define INIT_HEIGHT		240

#define MASKCOLOR			RGB(0, 6, 0)
#define MAX_LOADSTRING		100
#define INI_VERSION			8

#define SAVE_AVI		1
#define	SAVE_D2V		2
#define SAVE_WAV		3
#define	OPEN_D2V		4
#define OPEN_VOB		5
#define OPEN_WAV		6

#define PRIORITY_HIGH		1
#define PRIORITY_NORMAL		2
#define PRIORITY_LOW		3

BOOL PopFileDlg(PTSTR, HWND, int);
ATOM MyRegisterClass(HINSTANCE);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK Statistics(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK VideoList(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK AudioList(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK Delay(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK Luminance(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK Normalization(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);
static DWORD DDColorMatch(LPDIRECTDRAWSURFACE, COLORREF);
static void ShowStatistics(int);
static void DisableControl(void);
static void ClearTrack(void);
static void CheckCPU(void);
static void CheckINI(void);
static void CheckFlag(void);
static void Recovery(void);
static void OpenVideoFile(HWND);
static void OpenAudioFile(HWND);
DWORD WINAPI ProcessWAV(LPVOID);

OPENFILENAME ofn, sfn;
int INI_Version, INIT_X, INIT_Y, Priority_Flag, LumDlg_Flag, NormDlg_Flag;
FILE *INIFile, *BMPFile;
char szPath[_MAX_PATH], szTemp[_MAX_PATH], szWindowClass[MAX_LOADSTRING];
struct _finddata_t vfpfile, seqfile;

HMENU hMenu;
HINSTANCE hInst;
HANDLE hProcess, hThread;
DWORD threadId;
HWND hLumDlg, hNormDlg;

HDC hdc;
PAINTSTRUCT ps;
HBRUSH hBrush;
int LumOffset, LumGain;

char Outfilename[MAX_FILE_NUMBER][_MAX_PATH];
int SoundDelay[MAX_FILE_NUMBER];

static unsigned char BMPHeader[54] =
{
	0x42, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x0b,
	0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	HACCEL hAccel;

	// Initialize global strings
	LoadString(hInstance, IDC_GUI, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization
	hInst = hInstance;

	hWnd = CreateWindow(szWindowClass, "DVD2AVI", WS_OVERLAPPEDWINDOW & ~(WS_THICKFRAME|WS_MAXIMIZEBOX),
		CW_USEDEFAULT, 0, INIT_WIDTH, INIT_HEIGHT, NULL, NULL, hInstance, NULL);

	CheckCPU();
	CheckINI();

	// GetSystemMetrics TITLE/MENU is not always accurate
	GetClientRect(hWnd, &crect);
	Edge_Width = INIT_WIDTH - crect.right;
	Edge_Height = INIT_HEIGHT - crect.bottom;

	Coded_Picture_Width = INIT_WIDTH;
	Coded_Picture_Height = INIT_HEIGHT;

	MoveWindow(hWnd, INIT_X, INIT_Y, Coded_Picture_Width+Edge_Width,
		Coded_Picture_Height+Edge_Height+TRACK_HEIGHT, true);

	hTrack = CreateWindow(TRACKBAR_CLASS, NULL,
		WS_CHILD | WS_VISIBLE | WS_DISABLED | TBS_ENABLESELRANGE | TBS_NOTICKS | TBS_TOP,
		0, Coded_Picture_Height, Coded_Picture_Width-4*TRACK_HEIGHT, TRACK_HEIGHT, hWnd, (HMENU) ID_TRACKBAR, hInst, NULL);
	SendMessage(hTrack, TBM_SETRANGE, (WPARAM) true, (LPARAM) MAKELONG(0, TRACK_PITCH));

	hLeftButton = CreateWindow("BUTTON", "[",
		WS_CHILD | WS_VISIBLE | WS_DLGFRAME | WS_DISABLED,
		Coded_Picture_Width-4*TRACK_HEIGHT, Coded_Picture_Height,
		TRACK_HEIGHT, TRACK_HEIGHT, hWnd, (HMENU) ID_LEFT_BUTTON, hInst, NULL);

	hLeftArrow = CreateWindow("BUTTON", "<",
		WS_CHILD | WS_VISIBLE | WS_DLGFRAME | WS_DISABLED,
		Coded_Picture_Width-3*TRACK_HEIGHT, Coded_Picture_Height,
		TRACK_HEIGHT, TRACK_HEIGHT, hWnd, (HMENU) ID_LEFT_ARROW, hInst, NULL);

	hRightArrow = CreateWindow("BUTTON", ">",
		WS_CHILD | WS_VISIBLE | WS_DLGFRAME | WS_DISABLED,
		Coded_Picture_Width-2*TRACK_HEIGHT, Coded_Picture_Height,
		TRACK_HEIGHT, TRACK_HEIGHT, hWnd, (HMENU) ID_RIGHT_ARROW, hInst, NULL);

	hRightButton = CreateWindow("BUTTON", "]",
		WS_CHILD | WS_VISIBLE | WS_DLGFRAME | WS_DISABLED,
		Coded_Picture_Width-TRACK_HEIGHT, Coded_Picture_Height,
		TRACK_HEIGHT, TRACK_HEIGHT, hWnd, (HMENU) ID_RIGHT_BUTTON, hInst, NULL);

	ShowWindow(hWnd, nCmdShow);

	CheckFlag();

	// Load accelerators
	hAccel = LoadAccelerators(hInstance, (LPCTSTR)IDR_ACCELERATOR);

	// Main message loop
	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		if (!TranslateAccelerator(hWnd, hAccel, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return msg.wParam;
}

// Processes messages for the main window
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	DWORD wmId, wmEvent;
	int i, j;

	switch (message)
	{
		case WM_CREATE:
			DragAcceptFiles(hWnd, true);

			LumGain = 128; LumGainMask = 0x0080008000800080;

			hDC = GetDC(hWnd);
			hBrush = CreateSolidBrush(MASKCOLOR);
			hMenu = GetMenu(hWnd);
			hProcess = GetCurrentProcess();

			for (i=0; i<8; i++)
			{
				p_block[i] = (short *)malloc(sizeof(short)*64 + 64);
				block[i]   = (short *)((long)p_block[i] + 64 - (long)p_block[i]%64);
			}

			p_fTempArray = (void *)malloc(sizeof(float)*128 + 64);
		    fTempArray = (void *)((long)p_fTempArray + 64 - (long)p_fTempArray%64);

			Initialize_REF_IDCT();
			Initialize_FPU_IDCT();

			// register VFAPI
			HKEY key;
			DWORD trash;

			if (RegCreateKeyEx(HKEY_CURRENT_USER, "Software\\VFPlugin", 0, "",
				REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &trash) == ERROR_SUCCESS)
			{
				if (_getcwd(szBuffer, _MAX_PATH)!=NULL)
				{
					if (szBuffer[strlen(szBuffer)-1] != '\\')
						strcat(szBuffer, "\\");

					strcpy(szPath, szBuffer);

					if (_findfirst("DVD2AVI.vfp", &vfpfile) != -1L)
					{
						strcat(szBuffer, "DVD2AVI.vfp");

						RegSetValueEx(key, "DVD2AVI", 0, REG_SZ, (LPBYTE)szBuffer, strlen(szBuffer));
						CheckMenuItem(hMenu, IDM_VFAPI, MF_CHECKED);
					}

					RegCloseKey(key);
				}
			}
			break;

		case WM_COMMAND:
			wmId    = LOWORD(wParam);
			wmEvent = HIWORD(wParam);

			// parse the menu selections
			switch (wmId)
			{
				case IDM_OPEN:
					DialogBox(hInst, (LPCTSTR)IDD_FILELIST, hWnd, (DLGPROC)VideoList);
					break;

				case IDM_PREVIEW:
					Display_Flag = true;

					EnableMenuItem(hMenu, IDM_OPEN, MF_GRAYED);
					EnableMenuItem(hMenu, IDM_PREVIEW, MF_GRAYED);
					EnableMenuItem(hMenu, IDM_SAVE, MF_GRAYED);
					EnableMenuItem(hMenu, IDM_LOAD_D2V, MF_GRAYED);
					EnableMenuItem(hMenu, IDM_SAVE_D2V, MF_GRAYED);
					EnableMenuItem(hMenu, IDM_PAUSE, MF_ENABLED);
					EnableMenuItem(hMenu, IDM_STOP, MF_ENABLED);
					EnableMenuItem(GetSubMenu(hMenu, 1), 1, MF_BYPOSITION | MF_GRAYED);

					DisableControl();
					ShowStatistics(1);

					process.locate = LOCATE_RIP;

					if (WaitForSingleObject(hThread, INFINITE)==WAIT_OBJECT_0)
						hThread = CreateThread(NULL, 0, MPEG2Dec, 0, 0, &threadId);

					break;

				case IDM_SAVE:
					if (PopFileDlg(szOutput, hWnd, SAVE_AVI))
					{
						AVI_Flag = true;
						Display_Flag = false;

						EnableMenuItem(hMenu, IDM_OPEN, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_PREVIEW, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_SAVE, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_LOAD_D2V, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_SAVE_D2V, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_STOP, MF_ENABLED);
						EnableMenuItem(hMenu, IDM_PAUSE, MF_ENABLED);

						EnableMenuItem(hMenu, 1, MF_BYPOSITION | MF_GRAYED);
						EnableMenuItem(hMenu, 2, MF_BYPOSITION | MF_GRAYED);

						if (LumDlg_Flag)
							EnableWindow(hLumDlg, false);
						if (NormDlg_Flag)
							EnableWindow(hNormDlg, false);

						DisableControl();
						ShowStatistics(1);

						process.locate = LOCATE_RIP;

						if (WaitForSingleObject(hThread, INFINITE)==WAIT_OBJECT_0)
							hThread = CreateThread(NULL, 0, MPEG2Dec, 0, 0, &threadId);
					}
					break;

				case IDM_PROCESS_WAV:
					DialogBox(hInst, (LPCTSTR)IDD_FILELIST, hWnd, (DLGPROC)AudioList);
					break;

				case IDM_SAVE_D2V:
					if (PopFileDlg(szOutput, hWnd, SAVE_D2V))
					{
						sprintf(szBuffer, "%s.d2v", szOutput);

						D2VFile = fopen(szBuffer, "w+");
						i = File_Limit;

						fprintf(D2VFile, "DVD2AVIProjectFile\n%d\n", i);
						while (i)
						{
							fprintf(D2VFile, "%d %s\n", strlen(Infilename[File_Limit-i]), Infilename[File_Limit-i]);
							i--;
						}

						D2V_Flag = true;
						Display_Flag = false;

						EnableMenuItem(hMenu, IDM_OPEN, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_PREVIEW, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_SAVE, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_LOAD_D2V, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_SAVE_D2V, MF_GRAYED);
						EnableMenuItem(hMenu, IDM_STOP, MF_ENABLED);
						EnableMenuItem(hMenu, IDM_PAUSE, MF_ENABLED);

						EnableMenuItem(hMenu, 1, MF_BYPOSITION | MF_GRAYED);
						EnableMenuItem(hMenu, 2, MF_BYPOSITION | MF_GRAYED);

						if (LumDlg_Flag)
							EnableWindow(hLumDlg, false);
						if (NormDlg_Flag)
							EnableWindow(hNormDlg, false);

						DisableControl();
						ShowStatistics(1);

						process.locate = LOCATE_RIP;

						if (WaitForSingleObject(hThread, INFINITE)==WAIT_OBJECT_0)
							hThread = CreateThread(NULL, 0, MPEG2Dec, 0, 0, &threadId);
					}
					break;

				case IDM_LOAD_D2V:
					if (PopFileDlg(szInput, hWnd, OPEN_D2V))
					{
D2V_PROCESS:
						D2VFile = fopen(szInput, "r");

						while (File_Limit)
						{
							File_Limit--;
							_close(Infile[File_Limit]);
						}

						fscanf(D2VFile, "DVD2AVIProjectFile\n%d\n", &File_Limit);

						i = File_Limit;
						while (i)
						{
							fscanf(D2VFile, "%d ", &j);
							fgets(Infilename[File_Limit-i], j+1, D2VFile);
							if ((Infile[File_Limit-i] = _open(Infilename[File_Limit-i], _O_RDONLY | _O_BINARY))==-1)
							{
								while (i<File_Limit)
								{
									_close(Infile[File_Limit-i-1]);
									i++;
								}

								File_Limit = 0;
								break;
							}

							i--;
						}

						fscanf(D2VFile, "\nSystem_Stream=%d\n", &SystemStream_Flag);
						fscanf(D2VFile, "iDCT_Algorithm=%d\n", &iDCT_Flag);
						fscanf(D2VFile, "YUVRGB_Scale=%d\n", &Scale_Flag);
						fscanf(D2VFile, "Lum_Gain=%d\n", &LumGain);
						fscanf(D2VFile, "Lum_Offset=%d\n", &LumOffset);
						LumGainMask = ((__int64)LumGain<<48) + ((__int64)LumGain<<32) + ((__int64)LumGain<<16) + (__int64)LumGain;
						LumOffsetMask = ((__int64)LumOffset<<48) + ((__int64)LumOffset<<32) + ((__int64)LumOffset<<16) + (__int64)LumOffset;

						if (LumGain!=128 || LumOffset!=0)
						{
							CheckMenuItem(hMenu, IDM_LUMINANCE, MF_CHECKED);
							Luminance_Flag = true;				
						}
						else
						{
							CheckMenuItem(hMenu, IDM_LUMINANCE, MF_UNCHECKED);
							Luminance_Flag = false;
						}

						if (LumDlg_Flag)
						{
							DestroyWindow(hLumDlg);
							hLumDlg = CreateDialog(hInst, (LPCTSTR)IDD_LUMINANCE, hWnd, (DLGPROC)Luminance);
						}

						fscanf(D2VFile, "Field_Operation=%d\n", &FO_Flag);
						fscanf(D2VFile, "Frame_Rate=%d\n\n", &i);

						CheckFlag();

						ResizeWindow(INIT_WIDTH, INIT_HEIGHT);
						Recovery();

						if (File_Limit)
						{
							fscanf(D2VFile, "%d %X %d %X", &process.leftfile, &i, &process.rightfile, &j);
							process.leftlba = i;
							process.rightlba = j;

							process.startfile = process.leftfile;
							process.startloc = process.leftlba * BUFFER_SIZE;
							process.endfile = process.rightfile;
							process.endloc = (process.rightlba - 1) * BUFFER_SIZE;

							process.run = 0;
							for (i=0; i<process.startfile; i++)
								process.run += process.length[i];
							process.start = process.run + process.startloc;

							process.end = 0;
							for (i=0; i<process.endfile; i++)
								process.end += process.length[i];
							process.end += process.endloc;

							process.trackleft = (int)(process.start*TRACK_PITCH/process.total);
							process.trackright = (int)(process.end*TRACK_PITCH/process.total);

							process.locate = LOCATE_INIT;

							if (!threadId || WaitForSingleObject(hThread, INFINITE)==WAIT_OBJECT_0)
								hThread = CreateThread(NULL, 0, MPEG2Dec, 0, 0, &threadId);
						}
					}
					break;

				case IDM_STOP:
					Stop_Flag = true;

					if (Pause_Flag)
					{
						Pause_Flag = false;
						CheckMenuItem(hMenu, IDM_PAUSE, MF_UNCHECKED);
						ResumeThread(hThread);
					}
					break;

//-------------------------------------------------------------------------------------------