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.

Jeff Burdges
fonte
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));}

JiminP
fonte
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;
}
Joey Adams
fonte
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))));}
Pubby
fonte
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.

deixou de girar contra-relógio
fonte
2
main(){for(;;)putchar(rand());}

Soa como o oceano ;-)

Joey Adams
fonte
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
Kenn Downey
fonte