Update app.py

app.py

@@ -114,45 +114,65 @@ def decrypt_file(input_path, output_path, key, nonce):
         outfile.write(decrypted_data)
 
 def parse_dash_manifest(manifest_data):
-    """Parse DASH manifest XML and extract segment URLs"""
+    """Parse DASH manifest XML and extract segment URLs and audio format"""
     manifest_str = manifest_data.decode('utf-8')
-    
+
     base_url = ""
     segments = []
     media_template = ""
     start_number = 1
-    
+    audio_format = "flac"
+    codecs_detected = ""
+
     try:
         root = ET.fromstring(manifest_str)
-        
+
         for elem in root.iter():
             tag = elem.tag
             if '}' in tag:
                 tag = tag.split('}')[1]
-            
+
             if tag == 'BaseURL' or tag.lower() == 'baseurl':
                 base_url = elem.text
-            
+
+            if tag == 'Representation' or tag.lower() == 'representation':
+                codec = elem.get('codecs', '').upper()
+                codecs_detected = codec
+                if codec:
+                    print(f"   Found Representation with codecs: '{codec}'")
+                    if 'MP4A' in codec or 'AAC' in codec:
+                        audio_format = "m4a"
+                    elif 'FLAC' in codec:
+                        audio_format = "flac"
+                    elif 'EC3' in codec or 'EAC3' in codec:
+                        audio_format = "eac3"
+                    print(f"   Detected audio format: {audio_format}")
+
             if tag == 'SegmentTemplate' or tag.lower() == 'segmenttemplate':
                 media_template = elem.get('media', '')
+                initialization = elem.get('initialization', '')
                 start_number = int(elem.get('startNumber', '1'))
                 
+                if initialization:
+                    segments.append(initialization)
+                    print(f"✅ Added initialization segment: {initialization}")
+
                 for timeline in elem.iter():
                     tl_tag = timeline.tag
                     if '}' in tl_tag:
                         tl_tag = tl_tag.split('}')[1]
-                    
+
                     if tl_tag == 'SegmentTimeline' or tl_tag.lower() == 'segmenttimeline':
                         total_segments = 0
                         for s_elem in timeline.iter():
                             s_tag = s_elem.tag
                             if '}' in s_tag:
                                 s_tag = s_tag.split('}')[1]
-                            
+
                             if s_tag == 'S' or s_tag.lower() == 's':
                                 repeat = int(s_elem.get('r', '0'))
                                 total_segments += repeat + 1
-                        
+
                         if media_template and total_segments > 0:
                             for i in range(start_number, start_number + total_segments):
                                 segment_url = media_template.replace('$Number$', str(i))
@@ -160,34 +180,63 @@ def parse_dash_manifest(manifest_data):
                             print(f"✅ Generated {len(segments)} segment URLs from template")
     except Exception as e:
         print(f"⚠️ Error parsing DASH manifest: {e}")
-    
+
     if not segments:
         print("⚠️ Trying regex parsing...")
-        import re
-        
+
+        init_match = re.search(r'initialization="([^"]+)"', manifest_str)
+        if init_match:
+            initialization = init_match.group(1)
+            segments.append(initialization)
+            print(f"✅ Added initialization segment with regex: {initialization}")
+
         template_match = re.search(r'media="([^"]+\$Number\$[^"]+)"', manifest_str)
         if template_match:
             media_template = template_match.group(1)
-            
+
             start_num_match = re.search(r'startNumber="(\d+)"', manifest_str)
             if start_num_match:
                 start_number = int(start_num_match.group(1))
-            
+
             timeline_matches = re.findall(r'<S[^>]*d="(\d+)"[^>]*r="(\d+)"', manifest_str)
             total_segments = 0
             for d, r in timeline_matches:
                 total_segments += int(r) + 1
-            
+
             single_segments = re.findall(r'<S[^>]*d="(\d+)"[^>]*[^r][^>]*>', manifest_str)
             total_segments += len(single_segments)
