mme.c

由bmp生成mpeg2 的I_frame 数据

	h_diff = client_width - (client_rect.right - client_rect.left);
	v_diff = client_height - (client_rect.bottom - client_rect.top);

	rect.right += h_diff;
	rect.bottom += v_diff + 24;

	MoveWindow(mme_app.main_hwnd, rect.left, rect.top, (rect.right - rect.left), (rect.bottom - rect.top), TRUE);

	GetClientRect(mme_app.main_hwnd, &client_rect);

	h_diff = client_width - (client_rect.right - client_rect.left);
	v_diff = client_height - (client_rect.bottom - client_rect.top);

	rect.right += h_diff;
	rect.bottom += v_diff + 24;

	MoveWindow(mme_app.main_hwnd, rect.left, rect.top, (rect.right - rect.left), (rect.bottom - rect.top), TRUE);
	
	GetClientRect(mme_app.main_hwnd, &rect);
	
	MoveWindow(mme_app.slide_bar, rect.left, rect.bottom-24, (rect.right-rect.left), 24, TRUE);
}

/*-----------------------------------------------------------------*/
static void update_slider()
{
	__int64 index;

	index = get_frame_index_mme_project(&(mme_app.project));
	if(index > LONG_MAX){
		SendMessage(mme_app.slide_bar, TBM_SETPOS, TRUE, LONG_MAX);
	}else{
		SendMessage(mme_app.slide_bar, TBM_SETPOS, TRUE, (LONG)index);
	}
}

/*-----------------------------------------------------------------*/
static HRESULT _stdcall callback(char *path, DWORD percent)
{
	MSG msg;
	char buffer[64];
	HWND hwnd;
	DWORD old;
	
	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	if(mme_app.callback_dlg != INVALID_HANDLE_VALUE){
		old = SendDlgItemMessage(mme_app.callback_dlg, IDC_PROGRESS, PBM_GETPOS, 0, 0);
		SendDlgItemMessage(mme_app.callback_dlg, IDC_PROGRESS, PBM_SETPOS, percent, 0);
		if(old != percent){
			sprintf(buffer, msg_table[mme_app.lang][MSG_STORE_CALLBACK_PERCENT_TEMPLATE], percent);
			hwnd = GetDlgItem(mme_app.callback_dlg, IDC_PERCENT_TEXT);
			SetWindowText(hwnd, buffer);
		}
		return VF_OK;
	}else{
		return VF_ERROR;
	}
}

/*-----------------------------------------------------------------*/
static void msg_pump()
{
	MSG msg;
	
	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
		if(!TranslateAccelerator(mme_app.main_hwnd, mme_app.accel_tbl, &msg)){
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
}

/*-----------------------------------------------------------------*/
static void show_error(char *msg, DWORD code)
{
	int n;
	char *buf;
	LPVOID sys_msg_buf;

	static const char format[] = "%s\n\n\tCODE:\t%u\nREASON:\t%s";
	static const char emg[] = "No enough memory space!!!";

	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&sys_msg_buf, 0, NULL);

	n = strlen(msg) + strlen(sys_msg_buf) + sizeof(format) + 8;
	buf = (char *)malloc(n);
	if(buf == NULL){
		MessageBox(mme_app.main_hwnd, emg, "ERROR", MB_OK|MB_ICONERROR);
		LocalFree(sys_msg_buf);
		return;
	}

	sprintf(buf, format, msg, code, sys_msg_buf);

	MessageBox(mme_app.main_hwnd, buf, "ERROR", MB_OK|MB_ICONERROR);

	free(buf);
	
	LocalFree(sys_msg_buf);
}

static void repaint()
{
	InvalidateRgn(mme_app.main_hwnd, NULL, FALSE);
	UpdateWindow(mme_app.main_hwnd);
}

