TonieToolbox 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

TonieToolbox/tonie_analysis.py

@@ -6,18 +6,11 @@ import datetime
 import hashlib
 import struct
 import os
-import difflib
-from collections import defaultdict
-
 from  . import tonie_header_pb2
-
 from .ogg_page import OggPage
 from .logger import get_logger
 
-# Setup logging
 logger = get_logger('tonie_analysis')
-
-
 def format_time(ts):
     """
     Format a timestamp as a human-readable date and time string.
@@ -28,7 +21,7 @@ def format_time(ts):
     Returns:
         str: Formatted date and time string
     """
-    return datetime.datetime.utcfromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
+    return datetime.datetime.fromtimestamp(ts, datetime.timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
 
 
 def format_hex(data):
@@ -112,8 +105,6 @@ def get_header_info(in_file):
     
     logger.debug("Opus header found: %s, Version: %d, Channels: %d, Sample rate: %d Hz, Serial: %d", 
                 opus_head_found, opus_version, channel_count, sample_rate, bitstream_serial_no)
-
-    # Read and parse Opus comments from the second page
     opus_comments = {}
     found = OggPage.seek_to_page_header(in_file)
     if not found:
@@ -124,7 +115,6 @@ def get_header_info(in_file):
     logger.debug("Read second OGG page")
     
     try:
-        # Combine all segments data for the second page
         comment_data = bytearray()
         for segment in second_page.segments:
             comment_data.extend(segment.data)
@@ -461,7 +451,6 @@ def compare_taf_files(file1, file2, detailed=False):
     
     differences = []
     
-    # Compare headers and extract key information
     with open(file1, "rb") as f1, open(file2, "rb") as f2:
         # Read and compare header sizes
         header_size1 = struct.unpack(">L", f1.read(4))[0]
@@ -581,4 +570,175 @@ def compare_taf_files(file1, file2, detailed=False):
     else:
         print("\nFiles are equivalent")
         logger.info("Files comparison result: Equivalent")
-        return True
+        return True
+
+def get_header_info_cli(in_file):
+    """
+    Get header information from a Tonie file.
+    
+    Args:
+        in_file: Input file handle
+        
+    Returns:
+        tuple: Header size, Tonie header object, file size, audio size, SHA1 sum,
+               Opus header found flag, Opus version, channel count, sample rate, bitstream serial number,
+               Opus comments dictionary, valid flag
+               
+    Note:
+        Instead of raising exceptions, this function returns default values and a valid flag
+    """
+    logger.debug("Reading Tonie header information")
+    
+    try:
+        tonie_header = tonie_header_pb2.TonieHeader()
+        header_size = struct.unpack(">L", in_file.read(4))[0]
+        logger.debug("Header size: %d bytes", header_size)
+        
+        tonie_header = tonie_header.FromString(in_file.read(header_size))
+        logger.debug("Read Tonie header with %d chapter pages", len(tonie_header.chapterPages))
+
+        sha1sum = hashlib.sha1(in_file.read())
+        logger.debug("Calculated SHA1: %s", sha1sum.hexdigest())
+
+        file_size = in_file.tell()
+        in_file.seek(4 + header_size)
+        audio_size = file_size - in_file.tell()
+        logger.debug("File size: %d bytes, Audio size: %d bytes", file_size, audio_size)
+
+        found = OggPage.seek_to_page_header(in_file)
+        if not found:
+            logger.error("First OGG page not found")
+            return (header_size, tonie_header, file_size, audio_size, sha1sum,
+                    False, 0, 0, 0, 0, {}, False)
+        
+        first_page = OggPage(in_file)
+        logger.debug("Read first OGG page")
+
+        unpacked = struct.unpack("<8sBBHLH", first_page.segments[0].data[0:18])
+        opus_head_found = unpacked[0] == b"OpusHead"
+        opus_version = unpacked[1]
+        channel_count = unpacked[2]
+        sample_rate = unpacked[4]
+        bitstream_serial_no = first_page.serial_no
+        
+        logger.debug("Opus header found: %s, Version: %d, Channels: %d, Sample rate: %d Hz, Serial: %d", 
+                    opus_head_found, opus_version, channel_count, sample_rate, bitstream_serial_no)
+        opus_comments = {}
+        found = OggPage.seek_to_page_header(in_file)
+        if not found:
+            logger.error("Second OGG page not found")
+            return (header_size, tonie_header, file_size, audio_size, sha1sum,
+                   opus_head_found, opus_version, channel_count, sample_rate, bitstream_serial_no, {}, False)
+        
+        second_page = OggPage(in_file)
+        logger.debug("Read second OGG page")
+        
+        try:
+            comment_data = bytearray()
+            for segment in second_page.segments:
+                comment_data.extend(segment.data)
+            
+            if comment_data.startswith(b"OpusTags"):
+                pos = 8  # Skip "OpusTags"
+                # Extract vendor string
+                if pos + 4 <= len(comment_data):
+                    vendor_length = struct.unpack("<I", comment_data[pos:pos+4])[0]
+                    pos += 4
+                    if pos + vendor_length <= len(comment_data):
+                        vendor = comment_data[pos:pos+vendor_length].decode('utf-8', errors='replace')
+                        opus_comments["vendor"] = vendor
+                        pos += vendor_length
+                        
+                        # Extract comments count
+                        if pos + 4 <= len(comment_data):
+                            comments_count = struct.unpack("<I", comment_data[pos:pos+4])[0]
+                            pos += 4
+                            
+                            # Extract individual comments
+                            for i in range(comments_count):
+                                if pos + 4 <= len(comment_data):
+                                    comment_length = struct.unpack("<I", comment_data[pos:pos+4])[0]
+                                    pos += 4
+                                    if pos + comment_length <= len(comment_data):
+                                        comment = comment_data[pos:pos+comment_length].decode('utf-8', errors='replace')
+                                        pos += comment_length
+                                        
+                                        # Split comment into key/value if possible
+                                        if "=" in comment:
+                                            key, value = comment.split("=", 1)
+                                            opus_comments[key] = value
+                                        else:
+                                            opus_comments[f"comment_{i}"] = comment
+                                    else:
+                                        break
+                                else:
+                                    break
+        except Exception as e:
+            logger.error("Failed to parse Opus comments: %s", str(e))
+
+        return (
+            header_size, tonie_header, file_size, audio_size, sha1sum,
+            opus_head_found, opus_version, channel_count, sample_rate, bitstream_serial_no,
+            opus_comments, True
+        )
+    except Exception as e:
+        logger.error("Error processing Tonie file: %s", str(e))
+        # Return default values with valid=False
+        return (0, tonie_header_pb2.TonieHeader(), 0, 0, None, False, 0, 0, 0, 0, {}, False)
+
+
+def check_tonie_file_cli(filename):
+    """
+    Check if a file is a valid Tonie file
+    
+    Args:
+        filename: Path to the file to check
+        
+    Returns:
+        bool: True if the file is valid, False otherwise
+    """
+    logger.info("Checking Tonie file: %s", filename)
+    
+    try:
+        with open(filename, "rb") as in_file:
+            header_size, tonie_header, file_size, audio_size, sha1, opus_head_found, \
+            opus_version, channel_count, sample_rate, bitstream_serial_no, opus_comments, valid = get_header_info_cli(in_file)
+
+            if not valid:
+                logger.error("Invalid Tonie file: %s", filename)
+                return False
+
+            try:
+                page_count, alignment_okay, page_size_okay, total_time, \
+                chapters = get_audio_info(in_file, sample_rate, tonie_header, header_size)
+            except Exception as e:
+                logger.error("Error analyzing audio data: %s", str(e))
+                return False
+
+        hash_ok = tonie_header.dataHash == sha1.digest()
+        timestamp_ok = tonie_header.timestamp == bitstream_serial_no
+        audio_size_ok = tonie_header.dataLength == audio_size
+        opus_ok = opus_head_found and \
+                opus_version == 1 and \
+                (sample_rate == 48000 or sample_rate == 44100) and \
+                channel_count == 2
+
+        all_ok = hash_ok and \
+                timestamp_ok and \
+                opus_ok and \
+                alignment_okay and \
+                page_size_okay
+
+        logger.debug("Validation results:")
+        logger.debug("  Hash OK: %s", hash_ok)
+        logger.debug("  Timestamp OK: %s", timestamp_ok)
+        logger.debug("  Audio size OK: %s", audio_size_ok)
+        logger.debug("  Opus OK: %s", opus_ok)
+        logger.debug("  Alignment OK: %s", alignment_okay)
+        logger.debug("  Page size OK: %s", page_size_okay)
+        logger.debug("  All OK: %s", all_ok)
+
+        return all_ok
+    except Exception as e:
+        logger.error("Error checking Tonie file: %s", str(e))
+        return False

TonieToolbox/tonie_file.py

@@ -15,7 +15,6 @@ from .ogg_page import OggPage
 from .constants import OPUS_TAGS, SAMPLE_RATE_KHZ, TIMESTAMP_DEDUCT
 from .logger import get_logger
 
-# Setup logging
 logger = get_logger('tonie_file')
 
 
@@ -38,7 +37,6 @@ def toniefile_comment_add(buffer, length, comment_str):
     buffer[length:length+4] = struct.pack("<I", str_length)
     length += 4
     
-    # Add the actual string
     buffer[length:length+str_length] = comment_str.encode('utf-8')
     length += str_length
     
@@ -115,49 +113,38 @@ def prepare_opus_tags(page, custom_tags=False, bitrate=64, vbr=True, opus_binary
         # Use custom tags for TonieToolbox
         # Create buffer for opus tags (similar to teddyCloud implementation)
         logger.debug("Creating custom Opus tags")
-        comment_data = bytearray(0x1B4)  # Same size as in teddyCloud
-        
-        # OpusTags signature
+        comment_data = bytearray(0x1B4)
         comment_data_pos = 0
         comment_data[comment_data_pos:comment_data_pos+8] = b"OpusTags"
-        comment_data_pos += 8
-        
+        comment_data_pos += 8        
         # Vendor string
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, "TonieToolbox")
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, "TonieToolbox")        
         # Number of comments (3 comments: version, encoder info, and encoder options)
         comments_count = 3
         comment_data[comment_data_pos:comment_data_pos+4] = struct.pack("<I", comments_count)
