config.c

这是一个压缩解压包,用C语言进行编程的,里面有详细的源代码.

#define XVID_DLL_NAME "xvidcore.dll"

void config_reg_get(CONFIG * config)
{
	char tmp[32];
	HKEY hKey;
	DWORD size;
	int i,j;
	xvid_gbl_info_t info;
	HINSTANCE m_hdll;

	memset(&info, 0, sizeof(info));
	info.version = XVID_VERSION;

	m_hdll = LoadLibrary(XVID_DLL_NAME);
	if (m_hdll != NULL) {

		((int (__cdecl *)(void *, int, void *, void *))GetProcAddress(m_hdll, "xvid_global"))
			(0, XVID_GBL_INFO, &info, NULL);

		FreeLibrary(m_hdll);
	}

	reg.cpu = info.cpu_flags;
	reg.num_threads = info.num_threads;

	RegOpenKeyEx(XVID_REG_KEY, XVID_REG_PARENT "\\" XVID_REG_CHILD, 0, KEY_READ, &hKey);

	/* read integer values */
	for (i=0 ; i<sizeof(reg_ints)/sizeof(REG_INT); i++) {
		size = sizeof(int);
		if (RegQueryValueEx(hKey, reg_ints[i].reg_value, 0, 0, (LPBYTE)reg_ints[i].config_int, &size) != ERROR_SUCCESS) {
			*reg_ints[i].config_int = reg_ints[i].def;
		}
	}

	/* read string values */
	for (i=0 ; i<sizeof(reg_strs)/sizeof(REG_STR); i++) {
		size = MAX_PATH;
		if (RegQueryValueEx(hKey, reg_strs[i].reg_value, 0, 0, (LPBYTE)reg_strs[i].config_str, &size) != ERROR_SUCCESS) {
			memcpy(reg_strs[i].config_str, reg_strs[i].def, MAX_PATH);
		}
	}

  /* find profile table index */
	reg.profile = 0;
	for (i=0; i<sizeof(profiles)/sizeof(profile_t); i++) {
		if (lstrcmpi(profiles[i].name, reg.profile_name) == 0) {
			reg.profile = i;
		}
	}

  /* find quality table index */
	reg.quality = quality_table_num;
	for (i=0; i<quality_table_num; i++) {
		if (lstrcmpi(quality_table[i].name, reg.quality_name) == 0) {
			reg.quality = i;
		}
	}

	memcpy(config, &reg, sizeof(CONFIG));


	/* read quant matrices */
	REG_GET_B("qmatrix_intra", config->qmatrix_intra, default_qmatrix_intra);
	REG_GET_B("qmatrix_inter", config->qmatrix_inter, default_qmatrix_inter);


	/* read zones */
	if (config->num_zones>MAX_ZONES) {
		config->num_zones=MAX_ZONES;
	}else if (config->num_zones<=0) {
		config->num_zones = 1;
	}

	for (i=0; i<config->num_zones; i++) {
		for (j=0; j<sizeof(reg_zone)/sizeof(REG_INT); j++)  {
			size = sizeof(int);

			wsprintf(tmp, reg_zone[j].reg_value, i);
			if (RegQueryValueEx(hKey, tmp, 0, 0, (LPBYTE)reg_zone[j].config_int, &size) != ERROR_SUCCESS)
				*reg_zone[j].config_int = reg_zone[j].def;
		}

		memcpy(&config->zones[i], &stmp, sizeof(zone_t));
	}

	RegCloseKey(hKey);
}


/* put config settings in registry */

#define REG_SET_B(X, Y) RegSetValueEx(hKey, X, 0, REG_BINARY, Y, sizeof((Y)))

