I livelli di compressione FLAC sono (solo) uno scambio di tempo di codifica e dimensione del file . Il tempo di decodifica è praticamente indipendente dal tasso di compressione. Di seguito farò riferimento ai livelli di compressione 0, …, 8 come FLAC-0, …, FLAC-8.

In breve : consiglio FLAC-4 !

---

Le soluzioni facili

Ovviamente:

• Se non mi interessa codificare il tempo e poiché lo spazio è denaro, prendo il livello di compressione più alto FLAC-8 .

• Se non mi interessa lo spazio ma voglio risolverlo il più velocemente possibile, prendo il livello di compressione più basso FLAC-0 .

---

La soluzione difficile

Dovè a metà tra la dimensione del file e il tempo di codifica? Mi sono imbattuto in articolo di Nathan Zachary “ su questa domanda, ma confronta solo due file, li codifica solo una volta (il tempo di codifica varia enormemente a seconda del carico laterale del computer ) e le tabelle sono difficili da leggere rispetto ai grafici.

Quindi, ispirato da questo, ho rifatto le sue misurazioni con cinque album completi ciascuno in un genere diverso e ha codificato ogni file / traccia 10 volte .

Procedura:

• Copiare album con abcde e corretta cdparanoia a WAV non compresso.
• Converti ogni file 10 volte per ogni livello di compressione (da FLAC-0 a FLAC-8) e prendi il tempo di codifica medio relativo a FLAC-0 e la dimensione del file rispetto a F LAC-0 .
  • Per questo ho disabilitato la connessione a Internet, tutti i lavori periodici (cronjobs) e quasi tutto il resto in modo che la compressione venga eseguita per lo più e il minor numero possibile di interferenze.

Questa misura dovrebbe essere praticamente indipendente dallhardware utilizzato. Ho utilizzato la versione 1.3.2 di flac su Arch Linux utilizzando flac <infile> --compression-level-X -f -o flacX.flac.

Efficienza

Se moltiplichi dimensione relativa con tempo di codifica / compressione relativo , ottieni un valore per la cattiveria . Ma poiché questa cattiveria è per lo più governata dal tempo relativo, i grafici si sovrappongono ampiamente. Quindi, per chiarire il grafico, ho semplicemente rispecchiato la cattiveria in una bontà , chiamo efficienza qui.

Risultati

Da FLAC-4 in poi, il tempo di compressione esplode MA ci sono due sorprese:

1. Cè una significativa riduzione della dimensione del file tra FLAC-3 e FLAC-4 a seconda del genere musicale: la musica classica ha una compressione molto più bassa utilizzando FLAC-4. Presumo che ciò sia dovuto al fatto che FLAC utilizza un modello di previsione lineare per la compressione che funziona meno bene con musica più complessa (meno lineare).

2. Per la musica non classica, FLAC-3 è anche significativamente peggiore di FLAC-2 in termini di dimensione del file.

Consigli

Consiglio di utilizzare il livello di compressione FLAC-4 .

Aumentando significativamente il tempo di codifica con un miglioramento marginale nella riduzione delle dimensioni del file (riduzione media da FLAC-4 a FLAC-8 in questo test è 1,2% con 182% aumento del tempo medio di compressione).

---

Appendice

Album

Ho appena preso i primi cinque CD casuali (elencati di seguito) che ho pensato rappresentano un campo musicale diverso. I collegamenti vanno intenzionalmente ad Amazon per fornire una facile possibilità di dare uno sguardo alla musica / per avere unidea della musica poiché fa una differenza significativa nella compressione.

• Emil Gilels – Beethoven: Piano Sonatas Nos.21 “Waldstein”, 26 “Les Adieux” & 23 “Appassionata” ( classica)
• Karl Jenkins – The Armed Man – A Mass for Peace (classica, messa)
• Unni Wilhelmsen – 7 (pop, jazz, folk)
• Alin Coen Band – We ” re Not the Ones We Thought We Were (indie, folk, cantautore)
• Bukahara – Bukahara Trio ( neofolk , balkanfolk )

Programma

Per questo compito ho scritto un python programma che passa attraverso tutte le sottocartelle (gli album) in una determinata cartella () per testare tutti i file .wav e raggrupparli / tracciarli in base al nome della sottocartella.

<folder> Album 1 Album 2 ... 

Lanalisi verrà salvata in un file --outfile <file1>. Per tracciare, utilizza --infile <file1> e --outfile <file2>.

