zzip.c

zzip-zzlib-src.zip. A new archiver that uses a BWT algorithm to achieve superior compression. The

					do
					{
						if (strcmp(file_info.name, ".") != 0 && strcmp(file_info.name, "..") != 0)
						{
							*p = '\0';
							strcat(path, file_info.name);
							file_list[nb_input_file++] = strdup(path);
						}
					}
					while (_findnext(handle, &file_info) == 0);
					_findclose(handle);
				}
#else  /* WIN32 */
				{
					DIR				*dirp;
					struct dirent	*entry;

					if ((dirp = opendir(path)) == NULL) IO_ERROR();
					while ((entry = readdir(dirp)) != NULL)
					{
						if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0)
						{
							*p = '\0';
							strcat(path, entry->d_name);
							file_list[nb_input_file++] = strdup(path);
						}
					}
					if (closedir(dirp) != 0) IO_ERROR();
				}
#endif /* WIN32 */
			}
			else if ((file_stat.st_mode & (S_IFDIR | S_IREAD)) == S_IREAD)
			{
				file_list[j++] = file_list[i];
			}

			MyFree(path);
		}
		nb_input_file = j;

		/* if no output file, each input file is compressed into a 'single-archive' */
		if (*output_filename == '\0') 
		{
			nb_archive = nb_input_file;
			nb_input_file = 1;
			single_archive = true;
		}
		/* otherwise we build only one archive with every input file */
		else 
		{
			nb_archive = 1;
			/* we append extension '.zz' to the filename if it doesn't exist */
			l = strlen(output_filename) - 3;
			if (l < 0 || strcmp(output_filename + l, ".zz") != 0) 
				strcat(output_filename, ".zz");
			single_archive = false;
		}

		for (j = 0; j < nb_archive; ++j)
		{
			if (single_archive == true)
			{
				strcpy(output_filename, file_list[j]);
				strcat(output_filename, ".zz");
			}
			
			if (access(output_filename, 0) == -1)
			{ 
				/* we create a new archive */
				OpenArchive(CREATE, output_filename, info);
				if (last_error != OK) return;
				VERBOSE printf("\ncreating archive: %s", output_filename);
			}
			else
			{ /* we add to an existing archive */
				OpenArchive(UPDATE, output_filename, info);
				if (last_error != OK) return;
				VERBOSE printf("\nupdating archive: %s", output_filename);
			}

			/* output to screen formating */
			{
				char temp[32];
				sprintf(temp, "%d", nb_input_file);
				l = strlen(temp);
			}

			for (i = 0; i < nb_input_file; ++i)
			{
				input_filename = file_list[i + j];

				VERBOSE printf("\n  %0*u/%u %s ", l, i + 1, nb_input_file, input_filename);

				AddFile(input_filename, compression_mode, multimedia_test, block_size, info);
				if (last_error != OK) return;

				VERBOSE
				{
					if (info->input_size != 0) printf("%+#05.1f%%", MIN(((float)(info->output_size) * 100) / info->input_size - 100, 0));
					else printf("N/A");
				}
			}

			CloseArchive(info);
			if (last_error != OK) return;

			VERBOSE
			{
				printf("\n\n%d file(s) added,", nb_input_file);
				if (info->input_size != 0) printf(" %+#05.1f%%", MIN(((float)(info->output_size) * 100) / info->input_size - 100, 0));
				else printf(" N/A");
				printf(" (%u->%u)\n", info->input_size, info->output_size);
			}
		}
		break;