static void open_file(char *path)
{
	if(is_open_mme_project(&(mme_app.project))){
		close_mme_project(&(mme_app.project));
	}
	
	if(!open_mme_project(path, &(mme_app.project), &(mme_app.vfapi.func), &(mme_app.vfapi.func_edit_ext), mme_app.lang)){
		disable_menu_from_list(SWITCHING_MENU_ID, sizeof(SWITCHING_MENU_ID)/sizeof(UINT));
		SetWindowText(mme_app.main_hwnd, APP_NAME);
		InvalidateRgn(mme_app.main_hwnd, NULL, TRUE); /* repaint */
		SendMessage(mme_app.slide_bar, TBM_SETRANGE, (WPARAM) TRUE, (LPARAM) MAKELONG(0, 100));
		SendMessage(mme_app.slide_bar, TBM_SETSEL, (WPARAM) TRUE, (LPARAM) MAKELONG(0, 100));
		EnableWindow(mme_app.slide_bar, FALSE);
		MessageBox(mme_app.main_hwnd, get_error_msg_mme_project(&(mme_app.project)), "ERROR", MB_OK|MB_ICONERROR);
	}else{
		enable_menu_from_list(SWITCHING_MENU_ID, sizeof(SWITCHING_MENU_ID)/sizeof(UINT));
		SetWindowText(mme_app.main_hwnd, get_status_str_mme_project(&(mme_app.project)));
		resize(get_frame_width_mme_project(&(mme_app.project)), get_frame_height_mme_project(&(mme_app.project)));
		if(get_frame_count_mme_project(&(mme_app.project)) > LONG_MAX){
			SendMessage(mme_app.slide_bar, TBM_SETRANGEMAX, TRUE, LONG_MAX);
			SendMessage(mme_app.slide_bar, TBM_SETSELEND, TRUE, LONG_MAX);
		}else{
			SendMessage(mme_app.slide_bar, TBM_SETRANGEMAX, TRUE, (LONG)get_frame_count_mme_project(&(mme_app.project))-1);
			SendMessage(mme_app.slide_bar, TBM_SETSELEND, TRUE, (LONG)get_frame_count_mme_project(&(mme_app.project))-1);
		}
		SendMessage(mme_app.slide_bar, TBM_SETPOS, TRUE, 0);
		SendMessage(mme_app.slide_bar, TBM_SETSELSTART, TRUE, 0);
		EnableWindow(mme_app.slide_bar, TRUE);
		InvalidateRgn(mme_app.main_hwnd, NULL, FALSE); /* repaint */
	}
}

static void parse_cmdline(char *arg)
{
	int i;
	int n;
	char *work;
	char *p;
	char *path;
	
	int quotation;

	n = strlen(arg);

	if(n == 0){
		return;
	}

	work = malloc(n+1);
	if(work == NULL){
		return;
	}
	
	memcpy(work, arg, n+1);

	quotation = 0;

	p = work;
	while(*p){
		if((p[0] == ' ') && (quotation == 0)){
			p[0] = 0;
			p += 1;
		}
		if(p[0] == '"'){
			p[0] = 0;
			quotation = !quotation;
			p += 1;
		}
		p = CharNext(p);
	}

	path = NULL;
	p = work;
	for(i=0;i<n;i++){
		if( (path == NULL) && (p[i] != 0) ){
			path = p+i;
			open_file(path);
		}
		if(p[i] == 0){
			path = NULL;
		}
	}

	free(work);
}

/*----------------------------------------------------------------*/
static const char REGISTRY_POSITION[] = "Software\\marumo\\mme.exe";
static const char M2V_REG_POSITION[] = "Software\\marumo\\mpeg2vid_vfp";

/*-----------------------------------------------------------------*/
static void get_lastpath()
{
	HKEY key;
	DWORD type;
	DWORD size;
	DWORD value;

	memset(mme_app.openpath, 0, sizeof(mme_app.openpath));
	memset(mme_app.savepath, 0, sizeof(mme_app.savepath));
	
	if(RegOpenKeyEx(HKEY_CURRENT_USER, REGISTRY_POSITION, 0, KEY_READ, &key) != ERROR_SUCCESS){
		return;
	}
	
	type = REG_SZ;
	size = sizeof(mme_app.openpath);

	if(RegQueryValueEx(key, "openpath", NULL, &type, (LPBYTE)mme_app.openpath, &size) != ERROR_SUCCESS){
		RegCloseKey(key);
		return;
	}

	type = REG_SZ;
	size = sizeof(mme_app.savepath);

	if(RegQueryValueEx(key, "savepath", NULL, &type, (LPBYTE)mme_app.savepath, &size) != ERROR_SUCCESS){
		RegCloseKey(key);
		return;
	}

	RegCloseKey(key);

	return;
}

