A FLAC tömörítési szintek (csak) kódolási idő és fájlméret . A dekódolási idő nagyjából független a tömörítési aránytól. A következőkben a 0, …, 8 tömörítési szintekre FLAC-0, …, FLAC-8 néven hivatkozom.

Röviden: : Azt javaslom, hogy FLAC-4 !

---

Az egyszerű megoldások

Nyilvánvaló:

• Ha nem érdekel az idő kódolása, és mivel a tér pénz, akkor a legmagasabb tömörítési szintet FLAC-8 .

• Ha nem érdekel a hely, de a lehető leggyorsabban szeretnék mögé kerülni, akkor a legkisebb tömörítési szintet FLAC-0 .

---

A nehéz megoldás

Hol van a jobb közepe a fájlméret és a kódolási idő között? Nathan Zachary cikkére bukkantam ebben a kérdésben, de csak két fájlt hasonlít össze, csak egyszer kódol (a kódolási idő nagymértékben változik a számítógép oldaltöltetétől függően) ) és a táblázatok nehezen olvashatók a grafikonokhoz képest.

Így inspirálva átmértem a méréseimet öt teljes albummal mindegyik más-más műfajban, és minden fájlt / számot kódolt 10-szer .

Eljárás:

• Album másolása abcde és megfelelő cdparanoia beállítások tömörítetlen WAV-ra.
• Konvertáljon minden fájlt 10-szer minden tömörítési szintre (FLAC-0-ról FLAC-8-ra), és vegye fel a átlagos kódolási időt az FLAC-0-hoz viszonyítva és a fájlméret F-hez viszonyítva LAC-0 .
  • Ehhez letiltottam az internetkapcsolatot, az összes időszakos munkát (cronjobs) és majdnem minden mást, hogy valóban a tömörítés fusson, és a lehető legkevesebbet zavarjon.

Ennek az intézkedésnek nagyjából függetlennek kell lennie a használt hardvertől. Az flac 1.3.2 verziót használtam Arch Linux rendszeren az flac <infile> --compression-level-X -f -o flacX.flac használatával.

Hatékonyság

Ha a relatív méret a relatív kódolással / tömörítési idővel , akkor értéket kap a rosszság ról. De mivel ezt a rosszat leginkább a relatív idő szabályozza, a grafikonok nagymértékben átfednék egymást. Tehát a grafikon tisztázása érdekében a rosszat egy jóságba tükröztem, itt a hatékonyság t nevezem.

Megállapítások

Az FLAC-4-től kezdődően a tömörítési idő felrobban, DE két meglepetés van:

1. A fájlméret jelentősen csökken az FLAC-3 és FLAC-4, a zene műfajától függően: A klasszikus zene tömörítése sokkal alacsonyabb az FLAC-4 használatával. Feltételezem, hogy ez azért van, mert a FLAC lineáris predikciós modellt használ a tömörítéshez, amely kevésbé teljesít a bonyolultabb (kevésbé lineáris) zenéknél.

2. Nem klasszikus zene esetében az FLAC-3 a fájlméret szempontjából még lényegesen rosszabb, mint az FLAC-2.

Javaslatok

A tömörítési szint FLAC-4 .

Ha magasabbra lép, jelentősen megnöveli a kódolási időt, a fájlméret csökkentésének marginális javulásával (átlagos csökkentés FLAC-4-ről FLAC-8-ra ebben a tesztben) 1,2% 182% az átlagos tömörítési idő növekedése).

---

Függelék

Albumok

Most vettem az első öt véletlenszerű CD-t (alább felsorolva) hogy azt gondoltam, hogy a zene különböző területeit képviselem. A linkek szándékosan az Amazon-ba kerülnek, hogy könnyen bepillanthassanak a zenébe / képet alkothassanak a zenéről, mivel ez jelentős különbséget jelent a tömörítésben.

