Alphabetising 200GB plus of classical music arranged in composer order

masonic

OP (quoted below) is looking for an elegant solution to the problem described below, and posed their problem in a thread in Savings & Investments. Requirements (which have been drip-fed over several earlier posts) are that it must run on Windows 10, needs to be quick, and must guarantee files are listed in the file table in alphabetical order on an exFAT formatted card.

https://forums.moneysavingexpert.com/discussion/comment/82127437#Comment_82127437

User has been provided with a powershell script by AI, which they put into a bat file and tried to run in an elevated command prompt, but that didn't work. Was not interested in exploring cmd/bat file alternative. But it is likely these will all be too slow as they'd involve re-copying all of the data.

DriveSort was suggested, but this won't work with exFAT drives

FastCopy was suggested, but this was rejected untried (this would re-copy the files, so likely fail on the subsequently stated speed criteria)

SD Sorter was suggested, but is too slow

CopInOrder was found, but is buggy

sausage_time

That link is broken. The discussion is part of

https://forums.moneysavingexpert.com/discussion/6679955/doom-scrolling-and-the-next-financial-crash

talexuser

Correction. I did not "pose the problem" on Savings and Investment. The discussion was about the AI bubble, its effect on index funds and when it would burst and cause a downturn. I gave a short example of AI not being able to answer technical questions correctly to illustrate my personal opinion that AI is over-hyped, and the valuations associated with it are unrealistic.

talexuser

Now the problem: copy in windows about 100 folders of composers and 2500 sub and sub sub folders of works in flacs and some wavs within them to a exFat 256Gb card in strict alpha order because an mp3 players lists contents in order written. Explorer cannot do this in one copy. Two copies to two cards are required which takes some little time.

There are mac and linux programs that appear to suit, but not windows

DriveSort (which I already use) works but only on Fat file systems.

SdSorter would work but entails deletion and rewrite of every folder from and to the card again, obviously not optimum timewise to a simple correct copy.

CopyInOrder works but crashes every 20 or 30GB or so, so needs a manual check on progress and a restart every now and then. Beyond that been unsucessful in my search.

sausage_time

So you want the 100 or so composer folders written in alphabetical sort order. What about the sub and sub sub folders? Is there one audio file per work, or are works split into separate movements etc?

masonic

I've picked up discussion on the AI valuations over in the Savings & Investment thread where that discussion belongs, so I can keep this post purely on the technical challenge.

From the digging into the issue I have done, the reason you aren't finding a quick, elegant Windows utility for this comes down to the physical difference between exFAT and older FAT32 directory tables. From what I've come to understand, tools like DriveSort don't work on exFAT because it uses a variable-length chain of multiple entries for a single file. Sorting those in place at the raw disk level without corrupting the directory structure or allocation bitmap requires specialised low-level disk access.

To rewrite exFAT directory tables in place without re-copying the actual file data, a program has to bypass standard file system APIs and open a direct handle to write to raw volume sectors. Windows 10/11 heavily restricts direct sector writes on active, mounted drives to prevent corruption. This seems to be why native Windows GUI tools for in-place exFAT sorting are practically nonexistent, while the utilities that can do it safely (like fatsort) are Linux-native tools operating on unmounted block devices.

Because standard Windows tools and scripts are forced to go through the normal Windows file system driver rather than editing raw directory sectors, their only native way to guarantee alphabetical file table order is to write the files onto the card one by one in sequence. On a 200GB collection, that forced data rewrite is always going to hit a massive time wall.

It is possible (at least in theory) to run fatsort using Windows Subsystem for Linux (WSL). So that is a possible option, though a bit more technical than you wanted.

sausage_time

Would this work? In a DOS command prompt of course.

cd <top level of composer folders>

xcopy /s * <path to destination>

For me, this writes the top level folders in alphabetical order.

Vitor

I may be missing something, but this sounds like an extraordinary amount of work to accommodate a player with some fairly eccentric software.

Any half-decent player written this century should be sorting by filename, track number or tags rather than relying on the physical order in which directory entries happened to be written to an exFAT card.

Before spending hours copying 2,500 folders in some carefully engineered sequence, I’d be inclined to establish whether the player really is that primitive, and if so whether replacing the player might be easier than reorganising an entire music library around its quirks.

Vitor

Anyway, this ChatGPT created Powershell script will copy source to destination and create the output in alphabetical order.

<#

Copy-MusicInOrder.ps1
Copies a directory tree to a single destination so that directory