void config_reg_set(CONFIG * config)
{
	char tmp[64];
	HKEY hKey;
	DWORD dispo;
	int i,j;

	if (RegCreateKeyEx(
			XVID_REG_KEY,
			XVID_REG_PARENT "\\" XVID_REG_CHILD,
			0,
			XVID_REG_CLASS,
			REG_OPTION_NON_VOLATILE,
			KEY_WRITE,
			0,
			&hKey,
			&dispo) != ERROR_SUCCESS)
	{
		DPRINTF("Couldn't create XVID_REG_SUBKEY - GetLastError=%i", GetLastError());
		return;
	}

	memcpy(&reg, config, sizeof(CONFIG));

	/* set integer values */
	for (i=0 ; i<sizeof(reg_ints)/sizeof(REG_INT); i++) {
		RegSetValueEx(hKey, reg_ints[i].reg_value, 0, REG_DWORD, (LPBYTE)reg_ints[i].config_int, sizeof(int));
	}

	/* set string values */
	strcpy(reg.profile_name, profiles[reg.profile].name);
  strcpy(reg.quality_name, 
    reg.quality<quality_table_num ? quality_table[reg.quality].name : QUALITY_USER_STRING);
	for (i=0 ; i<sizeof(reg_strs)/sizeof(REG_STR); i++) {
		RegSetValueEx(hKey, reg_strs[i].reg_value, 0, REG_SZ, reg_strs[i].config_str, lstrlen(reg_strs[i].config_str)+1);
	}

	/* set quant matrices */
	REG_SET_B("qmatrix_intra", config->qmatrix_intra);
	REG_SET_B("qmatrix_inter", config->qmatrix_inter);

	/* set seections */
	for (i=0; i<config->num_zones; i++) {
		memcpy(&stmp, &config->zones[i], sizeof(zone_t));
		for (j=0; j<sizeof(reg_zone)/sizeof(REG_INT); j++)  {
			wsprintf(tmp, reg_zone[j].reg_value, i);
			RegSetValueEx(hKey, tmp, 0, REG_DWORD, (LPBYTE)reg_zone[j].config_int, sizeof(int));
		}
	}

	RegCloseKey(hKey);
}


/* clear XviD registry key, load defaults */

static void config_reg_default(CONFIG * config)
{
	HKEY hKey;

	if (RegOpenKeyEx(XVID_REG_KEY, XVID_REG_PARENT, 0, KEY_ALL_ACCESS, &hKey)) {
		DPRINTF("Couldn't open registry key for deletion - GetLastError=%i", GetLastError());
		return;
	}

	if (RegDeleteKey(hKey, XVID_REG_CHILD)) {
		DPRINTF("Couldn't delete registry key - GetLastError=%i", GetLastError());
		return;
	}

	RegCloseKey(hKey);
	config_reg_get(config);
	config_reg_set(config);
}


/* leaves current config value if dialog item is empty */
static int config_get_int(HWND hDlg, INT item, int config)
{
	BOOL success = FALSE;
	int tmp = GetDlgItemInt(hDlg, item, &success, TRUE);
	return (success) ? tmp : config;
}


static int config_get_uint(HWND hDlg, UINT item, int config)
{
	BOOL success = FALSE;
	int tmp = GetDlgItemInt(hDlg, item, &success, FALSE);
	return (success) ? tmp : config;
}

/* get uint from combobox
   GetDlgItemInt doesnt work properly for cb list items */
#define UINT_BUF_SZ	20
static int config_get_cbuint(HWND hDlg, UINT item, int def)
{
	int sel = SendMessage(GetDlgItem(hDlg, item), CB_GETCURSEL, 0, 0);
	char buf[UINT_BUF_SZ];

	if (sel<0) {
		return config_get_uint(hDlg, item, def);
	}
		
	if (SendMessage(GetDlgItem(hDlg, item), CB_GETLBTEXT, sel, (LPARAM)buf) == CB_ERR) {
		return def;
	}
	
	return atoi(buf);
}


/* we use "100 base" floats */

#define FLOAT_BUF_SZ	20
static int get_dlgitem_float(HWND hDlg, UINT item, int def)
{
	char buf[FLOAT_BUF_SZ];

	if (GetDlgItemText(hDlg, item, buf, FLOAT_BUF_SZ) == 0)
		return def;

	return (int)(atof(buf)*100);
}

static void set_dlgitem_float(HWND hDlg, UINT item, int value)
{
	char buf[FLOAT_BUF_SZ];
	sprintf(buf, "%.2f", (float)value/100);
	SetDlgItemText(hDlg, item, buf);
}

