static void
conversionview_scale_cb( GtkWidget *wid, Conversionview *cv )
{
Imagemodel *imagemodel = cv->imagemodel;
double min, max;
progress_begin();
if( !conversionview_findmaxmin( imagemodel, &min, &max ) ) {
progress_end();
iwindow_alert( wid, GTK_MESSAGE_ERROR );
return;
}
progress_end();
if( max - min < 1e-20 ) {
error_top( _( "Unable to scale image." ) );
error_sub( _( "Maximum and minimum pixel values are equal." ) );
iwindow_alert( wid, GTK_MESSAGE_ERROR );
return;
}
imagemodel->scale = 255.0 / (max - min);
imagemodel->offset = -(min * imagemodel->scale);
iobject_changed( IOBJECT( imagemodel ) );
}
bool liquid_reflection_maps_create(void)
{
bool ok;
char err_str[256];
if (os_dialog_confirm("Build Liquid Reflection Maps","Building liquids reflection maps will replace the 6th sets of textures and save the map.\nAre you sure you want to build the liquid reflection maps?",FALSE)!=0) return(FALSE);
// see if there are any liquids
if (map.liquid.nliquid==0) {
os_dialog_alert("Can not build liquid reflection maps","There are no liquids set to build reflection maps in this map.");
return(FALSE);
}
if (map.liquid.nliquid>max_liquid_reflection_map_textures) {
os_dialog_alert("Can not build liquid reflection maps","There are too many liquids set to build reflection maps in this map.");
return(FALSE);
}
// generate the reflection maps
progress_start("Generating Liquid Reflection Maps...",(2+map.liquid.nliquid));
ok=liquid_reflection_maps_create_process(map.liquid.nliquid,err_str);
progress_end();
if (!ok) {
os_dialog_alert("Can not build liquid reflection maps",err_str);
return(FALSE);
}
file_save_map();
return(TRUE);
}
static void pop_file_timeline(void)
{
HQASSERT(!stack_empty(), "file timeline stack empty");
progress_end(&aReadFile[maxIndex].tl_ref);
aReadFile[maxIndex].flptr = NULL;
maxIndex--;
}
static void program_file(const char *file, uint32_t start, uint32_t size)
{
int fd, rc;
ssize_t len;
uint32_t actual_size = 0;
fd = open(file, O_RDONLY);
if (fd == -1) {
perror("Failed to open file");
exit(1);
}
printf("About to program \"%s\" at 0x%08x..0x%08x !\n",
file, start, start + size);
check_confirm();
if (dummy_run) {
printf("skipped (dummy)\n");
close(fd);
return;
}
printf("Programming & Verifying...\n");
progress_init(size >> 8);
while(size) {
len = read(fd, file_buf, FILE_BUF_SIZE);
if (len < 0) {
perror("Error reading file");
exit(1);
}
if (len == 0)
break;
if (len > size)
len = size;
size -= len;
actual_size += len;
rc = blocklevel_write(bl, start, file_buf, len);
if (rc) {
if (rc == FLASH_ERR_VERIFY_FAILURE)
fprintf(stderr, "Verification failed for"
" chunk at 0x%08x\n", start);
else
fprintf(stderr, "Flash write error %d for"
" chunk at 0x%08x\n", rc, start);
exit(1);
}
start += len;
progress_tick(actual_size >> 8);
}
progress_end();
close(fd);
/* If this is a flash partition, adjust its size */
if (ffsh && ffs_index >= 0) {
printf("Updating actual size in partition header...\n");
ffs_update_act_size(ffsh, ffs_index, actual_size);
}
}
static void erase_range(uint32_t start, uint32_t size, bool will_program)
{
uint32_t done = 0;
int rc;
printf("About to erase 0x%08x..0x%08x !\n", start, start + size);
check_confirm();
if (dummy_run) {
printf("skipped (dummy)\n");
return;
}
printf("Erasing...\n");
progress_init(size >> 8);
while(size) {
/* If aligned to 64k and at least 64k, use 64k erase */
if ((start & 0xffff) == 0 && size >= 0x10000) {
rc = blocklevel_erase(bl, start, 0x10000);
if (rc) {
fprintf(stderr, "Error %d erasing 0x%08x\n",
rc, start);
exit(1);
}
start += 0x10000;
size -= 0x10000;
done += 0x10000;
} else {
rc = blocklevel_erase(bl, start, 0x1000);
if (rc) {
fprintf(stderr, "Error %d erasing 0x%08x\n",
rc, start);
exit(1);
}
start += 0x1000;
size -= 0x1000;
done += 0x1000;
}
progress_tick(done >> 8);
}
progress_end();
/* If this is a flash partition, mark it empty if we aren't
* going to program over it as well
*/
if (ffsh && ffs_index >= 0 && !will_program) {
printf("Updating actual size in partition header...\n");
ffs_update_act_size(ffsh, ffs_index, 0);
}
}
static void set_ecc(uint32_t start, uint32_t size)
{
uint32_t i = start + 8;
uint8_t ecc = 0;
printf("About to erase and set ECC bits in region 0x%08x to 0x%08x\n", start, start + size);
check_confirm();
erase_range(start, size, true);
printf("Programming ECC bits...\n");
progress_init(size);
while (i < start + size) {
blocklevel_write(bl, i, &ecc, sizeof(ecc));
i += 9;
progress_tick(i - start);
}
progress_end();
}
static void do_read_file(const char *file, uint32_t start, uint32_t size)
{
int fd, rc;
ssize_t len;
uint32_t done = 0;
fd = open(file, O_WRONLY | O_TRUNC | O_CREAT, 00666);
if (fd == -1) {
perror("Failed to open file");
exit(1);
}
printf("Reading to \"%s\" from 0x%08x..0x%08x !\n",
file, start, start + size);
progress_init(size >> 8);
while(size) {
len = size > FILE_BUF_SIZE ? FILE_BUF_SIZE : size;
rc = blocklevel_read(bl, start, file_buf, len);
if (rc) {
fprintf(stderr, "Flash read error %d for"
" chunk at 0x%08x\n", rc, start);
exit(1);
}
rc = write(fd, file_buf, len);
if (rc < 0) {
perror("Error writing file");
exit(1);
}
start += len;
size -= len;
done += len;
progress_tick(done >> 8);
}
progress_end();
close(fd);
}
void analyze_masters(int argc, char *argv[],
import_options_t *analyzer,
forest_t *forest)
/* main entry point; collect and parse CVS masters */
{
char name[PATH_MAX];
const char *last = NULL;
char *file;
size_t i, j = 1;
int c;
#ifdef THREADS
pthread_attr_t attr;
/* Initialize and reinforce default thread non-detached attribute */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
#endif /* THREADS */
striplen = analyzer->striplen;
forest->textsize = forest->filecount = 0;
progress_begin("Reading file list...", NO_MAX);
for (;;)
{
struct stat stb;
int l;
if (argc < 2) {
/* coverity[tainted_data] Safe, never handed to exec */
if (fgets(name, sizeof(name), stdin) == NULL)
break;
l = strlen(name);
if (name[l-1] == '\n')
name[l-1] = '\0';
file = name;
} else {
file = argv[j++];
if (!file)
break;
}
if (stat(file, &stb) != 0)
continue;
else if (S_ISDIR(stb.st_mode) != 0)
continue;
else if (!analyzer->promiscuous)
{
char *end = file + strlen(file);
if (end - file < 2 || end[-1] != 'v' || end[-2] != ',')
continue;
if (strstr(file, "CVSROOT") != NULL)
continue;
}
forest->textsize += stb.st_size;
fn = xcalloc(1, sizeof(rev_filename), "filename gathering");
*fn_tail = fn;
fn_tail = (rev_filename **)&fn->next;
if (striplen > 0 && last != NULL) {
c = strcommonendingwith(file, last, '/');
if (c < striplen)
striplen = c;
} else if (striplen < 0) {
striplen = 0;
for (i = 0; i < strlen(file); i++)
if (file[i] == '/')
striplen = i + 1;
}
fn->file = atom(file);
last = fn->file;
total_files++;
if (progress && total_files % 100 == 0)
progress_jump(total_files);
}
forest->filecount = total_files;
generators = xcalloc(sizeof(generator_t), total_files, "Generators");
sorted_files = xmalloc(sizeof(rev_file) * total_files, "sorted_files");
cvs_masters = xcalloc(total_files, sizeof(cvs_master), "cvs_masters");
rev_masters = xmalloc(sizeof(rev_master) * total_files, "rev_masters");
fn_n = total_files;
i = 0;
rev_filename *tn;
for (fn = fn_head; fn; fn = tn) {
tn = fn->next;
sorted_files[i].name = fn->file;
sorted_files[i++].rectified = atom_rectify_name(fn->file);
free(fn);
}
#ifdef FILESORT
/*
* Sort list of files in path_deep_compare order of output name.
* cvs_masters and rev_masters will be mainteined in this order.
* This causes commits to come out in correct pack order.
* It also causes operations to come out in correct fileop_sort order.
* Note some output names are different to input names.
* e.g. .cvsignore becomes .gitignore
*/
qsort(sorted_files, total_files, sizeof(rev_file), file_compare);
#endif /*FILESORT */
progress_end("done, %.3fKB in %d files",
(forest->textsize/1024.0), forest->filecount);
/* things that must be visible to inner functions */
load_current_file = 0;
verbose = analyzer->verbose;
/*
* Analyze the files for CVS revision structure.
*
* The result of this analysis is a rev_list, each element of
* which corresponds to a CVS master and points at a list of named
* CVS branch heads (rev_refs), each one of which points at a list
* of CVS commit structures (cvs_commit).
*/
#ifdef THREADS
if (threads > 1)
snprintf(name, sizeof(name),
"Analyzing masters with %d threads...", threads);
else
#endif /* THREADS */
strcpy(name, "Analyzing masters...");
progress_begin(name, total_files);
#ifdef THREADS
if (threads > 1)
{
int i;
workers = (pthread_t *)xcalloc(threads, sizeof(pthread_t), __func__);
for (i = 0; i < threads; i++)
pthread_create(&workers[i], &attr, worker, NULL);
/* Wait for all the threads to die off. */
for (i = 0; i < threads; i++)
pthread_join(workers[i], NULL);
pthread_mutex_destroy(&enqueue_mutex);
pthread_mutex_destroy(&revlist_mutex);
}
else
#endif /* THREADS */
worker(NULL);
progress_end("done, %d revisions", (int)total_revisions);
free(sorted_files);
forest->errcount = err;
forest->total_revisions = total_revisions;
forest->skew_vulnerable = skew_vulnerable;
forest->cvs = cvs_masters;
forest->generators = (generator_t *)generators;
}