-        comment_data_pos += 4
-        
+        comment_data_pos += 4        
         # Add version information
         from . import __version__
         version_str = f"version={__version__}"
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, version_str)
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, version_str)        
         # Get actual opusenc version
         from .dependency_manager import get_opus_version
         encoder_info = get_opus_version(opus_binary)
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, f"encoder={encoder_info}")
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, f"encoder={encoder_info}")        
         # Create encoder options string with actual settings
         vbr_opt = "--vbr" if vbr else "--cbr"
         encoder_options = f"encoder_options=--bitrate {bitrate} {vbr_opt}"
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, encoder_options)
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, encoder_options)        
         # Add padding
         remain = len(comment_data) - comment_data_pos - 4
         comment_data[comment_data_pos:comment_data_pos+4] = struct.pack("<I", remain)
         comment_data_pos += 4
-        comment_data[comment_data_pos:comment_data_pos+4] = b"pad="
-        
+        comment_data[comment_data_pos:comment_data_pos+4] = b"pad="        
         # Create segments - handle data in chunks of 255 bytes maximum
-        comment_data = comment_data[:comment_data_pos + remain]  # Trim to actual used size
-        
+        comment_data = comment_data[:comment_data_pos + remain]  # Trim to actual used size        
         # Split large data into smaller segments (each <= 255 bytes)
         remaining_data = comment_data