#!/usr/bin/python3 #encoding=utf8 import os, sys, subprocess, argparse from datetime import datetime, timedelta from os.path import isfile, isdir, join import numpy as np import matplotlib.pyplot as plt import pickle as pkl parser = argparse.ArgumentParser(description="Analyse flac compression and conversion time") group = parser.add_mutually_exclusive_group() group.add_argument("-d", "--directory", help="Input folder", type=str) group.add_argument("-if", "--infile", help="Plot saved stats (pickle file)", type=str) parser.add_argument("-of", "--outfile", help="Output file", type=str, required=True) parser.add_argument("-c", "--cycles", help="Number of cycles for each file", type=int, default=5) parser.add_argument("-C", "--maxcompression", help="Max compression level", type=int, default=8) args = parser.parse_args() args.maxcompression += 1 ############################################################ xlabel = "FLAC Compression Factor" ylabel_size = "Size Relative to FLAC-0" ylabel_time = "Mean Compression Time\nOver {} Cycles Relative to FLAC-0 [s]".format(args.cycles) ylabel_efficiency = r"Efficiency: $(-1)\cdot$ Fraction Time $\cdot$ Fraction Size $+ 2$" ############################################################ # Analyse and write mode if not args.infile: if isdir(args.directory): mypath = args.directory else: raise ValueError("Folder {} does not exist!".format(args.directory)) folders = [f for f in os.listdir(mypath) if isdir(join(mypath, f))] print("Found folders: {}".format(folders)) # Create temporary working folder temp_folder = "temp_{}".format(os.getpid()) if not os.path.exists(temp_folder): os.makedirs(temp_folder) # Every analysis will be storen in stats stats = {} remove = [] for folder in folders: stats[folder] = {} stats[folder]["files"] = [f for f in os.listdir(mypath+folder) if isfile(join(mypath+folder, f)) and f.endswith(".wav")] if len(stats[folder]["files"]) == 0: print("No .wav files found in {}. Skipping.".format(folder)) remove.append(folder) stats.pop(folder, None) else: stats[folder]["stats"] = np.empty([len(stats[folder]["files"]),args.maxcompression], dtype=object) # Remove empty (no .wav) folders from list for folder in remove: folders.remove(folder) totalfiles = [] for folder in folders: totalfiles += stats[folder]["files"] totalfiles = len(totalfiles) if totalfiles == 0: raise RuntimeError("No .wav files found!") totalcycles = totalfiles * args.cycles * args.maxcompression counter_cycles = 0 time_start = datetime.strptime(str(datetime.now()), "%Y-%m-%d %H:%M:%S.%f") for folder in folders: # i: 0..Nfiles # n: 0..8 files = stats[folder]["files"] for i in range(len(files)): infile = "{}/{}".format(mypath+folder,files[i]) for n in range(args.maxcompression): Dtime = [] for j in range(args.cycles): time1 = datetime.strptime(str(datetime.now()), "%Y-%m-%d %H:%M:%S.%f") subprocess.run(["flac", infile, "--compression-level-{}".format(n), "-f", "-o", "{}/flac{}.flac".format(temp_folder,n)]) time2 = datetime.strptime(str(datetime.now()), "%Y-%m-%d %H:%M:%S.%f") Dtime.append((time2-time1).total_seconds()) counter_cycles += 1 # Percentage of totalcycles status = counter_cycles/totalcycles remain_factor = (1 - status)/status time_current = datetime.strptime(str(datetime.now()), "%Y-%m-%d %H:%M:%S.%f") time_elapsed = (time_current - time_start).total_seconds() print("========================================") print("Status: {} %".format(int(100*status))) print("Estimated remaining time: {}".format(str(timedelta(seconds=int(remain_factor * time_elapsed))))) print("========================================") Dtime = np.mean(Dtime) size = os.path.getsize("{}/flac{}.flac".format(temp_folder,n)) # Array if size (regarded as constat) and mean compression time # (file1, FLAC0)(file1, FLAC1)...(file1, FLACmaxcompression) # (file2, FLAC0)(file2, FLAC1)...(file2, FLACmaxcompression) # ... stats[folder]["stats"][i,n] = (size, Dtime) for folder in folders: # Taking columnwise (for each compression level) means of size... stats[folder]["ploty_size"] = [np.mean([e[0] for e in stats[folder]["stats"][:,col]]) for col in range(np.shape(stats[folder]["stats"])[1])] # (relative to FLAC-0) stats[folder]["ploty_size"] = [i/stats[folder]["ploty_size"][0] for i in stats[folder]["ploty_size"]] # ... and mean time. stats[folder]["ploty_time"] = [np.mean([e[1] for e in stats[folder]["stats"][:,col]]) for col in range(np.shape(stats[folder]["stats"])[1])] # (relative to FLAC-0) stats[folder]["ploty_time"] = [i/stats[folder]["ploty_time"][0] for i in stats[folder]["ploty_time"]] # Rough "effectivity" estimation -size*time + 2 # Expl.: Starts at (0,1), therefore flipping with (-1) requires # + 2. Without (-1) would be "badness" stats[folder]["ploty_eff"] = [ 2 + (-1) * stats[folder]["ploty_size"][i] * stats[folder]["ploty_time"][i] for i in range(len(stats[folder]["ploty_size"]))] with open(args.outfile, "wb") as of: data = {} data["stats"] = stats data["folders"] = folders data["cycles"] = args.cycles data["maxcompression"] = args.maxcompression pkl.dump(data, of, protocol=pkl.HIGHEST_PROTOCOL) if os.path.isdir(temp_folder): subprocess.run(["rm", "-r", temp_folder]) else: with open(args.infile, "rb") as f: data = pkl.load(f) stats = data["stats"] folders = data["folders"] args.maxcompression = data["maxcompression"] args.cycles = data["cycles"] fig = plt.figure() plotx = range(args.maxcompression) pos = range(len(plotx)) ax_size = fig.add_subplot(111) ax_size.set_xticks(pos) ax_size.set_xticklabels(plotx) ax_size.set_title("FLAC compression comparison") ax_time = ax_size.twinx() ax_efficiency = ax_size.twinx() colorfracs = [i / (len(folders)-0.9) if i > 0 else 0 for i in range(len(folders))] # Actual plotting lns = [] for cfrac, folder in zip(colorfracs, folders): color = plt.cm.viridis(cfrac) l_size, = ax_size.plot(plotx, stats[folder]["ploty_size"], color=color, linestyle=":", label="Size Ratio: {}".format(folder)) l_time, = ax_time.plot(plotx, stats[folder]["ploty_time"], color=color, linestyle="--", label="Time Ratio: {}".format(folder)) l_eff, = ax_efficiency.plot(plotx, stats[folder]["ploty_eff"], color=color, linestyle="-", label="Efficiency: {}".format(folder)) lns.append(l_size) lns.append(l_time) lns.append(l_eff) ax_efficiency.spines["right"].set_position(("outward", 60)) ax_size.xaxis.grid(color=".85", linestyle="-", linewidth=.5) ax_size.set_xlabel(xlabel) ax_size.set_ylabel(ylabel_size) ax_efficiency.set_ylabel(ylabel_efficiency) ax_time.set_ylabel(ylabel_time) lgd = ax_time.legend(handles=lns, loc="upper center", bbox_to_anchor=(0.5, -.15), facecolor="#FFFFFF", prop={"family": "monospace","size": "small"}) fig.savefig(args.outfile, bbox_inches="tight", dpi=300) 

