PROGRAMOWANIE

1. Wstęp.
   Z tym terminem chyba każdy zetknął się chociaż raz, jak nie częściej. Jest to sposób wczytywania muzyki z odtwarzacza (np. płyt kompaktowych lub magnetofonu) do pamięci komputera przez specjalny przetwornik. Tak skomponowany kawałek można później bez problemu odtwarzać dowolną ilość razy z pamięci komputera. Kilka takich zsamplowanych fragmentów może tworzyć zupełnie ciekawą kompozycję, o czym wiemy słuchając gotowych prezentacji stworzonych przez muzyków, a ściślej sample-manów. Co jednak sprawia, że tak chętnie odbieramy? Efekty uzyskane tą techniką biją na głowę syntetycznie generowane dźwięki przez układ SID. A poza tym, sample może zrobić każdy, jest to zupełnie nietrudne i nie wymaga wiele wysiłku.

2. Podstawy.
   Do rozpoczęcia pracy potrzebny będzie sampler, oprogramowanie oraz commodore. Poza tym źródło dźwięku, z którego sygnał będzie pobierany. Może być nim; magnetofon, kompakt, lub inne urządzenie audio, nadające się do współpracy z posiadanym samplerem. Przy tym wyborze należy mieć świadomość z jakiego wyjścia można skorzystać. Sampler podłączamy zawsze do wyjść liniowych (line out) lub słuchawkowych (headphones). Nigdy nie używa się wyjść z końcówek mocy wzmacniaczy. Inne gniazda nie są przeznaczone do tego celu, a ponadto można przekroczyć maksymalną amplitudę (moc) jaką jest w stanie wytrzymać układ wejściowy przetwornika. Ocena właściwego doboru amplitudy w praktyce sprowadza się zazwyczaj do oceny "na oko", dzięki wyświetlanym na ekranie commodore kolorowym paskom podczas samplowania. Kolory o odcieniach szarych świadczą o przesterowaniu. Należy zmniejszyć głośność, tak by maksymalnie zmniejszyć częstość pojawiania się szarych pasów, jednocześnie uważać by nie wystąpił zupełny zanik jakichkolwiek pasów! Wtedy sampler będzie niewysterowany, a w głośniku usłyszymy same trzaski. Poprawne ustawienie powinno spowodować, iż dźwięk będzie czysty i bez zniekształceń. Czasem możemy spotkać się z sytuacją, gdy materiał dźwiękowy będzie zawierał przesyt tonów niskich lub wysokich. Należy bezzwłocznie skorygować taki stan właściwym ustawieniem suwaków equalizera. W przeciwnym razie szybko osiągniemy przesterowanie, w dodatku okupione gorszą słyszalnością pozostałych tonów.
   Zajmijmy się teraz oprogramowaniem. Nie da się ukryć, iż powstało dziesiątki różnych programów służących temu celowi. Generalnie możemy rozróżnić je na: proste programy zczytujące próbki z samplera i później odtwarzające je, lub wyrafinowane edytory, także z opcją zczytywania danych cyfrowych z samplera. Niektóre z nich ograniczają się do prostych funkcji układania paternów, inne wyróżniają się fantastycznymi możliwościami, jak dwiema lub trzema niezależnymi ścieżkami, filtrami odszumiającymi, equalizerami i tym podobnymi funkcjami, znanymi z edytorów na PC. A jaki będzie najodpowiedniejszy dla nas? W tym wypadku osądzcie sami, polegając na własnym przekonaniu. Jest to sprawa indywidualna, np. ja korzystam często z DIGI CATCHER grupy ATLANTIC oraz SAMPLE MON produkcji BIW. Mogę je śmiało polecić każdemu.

