Escreva a composição mais bonita de bytebeat


24

Bytebeat é um estilo de música que se pode compor escrevendo um programa C simples cuja saída é canalizada aplayou /dev/dsp.

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

Há muitas informações no site bytebeat , uma implementação em javascript e mais demos e composições de exemplo neste segmento .

Regras muito simples: tente escrever uma composição que soe bastante. A maioria dos votos ganha, pois isso é obviamente subjetivo, embora não seja subjetivo, considerando os resultados usuais.



Você está segurando isso com bytebeat estrito (ou seja, sem buffers)?
Peter Taylor

4
Por que é restrito a C?
usuário desconhecido

Não há nenhuma razão intrínseca para restringir o uso de buffers ou outros idiomas, mas geralmente bytebeat significa aquele loop C específico com a saída definida por uma fórmula. Votei na resposta de Joey Adams, mesmo que rand()não seja padrão.
Jeff Burdges

Embora eu goste dessa idéia, as Perguntas frequentes exigem um critério de vitória objetivo (é muito fácil ficar preso em cálculos ou na arte ASCII). Podemos procurar algo melhor definido do que "bonito"?
dmckee

Respostas:


16

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

Música

Muito melhor do que antes! (embora seja bastante longo)

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));}

(Você pode ouvir isso aqui )

Eu escrevi isso, mas mesmo eu não sei como algumas partes funcionam, como >0e (especialmente) a primeira 7&.

Mude para o loop para for(;!(t>>22);t++)... para ouvir 'uma vez'. Eu não sei se "loops" exatamente da mesma maneira, no entanto.

Melodia (base da música acima)

Eu amo essa melodia que eu fiz (CGAF ftw), mas é muito "simples" ...

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 simples (que eu fiz antes)

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


Se você clicar no link de bytebeat acima, verá uma linha de comando sox para convertê-lo em um arquivo .wav e uma linha de comando estranha do compressor.
Jeff Burdges

3
+1 Incrível! Alguns bits (por exemplo, 1:30 - 1:40) parecem meio "gaguejantes", mas, novamente, muito do charme de batidas de byte está nesses ritmos e melodias estranhos e não convencionais, e o efeito geral é excelente. (. Ps eu acidentalmente jogou este em 8 bits por amostra, e eu soa surpreendentemente bom dessa forma também Mais ou menos como jogar um 45 rpm vinil em 33,3 rpm..)
Ilmari Karonen

3

A função da régua em dó 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;
}

Melodia agradável, mas para ser uma "composição" dessa IMO precisa de algo mais ...
Ilmari Karonen

3
main(t){for(;;t+=(t%6)?1:2)putchar((((t<<t^(t>>8))|(t<<7))*((t<<t&(t>>12))|(t<<10))));}

Bytebeat muito clássico, se não for um oxímoro. +1 de mim.
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 usado em 8 kHz, uint8 mono. Soa melhor em alto-falantes decentemente capazes de graves.


2
main(){for(;;)putchar(rand());}

Soa como o oceano ;-)


11
Mais como uma passagem ferroviária muito movimentada para mim. :)
Ilmari Karonen

5
Protip: se soa como um tom contínuo, seu RNG está quebrado.
Llama

3
maneira mais fácil:$ cat /dev/urandom | aplay
Braden Best

2
@ B1KMusic muito mais simples:aplay /dev/urandom
minmaxavg

0

Melodia e harmonia 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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.