void parse(FILE *fp)
{
init_symbol_table(&symbol_table);
symbol_table_enter_next_scope(symbol_table);
init_dll(&call_patch_list);
init_dll(&var_patch_list);
yyrestart(fp);
yyparse();
}
/*
* Story 8: rprint_dll
*/
void test8(void)
{
dlist dl = NULL;
printf("Testing story 8: rprint_dll\n");
print_dll("Starting with empty list: ", dl);
fflush(stdout);
rprint_dll(dl);
dl = add_dll(dl, 3);
print_dll("Added 1, now: ", dl);
rprint_dll(dl);
dl = add_dll(dl, 2);
print_dll("Added 2, now: ", dl);
rprint_dll(dl);
print_dll("Added 1, now: ", dl);
dl = add_dll(dl, 1);
rprint_dll(dl);
dl = init_dll(dl);
print_dll("Initialized to: ", dl);
fflush(stdout);
rprint_dll(dl);
dl = add_dll(dl, 0);
print_dll("Added 0, now: ", dl);
fflush(stdout);
rprint_dll(dl);
}
int put_env_in_dll(char **envp, t_execution *exe)
{
int i;
i = -1;
if (!(exe->env->env_dll = init_dll()))
return (FAILURE);
while (envp[++i])
if (add_env_variable(exe->env->env_dll, my_strdup(envp[i])) == FAILURE)
return (FAILURE);
if (put_env_in_tab(exe->env) == FAILURE)
return (FAILURE);
return (SUCCESS);
}
LRESULT decompress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
{
xvid_gbl_init_t init;
xvid_dec_create_t create;
HKEY hKey;
if (init_dll(codec) != 0) return ICERR_ERROR;
memset(&init, 0, sizeof(init));
init.version = XVID_VERSION;
init.cpu_flags = codec->config.cpu;
init.debug = codec->config.debug;
codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
memset(&create, 0, sizeof(create));
create.version = XVID_VERSION;
create.width = lpbiInput->bmiHeader.biWidth;
create.height = lpbiInput->bmiHeader.biHeight;
switch(codec->xvid_decore_func(0, XVID_DEC_CREATE, &create, NULL))
{
case XVID_ERR_FAIL :
return ICERR_ERROR;
case XVID_ERR_MEMORY :
return ICERR_MEMORY;
case XVID_ERR_FORMAT :
return ICERR_BADFORMAT;
case XVID_ERR_VERSION :
return ICERR_UNSUPPORTED;
}
codec->dhandle = create.handle;
RegOpenKeyEx(XVID_REG_KEY, XVID_REG_PARENT "\\" XVID_REG_CHILD, 0, KEY_READ, &hKey);
REG_GET_N("Brightness", pp_brightness, 0);
REG_GET_N("Deblock_Y", pp_dy, 0)
REG_GET_N("Deblock_UV", pp_duv, 0)
REG_GET_N("Dering_Y", pp_dry, 0)
REG_GET_N("Dering_UV", pp_druv, 0)
REG_GET_N("FilmEffect", pp_fe, 0)
RegCloseKey(hKey);
return ICERR_OK;
}
/*
* Story 7: add_dll
*/
void test7(void)
{
dlist dl = NULL;
printf("Testing story 7: add_dll\n");
print_dll("Starting with empty list: ", dl);
dl = add_dll(dl, 3);
print_dll("Added 3: ", dl);
fflush(stdout);
dl = add_dll(dl, 2);
print_dll("Added 2: ", dl);
fflush(stdout);
dl = add_dll(dl, 1);
print_dll("Added 1: ", dl);
fflush(stdout);
dl = init_dll(dl);
print_dll("Initialized to: ", dl);
dl = add_dll(dl, 0);
print_dll("Added 0: ", dl);
fflush(stdout);
}
static void reset_clocks(struct atyfb_par *par, struct pll_ct *pll,
int hsync_enb)
{
reset_gui(par);
aty_st_pll(MCLK_FB_DIV, pll->mclk_fb_div, par);
aty_st_pll(SCLK_FB_DIV, pll->sclk_fb_div, par);
mdelay(15);
init_dll(par);
aty_st_8(GEN_TEST_CNTL+1, 0x00, par);
mdelay(5);
aty_st_8(CRTC_GEN_CNTL+3, 0x04, par);
mdelay(6);
reset_sdram(par);
aty_st_8(CRTC_GEN_CNTL+3,
hsync_enb ? 0x00 : 0x04, par);
aty_st_pll(SPLL_CNTL2, pll->spll_cntl2, par);
aty_st_pll(PLL_GEN_CNTL, pll->pll_gen_cntl, par);
aty_st_pll(PLL_VCLK_CNTL, pll->pll_vclk_cntl, par);
}
/*
* Story 9: delete_dll
*/
void test9(void)
{
dlist dl = NULL;
printf("Testing story 9: delete_dll\n");
print_dll("Starting with empty list: ", dl);
dl = delete_dll(dl, 5);
print_dll("Failed to delete position 5: ", dl);
fflush(stdout);
dl = init_dll(dl);
print_dll("Initialized to: ", dl);
dl = delete_dll(dl, 0);
print_dll("De1eted position 0: ", dl);
fflush(stdout);
dl = delete_dll(dl, 2);
print_dll("Failed to delete position 2: ", dl);
fflush(stdout);
dl = delete_dll(dl, 1);
print_dll("De1eted position 1: ", dl);
fflush(stdout);
}
int main(void)
{ int i, k, err, blocks, len, len2;
double a0, av, sig, td;
unsigned char buf1[BUFLEN];
unsigned char buf2[BUFLEN];
unsigned char iv1[AES_BLOCK_SIZE];
unsigned char iv2[AES_BLOCK_SIZE];
unsigned char key[32];
f_ectx ecx1[1];
f_dctx dcx1[1];
aligned_auto(unsigned char, buf3, BUFLEN, 16);
aligned_auto(unsigned char, iv3, AES_BLOCK_SIZE, 16);
aligned_auto(f_ectx, ecx2, 1, 16);
aligned_auto(f_dctx, dcx2, 1, 16);
#if defined( DLL_IMPORT ) && defined( DYNAMIC_LINK )
HINSTANCE h_dll;
#endif
#if defined( DUAL_CORE ) && defined( _WIN32 )
// we need to constrain the process to one core in order to
// obtain meaningful timing data
HANDLE ph;
DWORD_PTR afp;
DWORD_PTR afs;
ph = GetCurrentProcess();
if(GetProcessAffinityMask(ph, &afp, &afs))
{
afp &= (GetCurrentProcessorNumber() + 1);
if(!SetProcessAffinityMask(ph, afp))
{
printf("Couldn't set Process Affinity Mask\n\n"); return -1;
}
}
else
{
printf("Couldn't get Process Affinity Mask\n\n"); return -1;
}
#endif
#if defined( DLL_IMPORT ) && defined( DYNAMIC_LINK )
if(!(h_dll = init_dll(&fn)))
return -1;
#elif !defined(STATIC_TABLES)
aes_init();
#endif
if(f_talign(0,16) != EXIT_SUCCESS)
return -1;
printf("\nRun tests for the AES algorithm");
#if defined( DLL_IMPORT )
printf(" (DLL Version)");
#endif
#if defined( __cplusplus )
printf(" (CPP Version)");
#endif
for(k = 128; k <= 256; k += 64)
{
printf("\n\n%03i Bit Keys", k);
#ifdef TEST_ECB
err = 0;
for(i = 0; i < 100; ++i)
{
block_rndfill(key, 2 * AES_BLOCK_SIZE);
f_enc_key(ecx1, key, k);
f_enc_key(ecx2, key, k);
f_dec_key(dcx1, key, k);
f_dec_key(dcx2, key, k);
block_rndfill(buf1, BUFLEN);
memcpy(buf2, buf1, BUFLEN);
memcpy(buf3, buf1, BUFLEN);
td = rand32() / (65536.0 * 65536.0);
len = (unsigned int)(0.5 * BUFLEN * (1.0 + td));
len = AES_BLOCK_SIZE * (len / AES_BLOCK_SIZE);
ECBenc(buf2, len, ecx1);
f_ecb_enc(ecx2, buf3, buf3, len);
if(memcmp(buf2, buf3, len)) err |= 1;
if((err & 1) && !(err & 256))
printf("\nECB encryption FAILURE");
ECBdec(buf2, len, dcx1);
f_ecb_dec(dcx2, buf3, buf3, len);
if(memcmp(buf1, buf2, len)) err |= 2;
if(memcmp(buf1, buf3, len)) err |= 4;
if((err & 4) && !(err & 512))
printf("\nECB decryption FAILURE");
if(err & 1)
err |= 256;
if(err & 4)
err |= 512;
}
if(!err)
printf("\nECB encrypt and decrypt of data correct");
#endif
#ifdef TEST_CBC
err = 0;
for(i = 0; i < 100; ++i)
{
block_rndfill(key, 2 * AES_BLOCK_SIZE);
f_enc_key(ecx1, key, k);
f_enc_key(ecx2, key, k);
f_dec_key(dcx1, key, k);
f_dec_key(dcx2, key, k);
block_rndfill(iv1, AES_BLOCK_SIZE);
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
block_rndfill(buf1, BUFLEN);
memcpy(buf2, buf1, BUFLEN);
memcpy(buf3, buf1, BUFLEN);
td = rand32() / (65536.0 * 65536.0);
len = (unsigned int)(0.5 * BUFLEN * (1.0 + td));
len = AES_BLOCK_SIZE * (len / AES_BLOCK_SIZE);
CBCenc(buf2, len, iv2, ecx1);
f_cbc_enc(ecx2, buf3, buf3, len, iv3);
if(memcmp(buf2, buf3, len)) err |= 1;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 2;
if((err & 1) && !(err & 256))
printf("\nCBC encryption FAILURE");
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
CBCdec(buf2, len, iv2, dcx1);
f_cbc_dec(dcx2, buf3, buf3, len, iv3);
if(memcmp(buf1, buf2, len)) err |= 4;
if(memcmp(buf1, buf3, len)) err |= 8;
if(memcmp(buf2, buf3, len)) err |= 16;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 32;
if((err & 16) && !(err & 512))
printf("\nCBC decryption FAILURE");
if(err & 1)
err |= 256;
if(err & 16)
err |= 512;
}
if(!(err & ~(2 | 4 | 16 | 32)))
printf("\nCBC encrypt and decrypt of data correct");
if(err & (2 | 32))
{
printf(" (mismatch of final IV on ");
if(err & 2)
printf("encrypt");
if((err & (2 | 32)) == 34)
printf(" and ");
if(err & 32)
printf("decrypt");
printf(")");
}
#endif
#ifdef TEST_CFB
err = 0;
for(i = 0; i < 100; ++i)
{
block_rndfill(key, 2 * AES_BLOCK_SIZE);
f_enc_key(ecx1, key, k);
f_enc_key(ecx2, key, k);
f_dec_key(dcx1, key, k);
f_dec_key(dcx2, key, k);
block_rndfill(iv1, AES_BLOCK_SIZE);
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
block_rndfill(buf1, BUFLEN);
memcpy(buf2, buf1, BUFLEN);
memcpy(buf3, buf1, BUFLEN);
f_info(ecx1) = 0;
f_mode_reset(ecx2);
td = rand32() / (65536.0 * 65536.0);
len = (unsigned int)(0.5 * BUFLEN * (1.0 + td));
td = rand32() / (65536.0 * 65536.0);
len2 = (unsigned int)(td * len);
#ifdef WHOLE_BLOCKS
len = AES_BLOCK_SIZE * (len / AES_BLOCK_SIZE);
len2 = AES_BLOCK_SIZE * (len2 / AES_BLOCK_SIZE);
#endif
f_cfb_enc(ecx2, buf3, buf3, len2, iv3);
f_cfb_enc(ecx2, buf3 + len2, buf3 + len2, len - len2, iv3);
CFBenc(buf2, len, iv2, ecx1);
if(memcmp(buf2, buf3, len)) err |= 1;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 2;
if((err & 1) && !(err & 256))
printf("\nCFB encryption FAILURE");
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
f_info(ecx1) = 0;
f_mode_reset(ecx2);
CFBdec(buf2, len, iv2, ecx1);
td = rand32() / (65536.0 * 65536.0);
len2 = (unsigned int)(td * len);
#ifdef WHOLE_BLOCKS
len2 = AES_BLOCK_SIZE * (len2 / AES_BLOCK_SIZE);
#endif
f_cfb_dec(ecx2, buf3, buf3, len2, iv3);
f_cfb_dec(ecx2, buf3 + len2, buf3 + len2, len - len2, iv3);
if(memcmp(buf1, buf2, len)) err |= 4;
if(memcmp(buf1, buf3, len)) err |= 8;
if(memcmp(buf2, buf3, len)) err |= 16;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 32;
if((err & 16) && !(err & 512))
printf("\nCFB decryption FAILURE");
if(err & 1)
err |= 256;
if(err & 16)
err |= 512;
}
if(!(err & ~(2 | 4 | 16 | 32)))
printf("\nCFB encrypt and decrypt of data correct");
if(err & (2 | 32))
{
printf(" (mismatch of final IV on ");
if(err & 2)
printf("encrypt");
if((err & (2 | 32)) == 34)
printf(" and ");
if(err & 32)
printf("decrypt");
printf(")");
}
#endif
#ifdef TEST_OFB
err = 0;
for(i = 0; i < 100; ++i)
{
block_rndfill(key, 2 * AES_BLOCK_SIZE);
f_enc_key(ecx1, key, k);
f_enc_key(ecx2, key, k);
f_dec_key(dcx1, key, k);
f_dec_key(dcx2, key, k);
block_rndfill(iv1, AES_BLOCK_SIZE);
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
block_rndfill(buf1, BUFLEN);
memcpy(buf2, buf1, BUFLEN);
memcpy(buf3, buf1, BUFLEN);
f_info(ecx1) = 0;
f_mode_reset(ecx2);
td = rand32() / (65536.0 * 65536.0);
len = (unsigned int)(0.5 * BUFLEN * (1.0 + td));
td = rand32() / (65536.0 * 65536.0);
len2 = (unsigned int)(td * len);
#ifdef WHOLE_BLOCKS
len = AES_BLOCK_SIZE * (len / AES_BLOCK_SIZE);
len2 = AES_BLOCK_SIZE * (len2 / AES_BLOCK_SIZE);
#endif
f_ofb_cry(ecx2, buf3, buf3, len2, iv3);
f_ofb_cry(ecx2, buf3 + len2, buf3 + len2, len - len2, iv3);
OFBenc(buf2, len, iv2, ecx1);
if(memcmp(buf2, buf3, len)) err |= 1;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 2;
if((err & 1) && !(err & 256))
printf("\nOFB encryption FAILURE");
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
f_info(ecx1) = 0;
f_mode_reset(ecx2);
OFBdec(buf2, len, iv2, ecx1);
td = rand32() / (65536.0 * 65536.0);
len2 = (unsigned int)(td * len);
#ifdef WHOLE_BLOCKS
len2 = AES_BLOCK_SIZE * (len2 / AES_BLOCK_SIZE);
#endif
f_ofb_cry(ecx2, buf3, buf3, len2, iv3);
f_ofb_cry(ecx2, buf3 + len2, buf3 + len2, len - len2, iv3);
if(memcmp(buf1, buf2, len)) err |= 4;
if(memcmp(buf1, buf3, len)) err |= 8;
if(memcmp(buf2, buf3, len)) err |= 16;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 32;
if((err & 16) && !(err & 512))
printf("\nOFB decryption FAILURE");
if(err & 1)
err |= 256;
if(err & 16)
err |= 512;
}
if(!(err & ~(2 | 4 | 16 | 32)))
printf("\nOFB encrypt and decrypt of data correct");
if(err & (2 | 32))
{
printf(" (mismatch of final IV on ");
if(err & 2)
printf("encrypt");
if((err & (2 | 32)) == 34)
printf(" and ");
if(err & 32)
printf("decrypt");
printf(")");
}
#endif
#ifdef TEST_CTR
err = 0;
for(i = 0; i < 100; ++i)
{
block_rndfill(key, 2 * AES_BLOCK_SIZE);
f_enc_key(ecx1, key, k);
f_enc_key(ecx2, key, k);
f_dec_key(dcx1, key, k);
f_dec_key(dcx2, key, k);
block_rndfill(iv1, AES_BLOCK_SIZE);
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
block_rndfill(buf1, BUFLEN);
memcpy(buf2, buf1, BUFLEN);
memcpy(buf3, buf1, BUFLEN);
f_info(ecx1) = 0;
f_mode_reset(ecx2);
td = rand32() / (65536.0 * 65536.0);
len = (unsigned int)(0.5 * BUFLEN * (1.0 + td));
td = rand32() / (65536.0 * 65536.0);
len2 = (unsigned int)(td * len);
#ifdef WHOLE_BLOCKS
len = AES_BLOCK_SIZE * (len / AES_BLOCK_SIZE);
len2 = AES_BLOCK_SIZE * (len2 / AES_BLOCK_SIZE);
#endif
f_ctr_cry(ecx2, buf3, buf3, len2, iv3, ctr_inc);
f_ctr_cry(ecx2, buf3 + len2, buf3 + len2, len - len2, iv3, ctr_inc);
CTRcry(buf2, len, iv2, ctr_inc, ecx1);
if(memcmp(buf2, buf3, len)) err |= 1;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 2;
if((err & 1) && !(err & 256))
printf("\nCTR encryption FAILURE");
memcpy(iv2, iv1, AES_BLOCK_SIZE);
memcpy(iv3, iv1, AES_BLOCK_SIZE);
f_info(ecx1) = 0;
f_mode_reset(ecx2);
td = rand32() / (65536.0 * 65536.0);
len2 = (unsigned int)(td * len);
CTRcry(buf2, len, iv2, ctr_inc, ecx1);
#ifdef WHOLE_BLOCKS
len2 = AES_BLOCK_SIZE * (len2 / AES_BLOCK_SIZE);
#endif
f_ctr_cry(ecx2, buf3, buf3, len2, iv3, ctr_inc);
f_ctr_cry(ecx2, buf3 + len2, buf3 + len2, len - len2, iv3, ctr_inc);
if(memcmp(buf1, buf2, len)) err |= 4;
if(memcmp(buf1, buf3, len)) err |= 8;
if(memcmp(buf2, buf3, len)) err |= 16;
if(memcmp(iv2, iv3, AES_BLOCK_SIZE)) err |= 32;
if((err & 16) && !(err & 512))
printf("\nCTR decryption FAILURE");
if(err & 1)
err |= 256;
if(err & 16)
err |= 512;
}
if(!(err & ~(2 | 4 | 16 | 32)))
printf("\nCTR encrypt and decrypt of data correct");
if(err & (2 | 32))
{
printf(" (mismatch of final IV on ");
if(err & 2)
printf("encrypt");
if((err & (2 | 32)) == 34)
printf(" and ");
if(err & 32)
printf("decrypt");
printf(")");
}
#endif
}
#if defined( USE_VIA_ACE_IF_PRESENT )
if(VIA_ACE_AVAILABLE)
printf("\n\nAES Timing (Cycles/Byte) with the VIA ACE Engine");
else
#endif
printf("\n\nAES Timing (Cycles/Byte)");
printf("\nMode Blocks: 1 10 100 1000");
#ifdef TEST_ECB
printf("\necb encrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_ecb_enc(16, blocks, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
printf("\necb decrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_ecb_dec(16, blocks, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
#endif
#ifdef TEST_CBC
printf("\ncbc encrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_cbc_enc(16, blocks, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
printf("\ncbc decrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_cbc_dec(16, blocks, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
#endif
#ifdef TEST_CFB
printf("\ncfb encrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_cfb_enc(16, blocks, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
printf("\ncfb decrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_cfb_dec(16, blocks, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
#endif
#ifdef TEST_OFB
printf("\nofb encrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_ofb_enc(16, blocks, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
#endif
#ifdef TEST_CTR
printf("\nctr encrypt ");
for(blocks = 1; blocks < 10000; blocks *= 10)
{
time_base(&a0, &sig);
time_ctr_crypt(16, blocks, ctr_inc, &av, &sig);
sig *= 100.0 / av;
av = (int)(100.0 * (av - a0) / (16.0 * blocks)) / 100.0;
sig = (int)(10 * sig) / 10.0;
printf("%9.2f", av);
}
#endif
#if defined( DLL_IMPORT ) && defined( DYNAMIC_LINK )
if(h_dll) FreeLibrary(h_dll);
#endif
printf("\n\n");
return 0;
}
LRESULT compress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
{
xvid_gbl_init_t init;
xvid_enc_create_t create;
xvid_enc_plugin_t plugins[3];
xvid_plugin_single_t single;
xvid_plugin_2pass1_t pass1;
xvid_plugin_2pass2_t pass2;
int i;
HANDLE hFile;
CONFIG tmpCfg; /* if we want to alter config to suit our needs, it shouldn't be visible to user later */
memcpy(&tmpCfg, &codec->config, sizeof(CONFIG));
if (init_dll(codec) != 0) return ICERR_ERROR;
/* destroy previously created codec */
if(codec->ehandle) {
codec->xvid_encore_func(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
codec->ehandle = NULL;
}
memset(&init, 0, sizeof(init));
init.version = XVID_VERSION;
init.cpu_flags = codec->config.cpu;
init.debug = codec->config.debug;
codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
memset(&create, 0, sizeof(create));
create.version = XVID_VERSION;
/* plugins */
create.plugins = plugins;
switch (codec->config.mode)
{
case RC_MODE_1PASS :
memset(&single, 0, sizeof(single));
single.version = XVID_VERSION;
single.bitrate = codec->config.bitrate * CONFIG_KBPS;
single.reaction_delay_factor = codec->config.rc_reaction_delay_factor;
single.averaging_period = codec->config.rc_averaging_period;
single.buffer = codec->config.rc_buffer;
plugins[create.num_plugins].func = codec->xvid_plugin_single_func;
plugins[create.num_plugins].param = &single;
create.num_plugins++;
if (!codec->config.use_2pass_bitrate) /* constant-quant mode */
prepare_cquant_zones(&tmpCfg);
break;
case RC_MODE_2PASS1 :
memset(&pass1, 0, sizeof(pass1));
pass1.version = XVID_VERSION;
pass1.filename = codec->config.stats;
if (codec->config.full1pass)
prepare_full1pass_zones(&tmpCfg);
plugins[create.num_plugins].func = codec->xvid_plugin_2pass1_func;
plugins[create.num_plugins].param = &pass1;
create.num_plugins++;
break;
case RC_MODE_2PASS2 :
memset(&pass2, 0, sizeof(pass2));
pass2.version = XVID_VERSION;
if (codec->config.use_2pass_bitrate) {
pass2.bitrate = codec->config.bitrate * CONFIG_KBPS;
} else {
pass2.bitrate = -codec->config.desired_size; /* kilobytes */
}
pass2.filename = codec->config.stats;
hFile = CreateFile(pass2.filename, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
MessageBox(0, "Statsfile not found!","Error!", MB_ICONEXCLAMATION|MB_OK);
return XVID_ERR_FAIL;
} else
{
CloseHandle(hFile);
}
pass2.keyframe_boost = codec->config.keyframe_boost; /* keyframe boost percentage: [0..100...]; */
pass2.curve_compression_high = codec->config.curve_compression_high;
pass2.curve_compression_low = codec->config.curve_compression_low;
pass2.overflow_control_strength = codec->config.overflow_control_strength;
pass2.max_overflow_improvement = codec->config.twopass_max_overflow_improvement;
pass2.max_overflow_degradation = codec->config.twopass_max_overflow_degradation;
pass2.kfreduction = codec->config.kfreduction;
pass2.kfthreshold = codec->config.kfthreshold;
pass2.container_frame_overhead = 24; /* AVI */
plugins[create.num_plugins].func = codec->xvid_plugin_2pass2_func;
plugins[create.num_plugins].param = &pass2;
create.num_plugins++;
break;
case RC_MODE_NULL :
return ICERR_OK;
default :
break;
}
/* zones - copy from tmpCfg in case we automatically altered them above */
create.zones = malloc(sizeof(xvid_enc_zone_t) * tmpCfg.num_zones);
create.num_zones = tmpCfg.num_zones;
for (i=0; i < create.num_zones; i++) {
create.zones[i].frame = tmpCfg.zones[i].frame;
if (tmpCfg.zones[i].mode == RC_ZONE_QUANT) {
create.zones[i].mode = XVID_ZONE_QUANT;
create.zones[i].increment = tmpCfg.zones[i].quant;
}else{
create.zones[i].mode = XVID_ZONE_WEIGHT;
create.zones[i].increment = tmpCfg.zones[i].weight;
}
create.zones[i].base = 100;
}
/* lumimasking plugin */
if ((profiles[codec->config.profile].flags & PROFILE_ADAPTQUANT) && codec->config.lum_masking) {
plugins[create.num_plugins].func = codec->xvid_plugin_lumimasking_func;
plugins[create.num_plugins].param = NULL;
create.num_plugins++;
}
plugins[create.num_plugins].func = vfw_debug;
plugins[create.num_plugins].param = NULL;
create.num_plugins++;
create.profile = profiles[codec->config.profile].id;
create.width = lpbiInput->bmiHeader.biWidth;
create.height = lpbiInput->bmiHeader.biHeight;
create.fincr = codec->fincr;
create.fbase = codec->fbase;
create.max_key_interval = codec->config.max_key_interval;
create.min_quant[0] = codec->config.min_iquant;
create.max_quant[0] = codec->config.max_iquant;
create.min_quant[1] = codec->config.min_pquant;
create.max_quant[1] = codec->config.max_pquant;
create.min_quant[2] = codec->config.min_bquant;
create.max_quant[2] = codec->config.max_bquant;
if ((profiles[codec->config.profile].flags & PROFILE_BVOP) && codec->config.use_bvop) {
create.max_bframes = codec->config.max_bframes;
create.bquant_ratio = codec->config.bquant_ratio;
create.bquant_offset = codec->config.bquant_offset;
if (codec->config.packed)
create.global |= XVID_GLOBAL_PACKED;
if (codec->config.closed_gov)
create.global |= XVID_GLOBAL_CLOSED_GOP;
}
create.frame_drop_ratio = codec->config.frame_drop_ratio;
create.num_threads = codec->config.num_threads;
switch(codec->xvid_encore_func(0, XVID_ENC_CREATE, &create, NULL))
{
case XVID_ERR_FAIL :
return ICERR_ERROR;
case XVID_ERR_MEMORY :
return ICERR_MEMORY;
case XVID_ERR_FORMAT :
return ICERR_BADFORMAT;
case XVID_ERR_VERSION :
return ICERR_UNSUPPORTED;
}
free(create.zones);
codec->ehandle = create.handle;
codec->framenum = 0;
codec->keyspacing = 0;
if (codec->config.display_status) {
status_destroy_always(&codec->status);
status_create(&codec->status, codec->fincr, codec->fbase);
}
return ICERR_OK;
}
HWND njasiodrv_create_asio_configdlg(HWND parent, asio_config_type *cfg)
{
init_dll();
return cacd?cacd(parent,cfg):NULL;
}
audioStreamer *njasiodrv_create_asio_streamer(char **dev, SPLPROC proc)
{
init_dll();
return cas?cas(dev,proc):NULL;
}
int njasiodrv_avail(void)
{
init_dll();
return cas && cacd;
}
int main(int argc, char *argv[])
{ int do_cmp, tyf[4], kf[3], ki;
f_ectx alg[1];
#if defined(DLL_IMPORT) && defined(DLL_DYNAMIC_LOAD)
HINSTANCE h_dll;
if(!(h_dll = init_dll(&fn)))
return -1;
#else
aes_init();
#endif
if(argc == 1)
{
printf("\nusage: aes_gav /t:[knec] /k:[468] [/c]");
printf("\n");
printf("\nwhere the symbols in square brackets can be used in");
printf("\nany combination (without the brackets) and have the");
printf("\nfollowing meanings:");
printf("\n");
printf("\n /t:[knec] selects which tests are used");
printf("\n /k:[468] selects the key lengths used");
printf("\n /c compares output with reference");
printf("\nwhere:");
printf("\n k: generate ECB Known Answer Test files");
printf("\n n: generate ECB Known Answer Test files (new)");
printf("\n e: generate ECB Monte Carlo Test files");
printf("\n c: generate CBC Monte Carlo Test files");
printf("\n");
printf("\nand the characters giving block and key lengths are");
printf("\ndigits representing the lengths in 32-bit units.\n\n");
exit(0);
}
printf("\nRun tests for the AES algorithm %s",
#if defined(DLL_IMPORT)
" (DLL Version)\n");
#elif defined(AES_CPP)
" (CPP Version)\n");
#else
"");
#endif
do_cmp = test_args(argc, argv, 'c', '\0');
tyf[0] = test_args(argc, argv, 't', 'k');
tyf[1] = test_args(argc, argv, 't', 'n');
tyf[2] = test_args(argc, argv, 't', 'e');
tyf[3] = test_args(argc, argv, 't', 'c');
kf[0] = test_args(argc, argv, 'k', '4');
kf[1] = test_args(argc, argv, 'k', '6');
kf[2] = test_args(argc, argv, 'k', '8');
if(!(kf[0] || kf[1] || kf[2]))
{
kf[0] = kf[1] = kf[2] = TRUE; // AES key sizes if not specified
}
for(ki = 0; ki < 3; ++ki) if(kf[ki])
{
do_tests(do_cmp, tyf, alg, 16, 16 + 8 * ki);
}
#if defined(DLL_IMPORT) && defined(DLL_DYNAMIC_LOAD)
if(h_dll) FreeLibrary(h_dll);
#endif
printf("\n\n");
return 0;
}
LRESULT compress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
{
xvid_gbl_init_t init;
xvid_enc_create_t create;
xvid_enc_plugin_t plugins[3];
xvid_plugin_single_t single;
xvid_plugin_2pass1_t pass1;
xvid_plugin_2pass2_t pass2;
xvid_plugin_lumimasking_t masking;
xvid_gbl_info_t info;
int i;
HANDLE hFile;
const quality_t* quality_preset = (codec->config.quality==quality_table_num) ?
&codec->config.quality_user : &quality_table[codec->config.quality];
CONFIG tmpCfg; /* if we want to alter config to suit our needs, it shouldn't be visible to user later */
memcpy(&tmpCfg, &codec->config, sizeof(CONFIG));
if (init_dll(codec) != 0) return ICERR_ERROR;
/* destroy previously created codec */
if(codec->ehandle) {
codec->xvid_encore_func(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
codec->ehandle = NULL;
}
memset(&init, 0, sizeof(init));
init.version = XVID_VERSION;
init.cpu_flags = codec->config.cpu;
init.debug = codec->config.debug;
codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
memset(&info, 0, sizeof(info));
info.version = XVID_VERSION;
codec->xvid_global_func(0, XVID_GBL_INFO, &info, NULL);
memset(&create, 0, sizeof(create));
create.version = XVID_VERSION;
/* Encoder threads */
if (codec->config.cpu & XVID_CPU_FORCE)
create.num_threads = codec->config.num_threads;
else
create.num_threads = info.num_threads; /* Autodetect */
/* Encoder slices */
if ((profiles[codec->config.profile].flags & PROFILE_RESYNCMARKER) && codec->config.num_slices != 1) {
if (codec->config.num_slices == 0) { /* auto */
int mb_width = (lpbiInput->bmiHeader.biWidth + 15) / 16;
int mb_height = (lpbiInput->bmiHeader.biHeight + 15) / 16;
int slices = (int)((mb_width*mb_height) / 811); /* use multiple slices only above SD resolutions for now */
if (slices > 1) {
if (create.num_threads <= 1)
slices &= ~1; /* make even */
else if (create.num_threads <= slices)
slices = (slices / create.num_threads) * create.num_threads; /* multiple of threads */
else if (create.num_threads % slices)
slices = (!(create.num_threads%2)) ? (create.num_threads/2) : (create.num_threads/3);
}
create.num_slices = slices;
}
else {
create.num_slices = codec->config.num_slices; /* force manual value - by registry edit */
}
}
/* plugins */
create.plugins = plugins;
switch (codec->config.mode)
{
case RC_MODE_1PASS :
memset(&single, 0, sizeof(single));
single.version = XVID_VERSION;
single.bitrate = codec->config.bitrate * CONFIG_KBPS;
single.reaction_delay_factor = codec->config.rc_reaction_delay_factor;
single.averaging_period = codec->config.rc_averaging_period;
single.buffer = codec->config.rc_buffer;
plugins[create.num_plugins].func = codec->xvid_plugin_single_func;
plugins[create.num_plugins].param = &single;
create.num_plugins++;
if (!codec->config.use_2pass_bitrate) /* constant-quant mode */
prepare_cquant_zones(&tmpCfg);
break;
case RC_MODE_2PASS1 :
memset(&pass1, 0, sizeof(pass1));
pass1.version = XVID_VERSION;
pass1.filename = codec->config.stats;
if (codec->config.full1pass)
prepare_full1pass_zones(&tmpCfg);
plugins[create.num_plugins].func = codec->xvid_plugin_2pass1_func;
plugins[create.num_plugins].param = &pass1;
create.num_plugins++;
break;
case RC_MODE_2PASS2 :
memset(&pass2, 0, sizeof(pass2));
pass2.version = XVID_VERSION;
if (codec->config.use_2pass_bitrate) {
pass2.bitrate = codec->config.bitrate * CONFIG_KBPS;
} else {
pass2.bitrate = -codec->config.desired_size; /* kilobytes */
}
pass2.filename = codec->config.stats;
hFile = CreateFile(pass2.filename, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
MessageBox(0, "Statsfile not found!","Error!", MB_ICONEXCLAMATION|MB_OK);
return XVID_ERR_FAIL;
} else
{
CloseHandle(hFile);
}
pass2.keyframe_boost = codec->config.keyframe_boost; /* keyframe boost percentage: [0..100...]; */
pass2.curve_compression_high = codec->config.curve_compression_high;
pass2.curve_compression_low = codec->config.curve_compression_low;
pass2.overflow_control_strength = codec->config.overflow_control_strength;
pass2.max_overflow_improvement = codec->config.twopass_max_overflow_improvement;
pass2.max_overflow_degradation = codec->config.twopass_max_overflow_degradation;
pass2.kfreduction = codec->config.kfreduction;
pass2.kfthreshold = codec->config.kfthreshold;
pass2.container_frame_overhead = 24; /* AVI */
/* VBV */
pass2.vbv_size = profiles[codec->config.profile].max_vbv_size;
pass2.vbv_initial = (profiles[codec->config.profile].max_vbv_size*3)/4; /* 75% */
pass2.vbv_maxrate = profiles[codec->config.profile].max_bitrate;
pass2.vbv_peakrate = profiles[codec->config.profile].vbv_peakrate;
plugins[create.num_plugins].func = codec->xvid_plugin_2pass2_func;
plugins[create.num_plugins].param = &pass2;
create.num_plugins++;
break;
case RC_MODE_NULL :
return ICERR_OK;
default :
break;
}
/* zones - copy from tmpCfg in case we automatically altered them above */
create.zones = malloc(sizeof(xvid_enc_zone_t) * tmpCfg.num_zones);
create.num_zones = tmpCfg.num_zones;
for (i=0; i < create.num_zones; i++) {
create.zones[i].frame = tmpCfg.zones[i].frame;
if (tmpCfg.zones[i].mode == RC_ZONE_QUANT) {
create.zones[i].mode = XVID_ZONE_QUANT;
create.zones[i].increment = tmpCfg.zones[i].quant;
}else{
create.zones[i].mode = XVID_ZONE_WEIGHT;
create.zones[i].increment = tmpCfg.zones[i].weight;
}
create.zones[i].base = 100;
}
/* lumimasking plugin */
if ((profiles[codec->config.profile].flags & PROFILE_ADAPTQUANT) && (codec->config.lum_masking>0)) {
memset(&masking, 0, sizeof(masking));
masking.method = (codec->config.lum_masking==2);
plugins[create.num_plugins].func = codec->xvid_plugin_lumimasking_func;
plugins[create.num_plugins].param = &masking;
create.num_plugins++;
}
plugins[create.num_plugins].func = vfw_debug;
plugins[create.num_plugins].param = NULL;
create.num_plugins++;
create.profile = profiles[codec->config.profile].id;
create.width = lpbiInput->bmiHeader.biWidth;
create.height = lpbiInput->bmiHeader.biHeight;
create.fincr = codec->fincr;
create.fbase = codec->fbase;
create.max_key_interval = quality_preset->max_key_interval;
create.min_quant[0] = quality_preset->min_iquant;
create.max_quant[0] = quality_preset->max_iquant;
create.min_quant[1] = quality_preset->min_pquant;
create.max_quant[1] = quality_preset->max_pquant;
create.min_quant[2] = quality_preset->min_bquant;
create.max_quant[2] = quality_preset->max_bquant;
if ((profiles[codec->config.profile].flags & PROFILE_BVOP) && codec->config.use_bvop) {
/* dxn: prevent bframes usage if interlacing is selected */
if (!((profiles[codec->config.profile].flags & PROFILE_EXTRA) && codec->config.interlacing)) {
create.max_bframes = codec->config.max_bframes;
create.bquant_ratio = codec->config.bquant_ratio;
create.bquant_offset = codec->config.bquant_offset;
if (codec->config.packed)
create.global |= XVID_GLOBAL_PACKED;
create.global |= XVID_GLOBAL_CLOSED_GOP;
/* restrict max bframes */
if ((create.max_bframes > profiles[codec->config.profile].xvid_max_bframes) && (profiles[codec->config.profile].xvid_max_bframes >= 0))
create.max_bframes = profiles[codec->config.profile].xvid_max_bframes;
/* DXN: enable packed bframes */
if ((profiles[codec->config.profile].flags & PROFILE_PACKED)) {
create.global |= XVID_GLOBAL_PACKED;
}
}
}
/* dxn: always write divx5 userdata */
if ((profiles[codec->config.profile].flags & PROFILE_EXTRA))
create.global |= XVID_GLOBAL_DIVX5_USERDATA;
if ((profiles[codec->config.profile].flags & PROFILE_EXTRA) ||
(profiles[codec->config.profile].flags & PROFILE_XVID)) {
create.frame_drop_ratio = 0;
} else {
create.frame_drop_ratio = quality_preset->frame_drop_ratio;
}
switch(codec->xvid_encore_func(0, XVID_ENC_CREATE, &create, NULL))
{
case XVID_ERR_FAIL :
return ICERR_ERROR;
case XVID_ERR_MEMORY :
return ICERR_MEMORY;
case XVID_ERR_FORMAT :
return ICERR_BADFORMAT;
case XVID_ERR_VERSION :
return ICERR_UNSUPPORTED;
}
free(create.zones);
codec->ehandle = create.handle;
codec->framenum = 0;
codec->keyspacing = 0;
if (codec->config.display_status) {
status_destroy_always(&codec->status);
status_create(&codec->status, codec->fincr, codec->fbase);
}
return ICERR_OK;
}