Commenti

• Whoa … questa è unanalisi quantitativa fantastica che hai fatto lì! Apprezzo davvero che tu abbia dedicato del tempo a fare tutto questo. ‘ non è stato possibile ottenere risultati veloci, ma davvero ottimi. Grazie!

Flac 0. Lo spazio di archiviazione è così economico in questi giorni, mi sembra un gioco da ragazzi … anche Flac 0 ha meno probabilità di singhiozzo su un sistema più lento poiché la decodifica è meno impegnativa da decodificare.

Come seguito alla risposta di Suuuehgi, vorrei aggiungere che se stai partendo da un CD e copiarlo direttamente in FLAC, il tempo di codifica potrebbe non avere alcuna importanza perché devi prima copiare la musica, operazione che richiede tempo.

Ecco cosa ho provato:

Usando dbPowerAmp CD Ripper, ho estratto la mia copia di Mariah Carey “s ” Merry Album ” di Natale. Lho copiato una volta al livello di compressione FLAC 8, una volta al livello 5 (predefinito dbPowerAmps) e una volta al livello 0.

Ecco il totale volte per ogni copia, dal clic di inizio, alla fine con tutti i file FLAC completati:

Livello 0 = 6:19

Livello 5 = 6:18

Livello 8 = 6:23

Come puoi vedere, la varianza tra tutti e 3 è minima, entro < 5 secondi luno dallaltro. Mentre lo guardavo copiare e codificare, lo stato della codifica era un semplice lampo sullo schermo, a malapena registrato. E guardando il file system mentre veniva copiato, sembrava che codificasse al volo mentre lo stava eseguendo. Tuttavia, YMMV su sistemi più lenti.

Per quanto riguarda le dimensioni dei file, ecco le dimensioni dei file prodotti:

Livello 0 = 278 MB

Livello 5 = 257 MB

Livello 8 = 256 MB

Mentre il rip e lenc i tempi erano fondamentalmente gli stessi, le dimensioni dei file non lo erano, TUTTAVIA, ci sono rendimenti decisamente decrescenti nei livelli di compressione successivi (come allude la risposta di Suuuehgi).

A me sembra che se tu stai iniziando da CD e hai un PC decente, il tempo necessario per estrarre e codificare non cambierà molto in base al livello di compressione FLAC. Tuttavia, la dimensione del file cambia. Penso che il suggerimento di dbPowerAmps del livello FLAC 5 come impostazione predefinita sia buono. Solo 1 MB di differenza tra FLAC 5 e FLAC 8, dove, come se andassi a FLAC 0, il mio esempio mostra 21 MB di spazio di archiviazione in eccesso che potrebbe essere salvato. Potrebbe non sembrare molto, ma quando si estraggono raccolte vaste, si sommano rapidamente (una singola canzone FLAC può essere di quelle dimensioni.)

Ciò è stato fatto su un desktop con ununità DVD USB 2 , ripping in media a velocità 7x. Le specifiche del mio PC desktop sono una CPU Intel Core i5-6500 da 3,2 Ghz, 16 GB di RAM e ununità SSD Sata Samsung 860 EVO.