3. Co lepsze 4-ry czy 8-iem bitów.
   Skoro już tyle wiemy, pozostaje kwestia wyboru czy nasze sample będą 4-ro czy 8-io bitowe, a także jaką dobrać częstotliwość próbkowania. Jest to swego rodzaju kompromis, jaki musimy wybrać indywidualnie do każdego tworzonego kawałka. Ilość bitów ma decydujący wpływ na precyzję z jaką zostanie zarejestrowany, a później odtworzony sampl. Wiemy, że nasz commodore jest komputerem ośmiobitowym. Decyduje o tym szyna danych (magistrala danych) mikroprocesora. Oznacza to, że w normalnych warunkach nie będzie można zarejestrować więcej niż osiem bitów, a co za tym idzie - nie więcej niż 256 (bo 2^8= 256) poziomów głośności. Może się to wydawać mało interesującym wynikiem, ale praktyka dowodzi, że absolutnie wystarczalnym. Uzyskany dźwięk w tych warunkach sięga niemal jakości uzyskanemu na taśmie magnetofonowej. Teoretyczna wartość szumów w tym wypadku sięga granicy około 48-55 dB. Dla przypomnienia należy dodać, że odtwarzacz płyt kompaktowych charakteryzuje się 16-bitowym dźwiękiem, co daje 65536 (bo 2^16=65536) poziomów głośności. Wartość stosunku sygnał/szum sięga tu 90 dB i więcej.
   Dobrze, to dlaczego mamy zastanawiać się nad czterobitowym zapisem? Rzeczywiście odwzorowanie cyfrowe przekłada się tu na 16 (bo 2^4=16) poziomów głośności i w dodatku wartość S/N też maleje do około 24 dB. Zyskujemy za to znacznie więcej, bo w ten sposób wykorzystujemy tylko połowę pamięci komputera - dwukrotnie przecież zmniejsza się długość słowa. Tym samym sample mogą być rejestrowane dwukrotnie dłużej. W tym właśnie leży cała tajemnica.
   Zastanówmy się teraz nad najważniejszym zagadnieniem, jakim jest częstotliwość próbkowania. To od niej tak naprawdę uwarunkowane jest pasmo przenoszenia, które zawierać będzie materiał muzyczny. Musimy zdawać sobie sprawę z kilku niezaprzeczalnych faktów. Po pierwsze istnieje priorytetowa zasada, że częstotliwość próbkowania musi wynikać z pomnożenia przez 2 maksymalnej częstotliwości, jaką zawiera sygnał analogowy. I tak gdy chcemy zsamplować sygnał o częstotliwości 1 kHz (jaki towarzyszy obrazowi kontrolnemu w TV), prawidłowa częstotliwość próbkowania powinna być równa conajmniej 2 kHz. Po drugie ograniczenia wynikające ze skończonej pojemności pamięci RAM i szybkości systemu, nakładają pewne bariery. Tabelka ilustruje to najlepiej.

   Teraz jasno wynika, dlaczego dobór kroku próbkowania jest taki ważny. Dla uproszczenia sytuacji, przy digitalizowaniu muzyki, dobiera się stałą wartość z przedziału $C0-$A0. W wyjątkowych przypadkach - wyższą. Dla obliczenia innych częstotliwości, niż podane w tabelce, należy posłużyć się wzorem:

F_próbkowania= (980 000 / $FF) = 3843 Hz.

   Nie zaleca się mieszania różnie zsamplowanych kawałków, to jest z różnymi częstotliwościami próbkowania, ponieważ w trakcie odtwarzania bardzo wyczuwalne stają się przejścia pomiędzy następującymi paternami. Czyli trzeba być konsekwentnym od początku do końca.

4. Pierwsze podejście.
   Mamy wszystko przygotowane, co potrzebne. Pierwszą naszą próbą będzie sprawdzenie poprawności pracy samplera. Wpiszmy zatem:

       LDA #$00
       STA $DD03 ; ustaw USER PORT jako wejście
petla  LDA $DD01 ; pobierz dane z samplera
       STA $D418 ; przepisz do SID'a
       JMP petla ; powtórz pętlę

   Jeśli wszystko wykonaliśmy poprawnie, to z głośnika popłyną dźwięki w czasie rzeczywistym. Będzie można usłyszeć to, co podawane jest na wejście samplera. Jeśli sampler pracuje poprawnie, proponuję uruchomić edytor, zgrać kilka kawałków i zapisać na dysku / taśmie. Spróbujemy teraz to odtworzyć.

