rekordbox-edit 0.7.0.dev64__tar.gz → 0.7.0.dev71__tar.gz

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/.gitignore

@@ -48,9 +48,7 @@ Thumbs.db
 .coverage
 
 .claude
-docs/superpowers
-docs/decisions
-research
+ai-docs
 
 # MkDocs build output
 site/

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/AGENTS.md

@@ -91,7 +91,10 @@ Every module should get and use its own `logger` for all logging purposes and fo
 - Commit descriptions should be terse and use active tenses (e.g. "add feature")
 - Commit bodies are completely optional, and should be used to describe changes when they aren't easily inferred by the main message, they should not include agent conversation context, decisions, or plan notes.
 - The agent may commit. But the user always handles pushes, PR creation, and rebases after merges.
-- Do not commit spec, brainstorming, or design documents (e.g. anything under `docs/superpowers/specs/`).
+- Do not commit spec, brainstorming, or design documents (e.g. anything under `ai-docs/`).
+- **Save plans to:** `ai-docs/YYYYMMDD-HHmm-{session-slug}/plan.md` instead of the plugin or skill presets.
+- **Save specs to:** `ai-docs/YYYYMMDD-HHmm-{session-slug}/specs.md` instead of the plugin or skill presets.
+- **Save decision records to:** `ai-docs/decisions/{topic}.md` (not session-scoped).
 
 ## Tooling
 

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/CHANGELOG.md