#endif /* !SFX */
	case EXTRACT:
		{
			uint   nbfile, nbfile_extracted = 0;
			info_s **all_files_info = NULL;
			
#ifndef SFX
			CheckFilename(input_filename, file_list[0]);
			VERBOSE printf("\nextracting archive: %s", input_filename);
#else  /* !SFX */
			input_filename = file_list[0];
#endif /* !SFX */
			file_list++;
			
			OpenArchive(EXTRACT, input_filename, info);
			if (last_error != OK) return;
			
			nbfile = (nb_input_file > 1) ? nb_input_file - 1 : info->nb_of_file;

			all_files_info = (info_s**)MyMalloc(sizeof(info_s*) * info->nb_of_file);
			if (last_error != OK) return;

			for (j = 0; j < info->nb_of_file; ++j)
				all_files_info[j] = (info_s*)MyMalloc(sizeof(info_s));
			if (last_error != OK) return;

			ListAllFile(all_files_info);
			if (last_error != OK) return;

			SetArchivePointer(NULL, NULL);
			if (last_error != OK) return;

			/* output to screen formating */
			{
				char temp[32];
				sprintf(temp, "%d", nbfile);
				l = strlen(temp);
			}
			
			for (i = 0; i < nbfile; ++i)
			{
				char *name;

				if (nb_input_file > 1) 
				{
					name = file_list[i];
					SetArchivePointer(file_list[i], NULL);
					if (last_error == FILE_NOT_FOUND) 
					{ 
						VERBOSE printf("\n  %0*u/%u %s not found", l, i+1, nbfile, name);
						last_error = OK;
						continue;
					}
					if (last_error != OK) return;
				}
				else
				{
					name = all_files_info[i]->filename;
				}

				VERBOSE printf("\n  %0*u/%u %s", l, i+1, nbfile, name);

				ExtractNextFile(NULL, with_path, info);
				if (last_error != OK) return;

				nbfile_extracted++;
				
				VERBOSE printf(" done");
			}
			
			CloseArchive(info);
			if (last_error != OK) return;
			
			VERBOSE
			{
				printf("\n\n%d file(s) extracted,", nbfile_extracted);
				if (info->input_size != 0) 
					printf(" %+#05.1f%%", ((float)(info->output_size) * 100) / info->input_size - 100);
				else printf(" N/A");
				printf(" (%u->%u)\n", info->input_size, info->output_size);
			}
		}
		break;
	case LIST :
#ifndef SFX
		for (i = 0; i < nb_input_file; ++i)
#endif /* !SFX */
		{
			uint   nbfile;
			sint   namemax; 
			char   timestr[256], filename[FILENAME_LENGTH_MAX];
			info_s **all_files_info = NULL;

#ifndef SFX
			CheckFilename(input_filename, file_list[i]);
			VERBOSE printf("\nlisting archive: %s\n", input_filename);
#else  /* !SFX */
			input_filename = file_list[0];
#endif /* !SFX */

			OpenArchive(LIST, input_filename, info);
			if (last_error != OK) return;

			nbfile = info->nb_of_file;

			all_files_info = (info_s**)MyMalloc(sizeof(info_s*) * nbfile);
			if (last_error != OK) return;

			for (j = 0; j < nbfile; ++j)
				all_files_info[j] = (info_s*)MyMalloc(sizeof(info_s));
			if (last_error != OK) return;

			ListAllFile(all_files_info);
			if (last_error != OK) return;

			namemax = 0;
			for (j = 0; j < nbfile; ++j)
				if (namemax < (sint)strlen(all_files_info[j]->filename)) namemax = strlen(all_files_info[j]->filename);

			memset(filename, '-', FILENAME_LENGTH_MAX);
			filename[FILENAME_LENGTH_MAX-1] = '\0';
			namemax = MIN(namemax,32);
			namemax = MAX(namemax,8);
			printf(
				"\n%-*s       date & time   original compressed  ratio"
				"\n%.*s ----------------- ---------- ---------- ------",
				namemax, "filename",
				namemax, filename
				);
			
			for (j = 0; j < nbfile; ++j)
			{
				info = all_files_info[j];

				if ((sint)strlen(info->filename) > namemax) 
				{ 
					info->filename += (sint)strlen(info->filename) - namemax;
					info->filename[0] = '.'; 
					info->filename[1] = '.'; 
					info->filename[2] = '.'; 
				}

				strftime(timestr, 255, "%d-%b-%Y %H:%M", gmtime(&info->filetime));

				VERBOSE printf("\n%-*s %s %10d %10d %+#05.1f%%", namemax, info->filename, timestr, info->input_size, info->output_size,
					MIN(((float)(info->output_size) * 100) / info->input_size - 100,0));
			}

			CloseArchive(info);
			if (last_error != OK) return;

			printf("\n\n%d file(s) listed,", nbfile);
			if (info->input_size != 0) printf(" %+#05.1f%%", MIN(((float)(info->output_size) * 100) / info->input_size - 100,0));
			else printf(" N/A");
			printf(" (%u->%u)\n", info->input_size, info->output_size);
		}
		break;
	case TEST :
