Upload 3 files

app.py

@@ -370,14 +370,33 @@ def download_aac_segments(stream_data, track_title, artist, quality):
         print(f"Error downloading AAC: {e}")
         return None
 
+def get_extension(codec):
+    codec = codec.lower()
+    if 'flac' in codec or 'mqa' in codec:
+        return '.flac'
+    elif 'mp4a' in codec or 'aac' in codec:
+        return '.m4a'
+    elif 'ec-3' in codec or 'ac3' in codec or 'eac3' in codec:
+        return '.m4a'
+    elif 'ac-4' in codec or 'ac4' in codec:
+        return '.m4a'
+    elif 'mha1' in codec:
+        return '.m4a'
+    return '.flac' # Default
+
 def download_flac_segments(stream_data, track_title, artist, quality):
     """Download DASH segments and convert to FLAC using FFmpeg"""
     try:
-        dash_info = parse_dash_xml(stream_data.get("manifest"))
+        manifest_b64 = stream_data.get("manifest")
+        dash_info = parse_dash_xml(manifest_b64)
         if not dash_info:
             return None
 
-        print(f"Downloading {dash_info['segment_count']} segments for {track_title}...")
+        # Detect codec from dash_info
+        codec = dash_info.get('codecs', 'flac')
+        ext = get_extension(codec)
+        
+        print(f"Downloading {dash_info['segment_count']} segments for {track_title} (Codec: {codec})...")
 
         temp_dir = tempfile.mkdtemp()
         segments = []
@@ -421,8 +440,7 @@ def download_flac_segments(stream_data, track_title, artist, quality):
 
         safe_title = re.sub(r'[^\w\s-]', '', track_title).strip()
         safe_artist = re.sub(r'[^\w\s-]', '', artist).strip()
-        filename = f"{safe_artist} - {safe_title}.flac"
-        filename = re.sub(r'\s+', '_', filename)
+        filename = f"{safe_artist}_{safe_title}{ext}".replace(" ", "_")
         output_path = os.path.join(DOWNLOAD_DIR, filename)
         temp_mp4 = os.path.join(temp_dir, "temp_container.mp4")
 
@@ -437,27 +455,39 @@ def download_flac_segments(stream_data, track_title, artist, quality):
                         outfile.write(infile.read())
 
         try:
-            result = subprocess.run([
+            # Use acodec copy to avoid quality loss and preserve raw stream
+            # If output is .flac, FFmpeg will remux to FLAC container
+            ffmpeg_cmd = [
                 'ffmpeg', '-y', '-i', temp_mp4,
-                '-acodec', 'flac',
-                '-compression_level', '0',
+                '-vn', '-acodec', 'copy',
                 output_path
-            ], capture_output=True, text=True, timeout=120)
+            ]
+            
+            # If codec is FLAC but output is .flac, FFmpeg usually handles it well with 'copy'
+            # If it fails, we might need to specify the format or re-encode as a fallback
+            
+            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, timeout=120)
 
             if result.returncode != 0:
-                print(f"FFmpeg error: {result.stderr}")
-                shutil.copy(temp_mp4, output_path)
+                print(f"FFmpeg error with acodec copy: {result.stderr}")
+                # Fallback to re-encoding only if copy fails
+                print("Attempting fallback with explicit flac encoding...")
+                subprocess.run([
+                    'ffmpeg', '-y', '-i', temp_mp4,
+                    '-vn', '-acodec', 'flac', '-compression_level', '0',
+                    output_path
+                ], capture_output=True, text=True, timeout=120)
         except Exception as e:
             print(f"FFmpeg conversion error: {e}")
             shutil.copy(temp_mp4, output_path)
 
         shutil.rmtree(temp_dir)
 
-        print(f"✓ FLAC file saved: {output_path}")
+        print(f"✓ Audio file saved: {output_path}")
         return output_path
 
     except Exception as e:
-        print(f"Error downloading FLAC: {e}")
+        print(f"Error downloading audio segments: {e}")
         return None
 
 def load_tidal_session(client_id=None, client_secret=None):
