El programa cuyo código fuente aquí expongo realiza una simulación numérica de lo que es un proceso de suma en coma flotante de 32 y 64 bits.
He probado con dos versiones. Una genera un ruido diferente en cada "pista" en 24 bits y la convierte la muestra a 32-bit flotante para procesarla. Cada canal se atenúa de forma proporcional al número de pistas más una. Eso quiere decir que si se prueba la suma de 2 pistas, cada una estará atenuada algo más 6dB., con 4 pistas serán algo mas de 12dB, etc. En el sumador se tiene un acumulador de 32-bit flotante y otro de 64-bit flotante. Una vez hecha la suma se convierten los dos resultados otra vez a enteros de 24 bits y se restan para obtener el error del resultado entre la suma de 32 y la de 64. Esos errores se contabilizan para obtener el porcentaje del número de samples que han tenido un error de 1 bit o más.
Esa prueba se realiza con 2, 4, 8, 16, 32, 64, 128 y 256 pistas (todo mono). Cada pista tiene un ruido diferente (descorrelacionado). Los resultados son:
Porcentaje de muestras con error de 1 bit
- 2 pistas: 6.00692%
- 4 pistas: 8.87162%
- 8 pistas: 8.2706%
- 16 pistas: 7.59063%
- 32 pistas: 6.99218%
- 64 pistas: 6.59762%
- 128 pistas: 6.37732%
- 256 pistas: 6.2367%
He realizado una variante del programa donde introduce el mismo ruido en todas las pistas (correlación de 1), atenuándolas de la misma forma que en la versión anterior. Aquí los resultados son mucho mas drásticos acrecentándose la magnitud del error conforme se añaden pistas:
2: 13.8854%
4: 20.6459%
8: 29.7468%
16: 42.7539% 3.65476%
32: 58.6403% 22.8456% 0.602419%
64: 74.1061% 46.4723% 14.0073% 0.134732%
128: 84.1367% 66.0554% 41.0052% 12.1478% 0.0226757%
256: 90.7555% 79.6116% 62.8389% 38.276% 11.4212% 0.00657596%
1 bit 2 bits 3 bits 4 bits 5 bits 6 bits
Como puede observarse en cualquier caso hasta con dos pistas y correlación a cero se produce una diferencia entre el summing de 32-bit y el de 64-bit. La cuestión es si una mezcla real se parecerá a la prueba descorrelacionada o tenderá en algún grado a dar errores mas significativos acercándose a la estadística de la mezcla de pistas iguales.
Sería interesante hacer pruebas con fuentes sonoras diferentes como ondas o audio real. Pero por ahora aquí queda esta demostración. La verdad es que esperaba que los porcentajes fueran menores.
Pongo el código fuente por sí a alguien le interesa (la versión de un ruido diferente por pista). Y por cierto, no me funciona la vista previa del foro, no sé porqué.
#include
#include
#include
#include
using namespace std;
void do_summing(size_t num_tracks)
{
const size_t num_count = 23;
const size_t num_samples = 44100*60;
size_t count_e[num_count];
for (size_t *ptr = count_e; ptr != count_e+num_count; ++ptr)
*ptr = 0;
float level = 1.0/(num_tracks+1);
for (std::size_t n = num_samples; n > 0; --n) {
double sum_d = 0.0;
float sum_f = 0.0;
for (std::size_t i = 0; i < num_tracks; ++i) {
int sample_i = (rand()&0xFFFFFF)-0x7FFFFF;
float sample_f = static_cast(sample_i)/8388607.0;
sum_f += sample_f*level;
sum_d += static_cast(sample_f)*level;
}
long sum_fi = sum_f*0x7FFFFF;
long sum_di = sum_d*0x7FFFFF;
unsigned int abs_error = fabs(sum_di-sum_fi);
size_t *pcount = count_e;
for (size_t mask = 0x7FFFFF; mask > 0; mask
), acaba siendo evidente en cuanto tienes un proyecto con mucha edición (y como llevamos años escuchando baterías pasadas por beat detective, casi todos los proyectos acaban necesitando un huevo de edición). Yo me conozco Reaper a esta altura bastante bien, y la verdad es que trabajo bastante rápido, pero así y todo tengo la sensación de que ProTools es más rápido para trabajar, acaba siendo más práctico, de un modo u otro. Este es el principal valor, creo yo, amén del márketing y del hecho de que todos los estudios 'pro' lo tienen.