-            
+
             if total_segments > 0:
                 for i in range(start_number, start_number + total_segments):
                     segment_url = media_template.replace('$Number$', str(i))
                     segments.append(segment_url)
                 print(f"✅ Generated {len(segments)} segment URLs with regex")
-    
-    return base_url, segments
+
+        codecs_match = re.search(r'codecs="([^"]+)"', manifest_str)
+        if codecs_match:
+            codec = codecs_match.group(1).upper()
+            codecs_detected = codec
+            if 'MP4A' in codec or 'AAC' in codec:
+                audio_format = "m4a"
+            elif 'FLAC' in codec:
+                audio_format = "flac"
+            elif 'EC3' in codec or 'EAC3' in codec:
+                audio_format = "eac3"
+
+        mime_match = re.search(r'mimeType="([^"]+)"', manifest_str)
+        if mime_match:
+            mime = mime_match.group(1).lower()
+            if 'mp4' in mime or 'aac' in mime or 'm4a' in mime:
+                audio_format = "m4a"
+            elif 'flac' in mime:
+                audio_format = "flac"
+
+        base_match = re.search(r'<[^>]*BaseURL[^>]*>([^<]+)</', manifest_str)
+        if base_match:
+            base_url = base_match.group(1)
+
+    print(f"   Final detected codec: {codecs_detected}, format: {audio_format}")
+    return base_url, segments, audio_format
 
 def parse_bt_manifest(manifest_data):
     """Parse BT manifest (JSON format)"""
@@ -283,6 +332,7 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
         
         if is_lossless:
             security_token = data.get('securityToken')
+            print(f"   securityToken present: {bool(security_token)}, length: {len(security_token) if security_token else 0}")
             key = None
             nonce = None
             
@@ -292,18 +342,25 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
             
             download_dir = "./downloads"
             os.makedirs(download_dir, exist_ok=True)
-            
-            tmpdir = tempfile.mkdtemp(prefix="tidal-api-")
+            tmpdir = tempfile.mkdtemp(prefix="tidal-segments-")
+            temp_files = []
             
             try:
                 print("📦 Parsing DASH manifest...")
-                base_url, segments = parse_dash_manifest(manifest_data)
-                print(f"✅ Found {len(segments)} segments")
+                base_url, segments, audio_format = parse_dash_manifest(manifest_data)
+                print(f"✅ Found {len(segments)} segments, format: {audio_format}")
                 
                 print("⬇️ Downloading segments...")
+                
                 for i, seg in enumerate(segments):
-                    seg_url = seg
-                    seg_path = os.path.join(tmpdir, f"segment_{i:04d}.enc")
+                    if seg.startswith('http://') or seg.startswith('https://'):
+                        seg_url = seg
+                    elif base_url:
+                        seg_url = base_url + seg
+                    else:
+                        seg_url = seg
+                    seg_path = os.path.join(tmpdir, f"segment_{i:04d}.mp4")
+                    temp_files.append(seg_path)
                     
                     max_retries = 3
                     success = False
@@ -326,27 +383,94 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
                     
                     print(f"   Segment {i+1}/{len(segments)} downloaded")
                 
-                print("🔐 Decrypting and merging segments...")
-                output_filename = f"{artist} - {title}.flac"
+                print(f"🔄 Merging {len(segments)} segments into {audio_format}...")
+                print(f"   Temp files count: {len(temp_files)}")
+                print(f"   Temp directory: {tmpdir}")
+                
+                # Check first segment header
+                if temp_files:
+                    with open(temp_files[0], 'rb') as f:
+                        header = f.read(16).hex()
+                        print(f"   First segment header (hex): {header}")
+                        if header.startswith('0000001866747970'):
+                            print("   ✅ First segment is MP4 (ftyp header)")
+                        elif header.startswith('0000010c6d6f6f66'):
+                            print("   ⚠️ First segment is fragmented MP4 (moof header)")
+                        else:
+                            print(f"   ❓ Unknown header: {header[:20]}...")
+                
+                output_filename = f"{artist} - {title}.{audio_format}"
                 output_path = os.path.join(download_dir, output_filename)
+                print(f"   Output path: {output_path}")
                 