/*-----------------------------------------------------------------*/
static void put_openpath(char *path)
{
	HKEY key;
	DWORD type;
	DWORD size;
	DWORD value;
	DWORD trash;
	
	strncpy(mme_app.openpath, path, sizeof(mme_app.openpath)-1);
	cut_filename(mme_app.openpath);

	if(RegCreateKeyEx(HKEY_CURRENT_USER, REGISTRY_POSITION, 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &trash) != ERROR_SUCCESS){
		return;
	}
	
	type = REG_SZ;
	size = sizeof(mme_app.openpath);

	if(RegSetValueEx(key, "openpath", 0, type, (LPBYTE)mme_app.openpath, size) != ERROR_SUCCESS){
		RegCloseKey(key);
		return;
	}
	
	RegCloseKey(key);
	return;
}

/*-----------------------------------------------------------------*/
static void put_savepath(char *path)
{
	HKEY key;
	DWORD type;
	DWORD trash;
	DWORD size;
	DWORD value;

	strncpy(mme_app.savepath, path, sizeof(mme_app.savepath)-1);
	cut_filename(mme_app.savepath);
	
	if(RegCreateKeyEx(HKEY_CURRENT_USER, REGISTRY_POSITION, 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &trash) != ERROR_SUCCESS){
		return;
	}
	
	type = REG_SZ;
	size = sizeof(mme_app.openpath);

	if(RegSetValueEx(key, "savepath", 0, type, (LPBYTE)mme_app.savepath, size) != ERROR_SUCCESS){
		RegCloseKey(key);
		return;
	}
	
	RegCloseKey(key);
	return;
}

/*-----------------------------------------------------------------*/
static void cut_filename(char *path)
{
	HANDLE h;
	WIN32_FIND_DATA find;
	char *p,*last;

	h = FindFirstFile(path, &find);
	if(h != INVALID_HANDLE_VALUE){
		FindClose(h);
		if(find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){
			return;
		}
	}
	
	p = path;
	last = NULL;
	while(*p){
		if(*p == '\\'){
			last = p;
		}
		p = CharNext(p);
	}

	if(last){
		*last = 0;
	}
}

/*-----------------------------------------------------------------*/
static int has_suffix(char *path)
{
	char *p;
	char *suffix;
	
	p = path;
	suffix = NULL;

	while(*p){
		if(*p == '.'){
			suffix = p;
		}else if(*p == '\\'){
			suffix == NULL;
		}
		p = CharNext(p);
	}

	if(suffix){
		return 1;
	}

	return 0;
}

/*-----------------------------------------------------------------*/
static DWORD get_goplist_mode()
{
	HKEY key;
	DWORD type;
	DWORD size;
	DWORD value;
	DWORD trash;
	
	if(RegCreateKeyEx(HKEY_CURRENT_USER, M2V_REG_POSITION, 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &trash) != ERROR_SUCCESS){
		return;
	}
	
	type = REG_DWORD;
	size = sizeof(DWORD);

	if(RegQueryValueEx(key, "gl", NULL, &type, (LPBYTE)&value, &size) != ERROR_SUCCESS){
		value = 0;
	}
	
	RegCloseKey(key);
	
	return value;
}

/*-----------------------------------------------------------------*/
static void put_goplist_mode(DWORD gl_mode)
{
	HKEY key;
	DWORD type;
	DWORD size;
	DWORD trash;
	
	if(RegCreateKeyEx(HKEY_CURRENT_USER, M2V_REG_POSITION, 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &trash) != ERROR_SUCCESS){
		return;
	}
	
	type = REG_DWORD;
	size = sizeof(DWORD);

	RegSetValueEx(key, "gl", 0, REG_DWORD, (LPBYTE)&gl_mode, size);
	RegCloseKey(key);
	
	return;
}

/*-----------------------------------------------------------------*/
static void create_goplist(M2V_VFAPI *vfapi, char *path)
{
	VF_FileHandle file;

	if(vfapi->func.OpenFile(path, &file) != VF_OK){
		return;
	}

	vfapi->func.CloseFile(file);
}