/* FOLLOWING FUNCTIONS USED FOR TRACES IN TESTING AND DEBUGGING */
void dump_waitinglist (FILE * stream, bool statstoo)
{
int nb, x, y, *p;
fprintf (stream, "== START DUMP_WAITINGLIST ==\n");
if (statstoo) {
fprintf (stream, "waitlist_inited = %s\n", boolstr(waitlist_inited));
fprintf (stream, "waitinglist = %p\n", (void *)waitinglist);
fprintf (stream, "wait_curr = %p\n", (void *)wait_curr);
fprintf (stream, "wait_max = %p\n", (void *)wait_max);
}
if (waitlist_inited) {
if (0 != (wait_curr - waitinglist) % 2) {
fprintf (stderr, "ERROR: %s: nb elems in waitinglist should be even.\n", __func__);
fail();
}
if (statstoo) {
fprintf (stream, "Total capacity:\t%ld ints\n", wait_max - waitinglist);
fprintf (stream, "Used capacity:\t%ld ints\n", wait_curr - waitinglist);
fprintf (stream, "Remaining cap.:\t%ld ints\n", wait_max - wait_curr);
}
}
nb = 0; p = waitinglist;
while (p < wait_curr) {
x = *(p++); y = *(p++); nb++;
fprintf (stream, "WL[%d] = (%d,%d)\n", nb, x, y);
}
}
static void print_info(struct ddb *db)
{
static const char yes[] = "true";
static const char no[] = "false";
const char *boolstr(int boolean) { return boolean ? yes: no; }
ddb_features_t feat;
ddb_features(db, feat);
printf("Total size: %llu bytes\n", FEAT(DDB_TOTAL_SIZE));
printf("Items size: %llu bytes\n", FEAT(DDB_ITEMS_SIZE));
printf("Values size: %llu bytes\n", FEAT(DDB_VALUES_SIZE));
printf("Number of keys: %llu\n", FEAT(DDB_NUM_KEYS));
printf("Number of items: %llu\n", FEAT(DDB_NUM_VALUES));
printf("Number of unique values: %llu\n", FEAT(DDB_NUM_UNIQUE_VALUES));
printf("Compressed? %s\n", boolstr(feat[DDB_IS_COMPRESSED]));
printf("Hashed? %s\n", boolstr(feat[DDB_IS_HASHED]));
printf("Multiset? %s\n", boolstr(feat[DDB_IS_MULTISET]));
}
void status(int argc, char **argv)
{
safelock_status_t status;
int err, i;
for (i = 1; i < argc; i++ ) {
err = safelock_fetch_file_status(argv[i], &status);
if (err)
safelock_die(err, "Unable to fetch status: %s", argv[i]);
printf("%s: locked = %s, crashed = %s", argv[i],
boolstr(status.locked), boolstr(status.crashed));
if (status.data_valid)
printf(", PID = %ld, age = %lu, data = %d",
(long)status.pid, (unsigned long)status.age, status.data);
printf("\n");
}
}
void GUIoptions(){
//GUI设置菜单
gui::Form MainForm;
int leftp = windowwidth / 2 - 250;
int rightp = windowwidth / 2 + 250;
int midp = windowwidth / 2;
int upp = 60;
int downp = windowheight - 20;
int lspc = 36;
bool f = false;
MainForm.Init();
TextRenderer::setFontColor(1.0, 1.0, 1.0, 1.0);
gui::label* title = MainForm.createlabel("===============< 图形界面选项 >==============");
gui::button* fontbtn = MainForm.createbutton("全部使用Unicode字体：" + boolstr(TextRenderer::useUnicodeASCIIFont));
gui::button* backbtn = MainForm.createbutton("<< 返回选项菜单");
do{
leftp=windowwidth/2-250;
rightp=windowwidth/2+250;
midp=windowwidth/2;
downp=windowheight-20;
title->resize(midp-225,midp+225,20,36);
fontbtn->resize(leftp,midp-10,upp+lspc*0,upp+lspc*0+24);
backbtn->resize(leftp,rightp,downp-24,downp);
//更新GUI
glfwGetCursorPos(MainWindow, &mx, &my);
MainForm.mousedata((int)mx, (int)my, mw, mb);
MainForm.update();
if(fontbtn->clicked) TextRenderer::useUnicodeASCIIFont=!TextRenderer::useUnicodeASCIIFont;
if(backbtn->clicked) f=true;
fontbtn->text="全部使用Unicode字体：" + boolstr(TextRenderer::useUnicodeASCIIFont);
MainForm.render();
glfwSwapBuffers(MainWindow);
glfwPollEvents();
if (glfwWindowShouldClose(MainWindow)) exit(0);
} while (!f);
MainForm.cleanup();
}
//------------------------------------------------------------------------
// llgl_dump()
//------------------------------------------------------------------------
void llgl_dump()
{
int i;
F32 fv[16];
GLboolean b;
LL_INFOS() << "==========================" << LL_ENDL;
LL_INFOS() << "OpenGL State" << LL_ENDL;
LL_INFOS() << "==========================" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "Current Values" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
glGetFloatv(GL_CURRENT_COLOR, fv);
LL_INFOS() << "GL_CURRENT_COLOR : " << fv4(fv) << LL_ENDL;
glGetFloatv(GL_CURRENT_NORMAL, fv);
LL_INFOS() << "GL_CURRENT_NORMAL : " << fv3(fv) << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "Lighting" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "GL_LIGHTING : " << boolstr(glIsEnabled(GL_LIGHTING)) << LL_ENDL;
LL_INFOS() << "GL_COLOR_MATERIAL : " << boolstr(glIsEnabled(GL_COLOR_MATERIAL)) << LL_ENDL;
glGetIntegerv(GL_COLOR_MATERIAL_PARAMETER, (GLint*)&i);
LL_INFOS() << "GL_COLOR_MATERIAL_PARAMETER: " << cmstr(i) << LL_ENDL;
glGetIntegerv(GL_COLOR_MATERIAL_FACE, (GLint*)&i);
LL_INFOS() << "GL_COLOR_MATERIAL_FACE : " << facestr(i) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_AMBIENT, fv);
LL_INFOS() << "GL_AMBIENT material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, fv);
LL_INFOS() << "GL_DIFFUSE material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_SPECULAR, fv);
LL_INFOS() << "GL_SPECULAR material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_EMISSION, fv);
LL_INFOS() << "GL_EMISSION material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_SHININESS, fv);
LL_INFOS() << "GL_SHININESS material : " << fv1(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetFloatv(GL_LIGHT_MODEL_AMBIENT, fv);
LL_INFOS() << "GL_LIGHT_MODEL_AMBIENT : " << fv4(fv) << LL_ENDL;
glGetBooleanv(GL_LIGHT_MODEL_LOCAL_VIEWER, &b);
LL_INFOS() << "GL_LIGHT_MODEL_LOCAL_VIEWER: " << boolstr(b) << LL_ENDL;
glGetBooleanv(GL_LIGHT_MODEL_TWO_SIDE, &b);
LL_INFOS() << "GL_LIGHT_MODEL_TWO_SIDE : " << boolstr(b) << LL_ENDL;
for (int l=0; l<8; l++)
{
b = glIsEnabled(GL_LIGHT0+l);
LL_INFOS() << "GL_LIGHT" << l << " : " << boolstr(b) << LL_ENDL;
if (!b)
continue;
glGetLightfv(GL_LIGHT0+l, GL_AMBIENT, fv);
LL_INFOS() << " GL_AMBIENT light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_DIFFUSE, fv);
LL_INFOS() << " GL_DIFFUSE light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPECULAR, fv);
LL_INFOS() << " GL_SPECULAR light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_POSITION, fv);
LL_INFOS() << " GL_POSITION light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_CONSTANT_ATTENUATION, fv);
LL_INFOS() << " GL_CONSTANT_ATTENUATION : " << fv1(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_QUADRATIC_ATTENUATION, fv);
LL_INFOS() << " GL_QUADRATIC_ATTENUATION : " << fv1(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPOT_DIRECTION, fv);
LL_INFOS() << " GL_SPOT_DIRECTION : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPOT_EXPONENT, fv);
LL_INFOS() << " GL_SPOT_EXPONENT : " << fv1(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPOT_CUTOFF, fv);
LL_INFOS() << " GL_SPOT_CUTOFF : " << fv1(fv) << LL_ENDL;
}
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "Pixel Operations" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "GL_ALPHA_TEST : " << boolstr(glIsEnabled(GL_ALPHA_TEST)) << LL_ENDL;
LL_INFOS() << "GL_DEPTH_TEST : " << boolstr(glIsEnabled(GL_DEPTH_TEST)) << LL_ENDL;
glGetBooleanv(GL_DEPTH_WRITEMASK, &b);
LL_INFOS() << "GL_DEPTH_WRITEMASK : " << boolstr(b) << LL_ENDL;
LL_INFOS() << "GL_BLEND : " << boolstr(glIsEnabled(GL_BLEND)) << LL_ENDL;
LL_INFOS() << "GL_DITHER : " << boolstr(glIsEnabled(GL_DITHER)) << LL_ENDL;
}
int verify_id3v2_header(struct id3v2_header *header) {
if (strcmp(header->id, ID3V2_FILE_IDENTIFIER)) {
debug("Tag ID %s should be %s", header->id, ID3V2_FILE_IDENTIFIER);
return 0;
} else if (header->version > ID3V2_SUPPORTED_VERSION) {
debug("Tag version %"PRIu8" higher than supported version %d",
header->version, ID3V2_SUPPORTED_VERSION);
return 0;
} else if (header->frame_data_len > 0 && header->frame_data == NULL) {
debug("Tag frame data is NULL");
return 0;
} else if (header->frame_data_len > header->tag_size) {
debug("Tag frame data len %zu > tag size %"PRIu32,
header->frame_data_len, header->tag_size);
return 0;
} else if (header->frame_data_len && header->i >= header->frame_data_len) {
debug("Tag frame data index %zu >= frame data len %zu",
header->i, header->frame_data_len);
return 0;
}
if (header->extheader_present &&
header->extheader.flag_size != ID3V2_EXTENDED_FLAG_SIZE) {
debug("Extended header flag size %"PRIu8" should be %d",
header->extheader.flag_size, ID3V2_EXTENDED_FLAG_SIZE);
return 0;
}
if (header->footer_present) {
if (strcmp(header->footer.id, ID3V2_FOOTER_IDENTIFIER)) {
debug("Footer ID %s should be %s",
header->footer.id, ID3V2_FOOTER_IDENTIFIER);
return 0;
} else if (header->footer.version > ID3V2_SUPPORTED_VERSION) {
debug("Footer version %"PRIu8" higher than supported version %d",
header->footer.version, ID3V2_SUPPORTED_VERSION);
return 0;
} else if (header->footer.version != header->version) {
debug("Footer version %"PRIu8" != header version %"PRIu8,
header->footer.version, header->version);
return 0;
} else if (header->footer.revision != header->revision) {
debug("Footer revision %"PRIu8" != header revision %"PRIu8,
header->footer.revision, header->revision);
return 0;
} else if (header->footer.unsynchronization !=
header->unsynchronization) {
debug("Footer unsynchronization %s != header unsynchronization %s",
boolstr(header->footer.unsynchronization),
boolstr(header->unsynchronization));
return 0;
} else if (header->footer.extheader_present !=
header->extheader_present) {
debug("Footer ext header %s != header ext header %s",
boolstr(header->footer.extheader_present),
boolstr(header->extheader_present));
return 0;
} else if (header->footer.experimental != header->experimental) {
debug("Footer experimental %s != header experimental %s",
boolstr(header->footer.experimental),
boolstr(header->experimental));
return 0;
} else if (header->footer.footer_present != header->footer_present) {
debug("Footer footer %s != header footer %s",
boolstr(header->footer.footer_present),
boolstr(header->footer_present));
return 0;
}
}
return 1;
}