5. Playery, czyli odtwarzamy!
   Procedura odtwarzająca jest bliźniaczo podobna do zapisującej, a poważna różnica między nimi leży w kierunku przesyłania bitów. Naszym urządzeniem wyjściowym będzie układ dźwiękowy SID, a w szczególności jeden z jego rejestrów - komórka $D418. Komórka ta jest normalnie używana do regulacji poziomu głosu wychodzącego z commodore (4 młodsze bity) oraz uaktywniania filtrów dźwiękowych (4 starsze bity). Zastosujemy trik, polegający na przepisywaniu kolejnych porcji bitów z pamięci RAM do rejestru $D418. Korzystamy wyłącznie z jej czterech młodszych bitów, więc procedura którą widzimy poniżej odtwarza sample czterobitowe.

;---------------------------------------
wektor1  = $fb
wektor2  = $fd
ilosc    = $ff
;---------------------------------------
         lda #$37
         sta $01
;---------------------------------------
         ldx #$00   ;czyść ekran i rejestry
         stx $d011
         stx ilosc
         txa
         tay
czys     sta $d400,x
         inx
         cpx #$18
         bne czys
;---------------------------------------
         dey        ;głośne sample dla nowego SID'a
         sty $d404
         sty $d406
         sty $d40b
         sty $d40d
         sty $d412
         sty $d414
;---------------------------------------
         sei
         lda #<przer1
         ldx #>przer1
         sta $0314
         stx $0315  ;ustaw irq wektor
         jsr clear  ;ustaw parametry początkowe
         cli        ;uruchom przerwania irq
         jmp *      ;pętla
;---------------------------------------
clear    lda poczl  ;załaduj parametry początkowe
         sta wektor1
         lda poczh
         sta wektor1+$01
         lda konl
         sta wektor2
         lda konh
         sta wektor2+$01
         rts
;---------------------------------------
przer1   ldy #$00
         inc $01
         lda (wektor1),y ;pobierz 1 bajt
         dec $01
         lsr a
         lsr a
         lsr a
         lsr a      ;tylko 4 bity
         sta $d418  ;zagraj
         sta $d020  ;wyświetl kolor
         lda #<przer2
         ldx #>przer2
         sta $0314
         stx $0315  ;ustaw nowy wektor irq
         ldx #$17   ;ustaw prędkość
         dex        ;zmniejsz x o 1
         bne *-1    ;czy już x=0 ?
         jmp $ea81  ;wyjdź z przerwania irq
;---------------------------------------
przer2   ldy #$00
         inc $01
         lda (wektor1),y ;pobierz 1 bajt
         dec $01
         and #$0f   ;tylko 4 bity
         sta $d418  ;zagraj
         sta $d020  ;wyświetl kolor
         lda #<przer1
         ldx #>przer1
         sta $0314
         stx $0315  ;ustaw nowy wektor irq
         inc wektor1
         lda wektor1
         cmp #$00
         bne dalej  ;sprawdź, czy już koniec
         lda wektor1+$01
         cmp wektor2+$01
         beq clr    ;koniec, zacznij od początku
         inc wektor1+$01 ;nie koniec, graj dalej
         jmp $ea81  ;wyjdź z przerwania