• Emil Gilels – Beethoven: 21. zongoraszonáta “Waldstein”, 26 “Les Adieux” & 23 “Appassionata” ( klasszikus)
• Karl Jenkins – A fegyveres ember – szentmise a békéért (klasszikus, misei)
• Unni Wilhelmsen – 7 (pop, jazz, folk)
• Alin Coen Band – Mi ” re Nem azok, akikről azt hittük, hogy (indie, folk, énekes-dalszerző)
• Bukahara – Bukahara trió ( neofolk , balkanfolk )

program

Ehhez a feladathoz írtam egy python program, amely az adott mappában található összes almappát (albumot) átmegy () az összes .wav fájl teszteléséhez és az almappanevük szerinti csoportosításhoz / ábrázoláshoz.

<folder> Album 1 Album 2 ... 

Az elemzés mentésre kerül --outfile <file1> fájlban. Az ábrázoláshoz használja a --infile <file1> és a --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) 

megjegyzéseket

• Hú … ez egy fantasztikus kvantitatív elemzés, amelyet ott végeztél! Nagyon értékelem, hogy időt szánt erre. Nem sikerült ' t gyors, de nagyon jó eredmény elérni. Köszönöm!

Flac 0. A tárolás manapság olyan olcsó, számomra nem gond … a Flac 0 is kevésbé valószínű, hogy csuklik egy lassabb rendszeren, mivel a dekódolása kevésbé igényes a dekódoláshoz.

Suuuehgi válaszának folytatásaként azt is szeretném hozzáfűzni, hogy ha egy CD-t és közvetlenül a FLAC-ra másolva, az idő kódolása lehet, hogy egyáltalán nem számít, mert először be kell másolnia a zenét, ami időbe telik.

Íme, amit kipróbáltam:

A dbPowerAmp CD Ripper használatával kitéptem Mariah Carey “s " Merry példányát Karácsonyi " album. Egyszer letéptem a FLAC 8. tömörítési szintjén, egyszer az 5. szinten (alapértelmezett dbPowerAmps), és egyszer a 0. szinten.

Itt van a total idõ minden egyes rip-re, a kezdõkattintástól az összes FLAC-fájl végéig:

0. szint = 6:19

5. szint = 6:18

8. szint = 6:23

Mint láthatja, a 3 közötti eltérés minimális, belül < 5 másodperc egymástól. Amint néztem, ahogy rip-be-kódol, a kódolási állapot puszta villanás volt a képernyőn, alig regisztrálva. És miközben a fájlrendszert nézte, amikor éppen hasogatott, úgy tűnt, hogy menet közben is kódolva van. A YMMV azonban lassabb rendszereken.

A fájlméreteket illetően itt vannak az előállított fájlméretek:

0. szint = 278 MB

5. szint = 257 MB

8. szint = 256 MB

Míg a teljes rip és enc Az ode idők alapvetően megegyeztek, a fájlméretek nem voltak, azonban a későbbi tömörítési szinteknél egyértelműen csökken a hozam (amire Suuuehgi válasza utal).

Számomra úgy tűnik, hogy ha CD-kből indulnak és tisztességes PC-vel rendelkeznek, a repesztéshez és kódoláshoz szükséges idő nem változik sokat a FLAC tömörítési szint alapján. A fájl mérete azonban változik. Szerintem a dbPowerAmps alapértelmezett FLAC 5-ös javaslata jó. Csak 1 MB különbség van az FLAC 5 és a FLAC 8 között, ahol, mintha a FLAC 0-ra megyünk, a példám 21 MB-ot mutat a felesleges tárhelyen, amelyet el lehetne menteni. Lehet, hogy ez nem tűnik túl soknak, de amikor hatalmas gyűjteményeket szaggat, gyorsan összeadódik (egyetlen FLAC-dal is ekkora lehet.)

Ezt egy asztali számítógépen, USB 2 DVD-meghajtóval végezték. , átlagosan hétszeres sebességgel hasogatva. Asztali számítógépem műszaki adatai: Intel Core i5-6500 processzor, 3,2 GHz, 16 GB RAM, és egy Samsung 860 EVO Sata SSD meghajtó.