static void set_dlgitem_float1000(HWND hDlg, UINT item, int value)
{
	char buf[FLOAT_BUF_SZ];
	sprintf(buf, "%.3f", (float)value/1000);
	SetDlgItemText(hDlg, item, buf);
}

#define HEX_BUF_SZ  16
static unsigned int get_dlgitem_hex(HWND hDlg, UINT item, unsigned int def)
{
	char buf[HEX_BUF_SZ];
	unsigned int value;

	if (GetDlgItemText(hDlg, item, buf, HEX_BUF_SZ) == 0)
		return def;

	if (sscanf(buf,"0x%x", &value)==1 || sscanf(buf,"%x", &value)==1) {
		return value;
	}

	return def;
}

static void set_dlgitem_hex(HWND hDlg, UINT item, int value)
{
	char buf[HEX_BUF_SZ];
	wsprintf(buf, "0x%x", value);
	SetDlgItemText(hDlg, item, buf);
}

/* ===================================================================================== */
/* QUANT MATRIX DIALOG ================================================================= */
/* ===================================================================================== */

static void quant_upload(HWND hDlg, CONFIG* config)
{
	int i;

	for (i=0 ; i<64; i++) {
		SetDlgItemInt(hDlg, IDC_QINTRA00 + i, config->qmatrix_intra[i], FALSE);
		SetDlgItemInt(hDlg, IDC_QINTER00 + i, config->qmatrix_inter[i], FALSE);
	}
}


static void quant_download(HWND hDlg, CONFIG* config)
{
	int i;

	for (i=0; i<64; i++) {
		int temp;

		temp = config_get_uint(hDlg, i + IDC_QINTRA00, config->qmatrix_intra[i]);
		CONSTRAINVAL(temp, 1, 255);
		config->qmatrix_intra[i] = temp;

		temp = config_get_uint(hDlg, i + IDC_QINTER00, config->qmatrix_inter[i]);
		CONSTRAINVAL(temp, 1, 255);
		config->qmatrix_inter[i] = temp;
	}
}


static void quant_loadsave(HWND hDlg, CONFIG * config, int save)
{
	char file[MAX_PATH];
	OPENFILENAME ofn;
	HANDLE hFile;
	DWORD read=128, wrote=0;
	BYTE quant_data[128];

	strcpy(file, "\\matrix");
	memset(&ofn, 0, sizeof(OPENFILENAME));
	ofn.lStructSize = sizeof(OPENFILENAME);

	ofn.hwndOwner = hDlg;
	ofn.lpstrFilter = "All files (*.*)\0*.*\0\0";
	ofn.lpstrFile = file;
	ofn.nMaxFile = MAX_PATH;
	ofn.Flags = OFN_PATHMUSTEXIST;

	if (save) {
		ofn.Flags |= OFN_OVERWRITEPROMPT;
		if (GetSaveFileName(&ofn)) {
			hFile = CreateFile(file, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);

			quant_download(hDlg, config);
			memcpy(quant_data, config->qmatrix_intra, 64);
			memcpy(quant_data+64, config->qmatrix_inter, 64);

			if (hFile == INVALID_HANDLE_VALUE) {
				DPRINTF("Couldn't save quant matrix");
			}else{
				if (!WriteFile(hFile, quant_data, 128, &wrote, 0)) {
					DPRINTF("Couldnt write quant matrix");
				}
			}
			CloseHandle(hFile);
		}
	}else{
		ofn.Flags |= OFN_FILEMUSTEXIST;
		if (GetOpenFileName(&ofn)) {
			hFile = CreateFile(file, GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

			if (hFile == INVALID_HANDLE_VALUE) {
				DPRINTF("Couldn't load quant matrix");
			} else {
				if (!ReadFile(hFile, quant_data, 128, &read, 0)) {
					DPRINTF("Couldnt read quant matrix");
				}else{
					memcpy(config->qmatrix_intra, quant_data, 64);
					memcpy(config->qmatrix_inter, quant_data+64, 64);
					quant_upload(hDlg, config);
				}
			}
			CloseHandle(hFile);
		}
	}
}

/* quantization matrix dialog proc */

static BOOL CALLBACK quantmatrix_proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	CONFIG* config = (CONFIG*)GetWindowLong(hDlg, GWL_USERDATA);