clr      jsr clear  ;od początku
dalej    jmp $ea81  ;wyjdź z przerwania
;-------------------------------------
poczh    .byte $10 ;hi bajt (start)
;-------------------------------------
poczl    .byte $00 ;lo bajt (start)
;-------------------------------------
konh     .byte $7f ;hi bajt (koniec)
;-------------------------------------
konl     .byte $ff ;lo bajt (koniec)
;-------------------------------------

   Należy dodać kilka słów wyjaśnień. Zaznaczony na granatowy fragment można pominąć, w przypadku gdy pracujemy na starym c-64. We wszystkich nowszych komputerach, jest to niezbędne, ze względu na inną wersję SID'a (samplingi są zdecydowanie gorzej słyszalne). Ta część kodu ma za zadanie, takiego wypełnienia rejestrów układu dźwiękowego, by stały się one dobrze słyszalne, jak to ma miejsce w starym c-64.
   Przed uruchomieniem koniecznie trzeba wpisać w ostatnich liniach wartości początkowe i końcowe zakresu pamięci. Start i koniec digitalizacji został podzielony tu na młodsze i starsze bajty. W przykładzie będą to: START $1000 i KONIEC $7fff. Poza tym trzecią ważną czynnością jest właściwe określenie prędkości odtwarzania. Jest ona ustawiona tu na $17, co odpowiada szybkości około $A0. Zmniejszenie tej wartości, przyspieszy odtwarzanie, ponieważ czas oczekiwania w pętli zmaleje.
   Tak jak wyjaśniłem wcześniej, odtwarzane są tu czterobitowe sample. Ponieważ bajt ma osiem bitów, to w jednej komórce mieszczą się 2 próbki. Są zapisane jedna za drugą, czyli pierwsza w starszym półbajcie, a druga w młodszym półbajcie. I tak dalej. Procedura musi zatem odtworzyć raz starszą część, a następnie młodszą i tak w kółko. Toteż za każdym razem zmieniany jest wektor przerwania IRQ, a z kolei w każdym takim przerwaniu jest wyodrębniana właściwa część półbajta i przepisywana do $D418.
   Procedura pracuje w przerwaniach IRQ (wektory $0314 i $0315 wskazują odpowiednio na młodszy i starszy bajt adresu procedury odtwarzającej). Ma to swoje poważne wady, ponieważ nie jesteśmy w stanie odtwarzać sampli przy włączonym ekranie. Natychmiast staje się słyszalne charczenie przy odtwarzaniu. Podobne efekty ujawniają się przy wyższych częstotliwościach próbkowania (nawet przy wyłączonym ekranie - komórka $D011) lub próbie obsługi innych czynności przez program. W sytuacjach dużego przeciążenia można zaobserwować bardzo powolne odtwarzanie lub nawet zatrzymanie. Dlatego znacznie lepiej jest wykonać to samo w przerwaniach NMI, które nie mają powyższych wad i są bardzo często używane w tym celu. Poniższy listing pokazuje jak to zrobić.

;-------------------------------------
wektor1  = $fb
wektor2  = $fd
ilosc    = $ff
;-------------------------------------
         lda #$37
         sta $01
;-------------------------------------
         ldx #$00
         stx $d011
         stx ilosc
         txa
         tay
czys     sta $d400,x
         inx
         cpx #$18
         bne czys
;-------------------------------------
         dey
         sty $d404
         sty $d406
         sty $d40b
         sty $d40d
         sty $d412
         sty $d414
;-------------------------------------
         sei
         ldx #$81
         stx $dd0d
         ldx #$01
         stx $dd0e
         dex
         stx $dd05
         jsr clear
         lda #<przer1
         ldx #>przer1
         sta $0318
         stx $0319    ;ustaw wektor nmi
         cli
         jmp *
;-------------------------------------
clear    lda poczl
         sta wektor1
         lda poczh
         sta wektor1+$01
         lda konl
         sta wektor2
         lda konh
         sta wektor2+$01
         lda speed
         sta $dd04
         rts
;-------------------------------------
przer1   ldy #$00
         inc $01
         lda (wektor1),y
         dec $01
         lsr a
         lsr a
         lsr a
         lsr a
         sta $d418
         sta $d020
         lda #<przer2
         ldx #>przer2
         sta $0318
         stx $0319    ;ustaw nowy wektor nmi
         bit $dd0d
         rti
;-------------------------------------
przer2   ldy #$00
         inc $01
         lda (wektor1),y
         dec $01
         and #$0f
         sta $d418
         sta $d020
         lda #<przer1
         ldx #>przer1
         sta $0318
         stx $0319    ;ustaw nowy wektor nmi
         inc wektor1
         lda wektor1
         cmp #$00
         bne dalej
         lda wektor1+$01
         cmp wektor2+$01
         beq clr
         inc wektor1+$01
         jmp dalej
