Fixed acl_compressor.py script and added ability to calculate stats w…

…ithout recompressing everytime if the stat file already exists.

Minor fixes to properly support clips with a single sample (static pose).

includes/acl/algorithm/uniformly_sampled/common.h

@@ -65,14 +65,14 @@ namespace acl
 				uint32_t*		get_constant_tracks_bitset()		{ return constant_tracks_bitset_offset.add_to(this); }
 				const uint32_t*	get_constant_tracks_bitset() const	{ return constant_tracks_bitset_offset.add_to(this); }
 
-				uint8_t*		get_constant_track_data()			{ return constant_track_data_offset.add_to(this); }
-				const uint8_t*	get_constant_track_data() const		{ return constant_track_data_offset.add_to(this); }
+				uint8_t*		get_constant_track_data()			{ return constant_track_data_offset.safe_add_to(this); }
+				const uint8_t*	get_constant_track_data() const		{ return constant_track_data_offset.safe_add_to(this); }
 
 				uint8_t*		get_clip_range_data()				{ return clip_range_data_offset.safe_add_to(this); }
 				const uint8_t*	get_clip_range_data() const			{ return clip_range_data_offset.safe_add_to(this); }
 
-				uint8_t*		get_track_data()					{ return track_data_offset.add_to(this); }
-				const uint8_t*	get_track_data() const				{ return track_data_offset.add_to(this); }
+				uint8_t*		get_track_data()					{ return track_data_offset.safe_add_to(this); }
+				const uint8_t*	get_track_data() const				{ return track_data_offset.safe_add_to(this); }
 			};
 
 			constexpr FullPrecisionHeader& get_full_precision_header(CompressedClip& clip)

includes/acl/algorithm/uniformly_sampled/encoder.h

@@ -163,17 +163,21 @@ namespace acl
 
 			write_default_track_bitset(bone_streams, num_bones, header.get_default_tracks_bitset(), bitset_size);
 			write_constant_track_bitset(bone_streams, num_bones, header.get_constant_tracks_bitset(), bitset_size);
-			write_constant_track_data(bone_streams, num_bones, header.get_constant_track_data(), constant_data_size);
-			write_animated_track_data(bone_streams, num_bones, header.get_track_data(), animated_data_size);
+
+			if (constant_data_size > 0)
+				write_constant_track_data(bone_streams, num_bones, header.get_constant_track_data(), constant_data_size);
+			else
+				header.constant_track_data_offset = InvalidPtrOffset();
+
+			if (animated_data_size > 0)
+				write_animated_track_data(bone_streams, num_bones, header.get_track_data(), animated_data_size);
+			else
+				header.track_data_offset = InvalidPtrOffset();
 
 			if (is_enum_flag_set(settings.range_reduction, RangeReductionFlags8::PerClip))
-			{
 				write_range_track_data(bone_streams, num_bones, settings.range_reduction, settings.rotation_format, settings.translation_format, header.get_clip_range_data(), clip_range_data_size);
-			}
 			else
-			{
 				header.clip_range_data_offset = InvalidPtrOffset();
-			}
 
 			finalize_compressed_clip(*compressed_clip);
 

includes/acl/core/utils.h

