|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import os |
|
|
import wave |
|
|
from config import ( |
|
|
SUPPORTED_AUDIO_EXTENSIONS, |
|
|
AUDIO_FORMAT_DISPLAY_NAME_OVERRIDES, |
|
|
MAXIMUM_VOICE_CLONE_FILE_SIZE_BYTES |
|
|
) |
|
|
|
|
|
def build_format_display_names_from_supported_extensions(): |
|
|
format_display_names = {} |
|
|
|
|
|
for extension in SUPPORTED_AUDIO_EXTENSIONS: |
|
|
format_code = extension.lstrip(".") |
|
|
|
|
|
if format_code in AUDIO_FORMAT_DISPLAY_NAME_OVERRIDES: |
|
|
format_display_names[format_code] = AUDIO_FORMAT_DISPLAY_NAME_OVERRIDES[format_code] |
|
|
else: |
|
|
format_display_names[format_code] = format_code.upper() |
|
|
|
|
|
format_display_names["unknown"] = "Unknown" |
|
|
|
|
|
return format_display_names |
|
|
|
|
|
FORMAT_DISPLAY_NAMES = build_format_display_names_from_supported_extensions() |
|
|
|
|
|
def get_audio_file_extension(file_path): |
|
|
if not file_path: |
|
|
return None |
|
|
|
|
|
_, extension = os.path.splitext(file_path) |
|
|
|
|
|
return extension.lower() |
|
|
|
|
|
def is_supported_audio_extension(file_path): |
|
|
extension = get_audio_file_extension(file_path) |
|
|
|
|
|
if extension is None: |
|
|
return False |
|
|
|
|
|
return extension in SUPPORTED_AUDIO_EXTENSIONS |
|
|
|
|
|
def format_file_size_for_display(size_bytes): |
|
|
if size_bytes < 1024: |
|
|
return f"{size_bytes} bytes" |
|
|
|
|
|
elif size_bytes < 1024 * 1024: |
|
|
return f"{size_bytes / 1024:.1f} KB" |
|
|
|
|
|
else: |
|
|
return f"{size_bytes / (1024 * 1024):.2f} MB" |
|
|
|
|
|
def validate_file_size_for_voice_cloning(file_path): |
|
|
if not file_path: |
|
|
return False, "No audio file provided." |
|
|
|
|
|
try: |
|
|
file_size = os.path.getsize(file_path) |
|
|
|
|
|
except OSError as size_error: |
|
|
return False, f"Cannot read file size: {str(size_error)}" |
|
|
|
|
|
if file_size > MAXIMUM_VOICE_CLONE_FILE_SIZE_BYTES: |
|
|
max_size_display = format_file_size_for_display(MAXIMUM_VOICE_CLONE_FILE_SIZE_BYTES) |
|
|
actual_size_display = format_file_size_for_display(file_size) |
|
|
return False, f"Audio file size ({actual_size_display}) exceeds the maximum allowed size of {max_size_display}. Please upload a smaller audio file." |
|
|
|
|
|
return True, None |
|
|
|
|
|
def validate_file_exists_and_readable(file_path): |
|
|
if not file_path: |
|
|
return False, "No audio file provided." |
|
|
|
|
|
if not os.path.exists(file_path): |
|
|
return False, "Audio file does not exist." |
|
|
|
|
|
if not os.path.isfile(file_path): |
|
|
return False, "The provided path is not a valid file." |
|
|
|
|
|
try: |
|
|
file_size = os.path.getsize(file_path) |
|
|
|
|
|
except OSError as size_error: |
|
|
return False, f"Cannot read file size: {str(size_error)}" |
|
|
|
|
|
if file_size == 0: |
|
|
return False, "Audio file is empty (0 bytes)." |
|
|
|
|
|
if file_size < 44: |
|
|
return False, "Audio file is too small to be a valid audio file." |
|
|
|
|
|
try: |
|
|
with open(file_path, "rb") as test_file: |
|
|
test_file.read(1) |
|
|
except IOError as read_error: |
|
|
return False, f"Audio file is not readable: {str(read_error)}" |
|
|
|
|
|
return True, None |
|
|
|
|
|
def detect_audio_format_from_header(file_path): |
|
|
try: |
|
|
with open(file_path, "rb") as audio_file: |
|
|
header_bytes = audio_file.read(32) |
|
|
|
|
|
if len(header_bytes) < 4: |
|
|
return None, "File is too small to determine audio format." |
|
|
|
|
|
if len(header_bytes) >= 12: |
|
|
if header_bytes[:4] == b"RIFF" and header_bytes[8:12] == b"WAVE": |
|
|
return "wav", None |
|
|
|
|
|
if header_bytes[:3] == b"ID3": |
|
|
return "mp3", None |
|
|
|
|
|
if len(header_bytes) >= 2: |
|
|
first_two_bytes = header_bytes[:2] |
|
|
|
|
|
mp3_sync_bytes = [ |
|
|
b"\xff\xfb", |
|
|
b"\xff\xfa", |
|
|
b"\xff\xf3", |
|
|
b"\xff\xf2", |
|
|
b"\xff\xe0", |
|
|
b"\xff\xe2", |
|
|
b"\xff\xe3" |
|
|
] |
|
|
|
|
|
if first_two_bytes in mp3_sync_bytes: |
|
|
return "mp3", None |
|
|
|
|
|
if header_bytes[:4] == b"fLaC": |
|
|
return "flac", None |
|
|
|
|
|
if header_bytes[:4] == b"OggS": |
|
|
return "ogg", None |
|
|
|
|
|
if len(header_bytes) >= 12: |
|
|
if header_bytes[:4] == b"FORM" and header_bytes[8:12] in [b"AIFF", b"AIFC"]: |
|
|
return "aiff", None |
|
|
|
|
|
if len(header_bytes) >= 8: |
|
|
if header_bytes[4:8] == b"ftyp": |
|
|
return "m4a", None |
|
|
|
|
|
if len(header_bytes) >= 4: |
|
|
if header_bytes[:4] == b"\x1aE\xdf\xa3": |
|
|
return "webm", None |
|
|
|
|
|
if len(header_bytes) >= 8: |
|
|
if header_bytes[4:8] in [b"mdat", b"moov", b"free", b"skip", b"wide"]: |
|
|
return "m4a", None |
|
|
|
|
|
file_extension = get_audio_file_extension(file_path) |
|
|
|
|
|
if file_extension and file_extension in SUPPORTED_AUDIO_EXTENSIONS: |
|
|
return file_extension.lstrip("."), None |
|
|
|
|
|
return "unknown", "Could not determine audio format from file header. The file may be corrupted or in an unsupported format." |
|
|
|
|
|
except IOError as io_error: |
|
|
return None, f"Error reading file header: {str(io_error)}" |
|
|
|
|
|
except Exception as detection_error: |
|
|
return None, f"Unexpected error detecting audio format: {str(detection_error)}" |
|
|
|
|
|
def validate_wav_file_structure(file_path): |
|
|
try: |
|
|
with wave.open(file_path, "rb") as wav_file: |
|
|
number_of_channels = wav_file.getnchannels() |
|
|
sample_width_bytes = wav_file.getsampwidth() |
|
|
sample_rate = wav_file.getframerate() |
|
|
number_of_frames = wav_file.getnframes() |
|
|
|
|
|
if number_of_channels < 1: |
|
|
return False, "WAV file has no audio channels." |
|
|
|
|
|
if number_of_channels > 16: |
|
|
return False, f"WAV file has too many channels ({number_of_channels}). Maximum supported is 16." |
|
|
|
|
|
if sample_width_bytes < 1: |
|
|
return False, "WAV file has invalid sample width (less than 1 byte)." |
|
|
|
|
|
if sample_width_bytes > 4: |
|
|
return False, f"WAV file has unsupported sample width ({sample_width_bytes} bytes). Maximum supported is 4 bytes (32-bit)." |
|
|
|
|
|
if sample_rate < 100: |
|
|
return False, f"WAV file has invalid sample rate ({sample_rate} Hz). Minimum supported is 100 Hz." |
|
|
|
|
|
if sample_rate > 384000: |
|
|
return False, f"WAV file has unsupported sample rate ({sample_rate} Hz). Maximum supported is 384000 Hz." |
|
|
|
|
|
if number_of_frames < 1: |
|
|
return False, "WAV file contains no audio frames." |
|
|
|
|
|
audio_duration_seconds = number_of_frames / sample_rate |
|
|
|
|
|
if audio_duration_seconds < 0.1: |
|
|
return False, f"Audio is too short ({audio_duration_seconds:.2f} seconds). Minimum duration is 0.1 seconds." |
|
|
|
|
|
if audio_duration_seconds > 60: |
|
|
return False, f"Audio is too long ({audio_duration_seconds:.0f} seconds). Maximum duration is 1 minute." |
|
|
|
|
|
return True, None |
|
|
|
|
|
except wave.Error as wav_error: |
|
|
error_message = str(wav_error) |
|
|
|
|
|
if "file does not start with RIFF id" in error_message: |
|
|
return False, "File has .wav extension but is not a valid WAV file. It may be a different audio format renamed to .wav." |
|
|
|
|
|
if "unknown format" in error_message.lower(): |
|
|
return False, "WAV file uses an unsupported audio encoding format." |
|
|
|
|
|
return False, f"Invalid WAV file structure: {error_message}" |
|
|
|
|
|
except EOFError: |
|
|
return False, "WAV file is truncated or corrupted (unexpected end of file)." |
|
|
|
|
|
except Exception as validation_error: |
|
|
return False, f"Error validating WAV file: {str(validation_error)}" |
|
|
|
|
|
def perform_comprehensive_audio_validation(file_path): |
|
|
file_exists_valid, file_exists_error = validate_file_exists_and_readable(file_path) |
|
|
|
|
|
if not file_exists_valid: |
|
|
return False, False, None, file_exists_error |
|
|
|
|
|
file_extension = get_audio_file_extension(file_path) |
|
|
|
|
|
if not is_supported_audio_extension(file_path): |
|
|
supported_formats_list = ", ".join(SUPPORTED_AUDIO_EXTENSIONS) |
|
|
return False, False, None, f"Unsupported file format '{file_extension}'. Supported formats are: {supported_formats_list}" |
|
|
|
|
|
detected_format, detection_error = detect_audio_format_from_header(file_path) |
|
|
|
|
|
if detected_format is None: |
|
|
return False, False, None, detection_error |
|
|
|
|
|
is_wav_format = (detected_format == "wav") |
|
|
|
|
|
if is_wav_format: |
|
|
wav_structure_valid, wav_structure_error = validate_wav_file_structure(file_path) |
|
|
|
|
|
if not wav_structure_valid: |
|
|
return False, True, "wav", wav_structure_error |
|
|
|
|
|
return True, is_wav_format, detected_format, None |
|
|
|
|
|
def perform_voice_clone_file_validation(file_path): |
|
|
file_size_valid, file_size_error = validate_file_size_for_voice_cloning(file_path) |
|
|
|
|
|
if not file_size_valid: |
|
|
return False, False, None, file_size_error |
|
|
|
|
|
return perform_comprehensive_audio_validation(file_path) |
|
|
|
|
|
def get_format_display_name(format_code): |
|
|
if format_code is None: |
|
|
return "Unknown" |
|
|
|
|
|
if format_code in FORMAT_DISPLAY_NAMES: |
|
|
return FORMAT_DISPLAY_NAMES[format_code] |
|
|
|
|
|
return format_code.upper() |