clr      jsr clear
dalej    bit $dd0d
         rti
;-------------------------------------
poczh    .byte $10 ;hi bajt (start)
;-------------------------------------
poczl    .byte $00 ;lo bajt (start)
;-------------------------------------
konh     .byte $7f ;hi bajt (koniec)
;-------------------------------------
konl     .byte $ff ;lo bajt (koniec)
;-------------------------------------
speed    .byte $a0 ;ustaw prędkość
;-------------------------------------

   Musimy sobie prześledzić schemat postępowania w tym wypadku. Komórka $DD0D jest rejestrem sterującym A, natomiast komórka $DD0E - rejestrem sterującym B układu CIA #2. Wpisanie do $DD0D wartości #$81 (%10000001) włączy przerwania z timera A i wyłączy wszystkie inne przerwania. Wpisanie wartości #$01 do $DD0E włączy nam timer A. Następnie do komórek $DD04 i $DD05 są wpisywane odpowiednio młodszy i starszy bajt timera A. To właśnie te wartości decydują o prędkości odtwarzania sampli. Elastyczność tego rozwiązania zezwala teoretycznie na ustawienie prędkości z przedziału $0000-$FFFF, ale w zakresie naszych zainteresowań leży jedynie przedział około $0060-$00FF. Samo uruchomienie odtwarzania, to już tylko sprawa wpisania odpowiedniego wektora NMI do komórek $0318 i $0319. Odtwarzanie rozpocznie się automatycznie, jakby wskoczy w momencie wpisania tam nowego wektora. Koniec obsługi każdego przerwania NMI jest sygnalizowany dwoma instrukcjami;
BIT $DD0D
RTI
To gwarantuje poprawne wyjście z przerwania.
   Podsumowując stwierdzamy, że oprócz bardzo wygodnego sterowania prędkością, można wykorzystać przerwania do innych celów, sterować obsługą klawiatury bez uszczerbku na jakości digitalizacji. A jeśli przerwania IRQ nie będą do niczego wykorzystywane, najlepiej jest je pozostawić wyłączone (SEI). Może to okazać się przydatne podczas testowania programu.

6. Digitalizacje 8-io bitowe.
   Zdecydowanie najlepszą jakością odznaczają się sample 8-io bitowe. Biją na głowę sample czterobitowe pod względem dynamiki i parametrów szumowych, a także pod względem dokładności kwantowania. Ponieważ dane są zapisane porcjami po 1 bajcie, toteż cała procedura upraszcza się do przepisywania bajt po bajcie. Wykorzystanie do tego znanej komórki SID'a odpada (tzn. jest to technicznie możliwe, lecz tracimy na tym wszystkie zalety sampli ośmiobitowych - trzeba je konwerterować do czterech bitów). Musimy posiadać do tego przetwornik zwany COVOX'em. Jest to szereg rezystorów, dołączanych do USER PORT'u, zamieniających kombinacje bitów na napięcie, które jest w tym wypadku sygnałem akustycznym. Zobaczmy zatem jak wygląda ta procedura.

;-------------------------------------
wektor1  = $fb
wektor2  = $fd
ilosc    = $ff
;-------------------------------------
         lda #$37
         sta $01
;-------------------------------------
         ldx #$00
         stx $d011
         stx ilosc
         dex
         sta $dd03
;-------------------------------------
         sei
         ldx #$81
         stx $dd0d
         ldx #$01
         stx $dd0e
         dex
         stx $dd05
         jsr clear
         lda #<przer
         ldx #>przer
         sta $0318
         stx $0319
         cli
         jmp *
;-------------------------------------
clear    lda poczl
         sta wektor1
         lda poczh
         sta wektor1+$01
         lda konl
         sta wektor2
         lda konh
         sta wektor2+$01
         lda speed
         sta $dd04
         rts