entries are CREATED in alphabetical order.
Useful for devices which display exFAT directory contents in physical

directory-entry/write order rather than sorting them themselves.
Example:

    .\Copy-MusicInOrder.ps1 `
        -Source "D:\Classical" `
        -Destination "E:\Music"
#>
param (
    [Parameter(Mandatory = $true)]
    [string]$Source,

    [Parameter(Mandatory = $true)]
    [string]$Destination
)

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

# Resolve and validate source
$Source = (Resolve-Path -LiteralPath $Source).Path

if (-not (Test-Path -LiteralPath $Source -PathType Container)) {
    throw "Source '$Source' is not a directory."
}

# Create destination if it doesn't exist
if (-not (Test-Path -LiteralPath $Destination)) {
    New-Item -ItemType Directory -Path $Destination | Out-Null
}

# Destination must be empty
$ExistingItems = @(
    Get-ChildItem -LiteralPath $Destination -Force
)

if ($ExistingItems.Count -gt 0) {
    throw "Destination '$Destination' is not empty. Use an empty folder or freshly formatted card."
}

# Count files for progress display
Write-Host "Scanning source..."

$TotalFiles = @(
    Get-ChildItem -LiteralPath $Source -File -Recurse -Force
).Count

$script:FilesCopied = 0


function Copy-DirectoryInOrder {

    param (
        [Parameter(Mandatory = $true)]
        [string]$SourceDirectory,

        [Parameter(Mandatory = $true)]
        [string]$DestinationDirectory
    )

    # Get ONLY the immediate contents of this directory,
    # explicitly sorted alphabetically.
    $Items = @(
        Get-ChildItem -LiteralPath $SourceDirectory -Force |
        Sort-Object -Property Name
    )

    foreach ($Item in $Items) {

        $Target = Join-Path $DestinationDirectory $Item.Name

        if ($Item.PSIsContainer) {

            # Create folder at this precise point in the sorted sequence
            [System.IO.Directory]::CreateDirectory($Target) | Out-Null

            # Recursively populate that folder in sorted order
            Copy-DirectoryInOrder `
                -SourceDirectory $Item.FullName `
                -DestinationDirectory $Target

            # Preserve folder modification timestamp
            [System.IO.Directory]::SetLastWriteTimeUtc(
                $Target,
                $Item.LastWriteTimeUtc
            )
        }
        else {

            $script:FilesCopied++

            if ($TotalFiles -gt 0) {
                $Percent = [int](($script:FilesCopied / $TotalFiles) * 100)
            }
            else {
                $Percent = 100
            }

            Write-Progress `
                -Activity "Copying in alphabetical order" `
                -Status "$script:FilesCopied of $TotalFiles - $($Item.Name)" `
                -PercentComplete $Percent

            # Copy exactly one file before proceeding to the next entry
            [System.IO.File]::Copy(
                $Item.FullName,
                $Target,
                $false
            )

            # Preserve timestamps
            [System.IO.File]::SetCreationTimeUtc(
                $Target,
                $Item.CreationTimeUtc
            )

            [System.IO.File]::SetLastWriteTimeUtc(
                $Target,
                $Item.LastWriteTimeUtc
            )
        }
    }
}


Write-Host ""
Write-Host "Source:      $Source"
Write-Host "Destination: $Destination"
Write-Host "Files:       $TotalFiles"
Write-Host ""

Copy-DirectoryInOrder `
    -SourceDirectory $Source `
    -DestinationDirectory $Destination

Write-Progress `
    -Activity "Copying in alphabetical order" `
    -Completed

Write-Host ""
Write-Host "Copy complete."
Write-Host "$FilesCopied files copied successfully."

talexuser

Thanks, I'll try that. All subfolders need to be in order too, which I haven't found the correct syntax in dos yet.

Composer folder contains work folders, each symphony 1, 2, 3, etc piano concerto 1, 2 etc, etc. Each symphony folder could contain subfolders of several versions, Karajan/BPO, Solti/CSO etc. in flacs with a cover image. Playlists are less useful for classical, the easiest way to find what you want is that system. Playlists are used for the popular songs in high bitrate mp3s and not necessarily always in album order but also alpha order for single songs where more detailed ID3 tags can be used for searching.

I have more sophisticated players that can arrange contents in alpha order, but this is for family members with basic but good enough sound cheaper machines.

outtatune

Directory Opus might be able to do this. The developers read the forums so it can't hurt to ask.