Nivelele de compresie FLAC sunt (numai) o schimbare între timp de codificare și dimensiunea fișierului . Timpul de decodare este aproape independent de rata de compresie. În cele ce urmează mă voi referi la nivelurile de compresie 0, …, 8 ca FLAC-0, …, FLAC-8.

Pe scurt : recomand FLAC-4 !

---

Soluțiile ușoare

Evident:

• Dacă nu-mi pasă de timpul de codificare și deoarece spațiul este bani, iau cel mai înalt nivel de compresie FLAC-8 .

• Dacă nu-mi pasă de spațiu, dar vreau să mă retrag cât mai repede posibil, iau cel mai mic nivel de compresie FLAC-0 .

---

Soluția dificilă

Unde este mijloc dreapta între dimensiunea fișierului și timpul de codare? Am dat peste articolul lui Nathan Zachary despre această întrebare, dar compară doar două fișiere, le codifică o singură dată (timpul de codare variază enorm în funcție de încărcarea laterală a computerului ) și tabelele sunt greu de citit în comparație cu graficele.

Deci, inspirat de acest lucru, i-am refăcut măsurătorile cu cinci albume complete fiecare într-un gen diferit și a codificat fiecare fișier / pistă de 10 ori .

Procedură:

• Rip album cu abcde și corect cdparanoia setări pentru WAV necomprimat.
• Convertiți fiecare fișier de 10 ori pentru fiecare nivel de compresie (FLAC-0 în FLAC-8) și luați timpul mediu de codare relativ la FLAC-0 și dimensiunea fișierului față de F LAC-0 .
  • Pentru aceasta, am dezactivat conexiunea la internet, toate lucrările periodice (cronjobs) și aproape orice altceva, astfel încât într-adevăr să se execute mai ales compresia și cât mai puține interfere.

Această măsură ar trebui să fie aproape independentă de hardware-ul folosit. Am folosit versiunea 1.3.2 flac pe Arch Linux folosind flac <infile> --compression-level-X -f -o flacX.flac.

Eficiență

Dacă înmulțiți dimensiune relativă cu codare relativă / timp de compresie , veți obține o valoare pentru răutatea . Dar, deoarece această răutate este în mare parte guvernată de timpul relativ, graficele s-ar suprapune în mare măsură. Deci, pentru a clarifica graficul, tocmai am reflectat răutatea într-o bunătate , numesc eficiență aici.

Constatări

De la FLAC-4, timpul de comprimare explodează DAR există două surprize:

1. Există o reducere semnificativă a dimensiunii fișierului între FLAC-3 și FLAC-4 în funcție de genul de muzică: muzica clasică are o compresie mult mai mică folosind FLAC-4. Presupun că acest lucru se datorează faptului că FLAC folosește un model de predicție liniar pentru compresie care funcționează mai puțin bine cu muzica mai complexă (mai puțin liniară).

2. Pentru muzica non-clasică, FLAC-3 este chiar mai rău decât FLAC-2 în ceea ce privește dimensiunea fișierului.

Recomandări

Recomand utilizarea nivelului de compresie FLAC-4 .

Creșterea semnificativă crește semnificativ timpul de codificare cu îmbunătățirea marginală a reducerii dimensiunii fișierului (reducerea medie de la FLAC-4 la FLAC-8 în acest test este 1.2% cu un 182% creșterea timpului mediu de compresie).

---

Anexă

Albume

Tocmai am luat primele cinci CD-uri aleatorii (enumerate mai jos) că m-am gândit să reprezinte diferite domenii ale muzicii. Linkurile merg intenționat către Amazon pentru a oferi o posibilitate ușoară de a arunca o privire asupra muzicii / de a-și face o idee despre muzică, deoarece aceasta face o diferență semnificativă în compresie.

