Dźwięk z komputera, a C++

Dźwięk powiadomienia

Nasz program może wykonywać obliczenia przez dłuższy czas. Użytkownik znudzony długością trwania obliczeń może przejść do innej aplikacji. Komputery osobiste nie mają wibracji jak dzisiejsze urządzenia mobilne, więc warto rozważyć odtworzenie dźwięku. W systemie Windows możemy odtworzyć domyślny dźwięk powiadomienia wypisując na konsole znak specjalny \a.

1. cout << '\a';

Jest to znak ASCII numer 7, więc możemy też wypisać w drugi sposób:

1. cout << (char)(7);

Tylko tyle wystarczy, aby zwrócić uwagę użytkownika.

Inne dźwięki

Przypuśćmy jednak, że chcemy być bardziej oryginalni. API Windows'a pozwala nam na odegranie dźwięku dowolnej częstotliwości i dowolnej długości. Posłuży nam do tego funkcja Beep(), którą będziemy mogli użyć po dołączeniu biblioteki windows.h. Innymi słowy w nagłówku projektu dodajemy:

1. #include <windows.h>

Teraz możemy skorzystać z funkcji Beep(), która przyjmuje dwa argumenty będące liczbami całkowitymi: częstotliwość dźwięku oraz długość dźwięku. Częstotliwość dźwięku podajemy w Hz, a długość dźwięku w milisekundach. Przykładowo możemy wywołać:

1. Beep(1567, 200);

Dzięki tej prostej funkcji możemy odegrać bardziej skomplikowane utwory.

1. Beep(1567, 200);
2. Beep(1567, 200);
3. Beep(1567, 200);
4. Beep(1244, 1000);
5. Beep(1396, 200);
6. Beep(1396, 200);
7. Beep(1396, 200);
8. Beep(1174, 1000);

W celu wydobycia innych dźwięków z komputera warto skorzystać z poniższej tabelki:

Zadanie

Napisz aplikację, która wczyta n linijek tekstu. Na wejściu będzie podana najpierw liczba całkowita n, a potem n linijek, które będą składały się z opisu nuty, spacji oraz liczby całkowitej która będzie oznaczać długość trwania nuty w milisekundach. Program ma za zadanie odegrać wczytane nuty. Przykładowo

1. 2
2. G6 200
3. G6 200

Rozwiązanie

W celu ułatwienia wybierania częstotliwości danej nuty zadeklarujemy globalną listę częstotliwości - ze względu na długość zamieszczam tylko fragment, całość dostępna jest do skopiowania w kodzie źródłowym:

1. double nuty[84] = {32.7, ..., 3951.1};

Nuty oktawy zaczynają się od C kończą na B, więc warto dopisać funkcję note_value(), która powie na podstawie zapisu litery i ewentualnie # jaki indeks ma nuta w oktawie:

1. int note_value(char note, bool up){
2.   switch(note){
3.     case 'C': return up ? 1 : 0;
4.     case 'D': return up ? 3 : 2;
5.     case 'E': return 4;
6.     case 'F': return up ? 6 : 5;
7.     case 'G': return up ? 8 : 7;
8.     case 'A': return up ? 10 : 9;
9.     case 'B': return 11;
10.   }
11. }

Jako argument przyjmujemy dwa argumenty. Literę nuty oraz czy jest modyfikowana przez #.

Główna funkcja

1. int main (){
2.   int n;
3.   cin >> n;
4.   cin.clear();
5.   cin.sync();

(2.) Deklarujemy zmienną n, która określi ile nut zagramy. (3.) Wczytujemy ile nut mamy zagrać. (4. - 5.) Czyścimy strumień, aby mieć pewność, że będziemy wczytywać linijka po linijce to co chcemy.

6.   char* line = new char[16];
7.   for(int i = 0; i < n; i++){
8.     cin.getline(line, 16);
9.     int note = note_value(line[0], line[1] == '#');
10.     note += 12 * (line[(line[1] == '#') ? 2 : 1] - '1');

(6.) Deklarujemy zmienną line, która będzie naszym buforem przechowującym wczytane dane. (7.) Rozpoczynamy pętle dla każdej linijki danych. (9.) Wywołujemy note_value(), aby uzyskać indeks noty w oktawie. (10.) Następnie ustalamy indeks nuty na naszej liście - przesuwamy o 12 * cyfra po nucie miejsc w górę. Uwaga, musimy pamiętać, że mamy nuty z # i bez, więc cyfra określająca oktawę może być na 1 lub drugiej pozycji.

11.     int duration = 0;
12.     for(int j = (line[1] == '#') ? 4 : 3; line[j]; j++){
13.       duration *= 10;
14.       duration += line[j] - '0';
15.     }
16.     Beep(nuty[note], duration);
17.   }

(11.) Deklarujemy zmienną duration do której wczytam ile ma trwać nuta. (12. - 15.) Dopóki nie skończy nam się napis wczytujemy liczbę. (16.) Gramy nutę.

18.   system("pause");
19.   return 0;
20. }

(18.) Czekamy na interakcję użytkownika i (19.) zamykamy program.

Teraz można odegrać muzyczkę uruchamiając aplikację i wpisując:

1. 8
2. G6 200
3. G6 200
4. G6 200
5. D#6 1000
6. F6 200
7. F6 200
8. F6 200
9. D6 1000

• Kod źródłowy Implementacja

Zadania

Zadanie 1

Zmodyfikuj aplikację, aby wczytywała na końcu każdej linijki dodatkowy argument, który określa ile razy nuta ma być zagrana. Uwaga: argument ten nie musi być podany - program powinien to wykryć.

Dzięki tej zmianie wciąż ta sama muzyczka powinna być odegrana zgodnie z tymi danymi wejściowymi:

1. 4
2. G6 200 3
3. D#6 1000
4. F6 200 3
5. D6 1000

• Kod źródłowy Zadanie 1