718 lines
28 KiB
Python
718 lines
28 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
iPod Nano 7 Database Manager — iOpenPod-powered edition.
|
|
|
|
Uses iOpenPod's battle-tested SQLiteDB_Writer and iTunesDB_Writer to
|
|
generate correct databases for Nano 6G/7G firmware.
|
|
|
|
The firmware on Nano 6G/7G reads SQLite databases exclusively, with
|
|
cross-reference validation against the binary iTunesDB. Both must be
|
|
written with the same db_pid. iOpenPod handles all of this correctly.
|
|
|
|
Public API preserved for main.py compatibility:
|
|
Nano7Database(mount_point) — constructor
|
|
add_track(filepath) — copy + sync
|
|
get_all_tracks() — scan iPod filesystem
|
|
get_track_count() — count audio files on iPod
|
|
delete_track(pid) — delete by pid (db_track_id)
|
|
remove_duplicates() — find + remove duplicate tracks
|
|
get_orphaned_files() — files not in DB
|
|
delete_orphaned_files(paths) — remove orphan files
|
|
"""
|
|
|
|
import importlib
|
|
import os
|
|
import sys
|
|
import hashlib
|
|
import logging
|
|
import random
|
|
import shutil
|
|
import sqlite3
|
|
import struct
|
|
import subprocess
|
|
import time
|
|
from typing import Any, Optional
|
|
|
|
from mutagen import File as MutagenFile
|
|
from mutagen.easyid3 import EasyID3
|
|
|
|
from artwork import prepare_artwork_for_track, ArtworkEntry, write_artworkdb
|
|
|
|
_IOP_ROOT = "/tmp/iOpenPod"
|
|
_IOP_CACHE: dict[str, Any] = {}
|
|
_IOP_READY = False
|
|
|
|
|
|
def _import_iop(module_name: str):
|
|
"""Import a module from iOpenPod, evicting our local ipod_device once.
|
|
|
|
main.py imports our local ``ipod_device`` early, caching it in
|
|
``sys.modules``. On the FIRST call here we permanently evict the
|
|
local module so iOpenPod's ``ipod_device`` takes its place in
|
|
``sys.modules``. Our local classes (IPodDevice) were already
|
|
bound by ``from ipod_device import IPodDevice`` in main.py before
|
|
the eviction, so they stay alive through their own references.
|
|
|
|
Subsequent calls are served from a simple module cache.
|
|
"""
|
|
global _IOP_READY
|
|
if module_name in _IOP_CACHE:
|
|
return _IOP_CACHE[module_name]
|
|
|
|
if not _IOP_READY:
|
|
# Evict local shadows ONCE so iOpenPod modules resolve correctly.
|
|
sys.modules.pop("ipod_device", None)
|
|
_IOP_READY = True
|
|
logger.debug("iOpenPod boot: evicted local ipod_device")
|
|
|
|
had_iop = _IOP_ROOT in sys.path
|
|
if not had_iop:
|
|
sys.path.insert(0, _IOP_ROOT)
|
|
try:
|
|
mod = importlib.import_module(module_name)
|
|
finally:
|
|
if not had_iop:
|
|
sys.path.remove(_IOP_ROOT)
|
|
|
|
_IOP_CACHE[module_name] = mod
|
|
return mod
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# ── constants ────────────────────────────────────────────────────────
|
|
FILETYPE_CODES = {
|
|
"mp3": 0x4D503320,
|
|
"m4a": 0x4D344120,
|
|
"m4p": 0x4D345020,
|
|
"mp4": 0x4D503420,
|
|
"aac": 0x41414320,
|
|
}
|
|
|
|
MAC_EPOCH_OFFSET = 2082844800
|
|
MASTER_CONTAINER_PID = 203092939621887772
|
|
MUSIC_CONTAINER_PID = 4872745547565090077
|
|
|
|
|
|
# ── Helpers ──────────────────────────────────────────────────────────
|
|
|
|
def _to_mac_epoch(ts: int) -> int:
|
|
return ts + MAC_EPOCH_OFFSET if ts > 0 else 0
|
|
|
|
|
|
def _read_audio_tags(filepath: str) -> dict[str, Any]:
|
|
"""Extract title, artist, album, duration, etc. from an audio file."""
|
|
info: dict[str, Any] = {}
|
|
ext = os.path.splitext(filepath)[1].lower()
|
|
try:
|
|
audio = MutagenFile(filepath)
|
|
if audio is None:
|
|
return info
|
|
if hasattr(audio, "info") and audio.info and audio.info.length:
|
|
info["duration_ms"] = int(audio.info.length * 1000)
|
|
else:
|
|
info["duration_ms"] = 0
|
|
if hasattr(audio.info, "bitrate"):
|
|
info["bitrate"] = audio.info.bitrate
|
|
else:
|
|
info["bitrate"] = 0
|
|
if hasattr(audio.info, "sample_rate"):
|
|
info["sample_rate"] = audio.info.sample_rate or 44100
|
|
else:
|
|
info["sample_rate"] = 44100
|
|
if hasattr(audio.info, "channels"):
|
|
info["channels"] = audio.info.channels or 2
|
|
else:
|
|
info["channels"] = 2
|
|
|
|
if ext == ".mp3":
|
|
try:
|
|
easy = EasyID3(filepath)
|
|
for tag_k, dest in [("title", "title"), ("artist", "artist"),
|
|
("album", "album"), ("albumartist", "album_artist"),
|
|
("genre", "genre"), ("composer", "composer"),
|
|
("comment", "comment")]:
|
|
if tag_k in easy:
|
|
val = easy[tag_k]
|
|
if isinstance(val, list) and val:
|
|
info[dest] = str(val[0])
|
|
for tag_k, dest in [("tracknumber", "track_number"),
|
|
("discnumber", "disc_number")]:
|
|
if tag_k in easy:
|
|
val = easy[tag_k]
|
|
if isinstance(val, list) and val:
|
|
s = str(val[0])
|
|
if "/" in s:
|
|
parts = s.split("/")
|
|
info[dest] = int(parts[0]) if parts[0].isdigit() else 0
|
|
elif s.isdigit():
|
|
info[dest] = int(s)
|
|
if "date" in easy:
|
|
val = easy["date"]
|
|
if isinstance(val, list) and val:
|
|
ds = str(val[0])
|
|
if len(ds) >= 4:
|
|
info["year"] = int(ds[:4])
|
|
except Exception:
|
|
pass
|
|
elif ext in (".m4a", ".aac", ".mp4", ".m4p"):
|
|
if audio and audio.tags:
|
|
t = audio.tags
|
|
for mp4_k, dest in [("\xa9nam", "title"), ("\xa9ART", "artist"),
|
|
("\xa9alb", "album"), ("aART", "album_artist"),
|
|
("\xa9gen", "genre"), ("\xa9wrt", "composer"),
|
|
("\xa9day", "date")]:
|
|
if mp4_k in t:
|
|
v = t[mp4_k]
|
|
if isinstance(v, list) and v:
|
|
if dest == "date":
|
|
ds = str(v[0])
|
|
if len(ds) >= 4:
|
|
info["year"] = int(ds[:4])
|
|
else:
|
|
info[dest] = str(v[0])
|
|
if "trkn" in t:
|
|
tr = t["trkn"]
|
|
if isinstance(tr, list) and tr and isinstance(tr[0], tuple):
|
|
info["track_number"] = tr[0][0]
|
|
else:
|
|
if audio and audio.tags:
|
|
for tag_k, dest in [("title", "title"), ("artist", "artist"),
|
|
("album", "album"), ("albumartist", "album_artist"),
|
|
("genre", "genre"), ("composer", "composer")]:
|
|
try:
|
|
if tag_k in audio.tags:
|
|
v = audio.tags[tag_k]
|
|
info[dest] = str(v[0]) if isinstance(v, list) and v else str(v)
|
|
except (ValueError, TypeError):
|
|
pass
|
|
except Exception:
|
|
pass
|
|
return info
|
|
|
|
|
|
def _probe_gapless(filepath: str, sample_rate: int, duration_ms: int) -> tuple[int, int, int]:
|
|
"""Probe AAC/MP3 file for encoder delay and padding samples.
|
|
|
|
Returns (pregap, postgap, sample_count).
|
|
"""
|
|
pregap = 0
|
|
postgap = 0
|
|
try:
|
|
result = subprocess.run(
|
|
["ffprobe", "-v", "error", "-select_streams", "a:0",
|
|
"-show_entries", "stream_tags=encoder_delay,padding",
|
|
"-of", "csv=p=0", filepath],
|
|
capture_output=True, text=True, timeout=10,
|
|
)
|
|
if result.returncode == 0 and result.stdout.strip():
|
|
parts = result.stdout.strip().split(",")
|
|
pregap = int(parts[0]) if parts[0] else 0
|
|
postgap = int(parts[1]) if len(parts) > 1 and parts[1] else 0
|
|
except Exception:
|
|
pass
|
|
|
|
# Fallback: typical AAC-LC encoding delay (1 frame = 1024 samples at 44100 Hz)
|
|
if pregap == 0 and sample_rate == 44100:
|
|
ext = os.path.splitext(filepath)[1].lower()
|
|
if ext in (".m4a", ".aac", ".mp4"):
|
|
pregap = 1024
|
|
|
|
total_samples = int(duration_ms * sample_rate / 1000) if duration_ms else 0
|
|
sample_count = max(0, total_samples - pregap - postgap)
|
|
return pregap, postgap, sample_count
|
|
|
|
|
|
def _scanned_tracks_to_iop(mountpoint: str,
|
|
scanned: list[dict],
|
|
artwork_map: dict[str, tuple[int, int, int]] | None = None) -> list:
|
|
"""Convert our scanned track dicts to iOpenPod TrackInfo objects."""
|
|
IopTrackInfo = _import_iop("iTunesDB_Writer.mhit_writer").TrackInfo
|
|
tracks: list = []
|
|
for s in scanned:
|
|
fpath = s["file_path"]
|
|
fname = os.path.basename(fpath)
|
|
base, ext = os.path.splitext(fname)
|
|
ft = ext.lstrip(".").lower()
|
|
rel = os.path.relpath(fpath, os.path.join(mountpoint, "iPod_Control", "Music"))
|
|
location = f":iPod_Control:Music:{rel.replace('/', ':')}"
|
|
size = os.path.getsize(fpath)
|
|
|
|
art_count = 0
|
|
art_size = 0
|
|
mhii_link = 0
|
|
if artwork_map and fpath in artwork_map:
|
|
mhii_link, art_count, art_size = artwork_map[fpath]
|
|
|
|
sr = s.get("sample_rate", 44100)
|
|
dur_ms = s.get("duration_ms", 0)
|
|
pregap, postgap, sample_count = _probe_gapless(fpath, sr, dur_ms)
|
|
|
|
has_album = bool(s.get("album"))
|
|
|
|
t = IopTrackInfo(
|
|
title=s.get("title") or base,
|
|
location=location,
|
|
size=size,
|
|
length=dur_ms,
|
|
filetype=ft,
|
|
bitrate=s.get("bitrate", 0) // 1000,
|
|
sample_rate=sr,
|
|
artist=s.get("artist") or "",
|
|
album=s.get("album") or "",
|
|
album_artist=s.get("album_artist") or s.get("artist") or "",
|
|
genre=s.get("genre") or "",
|
|
composer=s.get("composer") or "",
|
|
year=s.get("year", 0),
|
|
track_number=s.get("track_number", 0),
|
|
total_tracks=s.get("track_count", 0),
|
|
disc_number=s.get("disc_number", 0),
|
|
total_discs=s.get("disc_count", 0),
|
|
artwork_count=art_count,
|
|
artwork_size=art_size,
|
|
mhii_link=mhii_link,
|
|
pregap=pregap,
|
|
postgap=postgap,
|
|
sample_count=sample_count,
|
|
gapless_track_flag=1,
|
|
gapless_album_flag=1 if has_album else 0,
|
|
)
|
|
tracks.append(t)
|
|
return tracks
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|
# Nano7Database (public API kept compatible with main.py)
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|
|
|
class Nano7Database:
|
|
"""Manages iPod Nano 7 database via iOpenPod writers."""
|
|
|
|
def __init__(self, mountpoint: str):
|
|
self.mountpoint = mountpoint
|
|
self.music_base = os.path.join(mountpoint, "iPod_Control", "Music")
|
|
self.firewire_id = self._detect_firewire_id()
|
|
|
|
# ── device info ────────────────────────────────────────────────────
|
|
|
|
def _detect_firewire_id(self) -> bytes:
|
|
sysinfo = os.path.join(self.mountpoint, "iPod_Control", "Device", "SysInfo")
|
|
if not os.path.exists(sysinfo):
|
|
return b""
|
|
try:
|
|
with open(sysinfo, "r") as f:
|
|
for line in f:
|
|
if line.startswith("FirewireGuid:"):
|
|
hs = line.split(":")[1].strip()
|
|
if hs.startswith("0x"):
|
|
hs = hs[2:]
|
|
fw = bytes.fromhex(hs)
|
|
logger.info("FireWire GUID: %s", hs)
|
|
return fw
|
|
except Exception as e:
|
|
logger.warning("Failed to parse FirewireGuid: %s", e)
|
|
return b""
|
|
|
|
# ── scan tracks from iPod filesystem ───────────────────────────────
|
|
|
|
def _scan_ipod_files(self) -> list[dict]:
|
|
"""Walk iPod_Control/Music/FXX/ and extract metadata from every audio file."""
|
|
results: list[dict] = []
|
|
if not os.path.isdir(self.music_base):
|
|
return results
|
|
for folder in sorted(os.listdir(self.music_base)):
|
|
d = os.path.join(self.music_base, folder)
|
|
if not os.path.isdir(d):
|
|
continue
|
|
for fname in sorted(os.listdir(d)):
|
|
fpath = os.path.join(d, fname)
|
|
if not os.path.isfile(fpath):
|
|
continue
|
|
ext = os.path.splitext(fname)[1].lower()
|
|
if ext not in (".mp3", ".m4a", ".aac", ".mp4", ".m4p"):
|
|
continue
|
|
tags = _read_audio_tags(fpath)
|
|
tags["file_path"] = fpath
|
|
tags["file_name"] = fname
|
|
tags["file_size"] = os.path.getsize(fpath)
|
|
tags["pid"] = self._hash_to_pid(fpath)
|
|
results.append(tags)
|
|
return results
|
|
|
|
def _hash_to_pid(self, filepath: str) -> int:
|
|
"""Generate a stable negative pid from file path (for API compat)."""
|
|
h = hashlib.sha1(filepath.encode()).digest()
|
|
# Map to signed 64-bit negative range
|
|
raw = int.from_bytes(h[:8], "big")
|
|
if raw >= (1 << 63):
|
|
raw = -(raw & ((1 << 63) - 1))
|
|
if raw >= 0:
|
|
raw = -raw - 1
|
|
return raw
|
|
|
|
# ── add / list / delete / dedup ───────────────────────────────────
|
|
|
|
def add_track(self, filepath: str, **kwargs) -> Optional[dict[str, Any]]:
|
|
"""Copy track to iPod and regenerate all databases.
|
|
|
|
Returns None if track is a duplicate (title+artist+album match).
|
|
"""
|
|
if not os.path.exists(filepath):
|
|
raise FileNotFoundError(f"File not found: {filepath}")
|
|
|
|
tags = _read_audio_tags(filepath)
|
|
title = tags.get("title", os.path.splitext(os.path.basename(filepath))[0])
|
|
artist = tags.get("artist", "Unknown Artist")
|
|
album = tags.get("album", "")
|
|
|
|
# Duplicate check: scan existing files on iPod
|
|
existing = self.get_all_tracks()
|
|
for e in existing:
|
|
if (e["title"].lower() == title.lower() and
|
|
e["artist"].lower() == artist.lower() and
|
|
(e.get("album") or "").lower() == album.lower()):
|
|
logger.info("Duplicate: '%s' by %s, skipping", title, artist)
|
|
return None
|
|
|
|
# Copy file
|
|
target_dir = self._find_free_music_dir()
|
|
os.makedirs(os.path.join(self.music_base, target_dir), exist_ok=True)
|
|
fname = self._gen_ipod_name(filepath)
|
|
dest = os.path.join(self.music_base, target_dir, fname)
|
|
shutil.copy2(filepath, dest)
|
|
|
|
logger.info("Copied: %s → :iPod_Control:Music:%s:%s",
|
|
os.path.basename(filepath), target_dir, fname)
|
|
|
|
# Regenerate all databases via iOpenPod
|
|
self.sync_itunescdb()
|
|
|
|
return {"title": title, "artist": artist, "album": album,
|
|
"pid": self._hash_to_pid(dest),
|
|
"ipod_path": f":iPod_Control:Music:{target_dir}:{fname}",
|
|
"physical_order": 0}
|
|
|
|
def _find_free_music_dir(self) -> str:
|
|
dirs = sorted(os.listdir(self.music_base)) if os.path.isdir(self.music_base) else []
|
|
min_files = float("inf")
|
|
target = "F00"
|
|
for d in dirs:
|
|
full = os.path.join(self.music_base, d)
|
|
if os.path.isdir(full):
|
|
cnt = len(os.listdir(full))
|
|
if cnt < min_files:
|
|
min_files = cnt
|
|
target = d
|
|
return target
|
|
|
|
def _gen_ipod_name(self, filepath: str) -> str:
|
|
base, ext = os.path.splitext(os.path.basename(filepath))
|
|
prefix = "".join(random.choices("ABCDEFGHIJKLMNOPQRSTUVWXYZ", k=4))
|
|
num = random.randint(0, 999999)
|
|
return f"{prefix}{num:06d}{ext}"
|
|
|
|
def get_track_count(self) -> int:
|
|
return len(self._scan_ipod_files())
|
|
|
|
def get_all_tracks(self) -> list[dict]:
|
|
"""Return all tracks on iPod with full metadata."""
|
|
scanned = self._scan_ipod_files()
|
|
tracks = []
|
|
for s in scanned:
|
|
tracks.append({
|
|
"pid": s["pid"],
|
|
"title": s.get("title") or os.path.splitext(s["file_name"])[0],
|
|
"artist": s.get("artist") or "Unknown Artist",
|
|
"album": s.get("album") or "",
|
|
"album_artist": s.get("album_artist") or "",
|
|
"duration_ms": s.get("duration_ms", 0),
|
|
"track_number": s.get("track_number", 0),
|
|
"disc_number": s.get("disc_number", 0),
|
|
"physical_order": 0,
|
|
"date_modified": 0,
|
|
"year": s.get("year", 0),
|
|
"ipod_path": None,
|
|
"file_path": s["file_path"],
|
|
})
|
|
return tracks
|
|
|
|
def delete_track(self, pid: int) -> bool:
|
|
"""Delete a single track by pid (scans, deletes, syncs)."""
|
|
return self.delete_tracks([pid]) > 0
|
|
|
|
def delete_tracks(self, pids: list[int], progress_callback=None) -> int:
|
|
"""Delete tracks by pid. Scans once, deletes all matching files,
|
|
then regenerates the database exactly once.
|
|
|
|
Args:
|
|
pids: List of track pids to delete.
|
|
progress_callback: Optional callable(percent, status) for progress.
|
|
|
|
Returns:
|
|
Number of files actually deleted.
|
|
"""
|
|
pid_set = set(pids)
|
|
scanned = self._scan_ipod_files()
|
|
deleted = 0
|
|
|
|
for i, s in enumerate(scanned):
|
|
if s["pid"] in pid_set and os.path.exists(s["file_path"]):
|
|
os.remove(s["file_path"])
|
|
logger.info("Deleted: %s", s["file_path"])
|
|
deleted += 1
|
|
pid_set.discard(s["pid"])
|
|
if progress_callback and i % 5 == 0:
|
|
progress_callback(
|
|
min(50, int((i + 1) / max(len(scanned), 1) * 50)),
|
|
f"Deleting files... {deleted} removed",
|
|
)
|
|
|
|
if deleted:
|
|
if progress_callback:
|
|
progress_callback(55, "Regenerating iPod database...")
|
|
self.sync_itunescdb()
|
|
if progress_callback:
|
|
progress_callback(100, f"Removed {deleted} track(s)")
|
|
|
|
return deleted
|
|
|
|
def remove_duplicates(self, progress_callback=None) -> list[dict]:
|
|
"""Find and remove duplicate tracks (same title+artist+album)."""
|
|
all_tracks = self._scan_ipod_files()
|
|
seen: dict[tuple, list[dict]] = {}
|
|
for t in all_tracks:
|
|
key = (t.get("title", "").lower(),
|
|
t.get("artist", "").lower(),
|
|
t.get("album", "").lower())
|
|
seen.setdefault(key, []).append(t)
|
|
|
|
removed = []
|
|
for key, items in seen.items():
|
|
if len(items) <= 1:
|
|
continue
|
|
for item in items[1:]:
|
|
fpath = item["file_path"]
|
|
if os.path.exists(fpath):
|
|
os.remove(fpath)
|
|
removed.append({
|
|
"pid": item["pid"],
|
|
"title": item.get("title", ""),
|
|
"artist": item.get("artist", ""),
|
|
"album": item.get("album", ""),
|
|
"file_path": fpath,
|
|
})
|
|
logger.info("Removed duplicate: %s", fpath)
|
|
if progress_callback:
|
|
progress_callback(
|
|
min(50, int(len(removed) / max(len(all_tracks), 1) * 50)),
|
|
f"Removing duplicates... {len(removed)} found",
|
|
)
|
|
|
|
if removed:
|
|
if progress_callback:
|
|
progress_callback(55, "Regenerating iPod database...")
|
|
self.sync_itunescdb()
|
|
if progress_callback:
|
|
progress_callback(100, f"Removed {len(removed)} duplicate(s)")
|
|
|
|
logger.info("Removed %d duplicate(s)", len(removed))
|
|
return removed
|
|
|
|
def get_orphaned_files(self) -> list[dict]:
|
|
"""Return files on iPod with no matching DB entry."""
|
|
# Since we regenerate the DB from scratch every sync, there
|
|
# shouldn't be orphans. Still check for non-audio files.
|
|
orphans = []
|
|
if not os.path.isdir(self.music_base):
|
|
return orphans
|
|
for folder in sorted(os.listdir(self.music_base)):
|
|
d = os.path.join(self.music_base, folder)
|
|
if not os.path.isdir(d):
|
|
continue
|
|
for fname in os.listdir(d):
|
|
fpath = os.path.join(d, fname)
|
|
if not os.path.isfile(fpath):
|
|
continue
|
|
ext = os.path.splitext(fname)[1].lower()
|
|
if ext not in (".mp3", ".m4a", ".aac", ".mp4", ".m4p"):
|
|
orphans.append({
|
|
"file_path": fpath,
|
|
"size": os.path.getsize(fpath),
|
|
"title": fname,
|
|
"artist": "Unknown",
|
|
})
|
|
return orphans
|
|
|
|
def delete_orphaned_files(self, file_paths: list[str] = None) -> int:
|
|
deleted = 0
|
|
if file_paths is None:
|
|
orphans = self.get_orphaned_files()
|
|
file_paths = [o["file_path"] for o in orphans]
|
|
for p in file_paths:
|
|
if os.path.exists(p):
|
|
os.remove(p)
|
|
deleted += 1
|
|
return deleted
|
|
|
|
# ── sync: regenerate everything via iOpenPod ──────────────────────
|
|
|
|
def sync_itunescdb(self) -> None:
|
|
"""Regenerate ALL databases using iOpenPod's writers."""
|
|
try:
|
|
self._sync_itunescdb_impl()
|
|
except Exception as e:
|
|
logger.exception("iTunesDB sync failed: %s", e)
|
|
|
|
def _sync_itunescdb_impl(self) -> None:
|
|
# 1. Scan all audio files on iPod
|
|
scanned = self._scan_ipod_files()
|
|
if not scanned:
|
|
logger.warning("No audio files found on iPod — writing empty databases")
|
|
# Write minimal empty databases
|
|
self._write_empty_databases()
|
|
return
|
|
|
|
# 2. Prepare artwork for all tracks
|
|
artwork_map: dict[str, tuple[int, int, int]] = {}
|
|
art_entries: list[ArtworkEntry] = []
|
|
art_hash_to_img_id: dict[str, int] = {}
|
|
next_img_id = 100
|
|
|
|
for idx, s in enumerate(scanned):
|
|
fpath = s["file_path"]
|
|
try:
|
|
art_result = prepare_artwork_for_track(fpath)
|
|
except Exception:
|
|
art_result = None
|
|
if art_result is not None:
|
|
art_hash, formats = art_result
|
|
art_count = len(formats)
|
|
total_size = sum(p.size for p in formats.values())
|
|
|
|
if art_hash not in art_hash_to_img_id:
|
|
img_id = next_img_id
|
|
next_img_id += 1
|
|
art_hash_to_img_id[art_hash] = img_id
|
|
art_entries.append(ArtworkEntry(
|
|
img_id=img_id,
|
|
db_track_id=idx,
|
|
art_hash=art_hash,
|
|
src_img_size=total_size,
|
|
formats=formats,
|
|
db_track_ids=[idx],
|
|
))
|
|
else:
|
|
img_id = art_hash_to_img_id[art_hash]
|
|
for entry in art_entries:
|
|
if entry.img_id == img_id:
|
|
if idx not in entry.db_track_ids:
|
|
entry.db_track_ids.append(idx)
|
|
break
|
|
|
|
artwork_map[fpath] = (img_id, art_count, total_size)
|
|
|
|
if art_entries:
|
|
try:
|
|
write_artworkdb(self.mountpoint, art_entries)
|
|
logger.info("ArtworkDB written: %d unique covers, %d total tracks",
|
|
len(art_entries), len(artwork_map))
|
|
except Exception as e:
|
|
logger.warning("ArtworkDB write failed: %s", e)
|
|
|
|
# 3. Convert to iOpenPod TrackInfo
|
|
tracks = _scanned_tracks_to_iop(self.mountpoint, scanned, artwork_map)
|
|
logger.info("Built %d iOpenPod TrackInfo objects", len(tracks))
|
|
|
|
# 4. Determine capabilities for this device
|
|
ipod_device = _import_iop("ipod_device")
|
|
capabilities = None
|
|
try:
|
|
dev = ipod_device.get_current_device()
|
|
if dev and dev.model_family:
|
|
capabilities = ipod_device.capabilities_for_family_gen(
|
|
dev.model_family, dev.generation or "",
|
|
)
|
|
if capabilities:
|
|
logger.debug("Device capabilities: %s", capabilities)
|
|
except Exception as e:
|
|
logger.debug("Capabilities detection failed: %s", e)
|
|
|
|
# 5. Generate and write binary iTunesDB first (to get db_pid)
|
|
try:
|
|
firewire_id = ipod_device.get_firewire_id(self.mountpoint)
|
|
except Exception:
|
|
firewire_id = self.firewire_id
|
|
|
|
iop_write_itunesdb = _import_iop("iTunesDB_Writer").write_itunesdb
|
|
ok = iop_write_itunesdb(
|
|
self.mountpoint,
|
|
tracks,
|
|
firewire_id=firewire_id,
|
|
backup=True,
|
|
capabilities=capabilities,
|
|
master_playlist_name="iPod",
|
|
)
|
|
if not ok:
|
|
logger.error("iTunesDB write failed")
|
|
return
|
|
logger.info("iTunesDB written (%d tracks)", len(tracks))
|
|
|
|
# 6. Extract db_pid from the binary DB for SQLite cross-reference
|
|
db_pid = 0
|
|
try:
|
|
ipod_dev = _import_iop("ipod_device")
|
|
cdb_path = ipod_dev.resolve_itdb_path(self.mountpoint)
|
|
if cdb_path:
|
|
with open(cdb_path, "rb") as f:
|
|
hdr = f.read(0x20)
|
|
if len(hdr) >= 0x20 and hdr[:4] == b"mhbd":
|
|
db_pid = struct.unpack_from("<Q", hdr, 0x18)[0]
|
|
logger.debug("db_pid from CDB: %016X", db_pid)
|
|
except Exception as e:
|
|
logger.warning("Could not extract db_pid: %s", e)
|
|
|
|
# 7. Write SQLite databases (Nano 6G/7G require this)
|
|
try:
|
|
write_sqlite_databases = _import_iop("SQLiteDB_Writer").write_sqlite_databases
|
|
sqlite_ok = write_sqlite_databases(
|
|
ipod_path=self.mountpoint,
|
|
tracks=tracks,
|
|
master_playlist_name="iPod",
|
|
db_pid=db_pid,
|
|
capabilities=capabilities,
|
|
firewire_id=firewire_id,
|
|
backup=True,
|
|
)
|
|
if sqlite_ok:
|
|
logger.info("SQLite databases written")
|
|
else:
|
|
logger.error("SQLite database write failed")
|
|
except Exception as e:
|
|
logger.exception("SQLite write error: %s", e)
|
|
|
|
def _write_empty_databases(self) -> None:
|
|
"""Write minimal empty databases when no tracks exist."""
|
|
ipod_device = _import_iop("ipod_device")
|
|
iop_write_itunesdb = _import_iop("iTunesDB_Writer").write_itunesdb
|
|
write_sqlite_databases = _import_iop("SQLiteDB_Writer").write_sqlite_databases
|
|
|
|
try:
|
|
fwid = ipod_device.get_firewire_id(self.mountpoint)
|
|
except Exception:
|
|
fwid = self.firewire_id
|
|
capabilities = None
|
|
try:
|
|
dev = ipod_device.get_current_device()
|
|
if dev and dev.model_family:
|
|
capabilities = ipod_device.capabilities_for_family_gen(
|
|
dev.model_family, dev.generation or "")
|
|
except Exception:
|
|
pass
|
|
iop_write_itunesdb(self.mountpoint, [], firewire_id=fwid,
|
|
backup=True, capabilities=capabilities)
|
|
write_sqlite_databases(
|
|
ipod_path=self.mountpoint, tracks=[],
|
|
master_playlist_name="iPod",
|
|
db_pid=random.getrandbits(64),
|
|
capabilities=capabilities, firewire_id=fwid, backup=True,
|
|
)
|