;-------------------------------------
przer    ldy #$00
         inc $01
         lda (wektor1),y
         dec $01
         sta $dd01
         sta $d020
         bit $dd0d
         rti
;-------------------------------------
         inc wektor1
         lda wektor1
         cmp #$00
         bne dalej
         lda wektor1+$01
         cmp wektor2+$01
         beq clr
         inc wektor1+$01
         jmp dalej
clr      jsr clear
dalej    bit $dd0d
         rti
;-------------------------------------
poczh    .byte $10 ;hi bajt (start)
;-------------------------------------
poczl    .byte $00 ;lo bajt (start)
;-------------------------------------
konh     .byte $7f ;hi bajt (koniec)
;-------------------------------------
konl     .byte $ff ;lo bajt (koniec)
;-------------------------------------
speed    .byte $a0 ;ustaw prędkość
;-------------------------------------

   Od razu zauważamy brak części programu odpowiedzialnej za wypełnianie rejestrów SID'a (wyżej wyróżnionej kolorem granatowym). Nie jest to już potrzebne, gdyż rezygnujemy z jego usług. Najważniejsze, byśmy pamiętali o ustawieniu USER PORT'u jako wyjście (wartość $ff do $DD03) oraz wpisywali próbki do USER PORT'u (do $DD01).

7. Co można jeszcze ?
   Można i to naprawdę jeszcze niemało zdziałać w tej sprawie. Chciałbym opowiedzieć o pomyśle mego autorstwa. Jest to powiązanie dwóch powszechnie znanych technik, o których pisałem wyżej. Zaprzęgniemy do pracy przetwornik COVOX, który będzie trzeba przygotować jak do pracy z samplami ośmiobitowymi, ale będziemy tak naprawdę przepuszczać przez niego sample czterobitowe. Dzięki temu uzyskamy jakość bliską samplom ośmiobitowym, a co najważniejsze wszystko odbędzie się przy dwukrotnie mniejszym zużyciu pamięci. Rezygnujemy z usług SID'a, a to oznacza likwidujemy szumy wprowadzane tradycyjnie przez przetworniki SID'a. Jeśli nasz COVOX jest wykonany solidnie i zaopatrzono go w wysokiej jakości układy filtrów, to efekt końcowy jest wielce zadowalający. W niektórych przypadkach można zauważyć lekkie wzmocnienie, podbarwienie tonów lub niewielkie obcięcie wysokich częstotliwości. Właściwie nie należy się tym zbyt przejmować, gdyż jak pokazuje praktyka, w większości przypadków wychodzi to tylko na plus. Należy przyznać, że zawiera się w tym prostota całego przedsięwzięcia - otrzymaliśmy bowiem zespolenie zalet sampli ośmiobitowych z czterobitowymi. Tak wygląda listing.

;-------------------------------------
wektor1  = $fb
wektor2  = $fd
ilosc    = $ff
;-------------------------------------
         lda #$37
         sta $01
;-------------------------------------
         ldx #$00
         stx $d011
         stx ilosc
         dex
         stx $dd03
;-------------------------------------
         sei
         ldx #$81
         stx $dd0d
         ldx #$01
         stx $dd0e
         dex
         stx $dd05
         jsr clear
         lda #<przer1
         ldx #>przer1
         sta $0318
         stx $0319
         cli
         jmp *
;-------------------------------------
clear    lda poczl
         sta wektor1
         lda poczh
         sta wektor1+$01
         lda konl
         sta wektor2
         lda konh
         sta wektor2+$01
         lda speed
         sta $dd04
         rts
;-------------------------------------
przer1   ldy #$00
         inc $01
         lda (wektor1),y
         dec $01
         and #$f0
         sta $dd01
         sta $d020
         lda #<przer2
         ldx #>przer2
         sta $0318
         stx $0319
         bit $dd0d
         rti