-        first_segment = True
-        
+        first_segment = True        
         while remaining_data:
             chunk_size = min(255, len(remaining_data))
             segment = OpusPacket(None)
@@ -377,7 +364,7 @@ def fix_tonie_header(out_file, chapters, timestamp, sha):
 
 def create_tonie_file(output_file, input_files, no_tonie_header=False, user_timestamp=None,
                      bitrate=96, vbr=True, ffmpeg_binary=None, opus_binary=None, keep_temp=False, auto_download=False, 
-                     use_custom_tags=True):
+                     use_custom_tags=True, no_mono_conversion=False):
     """
     Create a Tonie file from input files.
     
@@ -393,13 +380,14 @@ def create_tonie_file(output_file, input_files, no_tonie_header=False, user_time
         keep_temp: Whether to keep temporary opus files for testing
         auto_download: Whether to automatically download dependencies if not found
         use_custom_tags: Whether to use dynamic comment tags generated with toniefile_comment_add
+        no_mono_conversion: Whether to skip mono conversion during audio processing
     """
     from .audio_conversion import get_opus_tempfile
     
     logger.trace("Entering create_tonie_file(output_file=%s, input_files=%s, no_tonie_header=%s, user_timestamp=%s, "
-                "bitrate=%d, vbr=%s, ffmpeg_binary=%s, opus_binary=%s, keep_temp=%s, auto_download=%s, use_custom_tags=%s)",
+                "bitrate=%d, vbr=%s, ffmpeg_binary=%s, opus_binary=%s, keep_temp=%s, auto_download=%s, use_custom_tags=%s, no_mono_conversion=%s)",
                 output_file, input_files, no_tonie_header, user_timestamp, bitrate, vbr, ffmpeg_binary, 
-                opus_binary, keep_temp, auto_download, use_custom_tags)
+                opus_binary, keep_temp, auto_download, use_custom_tags, no_mono_conversion)
     
     logger.info("Creating Tonie file from %d input files", len(input_files))
     logger.debug("Output file: %s, Bitrate: %d kbps, VBR: %s, No header: %s", 
@@ -465,9 +453,9 @@ def create_tonie_file(output_file, input_files, no_tonie_header=False, user_time
                 handle = open(fname, "rb")
                 temp_file_path = None
             else:
-                logger.debug("Converting %s to Opus format (bitrate: %d kbps, VBR: %s)", 
-                            fname, bitrate, vbr)
-                handle, temp_file_path = get_opus_tempfile(ffmpeg_binary, opus_binary, fname, bitrate, vbr, keep_temp, auto_download)
+                logger.debug("Converting %s to Opus format (bitrate: %d kbps, VBR: %s, no_mono_conversion: %s)", 
+                            fname, bitrate, vbr, no_mono_conversion)
+                handle, temp_file_path = get_opus_tempfile(ffmpeg_binary, opus_binary, fname, bitrate, vbr, keep_temp, auto_download, no_mono_conversion=no_mono_conversion)
                 if temp_file_path:
                     temp_files.append(temp_file_path)
                     logger.debug("Temporary opus file saved to: %s", temp_file_path)