GLOBAL(void)jinit_compress_master(j_compress_ptr cinfo)
{
/* Initialize master control (includes parameter checking/processing) */
jinit_c_master_control(cinfo);
/* Preprocessing */
#ifndef JPEG_ENC_OPT
/* Forward DCT */
#ifndef DBUG_pk0157s
jinit_forward_dct(cinfo);
#endif
#endif
/* Entropy encoding: either Huffman or arithmetic coding. */
#ifndef JPEG_ENC_OPT //bmy 04.12.29 jpeg_enc_opt +
jinit_huff_encoder(cinfo);
#endif //bmy 04.12.29 jpeg_enc_opt +
/* Need a full-image coefficient buffer in any multi-pass mode. */
jinit_c_coef_controller(cinfo);
/* We can now tell the memory manager to allocate virtual arrays. */
// realize_virt_arrays ((j_common_ptr) cinfo);
/* Write the datastream header (SOI) immediately.
* Frame and scan headers are postponed till later.
* This lets application insert special markers after the SOI.
*/
write_file_header(cinfo);
}
int analyse_dir(DIR *dir, int tar, t_count *count, char *path)
{
char *full_path;
struct dirent *directory;
static int loop = 0;
int is_directory;
if (++loop && loop >= 40000 && write(2, "Too many files\n", 15) > -2)
return (0);
if ((full_path = NULL) == 0 &&
((directory = readdir(dir)) == NULL || path == NULL))
return (0);
if (strcmp(directory->d_name, "..") == 0 ||
strcmp(directory->d_name, ".") == 0)
return (analyse_dir(dir, tar, count, path));
if ((is_directory = is_dir(directory->d_name, path)) == -1 ||
((full_path = set_fullpath(directory->d_name, path, full_path))) == NULL)
return (0);
if (is_directory == 0)
write_file_header(full_path, tar, count);
else if (is_directory == 1)
write_dir_header(full_path, tar, count);
if (path != NULL && directory != NULL)
return (analyse_dir(dir, tar, count, path));
return (0);
}
int file_msg_logger::open(const char* filename)
{
fd_mut.lock();
if(fd != -1) {
ERROR("file already open\n");
fd_mut.unlock();
return -1;
}
fd = ::open(filename,O_WRONLY | O_CREAT | O_APPEND,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if(fd < 0) {
ERROR("could not open file '%s': %s", filename, strerror(errno));
fd_mut.unlock();
return -1;
}
// need not to work for 100% (the access will not to be locked if opened from
// another logger instance)
off_t pos = lseek(fd, 0, SEEK_END);
if (pos == 0) write_file_header();
fd_mut.unlock();
return 0;
}
/*Func: opt_q()
* If the -q has been specified, this function is called
* Read from file in argv[n]; n is filecount[lq|cq]
* Format the input and put the info. in temp file
* Read from temp into arch
*/
void opt_q(int argc, char **argv,int arch, int *filecount, int *fcalled, file *info){
int tempfile = 0;
for((*fcalled) = 0; (*fcalled)<filecount[1];++(*fcalled)){
tempfile = 0;
read_header(argc,argv,filecount, 0, fcalled,info );
tempfile = create_tempfile();
write_file_header(tempfile, info);
write_file_content(tempfile, info);
all_in_arch(tempfile,arch,fcalled ,info);
close(tempfile);
}
(*fcalled)=0;
return ;
}
void CompressList(LPCSTR in_name, xr_vector<char*>* list, xr_vector<char*>* fl_list, BOOL bFast, BOOL make_pack, LPCSTR copy_path)
{
if (!list->empty() && in_name && in_name[0]){
string256 caption;
VERIFY ('\\'!=in_name[xr_strlen(in_name)-1]);
string_path tgt_folder;
_splitpath (in_name,0,0,tgt_folder,0);
int pack_num = 0;
if (make_pack)
OpenPack (tgt_folder,pack_num++);
for (u32 it=0; it<fl_list->size(); it++)
write_file_header ((*fl_list)[it],0,0,0,0);
c_heap = xr_alloc<u8> (LZO1X_999_MEM_COMPRESS);
//***main process***: BEGIN
for (u32 it=0; it<list->size(); it++){
sprintf (caption,"Compress files: %d/%d - %d%%",it,list->size(),(it*100)/list->size());
SetWindowText (GetConsoleWindow(),caption);
printf ("\n%-80s ",(*list)[it]);
if (make_pack){
if (fs->tell()>XRP_MAX_SIZE){
ClosePack ();
OpenPack (tgt_folder,pack_num++);
}
Compress ((*list)[it],in_name,bFast);
}
if (copy_path && copy_path[0]){
string_path src_fn, dst_fn;
strconcat (sizeof(src_fn),src_fn,in_name,"\\",(*list)[it]);
strconcat (sizeof(dst_fn),dst_fn,copy_path,tgt_folder,"\\",(*list)[it]);
printf (" + COPY");
int age = FS.get_file_age(src_fn);
FS.file_copy (src_fn,dst_fn);
FS.set_file_age (dst_fn,age);
}
}
if (make_pack)
ClosePack ();
xr_free (c_heap);
//***main process***: END
} else {
Msg ("ERROR: folder not found.");
}
}
void XMLFileBenchmarkListener::begin_suite(
const BenchmarkSuite& benchmark_suite)
{
if (!impl->m_has_header)
{
write_file_header();
impl->m_has_header = true;
}
fprintf(
impl->m_file,
"%s<benchmarksuite name=\"%s\">\n",
impl->m_indenter.c_str(),
benchmark_suite.get_name());
++impl->m_indenter;
}
void
output_table(FILE *fp)
{
int i;
int table_position;
write_file_header(fp);
fprintf (fp,
"int _XfeNumCommands = %d;\n", num_commands);
fprintf (fp,
"int _XfeCommandIndices[] = {\n");
table_position = 0;
for (i = 0; i < num_commands; i ++)
{
fprintf (fp, "\t%d,", table_position);
if (i % 4 == 0) fprintf (fp, "\n");
table_position += strlen(commands[i].string) + 1;
}
fprintf (fp,
"};\n");
fprintf (fp,
"char _XfeCommands[] = \n");
table_position = 0;
for (i = 0; i < num_commands; i ++)
{
fprintf (fp, "\t/* %10d */ \"%s\\0\"\n", table_position, commands[i].string);
table_position += strlen(commands[i].string) + 1;
}
/* write out the closing semicolon. */
fprintf (fp, ";\n");
fclose(fp);
}
void
output_header(FILE *fp)
{
int table_position;
int i;
write_file_header(fp);
fprintf (fp, "extern char _XfeCommands[];\n");
fprintf (fp, "extern int _XfeNumCommands;\n");
fprintf (fp, "extern int _XfeCommandIndices[];\n");
table_position = 0;
for (i = 0; i < num_commands; i ++)
{
fprintf (fp, "#define %s ((char*)&_XfeCommands[ %d ])\n", commands[i].command, table_position);
table_position += strlen(commands[i].string) + 1;
}
fclose(fp);
}
void xrCompressor::PerformWork()
{
if (!files_list->empty() && target_name.size())
{
string256 caption;
int pack_num = 0;
OpenPack (target_name.c_str(), pack_num++);
for (u32 it=0; it<folders_list->size(); it++)
write_file_header ((*folders_list)[it],0,0,0,0);
if(!bStoreFiles)
c_heap = xr_alloc<u8> (LZO1X_999_MEM_COMPRESS);
for (u32 it=0; it<files_list->size(); it++)
{
xr_sprintf (caption,"Compress files: %d/%d - %d%%",it,files_list->size(),(it*100)/files_list->size());
SetWindowText (GetConsoleWindow(),caption);
printf ("\n%-80s ",(*files_list)[it]);
if (fs_pack_writer->tell()>XRP_MAX_SIZE)
{
ClosePack ();
OpenPack (target_name.c_str(), pack_num++);
}
CompressOne ((*files_list)[it]);
}
ClosePack ();
if(!bStoreFiles)
xr_free (c_heap);
}else
{
Msg ("ERROR: folder not found.");
}
}
int main(int argc, char *argv[]){
void *this_arte_packet;
this_arte_packet = malloc(MAX_PACKET_BYTES);
int sourcename;
packetType_t sourcetype;
int ok_packet;
int packet_count = 0;
char blank_data[MAX_PACKET_BYTES];
//this_arte_packet = (void *)&(blank_data[0]);
char input_filename[200], output_filename[200];
init_filenames(argc, argv,
input_filename, output_filename,
&sourcename, &sourcetype);
printf("sourcename:%d sourcetype:%c spike_sourcetype:%c\n",
sourcename, sourcetype, NETCOM_UDP_SPIKE);
if(this_arte_packet == NULL){
printf("Memory error, sorry :[\n");
exit(1);
}
in_f = fopen(input_filename, "rb");
out_f = fopen(output_filename, "wb");
if(in_f == NULL)
printf("Bad in file: %s\n", input_filename);
if(out_f == NULL)
printf("Bad out_file: %s\n", output_filename);
if(in_f == NULL || out_f == NULL)
exit(1);
ok_packet = false;
while(!ok_packet & (feof(in_f) == 0) ){
ok_packet = get_next_packet(this_arte_packet, sourcename, sourcetype);
}
printf("finished looking...\n"); fflush(stdout);
write_file_header(this_arte_packet, argc, argv, sourcetype);
printf("Finished writing file header.\n"); fflush(stdout);
if( sourcetype == NETCOM_UDP_SPIKE){
spike_net_t* test_spike = (spike_net_t*)this_arte_packet;
printf("test before first write_mwl: name:%d n_chans:%d\n",
test_spike->name, test_spike->n_chans);
}
write_mwl(this_arte_packet, sourcetype);
printf("Finished writing first packet with write_mwl.\n"); fflush(stdout);
if( sourcetype == NETCOM_UDP_SPIKE){
spike_net_t* test_spike = (spike_net_t*)this_arte_packet;
printf("test before loop: name:%d n_chans:%d\n",
test_spike->name, test_spike->n_chans);
}
if(true){
while( feof(in_f) == 0){
ok_packet = get_next_packet(this_arte_packet, sourcename, sourcetype);
if(verbose){
if (ok_packet){
printf("This packet was ok:\n");}
else {
printf("This packet was not ok:\n");}
print_packet(this_arte_packet, sourcetype);
}
if(ok_packet){
fflush(out_f);
//printf("in loop...\n");
if( sourcetype == NETCOM_UDP_SPIKE){
spike_net_t* test_spike = (spike_net_t*)this_arte_packet;
//printf("test before write_mwl in loop: name:%d n_chans:%d\n",
// test_spike->name, test_spike->n_chans);
}
write_mwl(this_arte_packet, sourcetype);
packet_count++;
}
interactive_wait("message1\n");
}
} // end if(true)
//free(this_arte_packet);
printf("finished. Wrote %d packet(s)\n", packet_count);
exit(0);
}
void xrCompressor::CompressOne(LPCSTR path)
{
filesTOTAL ++;
if (testSKIP(path))
{
filesSKIP ++;
printf (" - a SKIP");
Msg ("%-80s - SKIP",path);
return;
}
string_path fn;
strconcat (sizeof(fn), fn, target_name.c_str(), "\\", path);
if (::GetFileAttributes(fn)==u32(-1))
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
IReader* src = FS.r_open (fn);
if (0==src)
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
bytesSRC += src->length ();
u32 c_crc32 = crc32 (src->pointer(),src->length());
u32 c_ptr = 0;
u32 c_size_real = 0;
u32 c_size_compressed = 0;
u32 a_tests = 0;
ALIAS* A = testALIAS (src,c_crc32,a_tests);
printf ("%3da ",a_tests);
if(A)
{
filesALIAS ++;
printf ("ALIAS");
Msg ("%-80s - ALIAS (%s)",path,A->path);
// Alias found
c_ptr = A->c_ptr;
c_size_real = A->c_size_real;
c_size_compressed = A->c_size_compressed;
} else
{
if (testVFS(path))
{
filesVFS ++;
// Write into BaseFS
c_ptr = fs_pack_writer->tell ();
c_size_real = src->length();
c_size_compressed = src->length();
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS");
Msg ("%-80s - VFS",path);
} else
{ //if(testVFS(path))
// Compress into BaseFS
c_ptr = fs_pack_writer->tell();
c_size_real = src->length();
if (0!=c_size_real)
{
u32 c_size_max = rtc_csize (src->length());
u8* c_data = xr_alloc<u8> (c_size_max);
t_compress.Begin ();
c_size_compressed = c_size_max;
if (bFast)
{
R_ASSERT(LZO_E_OK == lzo1x_1_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}else
{
R_ASSERT(LZO_E_OK == lzo1x_999_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}
t_compress.End ();
if ((c_size_compressed+16) >= c_size_real)
{
// Failed to compress - revert to VFS
filesVFS ++;
c_size_compressed = c_size_real;
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS (R)");
Msg ("%-80s - VFS (R)",path);
} else
{
// Compressed OK - optimize
if (!bFast)
{
u8* c_out = xr_alloc<u8> (c_size_real);
u32 c_orig = c_size_real;
R_ASSERT (LZO_E_OK == lzo1x_optimize (c_data,c_size_compressed,c_out,&c_orig, NULL));
R_ASSERT (c_orig == c_size_real );
xr_free (c_out);
}//bFast
fs_pack_writer->w (c_data,c_size_compressed);
printf ("%3.1f%%", 100.f*float(c_size_compressed)/float(src->length()));
Msg ("%-80s - OK (%3.1f%%)",path,100.f*float(c_size_compressed)/float(src->length()));
}
// cleanup
xr_free (c_data);
}else
{ //0!=c_size_real
filesVFS ++;
c_size_compressed = c_size_real;
printf ("VFS (R)");
Msg ("%-80s - EMPTY FILE",path);
}
}//test VFS
} //(A)
// Write description
write_file_header (path,c_crc32,c_ptr,c_size_real,c_size_compressed);
if (0==A)
{
// Register for future aliasing
ALIAS R;
R.path = xr_strdup (fn);
R.crc = c_crc32;
R.c_ptr = c_ptr;
R.c_size_real = c_size_real;
R.c_size_compressed = c_size_compressed;
aliases.insert (mk_pair(R.c_size_real,R));
}
FS.r_close (src);
}
static int make_bmp_from_file(state *s, char *input)
{
char *o1, *o2, *output = (char *)malloc(sizeof(char) * PATH_MAX);
if (s->verbose)
print_status ("%s: Processing %s", __progname, input);
if ((o1 = strdup(input)) == NULL)
{
perror(__progname);
return TRUE;
}
o2 = basename(o1);
snprintf(output, PATH_MAX, "%s.bmp", o2);
// We don't free o2 as it's statically allocated
free(o1);
if ((s->in_handle = fopen(input,"rb")) == NULL)
{
free(output);
perror(input);
return TRUE;
}
snprintf(s->input_fn,PATH_MAX,"%s", input);
if ((s->out_handle = fopen(output,"wb")) == NULL)
{
fclose(s->in_handle);
perror(output);
free(output);
return TRUE;
}
if (find_file_size(input, s->in_handle, &s->input_length))
return TRUE;
s->image_height = (s->input_length / s->image_width);
if (s->input_length % s->image_width != 0)
s->image_height++;
if (write_file_header(s))
return TRUE;
if (write_file_info(s))
return TRUE;
if (s->orientation == ORIENTATION_VERTICAL) {
if (write_vertical_file(s)) {
perror(output);
}
} else {
write_horizontal_file(s);
}
if (s->verbose)
print_status ("%s: Done.", __progname);
fclose(s->in_handle);
fclose(s->out_handle);
free(output);
return FALSE;
}
void opt_d(int argc, char **argv,int *arch, int *filecount, int *fcalled, file *info){
int fbyte_max=1;
int fbyte=0;
int size = 0;
int tempfile=0;
int temparch =0;
char cur_name[16];
char *null_cur_name;
char *null_info_name;
char *str_buf;
struct stat archinfo;
struct stat temparch_info;
fstat((*arch),&archinfo);
temparch = create_tempfile();
write(temparch,"!<arch>\n",8);
fstat(temparch,&temparch_info);
fbyte_max = archinfo.st_size;
fbyte = 0;
lseek((*arch),8,SEEK_SET);
read_filename(argv,filecount,4,fcalled,info);
for(fbyte=0; fbyte < fbyte_max; fbyte++){
read((*arch),cur_name,16);
null_cur_name = null_str(cur_name,16);
null_cur_name = shrt_str(null_cur_name);
null_info_name= null_str(info->name,16);
null_info_name = shrt_str(null_info_name);
(fbyte) += 60+atoi(info->size);
if(fbyte < fbyte_max){
if(!strcmp(null_cur_name,null_info_name)){
iter_arch((*arch), &fbyte, info);
if(atoi(info->size)%2!=0){
lseek((*arch),1,SEEK_CUR);
(fbyte)++;
}
}else{
read_header(argc, argv, filecount, 4, fcalled, info);
tempfile = create_tempfile();
write_file_header(tempfile,info);
info->desc = (*arch);
write_file_content(tempfile,info);
all_in_arch(tempfile,temparch,fcalled,info);
close(tempfile);
}
}
}
remove(argv[1]);
(*arch) = open_file(argv[1],1);
size = temparch_info.st_size;
str_buf = malloc(sizeof(char)*size);
read(temparch,str_buf,size);
close(temparch);
}