@@ -1,6 +1,18 @@
-## v0.7.0.dev64 (2026-07-31)
-
-
+## v0.7.0.dev71 (2026-07-31)
+
+
+- chore: update AGENTS.md
+- docs: pave FAQ page based on convert + analysis research
+- feat(convert): verify source codec against FileType before converting
+- test(cli): mock rekordbox pid check in edit CLI tests
+- feat: add probe/file-type matcher and codec_mismatch skip reason
+- feat(utils): probe codec and container in get_audio_info
+- feat: adds display and filtering support for all rekordbox file types
+- - creates a FileTypeInfo registry to map all the different dimensions of
+  FileType under one database code
+- adds AAC and ALAC .m4a FileTypes (4 and 6)
+- adds .mp4 FileType (3)
+- adds video FileType (16)
 - chore(deps): update dependency ty to v0.0.64 (#152)
 - Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
 - chore(deps): update pre-commit hook astral-sh/ruff-pre-commit to v0.16.0 (#149)

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rekordbox-edit
-Version: 0.7.0.dev64
+Version: 0.7.0.dev71
 Summary: Tools for managing and modifying a RekordBox library en-masse
 Project-URL: Homepage, https://github.com/jviall/rekordbox-edit
 Project-URL: Repository, https://github.com/jviall/rekordbox-edit

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/docs/commands/convert.md

@@ -1,6 +1,6 @@
 # convert
 
-Convert audio files between formats and update the Rekordbox database to point at the new files. Your cues, analysis, beatgrids, and all metadata are preserved.
+Convert audio files between formats and update the Rekordbox database to point at the new files. Cues, analysis, beatgrids, and all other metadata are preserved — see [Frequently Asked Questions](../faqs.md) for more info.
 
 ## Supported Formats
 
@@ -50,6 +50,7 @@ rbe search --artist "Lauryn Hill" --print ids | rbe convert --yes
 ### Guardrails
 - Without flags, `convert` shows every planned change and asks once before applying. `--interactive` confirms each track individually; `--dry-run` previews without writing; `--yes` confirms the default choice for all prompts without asking.
 - Editing while Rekordbox is open risks corrupting your database. By default `convert` warns and asks for confirmation (defaulting to no, so a `--yes` would exit); in a non-interactive mode (e.g. `--print ids`) it throws an error.
+- Before a large run, walk through the checklist in [What Should I Do Before Converting?](../faqs.md#what-should-i-do-before-converting)
 
 ## Reference
 

rekordbox_edit-0.7.0.dev71/docs/faqs.md

@@ -0,0 +1,50 @@
+# Frequently Asked Questions
+
+Messing with your Rekordbox library is bound to raise some questions and concerns, particularly around preserving all the manual work you've done to organize, catalog, and prepare your library for gigs. This page is dedicated to answering those questions around what the impact and risks are of editing your rekordbox library or the underlying audio files using rekordbox-edit. If your question isn't answered here, please ask it in [a discussion](https://github.com/jviall/rekordbox-edit/discussions/new/choose).
+
+## How Does Rekordbox's Analysis Work?
+
+Analysis touches two places in your library. The database gets the summary values for things like tempo, key, and the flags Rekordbox uses to track analysis state. The heavier artifacts live in a per-track folder of analysis files (.ANLZ) containing the beat grid, waveforms, and phrase data. Your cues and loops live in neither; they are separate database records that only your own edits change.
+
+What analysis writes is a deterministic estimate. Deterministic, because the same file analyzed twice produces byte-identical results. An estimate, because tempo, grid, and key are inferred from the audio, and Rekordbox's inference is sometimes wrong. Both aspects are worth considering; when the analysis of a converted file produces a different result, it is simply a different estimate from different data.
+
+## How Does Converting a Track Affect the Analysis?
+
+The reason conversion is safe comes down to how Rekordbox stores analysis: positions are timestamps. The beat grid is a list of times in milliseconds, cues are stored in milliseconds, and phrases are anchored to beats. None of it references sample counts or byte positions in the audio file. Change the codec, the sample rate, or the bit depth, and every stored position still names the same musical moment.
+
+`rbe convert` therefore only has to update what identifies the file: the track's database row (the file path, sample rate, bit depth, and similar columns) and the path recorded inside the analysis files. It rewrites nothing else.
+
+There are a few minor things left stale by a conversion (without any consequence that I have observed yet):
+
+- The waveform still draws the old audio: identical unless you converted to MP3, and then only imperceptibly off.
+- A FLAC-specific seek index goes stale when you convert away from FLAC, which would be removed on any later analysis.
+
+Converting *to* FLAC does not create that seek index automatically either; only an analysis can. I have *not* tested (yet) whether that matters in practice, but it makes a stronger case for re-analyzing after a conversion to FLAC than for other targets. FLAC also is not the most ideal target format in general for Rekordbox (even though it's preferred for streaming and music hoarders), because only the more recent Pioneer devices support it. AIFF is what I would pick if you insist on lossless.
+
+## Does Converting to MP3 Shift the Audio?
+
+No. `rbe` uses LAME's gapless-playback encoding to avoid any start-of-file offset, and across many tests the MP3 320 output never differed in timing, sample for sample, from its lossless source. Cues and the beat grid stay exactly in register.
+
+The only artifact is visual: the drawn waveform still reflects the lossless original rather than the MP3. A re-analysis would redraw it, but you'd be hard-pressed to notice the difference.
+
+## Will My Cues and Beatgrid Survive?
+
+Yes. Cues, loops, and memory points are records in your library database, positioned in milliseconds and attached to the track's database entry, and `rbe convert` does not touch them. The beat grid lives in the analysis files, which convert also leaves alone. In all my testing, every cue and beat grid has been completely unchanged by a conversion, and works just as it did prior.
+
+This includes hand-tuned grids. Because convert never rewrites the grid a manually corrected beat grid survives conversion unchanged. The one operation that can replace it is a re-analysis you run yourself; see below.
+
+## Should I Re-Analyze After Converting?
+
+You do not need to. The existing analysis remains correct for the converted file, and Rekordbox never re-analyzes on its own; it waits for you to ask. Skipping re-analysis keeps your grid and cues exactly as they are.
+
+If you do re-analyze, the outcome depends on whether the conversion changed the audio samples. A pure container swap (WAV to FLAC or AIFF at the same depth and rate) reproduces the previous analysis exactly. A conversion that resamples, reduces bit depth, or lossily compresses to MP3 produces a slightly different estimate: about half a BPM of tempo difference, a first beat shifted by tens of milliseconds, cues sitting up to roughly 20 ms off the new grid. The new grid is not necessarily more or less correct than the previous; your ears and eyes will be the best judges of that. Ultimately it is the same song being analyzed, but Rekordbox made a fresh estimate on different underlying data. I would argue, though, that an analysis of a high-res file is more likely to be accurate than one of a lower-fidelity file.
+
+One real hazard: re-analysis replaces manually edited beat grids on any track that is not locked. If you plan to re-analyze after a bulk conversion, turn on Analysis Lock first for tracks whose grids you have tuned by hand.
+
+## What Should I Do Before Converting?
+
+- **Preview with `--dry-run`.** See exactly which tracks will convert and where the files will go before anything is written.
+- **Close Rekordbox.** Writing to the database while Rekordbox has it open risks corruption.
+- **Make fresh backups of your music and your Rekordbox database.** Conversion rewrites files and database rows in place; a current backup makes any surprise reversible.
+- **Keep your originals until you are satisfied.** The default `--delete-originals lossless` only deletes a source when no audio information was lost. Be deliberate before choosing `all`.
+- **Lock hand-tuned beat grids if you plan to re-analyze.** Conversion won't mess with your grids, but a later bulk re-analysis replaces grids on unlocked tracks. Analysis Lock exists for exactly this.

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/docs/filtering.md

@@ -17,7 +17,7 @@ Repeating a filter, or combining different filters, matches tracks that satisfy
 | `--exact-album TEXT` | album name is exactly `TEXT` |
 | `--playlist TEXT` | playlist name contains `TEXT` |
 | `--exact-playlist TEXT` | playlist name is exactly `TEXT` |
-| `--format FMT` | file format is `FMT` (`mp3`, `flac`, `aiff`, `wav`, `m4a`) |
+| `--format FMT` | Rekordbox file type is `FMT` (`mp3`, `mp4`, `aac`, `flac`, `alac`, `wav`, `aiff`, `video`, `invalid`) |
 | `--path TEXT` | file path contains `TEXT` (matched against the folder path, filename, or both) |
 | `--exact-path TEXT` | file path is exactly `TEXT` (resolved to an absolute path before matching) |
 | `--first N` | return only the first N results |
@@ -104,4 +104,4 @@ rbe search --artist "Daft Punk" --artist "Justice" --print ids \
   | rbe convert --format-out mp3 --dry-run
 ```
 
-For richer pipelines, `--print json` emits the same selection as structured data for `jq` and other shell tools. Use the [API functions](/api/#functions) if you want to build a more complex python script.
+For richer pipelines, `--print json` emits the same selection as structured data for `jq` and other shell tools. Use the [API functions](api.md#functions) if you want to build a more complex python script.

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/mkdocs.yml

@@ -4,9 +4,6 @@ site_url: https://rekordbox-edit.readthedocs.io/
 repo_url: https://github.com/jviall/rekordbox-edit
 repo_name: jviall/rekordbox-edit
 
-exclude_docs: |
-  superpowers/
-
 theme:
   name: material
   palette:
@@ -60,4 +57,5 @@ nav:
       - search: commands/search.md
       - edit: commands/edit.md
       - convert: commands/convert.md
+  - FAQs: faqs.md
   - API Reference: api.md

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rekordbox-edit"
-version = "0.7.0.dev64"
+version = "0.7.0.dev71"
 description = "Tools for managing and modifying a RekordBox library en-masse"
 authors = [{ name = "James Viall", email= "jamesviall@pm.me"}]
 license = "MIT"

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/rekordbox_edit/_click.py

@@ -91,7 +91,10 @@ global_click_filters = [
     ),
     click.option(
         "--format",
-        type=click.Choice(["mp3", "flac", "aiff", "wav", "m4a"], case_sensitive=False),
+        type=click.Choice(
+            ["mp3", "mp4", "aac", "flac", "alac", "wav", "aiff", "video", "invalid"],
+            case_sensitive=False,
+        ),
         multiple=True,
         help="Find tracks of this format",
     ),

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/rekordbox_edit/api/convert.py

@@ -21,12 +21,14 @@ from rekordbox_edit.models import (
 )
 from rekordbox_edit.query import get_filtered_content
 from rekordbox_edit.utils import (
-    InputFormats,
+    FILE_TYPES,
+    AudioInfo,
     OutputFormats,
     get_audio_info,
     get_extension_for_format,
     get_file_type_for_format,
     get_file_type_name,
+    probe_matches_file_type,
 )
 
 logger = logging.getLogger(__name__)
@@ -34,8 +36,8 @@ logger = logging.getLogger(__name__)
 TARGET_BIT_DEPTH = 16
 TARGET_SAMPLE_RATE = 44100
 
-# Rekordbox FileType codes RBE converts from: the hi-res lossless whitelist.
-_INPUT_FILE_TYPES = {get_file_type_for_format(fmt.value) for fmt in InputFormats}
+# Rekordbox FileType codes RBE converts from: the lossless whitelist.
+_INPUT_FILE_TYPES = {code for code, info in FILE_TYPES.items() if info.convertable}
 
 _HI_RES_CODECS = {
     "aiff": "pcm_s16be",
@@ -55,16 +57,14 @@ def _effective_sample_rate(source_rate: int | None) -> int:
     return TARGET_SAMPLE_RATE
 
 
-def _classify_source_fidelity(
-    source_path,
+def _classify_fidelity(
+    audio_info: AudioInfo,
 ) -> Tuple[Literal["lossless", "lossy"], int]:
-    """Probe a source file and return the conversion's fidelity along with
-    its effective sample rate. "lossless" means no audio information is lost:
-    the source is at the target bit depth and at or below the target sample
-    rate. An unknown bit depth counts as lossy so originals are kept when in
-    doubt.
+    """The conversion's fidelity and effective sample rate for a probed
+    source. "lossless" means no audio information is lost: the source is at
+    the target bit depth and at or below the target sample rate. An unknown
+    bit depth counts as lossy so originals are kept when in doubt.
     """
-    audio_info = get_audio_info(source_path)
     bit_depth = audio_info["bit_depth"]
     sample_rate = audio_info["sample_rate"]
     logger.debug(
@@ -374,13 +374,25 @@ def convert(
             if not os.path.exists(src):
                 raise RuntimeError(f"Source not found: {src}")
 
+            audio_info = get_audio_info(src)
+            if not probe_matches_file_type(
+                content.FileType, audio_info["codec"], audio_info["container"]
+            ):
+                logger.warning(
+                    f"Skipping {content.FileNameL}: probed codec "
+                    f"{audio_info['codec']!r} does not match its Rekordbox "
+                    f"file type {get_file_type_name(content.FileType)!r}"
+                )
+                skipped.append(SkippedTrack(id=op.id, reason="codec_mismatch"))
+                continue
+
             if args.format_out.upper() == "MP3":
                 output_sample_rate = TARGET_SAMPLE_RATE
                 success = _run_ffmpeg(
                     src, op.output_path, _mp3_output_kwargs(output_sample_rate), "mp3"
                 )
             else:
-                fidelity, output_sample_rate = _classify_source_fidelity(src)
+                fidelity, output_sample_rate = _classify_fidelity(audio_info)
                 if fidelity == "lossless":
                     lossless_op_ids.add(op.id)
                 output_format = OutputFormats(args.format_out.lower())

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/rekordbox_edit/cli/convert.py

@@ -48,9 +48,10 @@ logger = logging.getLogger(__name__)
 def convert_command(db, **kwargs):
     """Convert hi-res audio files between formats and update RekordBox database.
 
-    Supports conversion from any hi-res format (FLAC, AIFF, WAV) to:
-    AIFF, FLAC, WAV, or MP3. Skips lossy formats and files already in
-    the target format.
+    Supports conversion from any hi-res format (FLAC, ALAC, AIFF, WAV) to:
+    AIFF, FLAC, WAV, or MP3. Skips lossy formats, video, and files already
+    in the target format. Each source's codec is verified against its
+    database file type before converting; mismatches are skipped.
 
     Lossless conversions target 16-bit/44.1 kHz: higher-resolution sources
     are down-sampled, and sources below the target keep their own sample
@@ -122,6 +123,9 @@ def convert_command(db, **kwargs):
             return
         response = convert(db, args)
 
+    # The preview cannot surface codec_mismatch (dry runs never probe), so
+    # report skips found only during the live run.
+    _report_skips([s for s in response.result.skipped if s.reason == "codec_mismatch"])
     _print_convert_result(response, print_opt, scripting_mode, dry_run=False)
 
 
@@ -129,17 +133,23 @@ def _report_skips(skipped) -> None:
     already_target = sum(1 for s in skipped if s.reason == "already_target_format")
     unsupported = sum(1 for s in skipped if s.reason == "unsupported_source_format")
     conflicts = sum(1 for s in skipped if s.reason == "output_file_exists")
+    mismatches = sum(1 for s in skipped if s.reason == "codec_mismatch")
     if already_target:
         logger.warning(f"Skipping {already_target} file(s): already in target format")
     if unsupported:
         logger.warning(
             f"Skipping {unsupported} file(s): unsupported source format "
-            "(only FLAC, AIFF, WAV are converted)"
+            "(only FLAC, ALAC, AIFF, WAV are converted)"
         )
     if conflicts:
         logger.warning(
             f"Skipping {conflicts} file(s): output exists (use --overwrite to convert)"
         )
+    if mismatches:
+        logger.warning(
+            f"Skipping {mismatches} file(s): file content does not match its "
+            "Rekordbox file type"
+        )
 
 
 def _print_convert_result(

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/rekordbox_edit/models.py

@@ -130,6 +130,7 @@ SkipReason: TypeAlias = Literal[
     "already_target_format",
     "unsupported_source_format",
     "output_file_exists",
+    "codec_mismatch",
 ]
 
 

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/rekordbox_edit/query.py

@@ -132,7 +132,7 @@ class CollectionQuery:
 
     def by_format(self, format_name: str) -> "CollectionQuery":
         """Filter by file format."""
-        from rekordbox_edit.utils import get_file_type_for_format
+        from rekordbox_edit.utils import get_file_type_codes_for_format
 
         if not format_name:
             logger.warning("Empty format filter has no effect")
@@ -141,8 +141,8 @@ class CollectionQuery:
         new_inst = self._copy()
 
         try:
-            file_type_code = get_file_type_for_format(format_name)
-            condition = DjmdContent.FileType == file_type_code
+            file_type_codes = get_file_type_codes_for_format(format_name)
+            condition = DjmdContent.FileType.in_(file_type_codes)
             new_inst._conditions.append(condition)
         except ValueError:
             logger.warning(f"Invalid format: {format_name}")

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev71}/rekordbox_edit/utils.py

@@ -3,7 +3,9 @@
 import logging
 import platform
 import shutil
+from dataclasses import dataclass
 from enum import Enum
+from typing import TypedDict
 
 import click
 import ffmpeg
@@ -17,61 +19,131 @@ class UserQuit(Exception):
     pass
 
 
-# File type mappings for Rekordbox database
-def get_file_type_name(file_type_code: int | None) -> str | None:
-    """Map a Rekordbox FileType code to a display name, or None if unmapped.
+@dataclass(frozen=True)
+class FileTypeInfo:
+    """One Rekordbox FileType code: how RBE names, filters, probes, and
+    converts it. ``codecs`` are ffprobe codec_name prefixes and
+    ``containers`` are format_name substrings; a probe must satisfy both
+    (WAV and AIFF share PCM codecs, so their containers disambiguate)."""
+
+    code: int
+    name: str
+    token: str
+    extension: str | None = None
+    codecs: tuple[str, ...] = ()
+    containers: tuple[str, ...] = ()
+    convertable: bool = False
+
+
+FILE_TYPES: dict[int, FileTypeInfo] = {
+    # Corrupt or empty content, independent of container.
+    0: FileTypeInfo(code=0, name="INVALID", token="invalid"),
+    1: FileTypeInfo(code=1, name="MP3", token="mp3", extension=".mp3", codecs=("mp3",)),
+    # 3 is the .mp4 container regardless of content: audio-only AAC/ALAC
+    # .mp4 files land here alongside video .mp4, so RBE never converts it.
+    3: FileTypeInfo(code=3, name="MP4", token="mp4"),
+    4: FileTypeInfo(code=4, name="AAC", token="aac", codecs=("aac",)),
+    5: FileTypeInfo(
+        code=5,
+        name="FLAC",
+        token="flac",
+        extension=".flac",
+        codecs=("flac",),
+        convertable=True,
+    ),
+    6: FileTypeInfo(
+        code=6,
+        name="ALAC",
+        token="alac",
+        codecs=("alac",),
+        convertable=True,
+    ),
+    11: FileTypeInfo(
+        code=11,
+        name="WAV",
+        token="wav",
+        extension=".wav",
+        codecs=("pcm_",),
+        containers=("wav",),
+        convertable=True,
+    ),
+    12: FileTypeInfo(
+        code=12,
+        name="AIFF",
+        token="aiff",
+        extension=".aiff",
+        codecs=("pcm_",),
+        containers=("aiff",),
+        convertable=True,
+    ),
+    # Catch-all for non-mp4 video containers (avi, m4v, mov, mpg).
+    16: FileTypeInfo(code=16, name="VIDEO", token="video"),
+}
 
-    A total display map, not a guard: Rekordbox stores many codes RBE does not
-    convert (AAC, ALAC, video). Each caller chooses its own fallback for None.
-    """
+
+def get_file_type_name(file_type_code: int | None) -> str | None:
+    """Map a Rekordbox FileType code to a display name, or None if unmapped."""
     if file_type_code is None:
         return None
-    _get_file_type_name = {
-        0: "MP3",
-        1: "MP3",
-        4: "M4A",
-        5: "FLAC",
-        11: "WAV",
-        12: "AIFF",
-    }
-    return _get_file_type_name.get(file_type_code)
-
-
-def get_file_type_for_format(format_name: str):
-    """Get file type code for format name (case-insensitive)."""
+    info = FILE_TYPES.get(file_type_code)
+    return info.name if info else None
+
+
+def get_file_type_codes_for_format(format_name: str) -> set[int]:
+    """All FileType codes a format token matches (case-insensitive).
+
+    Tokens mirror FileType values one to one.
+    """
     if not format_name:
         raise ValueError("Format name cannot be empty or None")
-    _get_file_type_for_format = {"MP3": 1, "M4A": 4, "FLAC": 5, "WAV": 11, "AIFF": 12}
-    file_type = _get_file_type_for_format.get(format_name.upper())
-    if file_type is None:
+    token = format_name.lower()
+    codes = {code for code, info in FILE_TYPES.items() if token == info.token}
+    if not codes:
         raise ValueError(f"Unknown format: {format_name}")
-    return file_type
+    return codes
 
 
-def get_extension_for_format(format_name: str):
-    """Get file extension for format name (case-insensitive)."""
+def get_file_type_for_format(format_name: str) -> int:
+    """The FileType code Rekordbox records for files RBE writes in this
+    output format (case-insensitive). Raises for non-output formats."""
     if not format_name:
         raise ValueError("Format name cannot be empty or None")
-    _get_extension_for_format = {
-        "MP3": ".mp3",
-        "AIFF": ".aiff",
-        "FLAC": ".flac",
-        "WAV": ".wav",
-    }
-    extension = _get_extension_for_format.get(format_name.upper())
-    if extension is None:
-        raise ValueError(f"Unknown format: {format_name}")
+    token = format_name.lower()
+    for code, info in FILE_TYPES.items():
+        if info.extension and token == info.token:
+            return code
+    raise ValueError(f"Unknown format: {format_name}")
+
+
+def get_extension_for_format(format_name: str) -> str:
+    """Get file extension for an output format name (case-insensitive)."""
+    code = get_file_type_for_format(format_name)
+    extension = FILE_TYPES[code].extension
+    assert extension is not None  # get_file_type_for_format only returns such codes
     return extension
 
 
-class OutputFormats(Enum):
-    MP3 = "mp3"
-    FLAC = "flac"
-    AIFF = "aiff"
-    WAV = "wav"
+def probe_matches_file_type(
+    file_type_code: int | None, codec: str | None, container: str | None
+) -> bool:
+    """Whether a probed codec/container is consistent with a Rekordbox
+    FileType code. Unknown codes never match, so callers treat them as
+    mismatches instead of converting blind."""
+    if file_type_code is None:
+        return False
+    info = FILE_TYPES.get(file_type_code)
+    if info is None:
+        return False
+    if info.codecs and not (codec or "").startswith(info.codecs):
+        return False
+    if info.containers:
+        if not container or not any(c in container for c in info.containers):
+            return False
+    return True
 
 
-class InputFormats(Enum):
+class OutputFormats(Enum):
+    MP3 = "mp3"
     FLAC = "flac"
     AIFF = "aiff"
     WAV = "wav"
@@ -99,12 +171,24 @@ or https://ffmpeg.org/download.html
 """
 
 
-def get_audio_info(file_path) -> dict[str, int | None]:
+class AudioInfo(TypedDict):
+    """Fields extracted from an ffmpeg probe of one audio file."""
+
+    bit_depth: int | None
+    sample_rate: int
+    channels: int
+    bitrate: int | None
+    codec: str | None
+    container: str | None
+
+
+def get_audio_info(file_path) -> AudioInfo:
     """Get audio information from file using ffmpeg probe.
 
     Returns None for any field that cannot be determined from the probe data.
-    Callers are responsible for handling None values and applying format-specific
-    assumptions (e.g. MP3 has no true bit depth).
+    Callers are responsible for handling None values and applying
+    format-specific assumptions (e.g. MP3 has no true bit depth). ``codec``
+    is the stream's codec_name and ``container`` the probe's format_name.
     """
     try:
         # Check if ffmpeg is available first
@@ -163,6 +247,8 @@ def get_audio_info(file_path) -> dict[str, int | None]:
             "sample_rate": int(audio_stream.get("sample_rate", 44100)),
             "channels": int(audio_stream.get("channels", 2)),
             "bitrate": bitrate,
+            "codec": audio_stream.get("codec_name"),
+            "container": probe.get("format", {}).get("format_name"),
         }
     except Exception as e:
         logger.error(f"Failed to get audio info for {file_path}: {e}")