-                with open(output_path, 'wb') as out:
-                    for i in range(len(segments)):
-                        seg_path = os.path.join(tmpdir, f"segment_{i:04d}.enc")
-                        decrypted_path = os.path.join(tmpdir, f"decrypted_{i:04d}.flac")
+                if audio_format == "flac":
+                    merged_path = os.path.join(tmpdir, "merged.mp4")
+                    print(f"   Merged path: {merged_path}")
+                    
+                    with open(merged_path, 'wb') as out:
+                        print("   Starting merge...")
+                        for idx, temp_file in enumerate(temp_files):
+                            with open(temp_file, 'rb') as f:
+                                out.write(f.read())
+                        print("   Merge complete")
+                    
+                    print("   Starting FFmpeg conversion...")
+                    try:
+                        import subprocess
                         
-                        if key and nonce:
-                            decrypt_file(seg_path, decrypted_path, key, nonce)
+                        # First check if the merged file is valid with ffprobe
+                        probe_result = subprocess.run([
+                            'ffprobe', '-v', 'error', '-show_streams', '-of', 'json', merged_path
+                        ], capture_output=True, text=True, timeout=30)
+                        print(f"ffprobe return code: {probe_result.returncode}")
+                        if probe_result.returncode == 0:
+                            print(f"✅ Merged file is valid MP4")
+                            print(f"ffprobe output: {probe_result.stdout[:500]}")
                         else:
-                            with open(seg_path, 'rb') as f:
-                                with open(decrypted_path, 'wb') as df:
-                                    df.write(f.read())
+                            print(f"❌ Merged file analysis failed: {probe_result.stderr}")
                         
-                        with open(decrypted_path, 'rb') as f:
-                            out.write(f.read())
+                        # Use stream copy mode which is what OrpheusDL does
+                        result = subprocess.run([
+                            'ffmpeg', '-y', '-i', merged_path, 
+                            '-c', 'copy', 
+                            '-loglevel', 'error',
+                            output_path
+                        ], capture_output=True, text=True, timeout=120)
+                        
+                        print(f"FFmpeg return code: {result.returncode}")
+                        print(f"FFmpeg stdout: {result.stdout[:2000] if result.stdout else 'None'}")
+                        print(f"FFmpeg stderr: {result.stderr[:2000] if result.stderr else 'None'}")
+                        
+                        if result.returncode != 0:
+                            print(f"⚠️ FFmpeg conversion failed with code {result.returncode}: {result.stderr}")
+                            raise HTTPException(status_code=500, detail=f"FFmpeg conversion failed: {result.stderr}")
+                        
+                        print(f"✅ Converted to FLAC: {output_path}")
+                    except FileNotFoundError:
+                        print("⚠️ FFmpeg not found, using raw merge")
+                        with open(output_path, 'wb') as out:
+                            for temp_file in temp_files:
+                                with open(temp_file, 'rb') as f:
+                                    out.write(f.read())
+                    except subprocess.TimeoutExpired:
+                        print("⚠️ FFmpeg timeout")
+                        raise HTTPException(status_code=500, detail="FFmpeg timeout")
+                    except Exception as e:
+                        print(f"⚠️ Exception during FFmpeg: {e}")
+                        raise
+                else:
+                    with open(output_path, 'wb') as out:
+                        for temp_file in temp_files:
+                            with open(temp_file, 'rb') as f:
+                                out.write(f.read())
                 
                 print(f"✅ Download complete: {output_path}")
                 
+                print("   Cleaning up temp files...")
+                import shutil
+                shutil.rmtree(tmpdir, ignore_errors=True)
+                print("   Cleanup complete")
+                
                 file_size = os.path.getsize(output_path)
                 
                 return {
@@ -362,7 +486,7 @@ async def download_track(track_id: int, quality: str = "LOSSLESS"):
                         "isrc": isrc,
                         "quality": audio_quality,
                         "fileSize": file_size,
-                        "format": "flac"
+                        "format": audio_format
                     },
                     "downloadUrl": f"/download_file/{output_filename}",
                     "message": "File downloaded and ready for download"