@@ -565,39 +595,60 @@ async def get_tidal_track_info(
                         result["message"] = "Failed to download AAC file"
                 elif stream_data and stream_data.get("manifestMimeType") == "application/vnd.tidal.bts":
                     bts_urls = []
-                    if "urls" in stream_data and stream_data["urls"]:
-                        bts_urls = stream_data["urls"]
-                    elif "manifest" in stream_data:
+                    codec = 'aac' # Default for H/L
+                    if "manifest" in stream_data:
                         try:
                             manifest_json = json.loads(base64.b64decode(stream_data["manifest"]))
                             print(f"DEBUG [H/L]: Decoded bts manifest keys: {list(manifest_json.keys())}")
                             bts_urls = manifest_json.get("urls", [])
+                            codec = manifest_json.get("codecs", "aac")
                         except Exception as e:
                             print(f"DEBUG [H/L]: Error decoding bts manifest: {e}")
 
+                    if not bts_urls and "urls" in stream_data:
+                        bts_urls = stream_data["urls"]
+
                     if bts_urls:
                         direct_url = bts_urls[0]
-                        print(f"DEBUG [H/L]: Found bts URL: {direct_url[:50]}...")
+                        ext = get_extension(codec)
+                        print(f"DEBUG [H/L]: Found bts URL: {direct_url[:50]}... Codec: {codec}")
                         try:
                             safe_title = re.sub(r'[^\w\s-]', '', title).strip()
                             safe_artist = re.sub(r'[^\w\s-]', '', artist).strip()
-                            ext = ".m4a"
-                            filename = f"{safe_artist} - {safe_title}{ext}"
-                            filename = re.sub(r'\s+', '_', filename)
+                            filename = f"{safe_artist}_{safe_title}{ext}".replace(" ", "_")
                             output_path = os.path.join(DOWNLOAD_DIR, filename)
 
-                            response = r_session.get(direct_url, verify=False, stream=True, timeout=60)
-                            if response.status_code == 200:
-                                with open(output_path, 'wb') as f:
-                                    for chunk in response.iter_content(chunk_size=8192):
-                                        if chunk: f.write(chunk)
-                                result["download_url"] = f"/api/tidal/download/{filename}"
-                                result["file_path"] = output_path
-                                result["file_size"] = os.path.getsize(output_path)
+                            print(f"Processing H/L bts stream via FFmpeg (acodec copy): {direct_url[:50]}...")
+                            ffmpeg_res = subprocess.run([
+                                'ffmpeg', '-y', '-i', direct_url,
+                                '-vn', '-acodec', 'copy',
+                                output_path
+                            ], capture_output=True, text=True, timeout=180)
+
+                            if ffmpeg_res.returncode == 0 and os.path.exists(output_path):
+                                result.update({
+                                    "download_url": f"/api/tidal/download/{filename}",
+                                    "file_path": output_path,
+                                    "file_size": os.path.getsize(output_path)
+                                })
                             else:
-                                result["download_url"] = None
-                                result["message"] = f"Failed to download bts stream: {response.status_code}"
+                                print(f"FAILED to copy H/L bts stream: {ffmpeg_res.stderr}")
+                                # Try re-encoding if copy fails
+                                if ext == '.m4a':
+                                    print("Attempting fallback aac encoding...")
+                                    subprocess.run([
+                                        'ffmpeg', '-y', '-i', direct_url,
+                                        '-vn', '-acodec', 'aac', '-b:a', '320k',
+                                        output_path
+                                    ], capture_output=True, timeout=180)
+                                    if os.path.exists(output_path):
+                                        result.update({
+                                            "download_url": f"/api/tidal/download/{filename}",
+                                            "file_path": output_path,
+                                            "file_size": os.path.getsize(output_path)
+                                        })
                         except Exception as e:
+                            print(f"Error processing H/L bts stream: {e}")
                             result["download_url"] = None
                             result["message"] = f"Error: {e}"
                     else:
@@ -642,55 +693,60 @@ async def get_tidal_track_info(
                 elif stream_data and stream_data.get("manifestMimeType") == "application/vnd.tidal.bts":
                     # For bts, the URLs are usually inside the base64 encoded manifest JSON
                     bts_urls = []
-                    if "urls" in stream_data and stream_data["urls"]:
-                        bts_urls = stream_data["urls"]
-                    elif "manifest" in stream_data:
+                    codec = 'flac' # Default
+                    if "manifest" in stream_data:
                         try:
                             manifest_json = json.loads(base64.b64decode(stream_data["manifest"]))
                             print(f"DEBUG: Decoded bts manifest keys: {list(manifest_json.keys())}")
                             bts_urls = manifest_json.get("urls", [])
+                            codec = manifest_json.get("codecs", "flac")
                         except Exception as e:
                             print(f"DEBUG: Error decoding bts manifest: {e}")
 
+                    if not bts_urls and "urls" in stream_data:
+                        bts_urls = stream_data["urls"]
+
                     if bts_urls:
                         direct_url = bts_urls[0]
-                        print(f"DEBUG: Found bts URL: {direct_url[:50]}...")
+                        ext = get_extension(codec)
+                        print(f"DEBUG: Found bts URL: {direct_url[:50]}... Codec: {codec}")
                         try:
                             safe_title = re.sub(r'[^\w\s-]', '', title).strip()
                             safe_artist = re.sub(r'[^\w\s-]', '', artist).strip()
-                            filename = f"{safe_artist}_{safe_title}.flac".replace(" ", "_")
+                            filename = f"{safe_artist}_{safe_title}{ext}".replace(" ", "_")
                             output_path = os.path.join(DOWNLOAD_DIR, filename)
 
-                            print(f"Processing bts stream via FFmpeg to ensure FLAC: {direct_url[:50]}...")
-                            # Use FFmpeg to stream from the URL and convert/extract to FLAC
+                            print(f"Processing bts stream via FFmpeg (acodec copy): {direct_url[:50]}...")
+                            # Use acodec copy to preserve original quality
                             ffmpeg_res = subprocess.run([
                                 'ffmpeg', '-y', '-i', direct_url,
-                                '-vn', '-acodec', 'flac',
-                                '-compression_level', '0',
+                                '-vn', '-acodec', 'copy',
                                 output_path
                             ], capture_output=True, text=True, timeout=180)
 
                             if ffmpeg_res.returncode == 0 and os.path.exists(output_path):
-                                print(f"✓ FLAC file saved via FFmpeg: {output_path}")
+                                print(f"✓ Audio file saved via FFmpeg: {output_path}")
                                 result.update({
                                     "download_url": f"/api/tidal/download/{filename}",
                                     "file_path": output_path,
                                     "file_size": os.path.getsize(output_path)
                                 })
                             else:
-                                print(f"FAILED to convert bts stream with FFmpeg: {ffmpeg_res.stderr}")
-                                # Fallback: try direct download if FFmpeg fails
-                                response = r_session.get(direct_url, verify=False, stream=True, timeout=60)
-                                if response.status_code == 200:
-                                    with open(output_path, 'wb') as f:
-                                        for chunk in response.iter_content(chunk_size=8192):
-                                            if chunk: f.write(chunk)
-                                    result["download_url"] = f"/api/tidal/download/{filename}"
-                                    result["file_path"] = output_path
-                                    result["file_size"] = os.path.getsize(output_path)
-                                else:
-                                    result["download_url"] = None
-                                    result["message"] = f"Failed to download bts stream: {response.status_code}"
+                                print(f"FAILED to copy bts stream with FFmpeg: {ffmpeg_res.stderr}")
+                                # If it's FLAC and copy failed, try re-encoding as last resort
+                                if ext == '.flac':
+                                    print("Attempting fallback flac encoding...")
+                                    subprocess.run([
+                                        'ffmpeg', '-y', '-i', direct_url,
+                                        '-vn', '-acodec', 'flac', '-compression_level', '0',
+                                        output_path
+                                    ], capture_output=True, timeout=180)
+                                    if os.path.exists(output_path):
+                                        result.update({
+                                            "download_url": f"/api/tidal/download/{filename}",
+                                            "file_path": output_path,
+                                            "file_size": os.path.getsize(output_path)
+                                        })
                         except Exception as e:
                             print(f"Error processing bts stream: {e}")
                             result["download_url"] = None