;-------------------------------------
przer2   ldy #$00
         inc $01
         lda (wektor1),y
         dec $01
         asl a
         asl a
         asl a
         asl a
         and #$f0
         sta $dd01
         lda #<przer1
         ldx #>przer1
         sta $0318
         stx $0319
         inc wektor1
         lda wektor1
         cmp #$00
         bne dalej
         lda wektor1+$01
         cmp wektor2+$01
         beq clr
         inc wektor1+$01
         jmp dalej
clr      jsr clear
dalej    bit $dd0d
         rti
;-------------------------------------
poczh    .byte $10 ;hi bajt (start)
;-------------------------------------
poczl    .byte $00 ;lo bajt (start)
;-------------------------------------
konh     .byte $7f ;hi bajt (koniec)
;-------------------------------------
konl     .byte $ff ;lo bajt (koniec)
;-------------------------------------
speed    .byte $a0 ;ustaw prędkość
;-------------------------------------

   Zwracam waszą uwagę na wyróżnione czerwonym kolorem fragmenty kodu. Jest to istotne, każda z próbek 4-ro bitowych musi zostać jakby uzupełniona do 8-iu bitów (dane próbki są zawarte w starszym nibble, a młodszy nibble wypełniamy zerami). Tylko w taki sposób otrzyma się wyraźny, głośny dźwięk na wyjściu przetwornika. Naturalnie wcześniej ustawiamy USER PORT jako port wyjściowy (komórka $DD03).

8. Sprawdź to sam.
   Na koniec przygotowałem taką małą prezentację, która pozwoli ocenić Wam zalety i wady różnych technik w samplowaniu. Ten sam oryginalny fragment utworu został zpróbkowany z komputera PC samplerem produkcji BIW. Sampler posiadał zintegrowany moduł COVOX'a wraz z filtrami antyaliasingowymi. Następnie odtworzone fragmenty z pamięci RAM commodore zostały zsamplowane przez kartę dźwiękową komputera PC i zapisane w formacie 22kHz 16 bitów mono. Tak przygotowane pliki możecie posłuchać, ściągając poniższe pliki dźwiękowe.

[16 bit 44,1kHz]

[4 bit sid $70]

[4 bit covox $70]

[8 bit covox $a5]

   Wszystkich zainteresowanych użyciem powyższych programów we własnych prezentacjach polecam zajrzenie na stronę http://www.apidya.filety.net , skąd można skopiować kody źródłowe pod Turbo Assembler.

Autor: Data realizacji: Data publikacji: Data modyfikacji: Pierwsza publikacja:

Reiter (Apidya) - 1.12.2000 - Filety on-line

Instrukcja używania systemu komentarzy    

1. W polu "Podpisz się" umieszczasz swoje Imię, Nazwisko albo Pseudonim używając znaków alfanumerycznych: A-Z, 0-9 oraz znaków specjalnych, np.: !^<>" ' itp.
   Tagi HTML są nieaktywne.
   
   
2. W polu "Wpisz treść" umieszczasz komentarz używając znaków alfanumerycznych: A-Z, 0-9 oraz znaków specjalnych, np.: !^<>" ' itp. Klawisz ENTER tworzy nowy akapit.
   Tagi HTML są aktywne. Możesz:



Możliwość:	Komenda:	Przykład:
a.   Pogrubić tekst:	<B></B>	Pogrubiony
b.   Pochylić tekst:	<I></I>	Pochylony
c.   Podkreślić tekst:	<U></U>	Podkreślony
d.   Stworzyć indeks górny:	<SUP></SUP>	Indeks górny
e.   Stworzyć indeks dolny:	<SUB></SUB>	Indeks dolny
f.   Użyć czcionki maszynowej:	<TT></TT>	Czcionka maszynowa





Adresy URL wpisujemy w postaci http://nazwastrony.pl, ftp://nazwastrony.pl.
Adresy email wpisujemy w postaci nazwa@nazwa.pl.
Adresy Gadu-Gadu wpisujemy w postaci gg:1234567 (bez spacji).

Proszę pamiętać o domykaniu otwartych tagów.
Przed naciśnięciem przycisku Komentuj, zaznacz checkboks przy jego prawym boku.