Escribe la composición de bytebeat más bonita

24

Bytebeat es un estilo de música que se puede componer escribiendo un simple programa en C cuya salida se canaliza hacia aplayo /dev/dsp.

main(t){for(;;t++)putchar(((t<<1)^((t<<1)+(t>>7)&t>>12))|t>>(4-(1^7&(t>>19)))|t>>7);}

Hay una buena cantidad de información en el sitio bytebeat , una implementación de JavaScript y más demostraciones y composiciones de ejemplo en este hilo .

Reglas muy simples: Intenta escribir una composición que suene bonita. La mayoría de los votos aumentan ya que eso es obviamente subjetivo, aunque no tan subjetivo teniendo en cuenta los resultados habituales.

Jeff Burdges
fuente
¿Está sujetando esto a un bytebeat estricto (es decir, sin buffers)?
Peter Taylor
44
¿Por qué está restringido a C?
usuario desconocido el
No existe ninguna razón intrínseca para restringir el uso de buffers u otros lenguajes, pero generalmente bytebeat significa ese ciclo C particular con la salida definida por una fórmula. He votado por la respuesta de Joey Adams, incluso aunque rand()no sea estándar.
Jeff Burdges
Si bien me gusta esta idea, las preguntas frecuentes requieren un criterio ganador objetivo (es demasiado fácil quedar atrapado en los cálculos o en el arte ASCII). ¿Podemos buscar algo mejor definido que "bonito"?
dmckee

Respuestas:

16

(Firmado little endian de 16 bits, 8000Hz mono ( --format=S16_LE))

Música

Mucho mejor que antes! (aunque es bastante largo)

main(t){for(;;t++)putchar(((7&(((t>>17)+1)>>2)+((t>>10)&1+2*(t>>18&1))*(("23468643"[7&t>>12]-48)+(3&t>>11))+((3&t>>17)>0)*(3&t>>9)*!(1&t>>10)*(((2+t>>10&3)^(2+t>>11&3))))*t*"@06+"[3&t>>15]/32));}

(Puedes escuchar esto aquí )

Escribí esto, pero ni siquiera sé cómo funciona una parte, como >0y (especialmente) la primera 7&.

Cambiar por bucle a for(;!(t>>22);t++) ... para escucharlo 'una vez'. Sin embargo, no sé si se "repite" exactamente de la misma manera.

Melodía (base de la música anterior)

Me encanta esta melodía que hice (CGAF ftw), pero es demasiado 'simple' ...

main(t){for(;;t++)putchar(((t>>10)&1)*(t*("23468643"[7&t>>12]-48)+t*(3&t>>11))*"@06+"[3&t>>15]/32);}

Música simple (que hice antes)

main(t){for(;;t++)putchar(t*(3&t>>11)+(t&t>>11)*4*!((t>>11)%3));}

JiminP
fuente
Si hace clic en el enlace bytebeat anterior, verá una línea de comando sox para convertirlo en un archivo .wav y una línea de comando de compresor impar.
Jeff Burdges
3
+1 ¡Increíble! Unos pocos bits (p. Ej., 1:30 - 1:40) suenan como "tartamudeos", pero, una vez más, gran parte del encanto del bytebeat está en estos ritmos y melodías extraños y poco convencionales, y el efecto general es excelente. (Ps. Accidentalmente jugué esto a 8 bits por muestra, y también suena sorprendentemente bien así. Algo así como tocar un vinilo de 45 rpm a 33.3 rpm.)
Ilmari Karonen
3

La función de regla en do menor:

#include <math.h>
#include <stdio.h>

#define PI 3.14159265358979323846

#define step(freq, n) ((freq) * pow(2, (n) / 12.0))
#define note(n)       step(440, n)
#define MIDDLE_C      note(-9)

int count_zeros(unsigned int n)
{
    int count = 0;
    for (; (n & 1) == 0; n >>= 1)
        count++;
    return count;
}

int minor_note(int note)
{
    int octave = note / 7;
    int scale[] = {0, 2, 3, 5, 7, 8, 10};

    note %= 7;
    if (note < 0) {
        note += 7;
        octave--;
    }

    return scale[note] + octave*12;
}

int main(void) {
    double t = 0.0;
    double freq = MIDDLE_C * 2;
    double step = PI * 2 / 8192;
    int n = 0;
    int i = 0;

    for (i = 1;; t += step, i++) {
        if (i == 1024) {
            i = 0;
            n++;
            freq = step(MIDDLE_C, minor_note(count_zeros(n)));
        }

        putchar(sin(t * freq) * 50.0 + 128.0);
    }

    return 0;
}
Joey Adams
fuente
Bonita melodía, pero para ser una "composición", esta OMI necesita algo más ...
Ilmari Karonen
3
main(t){for(;;t+=(t%6)?1:2)putchar((((t<<t^(t>>8))|(t<<7))*((t<<t&(t>>12))|(t<<10))));}
Pubby
fuente
Bytebeat muy clásico, si eso no es un oxímoron. +1 de mi parte
Ilmari Karonen
3

Enfatizando "beat" sobre "byte":

#include<math.h>

double s(double,double);double r(double,double);double d(double);double f(double);

char bytebeat(int t){return (d(f(t/4000.)/3) + 1) * 63;}
double f(double t){
  double sn=s(1./2,t-1); sn*=(sn*sn);
  return 3*s(1./4,1/s(1,t))+3*s(4,1/sn)/2+s(4,1/(sn*sn*sn*sn*sn))/4
       +2*s(55+18.3*r(1./2,t),t)+s(110+s(5,t)/4000,t)*s(1,t)+s(220+110*r(1,t)+55*r(3,t),t)/5
       +s(880+440*r(1./2,t)-220*r(1,t)+110*r(2,t)+s(5,t)/4000,t)
       *(2+s(1760+438*r(3./2,t)-1234*r(2,t)+423*r(5,t),t))/9
       +s(s(1,t)+s(1./2,t)+s(1./4,t)+s(1./8,t),t)*s(s(1,t)+s(1./2,t)+s(1./4,t)+s(1./8,t)+1,t)
       +r(264+11*r(1./20,t),t)*s(1./20,t);
}
double s(double f,double t){return d(sin(f*3.14159265*(t+999)));}
double r(double f,double t){return s(f,t)<0;}
double d(double a){return tanh(a+a*a/4);}

main(t){for(;;++t)putchar(bytebeat(t));}

Para ser utilizado a 8 kHz, uint8 mono. Suena mejor con altavoces decentemente aptos para bajos.

dejó de girar en sentido antihorario
fuente
2
main(){for(;;)putchar(rand());}

Suena como el océano ;-)

Joey Adams
fuente
1
Más como un cruce de ferrocarril muy ocupado para mí. :)
Ilmari Karonen
55
Protip: si suena como un tono continuo, su RNG está roto.
Sr. Llama
3
manera más fácil:$ cat /dev/urandom | aplay
Braden Best
2
@ B1KMúsica mucho más simple:aplay /dev/urandom
minmaxavg
0

Melodía y armonía combinadas:

r=3,
r=3,
m=(t*(t>>12|t>>13|t>>14|t>>15|t>>16|t>>17|t>>18))&63,

h= ((t&t>>7&t>>6)|t*5&t>>8-c^t*6&t>>9-c|t*7&t>>12-c^t*9&t>>11-c^t*11&t>>22^t*19&t>>20^t*14&t>>20|t*23&t>>15-c|t*12&t>>9|t*30&t>>30|t>>5|t>>4)-31, m|h
Kenn Downey
fuente