#ifndef SFX
		for (i = 0; i < nb_input_file; ++i)
#endif /* !SFX */
		{
			info_s **all_files_info = NULL;

#ifndef SFX
			CheckFilename(input_filename, file_list[i]);
			VERBOSE printf("\ntesting archive: %s", input_filename);
#else  /* !SFX */
			input_filename = file_list[0];
#endif /* !SFX */

			OpenArchive(TEST, input_filename, info);
			if (last_error != OK) return;

			all_files_info = (info_s**)MyMalloc(sizeof(info_s*) * info->nb_of_file);
			if (last_error != OK) return;

			for (j = 0; j < info->nb_of_file ; ++j)
				all_files_info[j] = (info_s*)MyMalloc(sizeof(info_s));
			if (last_error != OK) return;

			ListAllFile(all_files_info);
			if (last_error != OK) return;

			SetArchivePointer(NULL, NULL);
			if (last_error != OK) return;

			/* output to screen formating */
			{
				char temp[32];
				sprintf(temp, "%d", info->nb_of_file);
				l = strlen(temp);
			}

			for (j = 0; j < info->nb_of_file; ++j)
			{
				VERBOSE printf("\n  %0*u/%u %s", l, j + 1, info->nb_of_file, all_files_info[j]->filename);

				TestNextFile(info);
				if (last_error != OK) return;

				VERBOSE printf(" CRC OK");
			}
			
			CloseArchive(info);
			if (last_error != OK) return;

			VERBOSE printf("\n\n%d file(s) tested\n", info->nb_of_file);
		}
		break;
#ifndef SFX
	case DELETE: 
		{
			uint nbfile, nb_deleted = 0;
			
			CheckFilename(input_filename, file_list[0]);
			file_list++;
			
			VERBOSE printf("\nprocessing archive: %s", input_filename);
			
			OpenArchive(DELETE, input_filename, info);
			if (last_error != OK) return;
			
			nbfile = (nb_input_file > 1) ? nb_input_file - 1 : info->nb_of_file;

			/* output to screen formating */
			{
				char temp[32];
				sprintf(temp, "%d", nbfile);
				l = strlen(temp);
			}
			
			for (i = 0; i < nbfile; ++i)
			{
				SetArchivePointer(file_list[i], NULL);

				if (last_error == FILE_NOT_FOUND)
				{
					last_error = OK;
					VERBOSE printf("\n  %0*u/%u %s not found", l, i+1, nbfile, file_list[i]);
				}
				else
				{
					if (last_error != OK) return;
					
					VERBOSE printf("\n  %0*u/%u deleting %s", l, i+1, nbfile, file_list[i]);

					DeleteNextFile();
					if (last_error != OK) return;

					VERBOSE printf(" done");
					
					nb_deleted++;
				}
			}
			
			CloseArchive(info);
			if (last_error != OK) return;

			VERBOSE printf("\n\n%d file(s) deleted\n", nb_deleted);
		}
		break; 
#endif /* !SFX */
	default:;
	}
}

/*---------------------------------------------*/

#ifdef GET_STAT

#define FORMAT1(a)   (float)(a)/(time_stat.cpuspeed>>16), (float)(a)*100/time_stat.time_tot
#define FORMAT2(a,b) (float)(a)*100/(b)
#define FORMAT3(a)   (float)(a)/(time_stat.cpuspeed>>16)
#define FORMAT4(a,b) (float)(a)*((float)(time_stat.cpuspeed>>16)/(1024))/(b)