@@ -37,7 +37,7 @@ namespace acl
 	inline void calculate_interpolation_keys(uint32_t num_samples, FloatType clip_duration, FloatType sample_time, uint32_t& out_key_frame0, uint32_t& out_key_frame1, FloatType& out_interpolation_alpha)
 	{
 		// Samples are evenly spaced, trivially calculate the indices that we need
-		FloatType normalized_sample_time = (sample_time / clip_duration);
+		FloatType normalized_sample_time = clip_duration == FloatType(0.0) ? FloatType(0.0) : (sample_time / clip_duration);
 		ACL_ENSURE(sample_time >= FloatType(0.0) && sample_time <= clip_duration, "Invalid sample time. 0.0 <= %f <= %f", sample_time, clip_duration);
 		ACL_ENSURE(normalized_sample_time >= FloatType(0.0) && normalized_sample_time <= FloatType(1.0), "Failed to normalize sample time: %f", normalized_sample_time);
 

tools/acl_compressor/acl_compressor.py

@@ -7,7 +7,8 @@
 def parse_argv():
 	options = {}
 	options['acl'] = ""
-	options['stat'] = ""
+	options['stats'] = ""
+	options['refresh'] = False
 
 	for i in range(1, len(sys.argv)):
 		value = sys.argv[i]
@@ -16,13 +17,26 @@ def parse_argv():
 		if value.startswith('-acl='):
 			options['acl'] = value[5:].replace('"', '')
 
-		if value.startswith('-stat='):
-			options['stat'] = value[6:].replace('"', '')
+		if value.startswith('-stats='):
+			options['stats'] = value[7:].replace('"', '')
+
+		if value == '-refresh':
+			options['refresh'] = True
+
+	if options['acl'] == None:
+		print('ACL input directory not found')
+		print_usage()
+		sys.exit(1)
+
+	if options['stats'] == None:
+		print('Stat output directory not found')
+		print_usage()
+		sys.exit(1)
 
 	return options
 
 def print_usage():
-	print('Usage: python acl_compressor.py -acl=<path to directory containing ACL files> -stat=<path to output directory for stats>')
+	print('Usage: python acl_compressor.py -acl=<path to directory containing ACL files> -stats=<path to output directory for stats> [-refresh]')
 
 def print_stat(stat):
 	print('Algorithm: {}, Format: {}, Ratio: {:.2f}, Error: {}'.format(stat.name, stat.rotation_format, stat.ratio, stat.max_error))
@@ -43,7 +57,8 @@ def print_stat(stat):
 		latest_exe_path = debug_exe_path
 
 	acl_dir = options['acl']
-	stat_dir = options['stat']
+	stat_dir = options['stats']
+	refresh = options['refresh']
 
 	if not os.path.exists(acl_dir) or not os.path.isdir(acl_dir):
 		print('ACL input directory not found: {}'.format(acl_dir))
@@ -70,6 +85,11 @@ def print_stat(stat):
 			acl_filename = os.path.join(dirpath, filename)
 			stat_filename = os.path.join(stat_dirname, filename.replace('.acl.js', '_stats.txt'))
 
+			stat_files.append(stat_filename)
+
+			if os.path.exists(stat_filename) and os.path.isfile(stat_filename) and not refresh:
+				continue
+
 			if not os.path.exists(stat_dirname):
 				os.makedirs(stat_dirname)
 
@@ -79,8 +99,6 @@ def print_stat(stat):
 			print('Compressing {}...'.format(acl_filename))
 			os.system(cmd)
 
-			stat_files.append(stat_filename)
-
 	if len(stat_files) == 0:
 		sys.exit(0)
 
@@ -96,30 +114,39 @@ def print_stat(stat):
 					line = file.readline()
 					continue
 
-				name = line.split(': ')[1].strip()
-				rotation_format = file.readline().split(': ')[1].strip()
-				raw_size = float(file.readline().split(': ')[1].strip())
-				compressed_size = float(file.readline().split(': ')[1].strip())
-				ratio = file.readline().strip()
+				parsed_stats = []
+				while len(line.strip()) != 0:
+					parsed_stats.append(line.strip().split(': '))
+					line = file.readline()
+
+				name = next(x[1] for x in parsed_stats if x[0] == 'Clip algorithm')
+				rotation_format = next(x[1] for x in parsed_stats if x[0] == 'Clip rotation format')
+				raw_size = float(next(x[1] for x in parsed_stats if x[0] == 'Clip raw size (bytes)'))
+				compressed_size = float(next(x[1] for x in parsed_stats if x[0] == 'Clip compressed size (bytes)'))
 				ratio = raw_size / compressed_size
-				max_error = float(file.readline().split(': ')[1].strip())
-				compression_time = float(file.readline().split(': ')[1].strip())
-				duration = float(file.readline().split(': ')[1].strip())
-				num_animated_tracks = int(file.readline().split(': ')[1].strip())
+				max_error = float(next(x[1] for x in parsed_stats if x[0] == 'Clip max error'))
+				compression_time = float(next(x[1] for x in parsed_stats if x[0] == 'Clip compression time (s)'))
+				duration = float(next(x[1] for x in parsed_stats if x[0] == 'Clip duration (s)'))
+				num_animated_tracks = int(next(x[1] for x in parsed_stats if x[0] == 'Clip num animated tracks'))
 
 				stats.append(Stats(stat_filename, name, rotation_format, raw_size, compressed_size, ratio, max_error, compression_time, duration, num_animated_tracks))
-				line = file.readline()
 
-	smallest_error = 100000000.0
-	smallest_error_entry = None
+	best_error = 100000000.0
+	best_error_entry = None
+	worst_error = -100000000.0
+	worst_error_entry = None
 	best_ratio = 0.0
 	best_ratio_entry = None
 	worst_ratio = 100000000.0
 	worst_ratio_entry = None
 	for stat in stats:
-		if stat.max_error < smallest_error:
-			smallest_error = stat.max_error
-			smallest_error_entry = stat
+		if stat.max_error < best_error:
+			best_error = stat.max_error
+			best_error_entry = stat
+
+		if stat.max_error > worst_error:
+			worst_error = stat.max_error
+			worst_error_entry = stat
 
 		if stat.ratio > best_ratio:
 			best_ratio = stat.ratio
@@ -129,8 +156,11 @@ def print_stat(stat):
 			worst_ratio = stat.ratio
 			worst_ratio_entry = stat
 
-	print('Most accurate: {}'.format(smallest_error_entry.file))
-	print_stat(smallest_error_entry)
+	print('Most accurate: {}'.format(best_error_entry.file))
+	print_stat(best_error_entry)
+
+	print('Least accurate: {}'.format(worst_error_entry.file))
+	print_stat(worst_error_entry)
 
 	print('Best ratio: {}'.format(best_ratio_entry.file))
 	print_stat(best_ratio_entry)

tools/acl_compressor/sources/main.cpp

@@ -153,24 +153,24 @@ struct Options
 	}
 };
 
-constexpr char* FILE_OPTION = "-file=";
-constexpr char* STATS_OPTION = "-stats";
+constexpr char* ACL_INPUT_FILE_OPTION = "-acl=";
+constexpr char* STATS_OUTPUT_OPTION = "-stats";
 
 static bool parse_options(int argc, char** argv, Options& options)
 {
 	for (int arg_index = 1; arg_index < argc; ++arg_index)
 	{
 		char* argument = argv[arg_index];
 
-		size_t option_length = std::strlen(FILE_OPTION);
-		if (std::strncmp(argument, FILE_OPTION, option_length) == 0)
+		size_t option_length = std::strlen(ACL_INPUT_FILE_OPTION);
+		if (std::strncmp(argument, ACL_INPUT_FILE_OPTION, option_length) == 0)
 		{
 			options.input_filename = argument + option_length;
 			continue;
 		}
 
-		option_length = std::strlen(STATS_OPTION);
-		if (std::strncmp(argument, STATS_OPTION, option_length) == 0)
+		option_length = std::strlen(STATS_OUTPUT_OPTION);
+		if (std::strncmp(argument, STATS_OUTPUT_OPTION, option_length) == 0)
 		{
 			options.output_stats = true;
 			options.output_stats_filename = argument[option_length] == '=' ? argument + option_length + 1 : nullptr;