• Emil Gilels – Beethoven: Sonate pentru pian Nr.21 „Waldstein”, 26 „Les Adieux” & 23 „Appassionata” ( clasic)
• Karl Jenkins – Omul armat – O masă pentru pace (clasic, masă)
• Unni Wilhelmsen – 7 (pop, jazz, folk)
• Alin Coen Band – We ” re Not The Ones We Thought We Were (indie, folk, cantautor)
• Bukahara – Bukahara Trio ( neofolk , balkanfolk )

Program

Pentru această sarcină am scris un python program care trece prin toate subdosarele (albumele) dintr-un folder dat () pentru a testa toate fișierele .wav și a le grupa / trasa după numele subdosarului lor.

<folder> Album 1 Album 2 ... 

Analiza va fi salvată într-un fișier --outfile <file1>. Pentru a face complot, utilizați --infile <file1> și --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) 

Comentarii

• Vai … aceasta este o minunată analiză cantitativă pe care ai făcut-o acolo! Apreciez foarte mult că ți-ai făcut timp pentru a face toate acestea. ' nu ar fi putut fi rapide, dar rezultate foarte bune. Mulțumesc!

Flac 0. Stocarea este atât de ieftină în zilele noastre, mi se pare o nebunie … de asemenea, Flac 0 este mai puțin probabil să sughite pe un sistem mai lent, deoarece decodarea este mai puțin solicitantă pentru decodare.

Ca urmare a răspunsului Suuuehgi, aș dori să adaug că, dacă începeți de la CD-ul și extragerea acestuia direct în FLAC, timpul de codare s-ar putea să nu aibă deloc importanță, deoarece trebuie să să rupi mai întâi muzica, ceea ce necesită timp.

Iată ce am încercat:

Folosind dbPowerAmp CD Ripper, mi-am copiat copia lui Mariah Carey „s " Merry Crăciun " album. L-am rupt o dată la nivelul de compresie FLAC 8, o dată la nivelul 5 (dbPowerAmps implicit) și o dată la nivelul 0.

Aici este total ori pentru fiecare rip, de la clic pe Start, până la sfârșitul cu toate fișierele FLAC finalizate:

Nivel 0 = 6:19

Nivel 5 = 6:18

Nivelul 8 = 6:23

După cum puteți vedea, varianța dintre toate cele 3 este minimă, < 5 secunde una de cealaltă. Pe măsură ce îl priveam cum se rupea și codifica, starea de codificare era un simplu flash pe ecran, abia înregistrat. Și urmărind sistemul de fișiere pe măsură ce se extragea, părea să fie codificat în timp ce se rupea. Totuși, YMMV pe sisteme mai lente.

În ceea ce privește dimensiunile fișierelor, iată dimensiunile fișierelor produse:

Nivel 0 = 278 MB

Nivel 5 = 257 MB

Nivel 8 = 256 MB

În timp ce copierea totală și enc timpii odelor au fost practic aceleași, dimensiunile fișierelor nu au fost, cu toate acestea, există cu siguranță o reducere a nivelurilor de compresie ulterioare (așa cum face aluzie la răspunsul lui Suuuehgi).

Pentru mine, se pare că dacă încep de la CD-uri și au un PC decent, timpul necesar pentru a rupe și codifica nu se va schimba mult în funcție de nivelul de compresie FLAC. Cu toate acestea, dimensiunea fișierului se schimbă. Cred că sugestia dbPowerAmps de nivel 5 FLAC ca implicit este una bună. Doar 1 MB diferență între FLAC 5 și FLAC 8, unde, ca și cum ați merge FLAC 0, exemplul meu arată 21 MB în exces de stocare care ar putea fi salvat. Poate că nu pare prea mult, dar când extrageți colecții vaste, se adaugă rapid (o singură melodie FLAC poate avea dimensiunea respectivă.)

Acest lucru a fost făcut pe un desktop cu o unitate USB 2 DVD , rupe în medie la viteza de 7x. Specificațiile computerului meu desktop sunt un procesor Intel Core i5-6500 @ 3.2Ghz, 16 GB de memorie RAM și o unitate SSD Samsung 860 EVO Sata.