static
void Print_Stat()
{
	uint32 bwt = time_stat.time_bwt1 + time_stat.time_bwt2 + time_stat.time_bwt3 + time_stat.time_bwt4;
	uint32 st  = time_stat.time_st0  + time_stat.time_st1;
	uint32 misc= time_stat.time_tot - bwt - st - time_stat.time_mtf - time_stat.time_rle - time_stat.time_txt - time_stat.time_mm - time_stat.time_ana;

	GetCpuSpeed();
	printf("\n(CPU speed : %d Mhz)\n", time_stat.cpuspeed / 1000000);

	if (time_stat.time_ana != 0)
	  printf("\nAnalyzing         = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(time_stat.time_ana), FORMAT4(time_stat.kb_ana,time_stat.time_ana));
	if (time_stat.time_rle != 0)
	  printf("\nRLE (de)coding    = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(time_stat.time_rle), FORMAT4(time_stat.kb_rle,time_stat.time_rle));
	if (time_stat.time_mm != 0)
	  printf("\nMmedia (de)coding = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(time_stat.time_mm), FORMAT4(time_stat.kb_mm,time_stat.time_mm));
	if (time_stat.time_txt != 0)
	  printf("\nTxt/Bin filtering = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(time_stat.time_txt), FORMAT4(time_stat.kb_txt,time_stat.time_txt));
	if (bwt != 0)
	{
		printf("\n(un)BWT           = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(bwt), FORMAT4(time_stat.kb_bwt,bwt));
		VERBOSE if (time_stat.time_bwt4 != 0) printf(" (%.1f%%, %.1f%%, %.1f%%, %.1f%%)", 
			FORMAT2(time_stat.time_bwt1,bwt),FORMAT2(time_stat.time_bwt2,bwt),
			FORMAT2(time_stat.time_bwt3,bwt),FORMAT2(time_stat.time_bwt4,bwt));
	}
	if (time_stat.time_mtf != 0)
	  printf("\nMTF (de)coding    = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(time_stat.time_mtf), FORMAT4(time_stat.kb_mtf,time_stat.time_mtf));
	if (st != 0)
	{
		printf("\nArith. (de)coding = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(st), FORMAT4(time_stat.kb_st0+time_stat.kb_st1,st));
		VERBOSE printf(" (%.1f%%, %.1f%%)", 
			FORMAT2(time_stat.time_st0,st), FORMAT2(time_stat.time_st1,st));
	}
	if (misc != 0)
	  printf("\nMisc (i/o,crc...) = %#7.3fs (%#4.1f%%) %#8.1f kb/s", FORMAT1(misc), FORMAT4(time_stat.kb_tot,misc));
	printf("\n\nTotal             = %#7.3fs         %#8.1f kb/s\n", FORMAT3(time_stat.time_tot), FORMAT4(time_stat.kb_tot,time_stat.time_tot));
}

#endif /* GET_STAT */

/*---------------------------------------------*/

int main(int  argc, 
		 char **argv)
{
#ifdef GET_STAT
	uint64 p1, p2;
#endif /* GET_STAT */

	CmdLineParameters(argc, argv);

	GET_TSC(p1);
	DoFiles();
	GET_TSC(p2);
	STAT_ADD_TIME(time_tot, p2, p1);

#ifdef GET_STAT
	if (time_stat.t_stamp == true) Print_Stat();
#endif /* GET_STAT */

	if (last_error != OK)
	{
		fprintf(stderr, "\nZzip error : ");
		switch (last_error)
		{
#ifndef SFX
		case NOT_A_ZZIP_FILE:
			fprintf(stderr, "this file is not a zzip file"); break;
		case UNSUPPORTED_VERSION :
			fprintf(stderr, "unsupported compression method"); break;
		case FILE_NOT_FOUND:
			fprintf(stderr, "file not found"); break;
		case UNEXPECTED_EOF:
			fprintf(stderr, "unexpected end of file"); break;
#endif /* !SFX */
		case NOT_ENOUGH_MEMORY :
			fprintf(stderr, "not enough memory"); break;
		case CRC_ERROR:
			fprintf(stderr, "CRC check failed"); break;
		case CANNOT_CLOSE_INPUT_FILE:
			fprintf(stderr, "cannot close input file"); break;
		case CANNOT_CLOSE_OUTPUT_FILE:
			fprintf(stderr, "cannot close output file"); break;
		case CANNOT_OPEN_INPUT_FILE:
			fprintf(stderr, "cannot open input file"); break;
		case CANNOT_OPEN_OUTPUT_FILE:
			fprintf(stderr, "cannot open output file"); break;
		case FSEEK_INPUT_FILE:
			fprintf(stderr, "fseek failed on input file"); break;
		case FSEEK_OUTPUT_FILE:
			fprintf(stderr, "fseek failed on output file"); break;
		default : 
			fprintf(stderr, strerror(errno)); break;
		}
		fprintf(stderr, "\n");
		CloseArchive(NULL);
#ifndef SFX
		CleanMemory();
#endif /* !SFX */
		return 1;
	}

	return 0;
}

/*---------------------------------------------*/
/* end                                  zzip.c */
/*---------------------------------------------*/