NL194874C - Werkwijze en inrichting voor het opslaan van MIDI-informatie in subcodepakketten. - Google Patents

Description

1 194874

Werkwijze en inrichting voor het opsiaan van MIDI-informatie in subcodepakketten

De onderhavige uitvinding heeft betrekking op een stelsel en werkwijze voor het opslaan van MIDI-informatie in subcodepakketten voor codering op een compactdisc met een hoofdkanaal en een subcode-5 kanaal zonder het gedigitaliseerde geluid dat is opgeslagen in het hoofdkanaal te beïnvloeden, door gebruik te maken van wat bekend is als een subcodekanaal van de compactdisc, welk kanaal is gereserveerd voor informatie anders dan gedigitaliseerde compactdisc audiodata. Thans gebruiken compactdiscs 95% van hun capaciteit om gedigitaliseerd geluid op te slaan, waarbij 5% overblijft voor wat wordt genoemd het subcodekanaal of -gebied. Het subcodekanaal, dat correspondeert met ongeveer 30 megabytes datacapaciteit, 10 wordt, voorzover het überhaupt wordt gebruikt, gebruikt voor grafische informatie. In het Journal Audio Engineering Society, Vol. 36, nr. 4, april 1988, is in zijn algemeenheid data-opslag op een compactdisc beschreven. In de publicatie is beschreven hoe muziek opgeslagen wordt op een compactdisc. Daarnaast is beschreven hoe op een dergelijke compactdisc ook andere informatie zoals bijvoorbeeld tracks, beeldmateriaal en ander materiaal op te slaan is. Daarnaast is de werking beschreven van een interactieve CD.

15 Opslag van MIDI-gegevens in het subcodekanaal op de compactdisc wordt echter niet beschreven.

De Japanse octrooiaanvrage JP 62-146470 beschrijft de opslag van muziek op digitale wijze op een magnetische tape. Daarnaast wordt beschreven hoe op de digitale tape additionele informatie geschreven kan worden, zoals een MIDI-code.

EP-A-0.093.969 beschrijft een werkwijze en inrichting voor het opslaan van subcodepakketten op een 20 compactdisc. Deze octrooipublicatie beschrijft echter slechts opslag van audiodata of data die nodig is voor weergave. De opslag van MIDI-data in zijn geheel niet beschreven of gesuggereerd.

Om nieuwe gebruiksmogelijkheden van een audio compactdisc te leveren, biedt de onderhavige uitvinding een stelsel voor het opslaan van MIDI-informatie in subcodepakketten voor codèring op een compactdisc met een hoofdkanaal en een subcodekanaal, omvattende: 25 a) een computer met een direct toegankelijk geheugen, een processor en gekoppeld aan een opslag-orgaan; b) MIDI-bronorganen voor het opwekken van MIDI-signalen; c) eerste interface-organen gekoppeld aan de MIDI-bronorganen en de computer voor het omzetten van de MIDI-signalen in een vorm door het laden in het geheugen om bereikt te worden door de processor; 30 d) programmeerorganen voor het sturen van de werking van de processor en het geheugen om de MIDI-gegevens in het geheugen om te zetten in een aantal subcodepakketten en het schrijven van subcodepakketten naar een opslagmedium in het opslagorgaan; e) tweede interface-organen voor het opzoeken van de subcodepakketten op het opslagmedium en voor het koppelen van een compactdisc-codeerorgaan voor het omzetten van de MIDI-gegevens in de opge-35 zochte subcodepakketten in elektrische signalen die bruikbaar zijn voor het compactdisc-codeerorgaan om de MIDI-gegevens in het subcodekanaal op de compactdisc te coderen. Daarnaast heeft de uitvinding betrekking op een werkwijze voor het opslaan van MIDI-informatie in subcodepakketten voor codering op een compactdisc met een hoofdkanaal en een subcodekanaal gebruikmakende van een computer met een direct toegankelijk geheugen, een processor en gekoppeld aan een opslagorgaan, waarbij de werkwijze de 40 stappen bevat van: a) het opwekken van MIDI-signalen uit een MIDI-bron; b) het omzetten van de MIDI-signalen in een vorm voor het laden in het geheugen om bereikt te worden door de processor; c) het sturen van de werking van de processor en het geheugen om de MIDI-gegevens in het geheugen om 45 te zetten in een aantal subcodepakketten en het schrijven van de subcodepakketten naar een opslagmedium in het opslagorgaan; d) het opzoeken van de subcodepakketten op het opslagmedium en het omzetten van de MIDI-gegevens in de opgezochte subcodepakketten in elektrische signalen voor het coderen van de MIDI-gegevens in het subcodekanaal op de compactdisc. Om grafische subcodedata af te spelen, is het voor een compactdisc- 50 afspeler vereist een grafische decoder te omvatten om de grafische subcodedata te decoderen. Om MIDI-gecodeerde data die is opgeslagen in het subcodegebied beschikbaar te maken voor een MIDI-orgaan, is het noodzakelijk een verbindingsorgaan toe te voegen waarin een kabel vanaf het MIDI-orgaan wordt gestoken in de compactdisc-afspeier en om de afspeler te wijzigen teneinde subcodedecodeerketens te omvatlen. In dit verband zou, indien een compactdisc-afspeier een grafische decoder omvat, de meeste 55 van de vereiste ketens worden omvat in de grafische decoder, indien een grafische decoder niet aanwezig is, zouden de vereiste ketens moeten worden toegevoegd teneinde voordeel te kunnen hebben van MIDI-data die is gecodeerd op een compactdisc volgens de onderhavige uitvinding.

194874 2

Door de MIDI-informatie die is geplaatst om een compactdisc beschikbaar te maken voor een MIDI-'orgaan, kan een gebruiker MIDI-informatie vanaf andere bronnen toevoegen en/of de MJDI-informatie · wijzigen teneinde de geluiden van instrumenten te wijzigen, het geluid van liedjes te herarrangeren, hun tempo en toonaard te wijzigen, en anderszins op creatieve wijze muziek te modificeren voor nieuwe 5 luisterervaringen en educatie. Bijvoorbeeld kan, door de toonaard van een lied te veranderen, worden meegezongen in zijn of haar eigen stembereik, of kan door de MIDI-informatie te richten op een verzameling muziekinstrumenten die verschillen van de oorspronkelijke instrumenten, de gebruiker de orchestratie wijzigen. Dit alles wordt tot stand gebracht zonder op welke wijze dan ook de oorspronkelijke gedigitaliseerde muziek, is geregistreerd op de compactdisc, te beïnvloeden.

10

Figuur 1a toont de opmaak van een subcodedatapakket voor een compactdisc; figuur 1b toont een codeerschema voor het opslaan van MIDI-data in een subcodedatapakket, waarbij 10 bytes MIDI-data per pakket worden gebruikt; figuur 1c toont een codeerschema voor het opslaan van MIDI-data in een subcodedatapakket, waarbij 15 11 byles MIDI-data per pakket worden gebruikt; figuur 1d toont een codeerschema voor het opslaan van MIDI-data in een subcodedatapakket, waarbij 12 bytes MIDI-data per pakket worden gebruikt; figuur 2 is een blokschema dat de componenten toont die nodig zijn om een geschikte inrichting uit te voeren; 20 figuur 3 is een schakelschema voor het implementeren van codeerinterfacelogica 21; de figuren 4a-4h tonen een hiërarchisch schema van een computerprogramma voor het omzetten van ruwe MIDI-data in subcodedata; figuur 5 is een hiërarchisch schema van een computerprogramma voor het lezen van subcodedata die is opgeslagen op een floppy of een harde schijf naar RAM voor toegang door codeerinterfacelogica 21.

25

Audiocompactdiscs reserveren, overeenkomstig een industriële standaard, 5% van de mogelijke data-opslag voor niet-compactdisc-geluid. Met andere woorden, 95% van de mogelijke data-opslag wordt gebruikt om de gedigitaliseerde audio-opname op te slaan. Het gereserveerde 5% gedeelte, dat bekend staat als het subcodekanaal, slaat in feite zuiver numerieke data op in een gespecificeerde opmaak. In het bijzonder 30 wordt data in het subcodekanaal opgeslagen in pakketten van 24 woorden, waarbij elk woord bestaat uit 6 bits, gemerkt R, S, T, U, V en W, respectievelijk, zoals is getoond in figuur 1a. Elk van de bits in het subcodekanaal is één van 6 subkanalen. Details betreffende de opmaak van subcodedata op een compactdisc worden uiteengezet in een document dat bekend staat als het "Red Book”, dat een technische specificatie is vervaardigd door Philips N.V. en Sony Corporation, getiteld "Compact Disc Digital Audio 35 System Description”. De voorgaande details vindt men in het gedeelte getiteld ”Sub Channels R, S, T, U, V and W”.

De uitvinding is gericht op een techniek voor het omzetten van MIDI-informatie die wordt gegenereerd door een MIDI-bron (bijvoorbeeld een keyboard of een sequencer) in subcodedata die kan worden geregistreerd op een verplaatsbare harde schijf of floppy-diskettes voor een daaropvolgende omzetting in 40 signalen die worden ingevoerd in een compactdisc-codeerorgaan dat de MIDI-informatie in het subcodekanaal plaatst. Op een andere wijze kan de subcodedata rechtstreeks worden omgezet in een vorm die bruikbaar is door een compactdisc-codeerorgaan. Een blokschema dat de verschillende componenten illustreert die nodig zijn om de MIDI-informatie om te zetten in data die kan worden gecodeerd in het subcodekanaal van een compactdisc is getoond in figuur 2 als een MIDI-bron 11, een MIDI-interface 13, dat 45 een interfacekaart is om het mogelijk te maken de MIDI-data in te voeren in een computer 15, welke computer 15 de omzetting van MIDI-data in subcodedata uitvoert, een schijf 17 die de subcodedata opslaat, een computer 19 met codeerinterfacelogica 21 voor het genereren van signalen om te worden ingevoerd in een compactdisc-codeerorgaan 23, waarbij het compactdisc-codeerorgaan 23 gedigitaliseerde audiohoofd-kanaaldata en subcodedata plaatst op een compactdisc 25. Volledigheidshalve zijn ook getoond een 50 compactdisc-afspeler met een MIDI-decoder 27 waarvan een uitgang wordt gebruikt om een muziekinstrument 29 aan te sturen.

De MIDI-bron 11 kan elke bron van MIDI-data zijn, zoals een keyboard met een MIDI-poort of een sequencer. Dergelijke componenten zijn gemakkelijk verkrijgbaar bij een verscheidenheid van fabrikanten.

De MIDI-interfacekaart 13 is een in de handel verkrijgbaar product, zoals een Voyetra OP-4000/1 kaart, die 55 is gebaseerd op Roland’s MPU-401 -technologie. De computers 15 en 19 kunnen elke digitale computer voor algemene doeleinden zijn. In de voorkeursuitvoering is een IBM-PC/AT of compatibel hiermee gebruikt. De software die is vereist om de MIDI-data vanaf de kaart 13 om te zetten in subcodedata zal nu worden 3 194874 beschreven. De subcodedata die wordt gevormd door de software in de computer 15 wordt geschreven op • de schijf 17 die een standaard floppy-diskette is of een ander verplaatsbaar medium voor data-opslag. Een verplaatsbaar medium wordt gebruikt omdat de MIDI-data gewoonlijk wordt gevormd op een ander tijdstip en een andere plaats dan die waarop de compactdisc wordt gecodeerd met de gedigitaliseerde 5 compactdisc-audiodata en MIDI-data.

Wanneer de compactdiscs worden vervaardigd, wordt de MIDI-data op de floppy-diskette 17 gelezen door de computer 19 en omgezet door de interfacekaart 21 in de vereiste elektrische signalen die nodig zijn om het compactdisc-codeerorgaan 23 aan te sturen. De interfacekaart 21, zoals is getoond in figuur 3, neemt bytes van MIDI-informatie bevattende subcodedata, welke zijn geladen in RAM 41 vanaf de schijf 17 10 en, onder gebruikmaking van een serie-naar-parallel schuifregister 45, laadt een buffer 47 met R, S, T, U en V subcodedata. Het RAM 41 wordt geladen met de subcodedata onder een programmabesturing (zie appendix 2) die de schijf 17 leest, de data op een bus 42 plaatst voor opslag in het RAM 41. De details betreffende de voorgaande componenten van de kaart 21 liggen binnen het bereik van hen die terzake kundig zijn en zullen bijgevolg hier niet worden uiteengezet. Op soortgelijke wijze is het codeerorgaan 23 15 een standaard compactdisc-mastering/persinrichting, waarbij het noodzakelijk kan zijn deze te wijzigen om de signalen die worden gegenereerd door de interfacekaart 21 te accepteren. De specifieke modificaties die nodig kunnen zijn, zijn afhankelijk van de bijzonderheden van het codeerorgaan en zullen gemakkelijk worden herkend door hen die terzake kundig zijn en zij zullen bijgevolg hier niet worden beschreven.

De details betreffende de software die wordt gebruikt om MIDI-data om te zetten in een vorm die kan 20 worden omgezet in signalen voor gebruik door het codeerorgaan 23 zijn als volgt. Op dit ogenblik is de standaardspecificatie voor MIDI bekend als MIDI 1.0 en deze is gepubliceerd en gedistribueerd door International MIDI Association. Volgens de standaard, wordt MIDI-data verzonden en ontvangen bij snelheden tot 3125 bytes per seconde, waarbij elke byte 8 bits informatie heeft. Anderzijds worden subcodepakketten die, zoals hierboven opgemerkt, bestaan uit 24 zes-bits woorden, overgedragen met 25 300 pakketten per seconde. Ofschoon elk pakket 24 zes-bits woorden heeft, zoals is getoond in figuur 1a, worden slechts de woorden 4-19 gebruikt voor data, voor een totaal van 16 zes-bits woorden of 96 bits per pakket. Aldus kan elk pakket tot 12 acht-bits MIDI-bytes onderbrengen. Echter zouden er, bij 300 pakketten per seconde, met 12 MIDI-bytes per pakket, 3600 MIDI-bytes per seconde zijn, hetgeen de MIDI-specificatie van een maximum van 3125 bytes per seconde overschrijdt. Voorzover niet alle 12 bytes kunnen worden 30 gebruikt, moet het schema voor het plaatsen van MIDI-data in het subcodegebied voorzien in een mechanisme om te waarborgen dat 3125 bytes of minder MIDI-data worden overgedragen per seconde.

Een mechanisme dat kan worden toegepast is het aantal MIDI-bytes te beperken tot niet meer dan 10 per pakket. Op deze wijze zouden, zelfs indien 300 opeenvolgende pakketten uitsluitend MIDI-data bevatten, slechts 3000 bytes MIDI-data kunnen worden overgedragen per seconde. Ofschoon een dergelijke 35 beperking voor de meeste toepassingen adequaat zou zijn, kan het voorkomen dat het wenselijk is om de maximale MIDI-datasnelheid van 3125 bytes per seconde te gebruiken. Indien niet meer dan 11 MIDI-bytes worden toegestaan per pakket, kan aan de 3125 bytes per seconde standaard worden voldaan door het aantal pakketten dat wordt toegestaan om 11 MIDI-bytes te hebben te beperken tot niet meer dan 5 uit 12 (dat wil zeggen, voor telkens 12 pakketten zijn er5x11+7x10= 125 bytes en er zijn 25 groepen van 40 12 pakketten elke seconde ofwel 125 x 25 = 3125 bytes per seconde). Echter, uit praktisch oogpunt is 11 MIDI-bytes per pakket niet praktisch aangezien sequenties van MIDI-commando’s zelden een totaal geven van 11 bytes. Bijvoorbeeld zijn de meest gebruikte MIDI-commando’s NOTE ON en NOTE OFF, die elk 3 bytes zijn, waarvan er vier in een 12-bytes pakket kunnen worden geplaatst. Op een andere wijze kunnen drie van dergelijke commando’s in een pakket worden geplaatst met één MIDI-klok voor een totaal 45 van 10 bytes. Op deze wijze zouden tot 12 bytes kunnen worden geplaatst in elk pakket zolang niet meer dan 125 bytes worden geplaatst in telkens 12 opeenvolgende pakketten.

Indien 12 bytes worden toegestaan in een pakket, moet het werkelijke aantal bytes in een pakket worden geplaatst in woord één van het pakket, dat bekend staat als het commandowoord. Geschikte 10,11 en 12-bytes per pakketschema’s zijn respectievelijk getoond in de figuren 1b-1d. Het schema dat is getoond in 50 de figuren 1c en 1d kan ook worden gebruikt voor minder dan 11 bytes door kleinere aantallen in het No. van het MIDI-bytesveld te plaatsen, en door minder dataruimte te gebruiken. Het schema in figuur 1b kan compatibel worden gemaakt met de schema’s die zijn getoond in de figuren 1c en 1d mits het commandowoord een waarde groter dan 12 bevat, waardoor aldus het schema dat is getoond in figuur 1b wordt geïdentificeerd.

55 Een geschikt programma in C-broncode voor een uitvoering in de computer 15 om MIDI-data van de MIDI-bron 11 om te zetten in geschikte subcodedata is als appendix 1 bijgevoegd. De uitvoeringsvorm die is getoond in appendix 1, gebruikt een codeerschema dat getoond in figuur 1b met 10 bytes MIDI-data per 194874 4 subcodepakket. Wijzigingen in de routine SAVE-SUBCODE voor het coderen van 11 en 12 MIDI-bytes per subcodepakket, zoals is getoond in de figuren 1c en 1d, liggen duidelijk binnen de vaardigheden van een terzake algemeen deskundige. Het doel van het programma is de MIDI-data vanuit de MIDI-bron 11 te plaatsen in een subcodepakket door de vereiste modus, item en commando-invoeren toe te voegen en de 5 zes pariteitswoorden te bepalen en toe te voegen. Een beschrijving van elk van zijn routines is als volgt.

Een hiërarchische kaart die beschrijft welke functie welke subfunctie oproept, is getoond in figuren 4a-4h. In de figuren 4a-4h zijn de verwijzingen naar MPU 401 de MIDI-interfacekaart 13, die zoals eerder is opgemerkt, is gebaseerd op MPU-401 technologie van Roland.

10 MAIN

Hoofdprogramma dat de hoofdfuncties oproept die hierna worden beschreven (accepteert een systeem-gekozen melodiebestandnaam als een commandolijnparameter indien aanwezig).

PUT-MENU

15 Geeft titel, actuele melodie en menu-items weer: "RECORD”, "RECORD WITH CLOCKS", "PLAY", "PLAY WITH CLOCKS”, 20 "SAVE”, "LOAD", "SELECT MENU”, "SAVE SUBCODE DATA", "LOAD SUBCODE DATA”, 25 "QUIT".

RECORD (int MIDI-sync)

Start registratie met MIDI-kloksynchronisatie naar keuze (MIDI-sync = TRUE). Start registratie wanneer MIDI-startcommando is ontvangen vanuit de MIDI-bron 11. Geeft tijdstip en registraties weer tot Esc wordt 30 beroerd, het MIDI-stopcommando wordt ontvangen of buiten geheugen.

Wanneer voltooid, is er een tabel in het geheugen dat de MIDI-gebeurtenissen bevat en het tijdstip waarop elke gebeurtenis werd ontvangen. Het tijdstip wordt geregistreerd als het aantal 1/300 seconden na het tijdstip waarop de aanvankelijke MIDI-gebeurtenis wordt ontvangen. Het geregistreerde tijdstip houdt rechtstreeks verband met in welk subcodepakket de MIDI-gebeurtenis tenslotte zal worden geplaatst (zie 35 SUBCODE-SAVE).

PLAY (int send-clocks)

Start het afspelen met naar keuze het verzenden van MIDI-kloksignalen (send-clocks = TRUE). Roept de gebruiker op een tempo in te voeren indien MIDI-kloksignalen moeten worden verzonden en een melodie 40 werd geregistreerd zonder MIDI-kloksignalen. Start het afspelen wanneer de spatiebalk wordt beroerd, of wanneer MIDI-start wordt ontvangen vanuit de MIDI-bron 11 (indien MIDI-kloksignalen worden uitgezonden) (dit maakt het het mogelijk dat de MIDI-bron 11 gelijktijdig wordt afgespeeld voor verificatie). Geeft tijdstip en spelen weer totdat Esc wordt beroerd, of MIDI-stop wordt ontvangen (indien MIDI-kloksignalen worden verzonden).

45

SAVE-TUNE

Bewaart huidige MIDI-data in huidige melodiebestand (tune-name), in een ruwe opmaak. Voor elke MIDI-gebeurtenis (inclusief kloksignalen), worden acht bytes als volgt bewaard: vier bytes voor tijd (in 1/300 sec vanaf het begin van de melodie), één byte voor MIDI-status, één byte voor een eerste 50 databyte (toetsnummer indien noot-gebeurtenis), één byte voor een tweede databyte (toetssnelheid indien noot-gebeurtenis), en één byte om MIDI-gebeurtenissen te verwerken die langer zijn dan drie bytes. Wanneer er drie bytes zijn wordt de vlag op nul ingesteld. Indien de melodiebestandnaam geen uitbreiding bevat, wordt ”.TUN” toegevoegd. Herinnert de gebruiker indien een bestand met dezelfde naam reeds bestaat om per ongeluk overschrijven te voorkomen.

5 194874

LOAD-TUNE

• Laadt huidige MIDI-data vanuit huidige melodiebestand (tune-name), in een ruwe opmaak. Voor elke MIDI-gebeurtenis in het bestand, worden acht bytes als volgt geladen: vier bytes voor tijd (in 1/300 sec vanaf het begin van de melodie), één byte voor een eerste databyte (frequentiegetal indien noot-5 gebeurtenis), één byte voor een tweede databyte (toetssnelheid indien noot-gebeurtenis), en één byte dat op nul wordt ingesteld voor 3-bytes commando’s. Indien een melodiebestandnaam geen uitbreiding bevat, wordt ”.TUN” toegevoegd. Geeft lengte van de melodie die is geladen weer en een tijdverschuiving van een eerste gebeurtenis.

10 DISP-TIMES

Geeft de lengte van de huidige melodie weer en een tijdverschuiving van de eerste gebeurtenis. SELECT-TUNE

Maakt het de gebruiker mogelijk de huidige melodiebestandnaam (tune-name) te wijzigen, geeft nieuwe 15 huidige melodie weer.

MIDMNTR

Wordt steeds aangeroepen wanneer een onderbreking wordt ontvangen vanuit het interface 13. Leest data vanuit het interface 13 en bepaalt of het een MIDI-gebeurtenis is om te worden geregistreerd, een verzoek 20 voor de volgende MIDI-gebeurtenis om te worden afgespeeld, of een interface 13 bericht, roept vervolgens passende routines op of stelt vlaggen in zoals wordt vereist.

PUT-PACK (long cur-pack, unsigned length)

Berekent pariteitssymbolen voor huidige pakket (pack) van een gegeven lengte (length), en slaat deze en 25 de lengte op in het huidige pakket. Slaat een pakket op in een subcodebestand bij een gegeven pakket-locatie (cur-pack), waarbij FALSE ("onwaar") wordt geretourneerd indien succesvol, anders TRUE ("waar”).

REC-EVENT (char offset)

Ontvangt een MIDI-gebeurtenis vanuit het interface 13 tijdens een registratie en bewaart als MIDI-30 datagebeurtenis, waarbij het gebeurtenistijdstip wordt ingesteid op het huidige tijdstip, nadat een timing-byte die Is ontvangen door MIDI-intr is opgeteld en naar deze routine (offset) is doorgelaten. .Indien de gebeurtenis "data-end” is, wordt ”all-end”-vlag ingesteld om het einde van een registratie aan te duiden. In geval van een registratie met MIDI-kloksignalen (add-clocks = TRUE), worden MIDI-kloksignalen ingevoegd op passende tijdstippen tussen ontvangen gebeurtenissen.

35

SEND-EVENT

Zendt MIDI-gebeurtenissen naar interface 13 tijdens afspelen, waarbij een timingbyte die wordt bepaald door het aftrekken van het huidige tijdstip van het gebeurtenistijdstip wordt toegevoegd. Indien de timingbyte te groot zou zijn, wordt een timing-overloop bericht daarvoor in de plaats naar het interface 13 40 verzonden. Indien het einde van afspeeldata is bereikt, wordt een "data end"-bericht verzonden naar het interface 13. Indien wordt afgespeeld met MIDI-kloksignalen (adjust-tempo = TRUE), worden gebeurtenistijdstippen zodanig ingesteld zodat zij corresponderen met het gewenste afspeeltempo.

REC-MESSAGE

45 Ontvangt een MIDI-systeembericht vanuit het interface 13, waarbij een ”MIDI-stop”-vlag wordt ingesteld indien het bericht "MIDI stop” was. Dit geeft aan dat de MIDI-bron 11 werd stilgezet, en sluit het afspelen voortijdig af.

SEND-RESET

50 Stelt het interface 13 terug, waarbij wordt teruggekeerd naar FALSE indien een terugstelling succesvol is, anders TRUE.

SEND-AND-REC (char command)

Zendt een dataverzoekcommando naar het interface 13 en voert interface 13 responsie terug. Stelt een 55 "waiting-for-response’’-vlag in zodat "MIDI-intr” een responsiebyte zal lezen wanneer het een commando-bevestiging ontvangt.

194874 6 SEND-COM (char command) 'Zendt een commando naar het interface 13, waarbij FALSE wordt geretourneerd indien een overdracht succesvol is, anders TRUE.

5 SEND-DATA (char data)

Zendt een databyte naar het interface 13, waarbij FALSE wordt geretourneerd indien een overdracht succesvol is, anders TRUE.

REC-DATA

10 Ontvangt een databyte vanaf het interface 13, waarbij een databyte wordt geretourneerd indien succesvoi anders 0.

GETSTR (int length, int caps-only)

Geeft huidige waarde van een data-invoerrij (in-text) weer bij een huidige schermpositie, beweegt de cursor 15 naar het einde van de rij, en staat het de gebruiker toe een rij op te maken door "backspace” te gebruiken en tekens in te voeren. Een rij-invoer wordt beperkt tot "length”, en elke alfa-invoer wordt omgezet in hoofdletters indien "caps-only” TRUE is. Retourneert TRUE indien de gebruiker het opmaken verlaat met een return, FALSE indien de gebruiker verlaat met ESC.

20 GETYN

Wacht tot de gebruiker ”Y” (of ”y”) invoert, ”N" (of ”n”) of ESC. Retourneert TRUE indien de gebruiker "Y" (of "y") invoert, anders FALSE.

SAVE-SUBCODE

25 Bewaart huidige MIDI-data in een subcodedatabestand. Roept de gebruiker op met laatst ingevoerde subcodebestandnaam (of systeemgekozen bij het begin), en staat het toe deze te wijzigen. Controleert dat een subcodebestand bestaat, en dat het een veelvoud is van 10 pakketten (240) in lengte. Staat het de gebruiker toe het aantal seconden en frames te wijzigen/in te voeren naar begin van audio, controleert vervolgens dat er genoeg ruimte is in het subcodebestand om alle MIDI-data met die inleiding te bewaren. 30 Deze routine brengt vervolgens de eerste niet-kloksignaal MIDI-gebeurtenis "op één lijn” met de positie in het subcodebestand die synchroon is met het audiobegin. Het bepaalt vervolgens een positie in het bestand die synchroon is met waar het MIDI-kloksignaal voor de eerste niet-kloksignaal MIDI-gebeurtenis zou moeten optreden. Het schrijft een subcodepakket dat een MIDI-kloksignaal in deze positie bevat en baseert de posities van alle kloksignalen en niet-kloksignaalgebeurtenissen die volgen op deze eerste plaatsing. De 35 routine slaat data op in de passende pakketten, waarbij elk pakket dat bedoeld is voor MIDI die niet wordt gebruikt wordt gewist, totdat alle pakketten van de resterende pakketten in het subcodebestand zijn "gepasseerd”. Geeft een foutbericht weer indien alle MIDI-data niet pasten.

De exacte locatie van elke MIDI-gebeurtenis in het subcodedatabestand wordt bepaald door het tijdstip waarop de gebeurtenis optreedt. Dit tijdstip wordt geregistreerd (zie RECORD) in ééndriehonderdste 40 seconden. 300 subcodepakketten worden overgedragen vanuit een compactdisc elke seconde wanneer de schijf wordt afgespeeld. Dientengevolge is de ideale locatie voor een MIDI-gebeurtenis het pakket dat het exacte aantal 1/300 seconde in het subcodebestand is. Indien dit pakket niet is bedoeld voor MIDI, maar bijvoorbeeld is gereserveerd voor grafische doeleinden, krijgt het volgende pakket dat beschikbaar is voor MIDI de gebeurtenis.

45 MIDI-gebèurtenissen worden in een enkel pakket geplaatst, zij omspannen niet pakketten. Bijvoorbeeld zullen de drie bytes van een NOTE-ON-gebeurtenis, een statusbyte, een frequentiebyte en een snelheids-byte, altijd in hetzelfde pakket zijn, de status zal nooit in één pakket zijn terwijl de frequentie en de snelheid in het volgende beschikbare MIDI-pakket zijn. Dit garandeert dat muziekinstrumenten de NOTE-ON-gebeurtenis zullen ontvangen zonder een significante vertraging tussen bytes.

50 De bytes van MIDI-data worden geformatteerd in subcodepakketten van 24 woorden waarbij er zes bits in elk woord zijn, hetgeen volledig compatibel is met compactdisc-subcode voor grafische voorstellingen. De bit-voor-bit wijze van lormatteren van de MIDI-data wordt beschreven in de figuren 1b tot en met 1d.

PUT-PACK (long cur-pack, unsigned length) 55 Berekent pariteitssymbolen voor huidige pakket (pack) van een gegeven lengte (length) en slaat deze in de lengte op in het huidige pakket. Slaat pakket op in subcodebestand bij gegeven pakketlocatie (cur-pack), waarbij FALSE wordt geretourneerd indien succesvol, anders TRUE.

7 194874

LOAD-SUBCOD

* Laadt huidige MIDI-data vanuit subcodedatabestand. Roept gebruiker op met laatst ingevoerde subcode- bestandnaam (of systeemgekozen bij start), en maakt het mogelijk deze te veranderen. Controleert dat subcodebestand bestaat en dat het een veelvoud van 10 pakketten (240) in lengte is. Het laadt MIDI-data 5 vanuit een subcodebestand met de gewenste bandbreedte, totdat alle pakketten in het subcodebestand zijn ’’doorgelaten”. Het laden wordt slechts gebruikt om de vervorming (voorzover aanwezig) te controleren die wordt opgewekt door het subcodevertalen.

GET-PACK (long cur-pack) 10 Laadt huidige pakket (pack) vanuit gegeven subcodebestandpakketpositie (cur-pack). Retourneert FALSE indien succesvol, anders TRUE.

CALQPAR

Berekent q-pariteit volgens het "Red Book”.

15

CALPAR

Berekent niet-q (”p”)-pariteit volgens het ’’Red Book”.

Een geschikt programma in C-broncode en Microsoft Macro-assembleerprogramma voor uitvoering in computer 19 om subcodedata vanaf een bestand op een harde of een floppy-schijf 17 over te brengen naar 20 het willekeurig toegankelijke geheugen (RAM) van de computer is als appendix 2 bijgevoegd. De data in het RAM wordt vervolgens benaderd door codeerinterfacelogica 21 door rechtstreeks geheugentoegang (DMA) en aangeboden aan een compactdisc-codeerorgaan 23 als parallelle elektronische signalen. Het codeer-orgaan 23 gebruikt deze signalen in samenhang met hoofdkanaal audiodata vanuit een andere bron, teneinde de moeder te snijden voor een digitale audiocompactdisc met subcodedata.

25 Een beschrijving van elk van de routines van het programma volgt hierna. Een hiërarchische kaart waarin wordt beschreven welke functie welke subfunctie oproept is getoond in figuur 5.

MAIN()

Verzoekt en ontvangt de bestandsnaam voor de subcodedata op een harde of een floppy schijf 17. Het laat 30 deze naam door naar de ”afspeel”-routine die feitelijk de data-overdracht leidt. Na een "return”, vraagt "main” om een andere bestandsnaam en wordt de operatie herhaald totdat deze wordt gestopt door een "control C" of een "control break".

PLAYBACK (filename) 35 Deze routine opent het bestand van subcodedata en keert terug indien er een fout is. Indien er geen fout is, roept het "dmaseton” aan die de codeerinterfacelogica 21 initialiseert om te beginnen met het naderen en het overdragen van data naar het codeerorgaan 23 wanneer de kaart een elektronisch signaal ontvangt om dit te doen. "Playback” roept dan "readdat" aan die data vanuit het bestand leest, synchronisatiebytes toevoegt overeenkomstig het "Red Book” en die de data naar één van twee databuffers in RAM beweegt. In 40 de huidige uitvoeringsvorm van het programma is elke databuffer 8134 bytes en in staat om 83 subcode-datapakketten vast te houden. Een andere oproep voor "readdat” wordt gebruikt om de tweede buffer te vullen, de "waitint” wordt opgeroepen die wacht voor een signaal vanuit het codeerorgaan. Wanneer dat signaal wordt gedetecteerd roept "playback” "readdat” weer op om de eerste buffer opnieuw te vullen en ’’waitint” om te wachten voor een signaal dat de tweede buffer is gelezen en overgedragen. Dit proces zet 45 zich voort met data die wordt gelezen in een buffer, terwijl de codeerinterfacelogica 21 data vanuit de andere buffer overdraagt totdat alle data vanuit het bestand is overgedragen. "Playback” roept "dmaoff” aan om de activiteit van interfacelogica 21 effectief af te sluiten, en sluit het schijfbestand dat subcodedata bevat en keert terug naar "main”.

50 READDAT (bufnum)

Aan deze routine wordt "bufnum” doorgelaten, dat aangeeft of de data zou moeten worden overgedragen naar de tweede of de eerste buffer. "Readdat” begint door het lezen van data ter waarde van 83 pakketten vanuit het subcodebestand op de schijf 17. Aangezien het schijfbestand geen synchronisatiebytes S0 en S1 bevat (toegelicht in het "Red Book”), zijn er slechts 96 bytes voor elk pakket in het bestand. Aldus probeert 55 het programma 83 x 96 bytes = 7968 bytes te lezen. Indien er minder dan 7968 bytes over zijn in het bestand, ongeacht de data die er is op het bestand dat wordt ingelezen, worden binaire nullen toegevoegd om het einde van de data op te vullen tot 7698 bytes. Indien de leespoging geen data detecteert (zoals in 194874 8 de lezing na een gedeeltelijke lezing), keert het programma terug naar "playback” met een einde-bestandstatus.

De data die is gelezen vanuit het bestand wordt pakket-voor-pakket, bewogen naar het buffergebied dat wordt aangeduid door "butnum”. Vooralgaande aan elke beweging naar de buffer, worden een SO byte en 5 een S1 byte toegevoegd voor de 96 bytes datalezing, hetgeen een beweging maakt van 98 bytes naar de buffer. Op deze wijze bevat de butler alle SO en S1 data die nodig is voor het codeerorgaan.

DMASETONO

Begint kanaal 1 DMA vanaf 2c00:0 tot 2c00:(83 * 98)d-doorrolmodus. Roept ”dma-on” op om feitelijk het 10 DMA-besturingsorgaan van de computer 19 te initialiseren en het DMA-kanaal op te stellen.

DMA-ONO

Stelt DMA-kanaal 1 op voor een 7,35 kHz overdracht van subcodebytes naar de codeerintërfacelogica 21. De details hiervoor kunnen worden gevonden in de IBM PC Technical Reference Guide.

15

DMA-OFFO

Stopt DMA op kanaal 1 (subcode) door ch 1 maskerbit in te stellen.

WAIT-INTO

20 Wacht voor een verandering in het bit 15 van de DMA van het besturingsorgaan van het uitvoertelregister dat wordt benaderd onder gebruikmaking van een routine ”get-dma-count” (aangevende een bufferrandkruising-einde buffer).

GET-DMA-COUNTO

25 Leest de inhoud van het resterende telregister van DMA-kanaal 1 en retourneert de telling.

Appendix 1 r 30 Three files comprise the source: midiator.c midisubc.c midiglob.c 35 Compile midiator.c with: tcc -c -ml -K -lc:\turboc\include midiator.c

Compile midisubc.c with: tcc -c -ml -K -lc:\turboc\indude midisubc.c 40

Link with: tlink c:\turboc\lib\c01.obj /x midiator midisubc.midiator,, c:\turboc\lib\emu c:\turboc\lib\math c:\turboc\lib\cl (all on one line of course!) 45 or use clmidi.bat to compile and link either midiator or midisubc: clmidi midiator or clmidi midisubc 50 7 flinclude ’’midiglob.c" Γ----------------**********-------- 55 void main()

Hoofdprogramma accepteert systeem-gekozen melodiebestandnaam als commandolijnparameter 9 194874 ·«·········*··«·«···*·«·*·«·**····«·*········*··* + ·**»* / * void main(int argc, char ’argv[]) \ if (argc > 1) 5 strcpy(tune_name, argv[1]); else strcpy(tune_name,DEFAULT_TUNE_NAME); strcpy(subc_name, DEFAULT_SUBC_NAME); 10 strcat(subc_name,”.”); strcat(subc_name,SUBC_EXT); percent = DEFAULT_PERCENT; 15 start_second = 10; startJrame = 0; textcolor(NORMAL_COLOR); textbackground(NORMAL_BACK); 20 clrscrO; start_event = (event huge *) farcalloc((unsigned long) MAX_EVENT,sizeof(event)); end_event = start_event; if (start_event == (event b ge *) NULL) 25 \ printf(”%ld bytes of free memory required, only %lu available\n”,(unsigned long) MAX_EVENT*sizeof(event),farcoreleft()); exit(1); ) 30 waiting_for_resp = FALSE; add_clocks = FALSE; adjust_tempo = FALSE; send_reset(); 35 setvect(8+IRQ_NO,midi_intr); outportb(0x21,(inportb(0x21) & -(1 « IRG_NO))); send_com(MEASURE_END_OFF_CMD); send_com(MIDI_THRU_OFF_CMD); send_com(REAL_TIME_ON_ CMD); 40 send_com(AFFECTATION_OFF_CMD); Γ

Ignore pitch wheel and continuous controller information for now! 45 send_com(BENDER_ON_CMD); */ quit = FALSE; not_saved = FALSE; 50 cur^opt = 0; put_menu(); do { gotoxy(MENU_COL+strlen(menu_text[cur_opt]),MENU_LINE + (cur_opt « 1)); 55 ch = bioskey(O); if ((ch & OxOOff) = 0) { 194874 10 gotoxy( 1 ,ERR_LINE); clreol(); switch ((ch & OxffOO) » 8) < 5 case UP: it (cur_opt > 0) cur_opt--; else cur.opt = MENU.OPT-1; 10 put_menu(); break; case DOWN: if (cur_opt < MENU_OPT-1) cur_opt++; 15 else cur_opt = 0; put_menu(); break; } 20 } else if ((ch & OxOOff) == ENTER) < gotoxy(1 ,ERR_LINE); 25 clreol(); switch (cur_opt) ( case 0: record(FALSE); 30 break; case 1: record(TRUE); break; case 2: 35 play(FALSE); break; case 3: play(TRUE); break; 40 case 4: save_tune(); break; case 5: load_tune(); 45 break; case 6: select_tune(); break; case 7: 50 save_subcode(); gotoxy(1,STATUS_LINE); clreolO; break; case 8: 55 load_subcode(); disp_times(); break; 11 194874 case 9: if (not_ saved) \ gotoxy(1,STATUS_LINE); 5 cputs(”Tune not saved since last record, quit anyway (Y/N)?”); if (IgetynQ) gotoxy(1,STATUS_LINE); clreol(); 10 break; ) } quit = TRUE; break; 15 } } } while (Iquit); send_reset(); farfree((void far *) start_event); 20 clrscr(); } Γ..................**’*................******.........

void put-menu() 25

Geeft titel, huidige melodie en menu-items weer ..................................*..................../ void put_menu() 30 { int opt; gotoxy(25,1); textcolor(TITLE_COLOR); 35 textbackground(TITLE_BACK); cputs(”MIDI TO SUBCODE DATA CONVERSION"); textcolor(HIGHLIGHT_COLOR); textbackground(HIGHLIGHT_BACK); gotoxy(28,2); 40 cputsC'CURRENT TUNE IS”); cputs(tune_name); textcolor(NORMAL_COLOR); textbackground(NORMAL_BACK); clreol(); 45 for (opt = 0; opt < MENU.OP7; opt++) i gotoxy(MENU_COL,MENU. LINE + (opt « 1)); if (opt == cur_opt) { 50 textcolor(SELECT_COLOR); textbackg round(SE LECT_ B ACK); } cputs(menu_text[opt]); textcolor(NORMAL_COLOR); 55 textbackground(NORMAL.BACK); } gotoxy(MENU_COL+strlen(menu_text[cur_opt]),MENU_LINE + (cur_opt « 1)); 194874 12 t Γ...................................................** void record (int midi-sync) 5

Start registreren met midikloksynchronisatie naar keuze (midi-sync = TRUE). Start registratie wanneer midi-start wordt ontvangen vanuit sequencer. Geeft tijdstip en registraties weer totdat Esc wordt beroerd, midi-stop wordt ontvangen of buiten geheugen.

10 .......................********......................../ void record(int midi_sync) { unsigned int tempo_count.last_clock; int auto_detect; 15 long tempoJotal; float tempo_flt; cur_event = start_event; num_event = 0; 20 run_stat = 0; midijime = 0; next_clock = 0; tempo_total = 0; tempo_count = 0; 25 all.end = FALSE; if (midi_sync) { in_text[0] = \0’; do 30 { gotoxy(1 ,STATUS_LINE); cputs(”Enter tempo, or return for autodetection : ’’); getstr(6,TRUE); if (in_text[0] == \0’) 35 { auto_detect = TRUE; break; } else 40 ( auto_detect = FALSE; tempojlt = atof(in_text); } gotoxy(1 ,ERR_LINE); 45 clreol(); if (tempojlt < MIN_TEMPO II tempo_flt > MAX_TEMPO) cprintffT empo must be in range %d - %d”,MIN_TEMPO,MAX_TEMPO); else break; 50 } while (TRUE); send_com(MIDLCLK_CMD); add_clocks = TRUE; } else 55 ( auto_detect = FALSE; tempojlt = SYNC_TEMPO; 13 194874 send_com(iNT_CLK_CMD); send_com(SET_TEMPO_CMD); send_data(SYNC_TEMPO); } 5 send_com(CLOCK_ON_CMD); send_com(SET_ACTIVE_TRACKS_CMD); send_data(OxOO); send_com(AFFECTATION_ON_CMD); send_com(START_REC_CMD); 10 gotoxy(1,STATUS_LINE); cireoiQ; cputs(”Slart sequencer, or hit Esc to abort”); while (midi_time == 0 && !all_end) < 15 if (bioskey(1)) if ((char) bioskey(O) == ESC) break; ) clock = 0; 20 last_clock = 0; if (midi_time != 0) < gotoxy(CLOCK_COL1 ,CLOCK_LINE1); clreol(); 25 gotoxy(1 ,STATUS_LINE); clreol(); cputs(”Recording, stop sequencer or hit Esc to abort”); not_saved = TRUE; while (!all_end) 30 { if (bioskey(1)) if ((char) bioskey(O) == ESC) break; if (clock != last_clock) ( 35 if (num_event == MAX_EVENT) ( gotoxy(1 ,ERR_LINE); cputs(”Out of memory during record”); break; 40 ) if (auto_detect) < if (clock == 1) ( 45 tempo = send_and_rec(GET_TEMPO_CMD); tempojotal += tempo; termpo_flt = tempo; i else 50 tempo_total += send_and_rec(GET_TEMPO_CMD); tempo_count++; } last_clock = clock; gotoxy(CLOCK_COL1 ,CLOCK_ LINE1); 55 cprintf(”Time =%2d:%02d”,(int)((clock » 1)/ tempo_flt),((int) (((clock » 1) * 60) / tempojlt)) % 60);

J

194874 14 } send_com(STOP_REC_CMD I WITH_MIDI_STOP); send_com(AFFECTATION_OFF_CMD); send_com(CLOCK_OFF_CMD); 5 gotoxy(1 ,STATUS_LINE); clreol(); end_event = cur_event; add_clocks = FALSE; if (midi_sync) 10 { if (auto_detect) if (tempo_count == 0) tempojlt = SYNC_TEMPO; else 15 tempojlt = (tempoJotal + (tempo_count » 1))/ tempo_count; gotoxy(1 ,STATUS_LINE); clreol(); cprintffAdjusting tempo to %3.2f” .tempojlt); for (cur_event = start_event; cur_event < end_event; cur_event++) 20 cur_event->time = (cur_event->time * SYNC_TEMPO) / tempojlt; } gotoxy(1 ,STATUS_LINE); clreol(); dispjimes(); 25 } r..................*...........................—*** void play(int send-clocks) 30 Start afspelen met naar keuze verzenden van midikloksignalen (send-clocks = TRUE). Roept de gebruiker op een tempo in te voeren indien midikloksignalen moeten worden verzonden en een melodie werd geregistreerd zonder midikloksignalen. Start het afspelen wanneer spatiebalk wordt beroerd, of wanneer midi-start wordt ontvangen vanuit sequencer (indien midi-kloksignalen moeten worden verzonden) (dit staat het toe de sequencer gelijktijdig af te spelen voor verificatie. Geeft tijdstip en spelen weer tot dat Esc wordt 35 beroerd, of midi-stop wordt ontvangen (indien midikloksignalen zijn verzonden).

......................................................./ void play(int send_clocks) { 40 long tot_clocks,tot_packs,long_value; if (end_event == start_event) { gotoxy(1 ,ERR J.INE); 45 clreol(); cputs(”Nothing to play”); return; } if (send_clocks) 50 { tot_ clocks = 0; for (cur_event = start_event; cur_event < end_event; cur_event++) if (cur_event->status == MIDLCLOCK) ( 55 tot_ clocks+4; tot_packs = cur_event->time; t

J

15 194874 it (tot_packs == O H tot_clocks == 0) ( in_text[0] = \0’; do 5 < gotoxy(1 ,STATUS_LINE); cputs(” Recorded without clocks, enter tempo : getstr(3,TRUE); tempo = atoi(in_text); 10 gotoxy(1 ,ERR_LINE); clreol(); if (tempo < MIN.TEMPO II tempo > MAX_TEMPO) cprintf(”7empo must be in range %d - %d”,MIN_TEMPO,MAX_TEMPO); else 15 break; } while (TRUE); } else { 20 long.value = ((tot_clocks + 12L) / 24L) * PACKS_PER_MINUTE; tempo = (long_value + (tot_packs » 1))/ tot_packs; } adjustjempo = TRUE; } 25 else tempo = SYNC.TEMPO; cur.event = start_event; run_stat = 0; midi_time = 0; 30 all_end = FALSE; midi_stop = FALSE send_com(INT_CLK_CMD); send_com(SET_TEMPO_CMD); send_data(tempo); 35 send_com(CLOCK_ON_CM D); send_com(SET_ACTIVE_TRACKS_CMD); send_data(0x01); send_com(CLEAR_COUNTERS_CMD); send_com(AFFECT ATION_ON_ CMD); 40 gotoxy(1,STATUS_LINE); clreol(); if (send_clocks) cputsf’Hit space bar to start, Esc to abort”); else 45 cputs(”Start sequencer or hit space bar to start, Esc to abort”); do ( if (bioskey(1)) ( 50 if (((ch = bioskey(O)) & OxOOff) == ESC) break; if ((ch & OxOOff) == ' ’) ( send_com(AFFECTATION_OFF_CMD); 55 send_com(START_PLAY_CMD I WITH_MIDI_START);

J

J

194874 16 } while (midLtime == 0 && !all_end); clock = 0; if (midLtime != 0) ( 5 gotoxy(1,STATUS_LINE); clreol(); if (send_clocks) cputs("Playing, hit Esc to abort”); else 10 cputs(”Playing, stop sequencer or hit Esc to abort”); while (!all_end && !midi_stop) { if (bioskey(l)) if ((char) bioskey(O) == ESC) break; 15 gotoxy(CLOCK_COL1 ,CLOCK_LINE2); cprintf(”Time =%2d:%02d”,(int)((clock » 1) / tempo),(int)((((clock » 1) * 60) / tempo)) % 60); } } send_com(STOP_PLAY_CMD I WITH_MIDI_STOP); 20 send_com(AFFECTATION_OFF_CMD); send_com(CLOCK_OFF_CMD); adjust_tempo = FALSE; gotoxy(CLOCK_COL1 ,CLOCK_LINE2); clreolO; 25 gotoxy(1 ,STATUS_LINE); clreol(): } Γ..............................................—...

30 void save-tune()

Bewaart huidige midi-data in huidige melodiebestand (tune-name), in ruwe opmaak. Voor elke midi-gebeurtenis (inclusief kloksignalen), worden acht bytes bewaard, vier bytes (lang) voor het tijdstip (in aantal 1/300 sec vanaf het melodiebegin), één byte voor midi-status, één byte voor een eerste databyte (toets 35 nummer indien een nootgebeurtenis), één byte voor een tweede databyte (toets snelheid indien noot- gebeurtenis), en één byte dat thans niet wordt gebruikt (ingesteld op nul). Indien een melodiebestandnaam geen uitbreiding bevat, wordt ”.TUN” toegevoegd. Herinnert gebruiker indien bestand reeds bestaat, teneinde het mogelijk te maken dat overschrijven wordt vermeden.

40 ------------------------------------------—....., void save_tune() { char file_name[80]; 45 if (end_ event == start_event) ( gotoxy(1 ,ERR_LINE); clreol(); cputsfNothing to save”); 50 return; i strcpy(f ile_name,tune_name); if (strchrffile.name,’.’) == NULL) ( 55 strcat(file_name,”.”); strcat(file_name,TUNE_EXT); } 17 194874 ii ((midijiie = open(fiie_name,0_RDONLY)) i= -1) { close(midi_file); gotoxy(1,STATUS_LINE); 5 cprintf(”%s already exists, overwrite (Y/N)?”,file_name); if (!getyn()) ( gotoxy(1,STATUS_LINE); clreol(); 10 return; } } if ((midijiie = open(file_name,0_WRONLY I 0_TRUNC I O CREAT I 0_BINARY,S_IREAD I SJWRITE)) == •1) 15 { gotoxy(1 ,ERR_LINE); clreol(); cprintf("Error opening file %s",file_name); } 20 else { gotoxy(1,STATUS_LINE); clreol(); cprintffSaving %s”,file_name); 25 not_saved = FALSE; for (cur_event = start_event; cur_event < end_event; cur_event++) if (write(midi_file,(void *) cur_event,8) == -1) { gotoxy(1 ,ERR_LINE); 30 clreol(); cprintf(”Error writing to file %s”,file_name); cur_event = end_event; } close(midi_file); 35 gotoxy(1 ,STATUS_LINE); clreol(); } } 40 /’***’*............*...................................

void Load*tune()

Laadt huidige midi-data vanaf huidige melodiebestand (tune-name), in een ruwe opmaak. Voor elke midi-gebeurtenis in een bestand, worden acht bytes geladen, vier bytes (lang) voor het tijdstip (in 1/300 45 seen vanaf het melodiebegin), één byte voor midi-status, één byte voor een eerste databyte (toets nummer indien een nootgebeurtenis), één byte voor een tweede databyte (toets snelheid indien een noot-gebeurtenis), en één byte dat thans niet wordt gebruikt (ingesteld op nul). Indien een melodiebestandnaam geen uitbreiding bevat, wordt ”.TUN” toegevoegd. Geeft lengte een melodie die is geladen weer en een SMPTE-verschuiving van eerste gebeurtenis.

50 ......*...............

void load_tune() ( char file_name[80]; strcpy(f ile_ name,tune_name); if (strchr(file_name,\‘) == NULL) 55 194874 18 \ étrcat(file_name,”.”); strcat(file_name,TUNE_EXT); } 5 if ((midijile = open(file_name,0_RDONLY I 0_BINARY)) == -1) { gotoxy(1 ,ERR_LINE); clreol(); cprintf(”Error opening file %s”,file_name); 10 } else { gotoxy(1 ,STATUSJJNE); cprintf(”Loading %s”,file_name); 15 not_saved = FALSE; cur_event = start_event; while (read(midi_file,(void *) cur_event,8) != 0) { cur_event++; 20 } close(midLfile); end_event = cur_event; disp_timesO; } 25 } r........*-----------------------*—**********—** void disp-times() 30 Geeft lengte van huidige melodie weer en SMPTE-verschuiving van eerste gebeurtenis.

.......................*-----********----- void disp_times() { 35 long loadjime; if (end_event == start_event) loadjime = 0; else { 40 cur_event = end_event; cur_event--; loadjime - cur_event->time; } gotoxy(CLOCK)_COL1,CLOCKJ.INE1); 45 cprintf(”Time =%2d:%02d”,(int) (loadjime / ((SYNC_TEMPO « 1) * 60)). (int) ((loadjime / SYNC_TEMPO « 1)) % 60)); for (cur_event = start_event; cur_event != end_event; cur_event++) if (cur_event->status != MIDI_CLOCK)break; gotoxy(CLOCK_COL2,CLOCK_LINE1); 50 if (cur_event == end_event) cputs(”No events ”); else cprintf(”1st event =%2d:%02d:%02d”.

(int) (cur_event->time / ((SYNC_TEMPO « 1) * 60)), 55 (int) ((cur_event->time / (SYNC_TEMPO « 1)) % 60), (int) ((cur_event->time / ((SYNC_TEMPO « 1) / 30)) % 30)); gotoxy(1 ,STATUS_LINE); 19 194874 , clreolO: } r.....................................................

5 void select-tune()

Staat het de gebruiker toe huidige melodiebestandnaam (tune-name) te wijzigen, geelt nieuwe huidige melodie weer.

10 ........*............................................../ void select_tune() i gotoxy(1 ,STATUS_LINE); cputs(”Enter tune name, or Esc to abort: ”); 15 strcpy(in_text,tune_name); if (getstr(0,TRUE)) strcpy(tune_name,in_text); gotoxy(1 ,STATUS_LINE); clreol(); 20 textcolor(HIGHLIGHT_COLOR); textbackground(HIGHLIGHT_BACK); gotoxy(28,2); cputs("CURRENT TUNE IS "); cputs(tune_name); 25 textcolor(NORMAL_COLOR); textbackground(NORMAL_BACK); clreolO; } 30 /*************.........................................

void interrupt midi-intr()

Wordt opgeroepen steeds wanneer een onderbreking wordt ontvangen vanuit MPU-401. Leest data vanuit MPU-401 en bepaalt of het een midi-gebeurtenis is om te worden geregistreerd, een verzoek voor een 35 volgende midi-gebeurtenis om te worden afgespeeld, of een MPU-bericht, roept vervolgens passende routines op of stelt vlaggen zoals wordt vereist.

*****................................................../ void interrupt midi_intr() 40 { char response; response = inportb(DATA_PORT); if (response < OxfO) 45 rec_event(response); else switch(response) ( case SEND_DATA_RESP: 50 send_event(); break; case OVRFLW_RESP: midLtime += OVRFLW_CLKS, break; 55 case END.RESP: all_end = TRUE; break; 194874 20 case CLK_RESP: clock+4; break; case ACK_RESP: 5 cmd_ack = TRUE; if (waiting_for_resp) { resp_data = rec_data(); waiting_for_resp = FALSE; 10 } break; case MESSAGE_RESP: rec_message(); } 15 outportb(0x20,0x20); } r...........*---------------**—****--------******** void rec-event(char offset) 20

Ontvangt midi-gebeurtenis vanuit MPU-401 tijdens registratie en bewaart als midi-data-gebeurtenis, waarbij gebeurtenistijdstip en huidige tijdstip worden ingesteld, na het toevoegen van een timingbyte die wordt ontvangen door ”midi-intr” en naar deze routine (offset) doorgelaten. Indien gebeurtenis ”data-end” is, wordt ”all-end”-vlag ingesteld om einde registratie aan te geven. Indien wordt geregistreerd met midikloksignalen 25 (add-clocks = TRUE), worden kloksignalen op passende tijdstippen tussen ontvangen gebeurtenissen ingevoegd.

Opmerking: herinnerd zij dat MPU-401 geen midikloksignalen zal verzenden naar de gastheer, maar noot-timing zal instellen om te passen bij een tempo van ontvangen midikloksignalen.

30 ......................................................./ void rec_event(char offset) i char response: 35 midi_time += offset; if (add_clocks) { while (next_clock <= midi_time) 40 { cur_event->time = next_clock; cur_event->status = MIDLCLOCK; cur_event->1irst_byte = 0; cur_event->second_byte = 0; 45 if (num_event < MAX_ EVENT) { cur_event++; num_event+4; } 50 next_clock += INT_TO_MIDI_CLKS; } } response = rec_data(); if (response < OxfO) 55 { cur_event->time = midi_time; if (response >= 0x80) 21 194874 { run_stat = response; response = rec_data(); ) 5 cur_event->status = run_stat; cur_event->first_byte = response; if (run_stat < OxcO ll run.stat >= OxeO) cur_event->second_byte = rec_data(); else 10 cur_event->second_byte = Q; if (num_event < MAX_EVENT) { cur_event++; num_event++; 15 } } else if (response == END_RESP) all_end = TRUE; 20 } Γ-----------------*—**********------*******-------- void send-event() 25

Zendt midi-gebeurtenissen naar MPU-401 tijdens afspelen, waarbij een timingbyte wordt toegevoegd die wordt bepaald door het aftrekken van het huidige tijdstip van het gebeurtenistijdstip. Indien de timingbyte te groot zou zijn, wordt een timingoverloopbericht naar MPU-401 hiervoor in de plaats verzonden. Indien het einde van afspeeldata is bereikt, wordt een "data end” bericht naar MPU-401 verzonden. Indien wordt 30 afgespeeld met midikloksignalen (adjust-tempo), worden gebeurtenistijdstippen zodanig ingesteld dat zij corresponderen met het gewenste afspeeltempo.

Opmerking: herinnerd zij dat MPU-401 geen midikloksignalen zal ontvangen vanaf de gastheer, maar hen automatisch zal opwekken voor het huidige tempo.

35 void send_event() { char response; 40 long clks_to_next; if (cur_event < end_event) ( while (cur_event->status == MIDI. CLOCK) 45 cur_event+-r; if (adjust_tempo) clksjo_next = ((cur_event->time ’ tempo) / SYNC_TEMPO) - midLtime; else clks_to_next = cur_event->time - midijime; 50 if (clks_to_next < OVRFLW.CLKS) { midijime += clksJo_next; response = clksjo_next; send.data(response); 55 if (cur_event->status != run_stat) ( run_stat = cur_event->status; 194874 22 send_data(cur_event->status); }' send_data(cur_event->first_byte); if (run_stat < OxcO n run_stat >= OxeO) 5 send_data(cur_even1->second_byte); cur_event++; } else ( 10 midi_time += OVRFLW_CLKS; send_data(OVRFLW_RESP); } } else 15 { send_data(0); send_data(END_RESP); } } 20 /..............................*.......................

void rec-message()

Ontvangt midi-systeembericht vanuit MPU-401, waarbij "midi stop”-vlag wordt ingesteld indien het bericht 25 "midi stop” was. Dit geeft aan dat de sequencer werd stilgezet en onderbreekt vroegtijdig het afspelen.

......................................................./ void rec_message() { 30 char response; response = rec_data(); if (response == MIDI_STOP) midi_stop = TRUE; 35 } ƒ***·*·«#**«*·*·******·»»»»»·*·*#*·»*#**#*»**·*·#·*··*# int send-reset() 40 Stelt MPU-401 terug, waarbij FALSE wordt geretourneerd indien terugstelling succesvol is, anders TRUE.

----------------------------.....— int send_reset() { 45 long timeout; outportb(0x21 ,(inportb(0x21) I (1 « IRQ_NO))); outportb(CMD_PORT,RESET_CMD); do 50 { timeout = OL; while ((inportb(CMD_PORT) & 0x80) && timeout < TOO.LONG) timeout ++; } while ((inportb(DATA_PORT) != ACK.RESP && timeout < TOO_LONG); 55 if (timeout == TOO_LONG); { gotoxy(1 ,ERR_LINE); 23 194874 clreol(); cputs(”MPU-401 will not reset”); return(TRUE); } 5 return(FALSE); } r.....*............*.............................**** char send_end_rec(char command) 10

Zendt dataverzoekcommando naar MPU-401, en retourneert MPU-401 responsie. Stelt "waiting-for-response"-vlag in zodat "midi-intr" een responsiebyte zal lezen wanneer het een commandobevestiging ontvangt.

15 ...............*...................................****/ char send_and_rec(char command) { long timeout; 20 waiting_for_resp = TRUE; send_com(command); waiting_for_resp = FALSE; return(resp_data); } 25 Λ--------------------------------------—****— int send-com(char command)

Zendt commando naar MPU-401, waarbij FALSE wordt geretourneerd indien overdracht succesvol is, 30 anders TRUE.

......................................................./ int send_com(char command) { 35 long timeout; timeout = OL; while ((inportb(CMD_PORT) & 0x40) && timeout < TOO_LONG) timeout ++; if (timeout == TOO_LONG) 40 { gotOxy(1 ,ERR_LINE); clreol(); cputsfMPU not ready to receive command”); return(TRUE); 45 } cmd)ack = FALSE; outportb(CMD_PORT,command); timeout = OL; while (!cmd_ack && timeout < TOO_LONG) timeout ++; 50 if (!cmd_ack) gotoxy(1 ,ERR_LINE); clreol(); cprintf("Command %2x not acknowledged",command); 55 returnfTRUE); } return(FALSE); 194874 24 } r.................................................**** int send-data(char data) 5

Zendt databyte naar MPU-401, waarbij FALSE wordt geretourneerd indien overdracht succesvol is, anders TRUE.

............ ........**—*--------*--------**-----**7 10 int send_data(char data) { long timeout; timeout = OL; 15 while ((inportb(CMD_PORT) & 0x40) && timeout < TOO_LONG) timeout ++; if (timeout == TOO_LONG) < gotoxy(1 ,ERR_LINE); clreolO; 20 cprintf(”Data %2x cannot be sent”.data); return(TRUE); } outportb(DATA_PORT,data); return(FALSE); 25 } /-----------------*-----****-------- char rec-data() 30 Ontvangt databyte vanuit MPU-401, waarbij een databyte wordt geretourneerd indien succesvol, anders 0.

.....................******.........

char rec_data() { 35 long timeout; timeout = OL; while ((inportb(CMD_PORT) & 0x80) && timeout < TOO_LONG) timeout ++; if (timeout == TOO_LONG) 40 ( gotoxy(1 ,ERR_LINE); clreol(); cputsfExpected data not recieved”); return(O); 45 ) return(inportb(DAT A_ PORT)); } Γ.........................*.....****.............***** 50 int getstr(int length,int caps-only)

Geeft huidige waarde van data-invoerrij weer (in-text) bij huidige schermpositie, beweegt cursor naar einde rij, en staat het de gebruiker toe een rij op te maken door gebruik te maken van "backspace” en het invoeren van tekens. Rij-invoer wordt beperkt tot "length", en elke alpha-invoer wordt omgezet in indien 55 "caps-only” TRUE is. Retourneert TRUE indien de gebruiker het opmaken verlaat met CR, FALSE indien de gebruiker met ESC verlaat.

25 194874 ·***··«·*·*·······*·····**··««*···«··****«······****·*·/ t int getstr(int length.int caps_only)

K

int start_x.start_y.str_pos; 5 textcolor(INPUT_COLOR); textbackground(INPUT_BACK); start_x = wherex(); start_y = wherex(); 10 cputs(in_text); str_pos = strlen(injext); gotoxy(start_x + str_pos,start_y); do < 15 ch = bioskey(O); if ((ch & OxOOff) != 0) ( ch &= OxOOff; if (isalnum(ch) II ch == 7 II ch == ll ch == ’W) 20 { if (start_x + str_pos < 80 && (str_pos < length II length == 0)) { if (caps_only) ch = toupper(ch); 25 in_text[str_pos] = ch; str_pos++; putch(ch); } } 30 else if (ch == BACKSPACE && str_pos > 0) ( str_pos~; gotoxy(start_x+str_pos,start_y); 35 putch("); } else if (ch == ESC) { 40 in_text[str_pos] = Λ0’; textcolor(NORMAL_COLOR); textbackground(NORMAL_BACK); return(FALSE); } 45 } gotoxy(start_x + str_pos,start_y); } while (ch != ENTER); in_text[str_pos] = ’\0’; textcolor(NORMAL_COLOR); 50 textbackground(NORMAL_BACK); return(TRUE); } ƒ**********♦*************************·*********»******* 55 int getyn()

Wacht voor de gebruiker om ”Y” (of ”y”). ”N" (of ”n”) of ESC in te voeren. Retourneert TRUE indien de 194874 26 gebruiker ”Y” (of ”y”) invoert, anders FALSE.

...................................*..................7 int getyn() 5 < do { ch = bioskey(O) & 0x00ft; if (toupper(ch) == Ύ’) 10 return(TRUE); if (ch == ESC) break; } while (toupper(ch) != ’N'); return(FALSE); 15 } «include <stdlib.h> «include <ctype.h> «include <conio.h> 20 «include <fcntl.h> «include <io.h> «include <stat.h> «include <dos.h> «include <bios.h> 25 «include <alloc.h> «include <float.h> «define TRUE -1 «define FALSE 0 30 «define ESC 0x1 b «define BACKSPACE 0x08 «define ENTER OxOd 35 «define UP 72 «define DOWN 80 Λ maximum input string length 7 «define IN_STR_LEN 80 40 Γ maximum number of midi events 7 «define MAX_EVENT 65000 Γ default filenames and extensions 7 45 «define DEFAULT_TUNE_ NAME ’’MIDIDATA” «define DEFAULT,SUBC_NAME ’’SUBCODE” «define TUNE.EXT ”TUN” «define SUBC_EXT "BIN” 50 Γ default subcode bandwidth 7 «define DEFAULT_PERCENT 50 Γ subcode packs per minute 7

Γ 300 packs per second * 60 seconds = 18000 packs per minute 7 55 «define PACKS_PER_MINUTE 18000L

Γ bytes per subcode pack 7 27 194874

«define BYTES_PER_PACK 24L

Γ desired subcode resolution in packs per second / 2 7 Γ when tempo is set to this value, we have one clock per pack 7 5 Γ 18000 packs per minute /120 clocks per beat = 150 beats per minute 7 «define SYNC_TEMPO 150 Γ minimum and maximum tempos allowed by MPU-401 7 «define MIN.TEMPO 8 10 «define MAX_TEMPO 240

P midi clocks per beat 7 «define MIDI_CLKS_TO_BEAT 24L

15 Γ internal clocks per midi clock 7 Λ 120 internal clocks per beat / 24 midi clocks per beat V «define INT_TO_MIDI_CLKS 5 Γ number of clocks represented by overflow message 7 20 «define OVRFLW_CLKS 240 Γ MIDI real time messages 7 «define MIDLCLOCK 0xf8 «define MIDLSTOP Oxfc 25 Λ MPU-401 response code 7 «define SEND_DATA_RESP OxfO «define OVRFLW_RESP 0xf8 «define END_RESP Oxfc 30 «define CLK_RESP Oxfd «define ACK_RESP Oxfe «define MESSAGE_RESP Oxff Γ MPU-401 commands 7 35 «define STOP_PLAY_CMD 0x04 «define START_PLAY_CMD 0x08 «define STOP_REC_CMD 0x10 «define START_REC_CMD 0x20 «define REAL_TIME_ON_CMD 0x39 40 «define INT_CLK_CMD 0x80 «define MIDI_CLK_CMD 0x82 «define METRO_OFF_CMD 0x84 «define METRO.Of'LCMD 0x85 «define BENDER.ON_CMD 0x87 45 «define MIDI_THRU_OFF.CMD 0x88 «define MEASURE_END_OFF.CMD 0x8c «define AFFECTATION_OFF_CMD 0x90 «define AFFECTATION_ON.CMD 0x91 «define CLOCK_OFF.CMD 0x94 50 «define CLOCK_ON.CMD 0x95 «define GET_TEMPO.CMD Oxaf «define CLEAR_COUNTERS.CMD 0xb8 «define SET_TEMPO_CMD OxeO «define SET_CLK_TO_HOST_RATE_CMD 0xe7 55 «define SET_ACTIVE_TRACKS_CMD Oxec «define RESET.CMD Oxff 194874 28 Γ MPU-401 play/record command extensions 7 «'define WITH_MIDI_STOP 0x01 «define WITH_MIDI_START 0x02 5 Λ MPU-401 hardware defines 7 «define DATA_PORT 0x330 «define CMD_PORT 0x331 «define IRQ.NO 2

10 Γ MPU-401 timeout value 7 «define TOO_LONG 30000L

Λ number of menu options 7 «define MENUJDPT 10 15 Λ colors 7

«define NORMAL_COLOR LIGHTGRAY «define NORMAL.BACK BLACK «define TITLE_COLOR LIGHTBLUE 20 «define TITLE_BACK BLACK

«define SELECT.COLOR LIGHTGRAY «define SELECT_BACK BLUE «define HIGHLIGHT_COLOR YELLOW «define HIGHLIGHT_BACK BLACK 25 «define INPUT_COLOR YELLOW «define INPUT_BACK BLUE

Γ screen positions 7 «define MENUJJNE 4 30 «define MENU_COL 30 «define STATUS_LINE 24 «define CLOCK_LINE1 4 «define CLOCK_LINE2 8 «define CLOCK_COL1 49 35 «define CLOCK_COL2 62 «define ERRJJNE 25 Λ shorthand for exclusive oring 7 «define uxor(a,b) ((a) Λ (b)) 40 typedef struct { long time; char status; char first_byte; char second_byte; 45 char flag; } event;

«ifndef COMMONX

50 char *menu_text[MENU_OPTj = { "RECORD”, "RECORD WITH CLOCKS", ’’PLAY”, "PLAY WITH CLOCKS”, 55 "SAVE”, "LOAD”, "SELECT TUNE”, 29 194B74 , "SAVE SUBCODE DATA”, "LOAD SUBCODE DATA”, "QUIT”}; # define COMMONX 5 #else COMMONX char *menu_text[MENU_OPT]; 10 #endif COMMONX unsigned int ch; COMMONX int midi_file,subc_file; COMMONX int 15 cmd_ack,alLend,midLstop,waiting_for_resp,add_clocks,adjust_tempo; COMMONX int quit,not_saved; COMMONX int cur_opt; COMMONX int percent; COMMONX long clock; 20 COMMONX unsigned int num_event; COMMONX unsigned int tempo; COMMONX char run_stat,resp_data; COMMONX long midi_time,next_clock; COMMONX int start_second,start_frame; 25 COMMONX event huge *start_event; COMMONX event huge *cur_event; COMMONX event huge *end_event; COMMONX char tune_name[80]; COMMONX char subc_name[80]; 30 COMMONX char in_text[IN_STR_LEN+1]; COMMONX unsigned antilog[64); COMMONX unsigned mul6[64]; COMMONX unsigned mul21[64]; 35 COMMONX unsigned mul39[64]; COMMONX unsigned mul18[64]; COMMONX unsigned mull [64); COMMONX unsigned int log[64); 40 COMMONX char pack[24); void put_menu(); void record(int); void play(int); 45 void save_tune(); void load_tune(); void disp_times(); void select.tune(); void interrupt midi_intr(); 50 void rec.event(char); void send_event(); void rec_message(); int send_reset(); char send_and_rec(char); 55 int send_com(char); int send.data(char); char rec_data(); 194874 30 int getstr(int.int); int getyn(); void save_subcode(); int put_pack(long,unsigned); 5 void calqpar(); void calpar(); unsigned multi (), mult(); void load_subcode(); int getpack(long); 10 #define COMMONX extern ^include "midiglob.c” /....................*-------***********----------**·*· 15 void save-subcode()

Bewaart huidige midi-data in subcodedatabestand. Roept gebruiker op met laatst ingevoerde subcode-bestandnaam (of systeem gekozen bij begin), en staat het toe deze te veranderen. Controleert dat subcodebestand bestaat en dat het een veelvoud van 10 pakketten (240) in lengte is. Staat het de gebruiker 20 toe het aantal seconden en frames naar begin van audio te wijzigen/in te voeren, controleert vervolgens dat er genoeg ruimte in het subcodebestand is om alle midi-data met die inleiding te bewaren (dit is slechts een ruwe schatting bij dit punt, aangezien een lage bandbreedte midi-data zou kunnen uittrekken). Staat het de gebruiker toe de bandbreedte (10%, 50%, 90%, 100% te wijzigen/ in te voeren, brengt vervolgens de eerste niet-kloksignaal-midigebeurtenis ”op één lijn” met de positie in het subcodebestand van het tijdstip om audio 25 te starten. Het ’’beweegt terug" naar de positie van het eerdere kloksignaal in de mididata en start het opslaan bij het tijdstip waarop het kloksignaal zal vallen in het subcodebestand, gegeven het eerdere ”op één lijn brengen”. Slaat data op met de gewenste bandbreedte, wist welke pakketten dan ook in het midi-gedeelte van de bandbreedte die niet worden gebruikt, totdat alle pakketten de overige pakketten in het subcodebestand zijn "gepasseerd”. Geeft een foutbericht weer indien alle midi-data niet pasten.

30 ............*.............**.....................*****7 void save_subcode() < char byte_val,mask1 ,mask2,stat_type; 35 long cur_pack1packsJn_file,start_pack,start_midi_pack,first_pack_to_store; int i,m,n,cur_byte,cur_midi_byte,num_midi_bytes,pack_byte,pack_cnt; if (end_event == start_event) \ 40 gotoxy(1,ERR_LINE); clreol(); cputs("Nothing to save”); return; } 45 gotoxy(1 .STATUS.LINE); cputsfEnter subcode file name, or Esc to abort: ”); strcpy(in_text,subc_name); if (Igetstr(O.TRUE)) return; 50 strcpy(subc_name, in text); if (strchr(subc_name,’.’) = NULL) ( strcat(subc_name,”.’’); strcat(subc_name,SUBC_EXT); 55 } if ((subc_file = open(subc^name,0_WRONLY I 0_BINARY)) == -1 31 194874 , { gotoxy(1 ,ERR_LINE); clreol(); cprint1(”Subcode file %s does not exist”,subc_name); 5 return; } if (lseek(subc_file,OL,SEEK_END) == -1L) \ 10 gotoxy(1,ERR_LINE); clreol(); cprintf(”Error writing to subcode file %s”,subc_name); close(subc_file); } 15 packs_in_file = tell(subc_file) / BYTES_PER_PACK; if (packs_in_file % 10L != OL) { 20 gotoxy(1,ERR_LINE); clreol(); cprint1(”Number of packs in subcode file %s is not divisible by ten”,subc_name); close(subc_file); return; 25 } sprintf(in_text1''%d",start_second); while (TRUE) ( 30 gotoxy(1 .STATUSJJNE); clreol(); cputs(”Enter number of seconds to start of audio : ”); if (!getstr(2,TRUE)) ( 35 close(subc_file); return; ) start_second = atoi(in_text); gotoxy(1 ,ERR_LINE); 40 clreol(); if (start_second < 0) cputsfMust be positive”); else break; 45 } sprintf(in_text,”%d”,start_frame); while (TRUE) ( 50 gotoxy(1 ,STATUS_LINE); clreol(); cputs(”Enter number of remaining frames to start of audio : ”); if (!getstr(2,TRUE)) ( 55 close(subc_file); return; } 194874 32 start_ frame = atoi(in_text); gotoxy(1,ERR_LINE); clreol(); if (startjrame < 0 II startjrame >= 30) 5 cputsf’Must be in range 0 - 29”); else break; } 10 start_pack = (start_second * 300) + (startjrame * 10); cur_event = end_event; cur_event-*; 15 if (cur_event->time + start_pack >= packs_injile) { gotoxy(1 ,ERR_LINE); clreolO; cprintf(”Only %ld packs in subcode file %s, %ld needed”, 20 packsjnjile,subc_name,cur_event->time + start_pack + 1); close(subcjile); return; } 25 sprintf(injext,”%d”,percent); while (TRUE) { gotoxy(1 ,STATUS_LINE); clreol(); 30 cputsfEnter percentage of subcode data used for midi (10, 50, 90, or 100): ”); if (!getstr(3,TRUE)) { close(subcjile); return; 35 } percent = atoi(injext); gotoxy(1 ,ERR_LINE); clreol(); if (percent != && percent != 50 && percent != 90 && percent != 100) 40 cputs(”Percentage must be 10, 50, 90 or 100”); else break; } 45 gotoxy( 1 ,STATUS_LINE); clreol(); pack_cnt = 0; antilog[0] = 1; 50 for (n = 1; n <= 63; n++) antilog[n] = multi (antilog[n-1J); for (m = 0; m <= 62; m++) ( n = antilog[m]; 55 log[n] = m; log[0] = 255; 33 194874 for in = η· n <s fi3· mul6[n] = mult(n,3); mul21[n] = mult(n,59); 5 mul39[n] = mult(n,54); mul18[n] = mult(n,15); mul1[n] = mult(n,2); } 10 lor (cur_event = start_event; cur_event != end_event; cur_event++) if (cur_event->status != MIDI_CLOCK) break; start_midi_pack = cur_event->time; if (cur_event != end_event && cur_event!- start_event) cur_event--; 15 first_pack_to_store = (cur_event->time - start_midi_pack) + start_pack; if (percent == 50 II percent == 90) cur_pack = 1; else cur_pack = 0; 20 while (cur_pack < packsjnJile) \ for (i = 4; 1 < 20; i++) pack[i] = 0; cur_byte = 0; 25 while ((cur_event->time - start_midi_pack) + start_pack <= cur_pack && cur_event != end_event) { statjype = cur_event->status & OxfO; if (stat_type < OxcO) 30 num_midi_bytes = 3; else if (statjype < OxeO) num_midi_bytes = 2; else 35 if (statjype < OxfO) num_midi_bytes = 3; else num_midi_bytes = 1; if (cur_byte + num_midi_bytes >10) 40 break; for (cur_midi_byte = 0; cur_midi_byte < num_midi_bytes; cur_midi_byte++) { euiitnh inttr miHi K\/to\ wtmvi * (wvii I * i»\»i_wj »v/ { 45 case 0: byte_val = cur_event->status; break; case 1: byte_val = cur_event->first_byte; 50 break; case 2: byte_val = cur_event->second_byte; break;

J

55 switch (cur_byte) ( case 0: 194874 34 case 3: case 6: case 9: maskl = byte_val » 2; 5 mask2 = (byte_val « 4) & 0x3f; break; case 1: case 4: case 7: 10 maskl = byte_val » 4; mask2 = (byte_val « 2 ) & 0x3f; break; case 2: case 5: 15 case 8: maskl = byte_val » 6; mask2 = byte_val & 0x3f; break; } 20 pack_byte = v + cur_byte + (cur_byte / 3); pack[pack_byte] l= maskl; pack[pack_byte + 1] l= mask2; 25 cur_byte++; } cur_event++; } if (cur_pack >= first_pack_to_store) 30 if (put_pack(cur_pack,cur_byte)) i close(subc_file); return; } 35 pack_cnt++; if (pack_cnt == 100) i pack_cnt = 0; gotoxy(1 ,STATUS_LINE); 40 cprintf(”Writing pack : %)d, hit Esc to abort”,cur_pack); if (bioskey(1)) if ((bioskey(O) & OxOOff) == ESC) close(subcjile); 45 return;

J

J

switch (percent) \ 50 case 10: cur_pack += 10; break; case 50: cur_pack += 2; 55 break; case 90: if (cur_pack % 10L == 9) 35 194874 cur_pack += 2; else cur_pack++; break; 5 case 100: cur_pack++; break;

J

} 10 close(subcjile); ii (cur_event i= end_event; { gotoxy(1 ,ERR_LINE); clreol(); 15 cprintf(”AII midi data did not fit in subcode file %s”,subc_name); } else not_saved = FALSE; } 20 r.....................*.....*........................* int put-pack (long cur-pack, unsigned length)

Berekent pariteitssymbolen voor huidige pakket (pack) van gegeven lengte (length), en slaat deze en de 25 lengte op in het huidige pakket. Slaat pakket in subcode-bestand op bij gegeven pakketlocatie (cur-pack), waarbij FALSE wordt geretourneerd indien succesvol, anders TRUE.

...................................*...............—/ int put_pack(long cur_pack,unsigned length) 30 { int i; long file_off; if (length == 0) 35 for (i = 0; i < 24; i++) pack[i] = 0; else \ pack[0] = 0x3d; 40 pack[1] = 0x15; pack[17] l= length; calqpar(); caiparü; } 45 file_off = cur_pack * BYTES_PER_PACK; 1seek(subc_file,file_otf,SEEK_SET); if (write(subc_file,(void *) pack,24) == -1) 50 ( gotoxy(1 ,ERR_LINE); clreol(); cprintf(”Error writing to subcode file %s”,subc_name); return(TRUE); 55 ) return(FALSE); } 194874 36 Γ calqpar - do the q parity symbols 7 void calqpar() { int n; 5 unsigned a[2); /* will contain the 2 parity symbols*/ unsigned z; Γ see the ’’red book” by Sony and Philips for details on calculating ”q” parity 7 } 10 void calpar() { int n; unsigned a[4]; Γ contains 4 parity symbols 7 f5 unsigned z; Λ see the "red book” by Sony and Philips for details on calculating ”p” parity 7 } 20 unsigned mult(p,q) unsigned p,q; { unsigned z; 25 intpp.qq.zz; if ((p==0) II (q==0)) z = 0; else { zz = log[p] + log[q]; 30 if (zz > 62) zz = zz-63; z = antilog[zz]; } return(z); } 35

void load-subcodeO

Laadt huidige mididata vanuit subcodedatabestand. Roept gebruiker op met laatst ingevoerde subcode-40 bestandnaam (of systeem gekozen bij begin), en staat het toe deze te veranderen. Controleert dat subcodebestand bestaat, en dat het een veelvoud van 10 pakketten (240) in lengte is. Staat het de gebruiker toe de bandbreedte (10%, 50%, 90%, 100%) te wijzigen/in te voeren, laadt vervolgens midi-data vanuit subcodebestand met de gewenste bandbreedte, totdat alle pakketten in het subcodebestand zijn ’’gepasseerd”. Dit zou slechts worden gebruikt met subcodebestanden die zijn bewaard zonder ’’inleiding” 45 (tijdstip starten van audio), aangezien de data in het inleidingsgedeelte zou worden gezien als midi-data, maar dit is OK, aangezien het laden slechts wordt gebruikt om de vervorming die wordt opgewekt door het subcodevertalen te controleren.

......................................................7 50 void load_subcode() \ char byte_val,stat_type; long cur_pack,packs_in_file; int cur_byte,bytes_in_pack,cur_midLbyte,num_midi_bytes,pack_byte,pack_cnt; gotoxy(1 ,STATUS_LINE); cputs(’’Enter subcode file name, or Esc to abort: ”); 55 37 194874 strcpy{in_isxt,s‘ubc_naiTie); if (!getstr(0,TRUE)) return; strcpy (su bc_ name ,in_text); 5 if (strchr(subc_name,7) == NULL) \ strcat(subc_name,”.”) strcat(subc_name,SUBC_EXT); Λ

J

10 if ((subc_file = open(subc_name,0_RDONLY I 0_BINARY)) == -1 < gotoxy(1 ,ERR_LINE); clreolO; 15 cprintffSubcode file %s does not exist”,subc_name); return; } if (lseek(subcJile,OL,SEEK_END) == -1L) 20 { gotoxy(1 ,ERR_LINE); clreol(); cprintf("Error reading subcode file %s",subc_name); close(subc_file); 25 return; Ϊ

J

packs_in_file = tell(subc_file) / BYTES_PER_PACK; 30 if (packs_in_file % 10L != OL) { gotoxy(1 ,ERR_LINE); clreol(); cprintf(”Number of packs in subcode file %s is not divisible by ten”,subc_name); 35 close(subc_file); return; } sprintf(in_text,”%d”,percent); 40 while (TRUE) ( gotoxy(1 ,STATUS_LINE); cputs("Enter percentage of subcode data used for midi (10, 50, 90 or 100): ”); 45 if (!getstr(3,TRUE)) ( close(subcjile); return; } 50 percent = atoi(injext); gotoxy(1 ,ERR_LINE); clreolO; if (percent != 10 && percent != 50 && percent != 90 && percent != 100) cputs(”Percentage must be 10, 50, 90 or 100”); 55 else break;

J

194874 38 gotoxy(1 ,STATUS_LINE); cireol(); pack_cnt = 0; 5 cur_event = start_event; if (percent == 50II percent == 90) cur_pack = 1; else cur_pack = 0; 10 while (cur_pack < packs_in_file) { if (get_pack(cur_pack)) { end_event = cur_event; 15 cose(subcjile); return; } bytes_in_pack = pack[17] & OxOf; 20 cur_midi_byte = 0; cur_byte = 0; while (cur_byte < bytes_in_pack) { 25 pack_byte = 4 + cur_byte + (cur_byte/3); switch (cur_byte) { case 0: 30 case 3: case 6: case 9: byte_val = (pack[pack_byte] « 2) I (pack[pack_byte+1] « 4); break; 35 case 1; case 4: case 7: byte_val = (pack[pack_byte) « 4) I (pack[pack_byte+1] « 2); break; 40 case 2: case 5: case 8: byte_val = (pack[pack_byte] « 6) I pack[pack_byte+1]; break; 45 ] switch (cur_midi_byte) \ case 0: 50 cur_event->status = byte^val; stat_type = byte_val & OxfO; if (stat_type < OxcO) num_midi_bytes = 3; else 55 if (stat_type < OxeO) num_midLbytes = 2; else 39 194874 if (siaijype < OxfO) num_midi_bytes = 3; else num_midi_bytes = 1; 5 break; case 1: cur_event->first_byte = byte_val; break; case 2: 10 cur_event->second_byte = byte_val; break; } cur_midi_byte++; if (cur_midi_byte == num_midi_bytes) 15 { cur_midi_byte = 0; cur_event->time = cur_pack; cur_event++; } 20 cur_byte++; } pack_cnt++; if (pack_cnt == 100) < 25 pack_cnt = 0; gotoxy(1 ,STATUS_LINE); cprintf(”Reading pack : %1d, hit Esc to abort",cur_pack); if (bioskey(1)) if ((bioskey(O) & OxOOff) == ESC) 30 { end_event = cur_event; close(subc_file); return; } 35 } switch (percent) \ case 10: cur_pack += 10; 40 break; case 50: cur_pack += 2; break; case 90: 45 if (cur_pack % 10L == 9) cur_pack += 2; else cur_pack++; break; 50 case 100: cur_pack++; break; ) Ί

J

55 end_event = cur_event; close(subcjile);

T

S

194874 40 Λ.....................................................

int get-pack (long cur-pack)

Laadt huidige pakket (pack) van gegeven subcodebestandpakketpositie (cur-pack). Retourneert FALSE 5 indien succesvol, anders TRUE.

......”**.....*......................................./ int get_pack(long cur_pack) < 10 long tile_off; file.off = cur_pack * BYTES_PER_PACK; lseek(subc_file,file_off,SEEK_SET); 15 if (read(subc_file,(void *) pack.24) == -1) gotoxy(1 ,ERR_LINE); clreol(); cprintf(”Error reading to subcode file %s”,subc_name); 20 return(TRUE); } return(FALSE); } 25 Appendix 2 #define READNT 0x8000 char filename [80]; 30 char pbuffer [16384]; main() { 35 while (1) { printf(”\n File to playback:”); gets (filename); 40 playback (filename); } } ƒ*******·***··«***♦#*********«*******♦***»*♦****·♦****·ƒ 45 #define BUFFER1 0x2c00 «define BUFFER2 0x2dfc Λ «define BUFFER1 0x3000 50 «define BUFFER2 0x31 fc 7 «define SO OxcO «define S1 0x80 55 playback(name) char ’name; 41 194874 . { char z, i, stime[10]; long packs, delay, orig, origs, origb, distance, header = OL;

Tint inthnd();7 5 int filout, wipei, status, flag=1; if ((filout = open(name, READNT)) == -1) {ioerr(”opening”); return;} 10 Γ skip 1st 4 bytes 7 if ((status = read(filout,pbuffer, 48)) < 0) {ioerrf reading length”); return;} if ((status = readdat(1, filout, 1)) < 0) 15 {ioerrfreading 1st 1”); return;} if (status != 0) if ((status = readdat(2, filout, 0)) < 0) {ioerrfreading 1st 2"); return;} 20 printffTO EXIT PLAYBACK PRESS Ctrl.”); Γ wrk 11/20/87 for (wipei = 0; wipei < 96 * 83; wipei++) pbuffer[wipei] = 0; 25 poke(BUFFER1, 0, pbuffer, 96 * 83); poke(BUFFER2, 6, pbuffer, 96 * 83); 7 if ((i = key()) == 4) { 30 if ((status = close(filout)) < 0) ioerrfclosing”); return; } delay = 0L; 35 orig = delay; origs = delay + 1260001 - 6641; origb = delay + 13320001 - 6641; dmaseton(); if (status != 0) 40 { while (1) { if ((i = keyO) == 4) break; 45 WAITJNTOO; if ((status = readdat(1, filout, 0)) < 0) {ioerrfreading 1”); return;} if (status == 0) 50 break, if ((i = key()) == 4) break; WAITJNTOO; 55 if ((status = readdat(2, filout, 0)) < 0) {ioerrfreading 2”); return;} if (status == 0) 194874 42 break; } } 5 WAITJNTO; DMA_OFF(); if ((status = close(filout)) < 0) {ioerrfclosing”); return;} 10 } ƒ*»*··*··»*··»*·····***·***·*·**·*·*♦*********·**«·*·** j readdat(bufnum, filout, skipread) 15 int bufnum, filout, skipread; { int i, status; unsigned offset, offset!, segment, readidx;

20 struct SET

{ char sObyte; char s1 byte; char data96[98]; 25 }; struct SET set1; char *set1 pt; 30 char *readpt; char *topt; if (bufnum == 1) ( 35 segment = BUFFER1; offsetl = 0; } else { 40 segment = BUFFER2; offsetl = 6; } set1 .sObyte = SO; 45 setl.slbyte = SI; setlpt = &set1 .sObyte; offset = offsetl; 50 if (skipread) ( status = 0; } else 55 5 43 194874 { if ((status = read(filout,pbuffer, 96 * 83)) < 0) return(status); ) fort (readidx = 0; readidx < status; readidx++) if (pbuffer[readidx] == Oxff) pbuffer[readidx] = 0; 10 if ((status < 96 * 83) && (status >-1)) for (readidx = status; readidx < 96 * 83; readidx++) pbuffer[readidx] = 0; for (readidx = 0; readidx < 96 * 83; readidx += 96) 15 { readpt = &pbuffer[readidx); topt = &set1.data96[0]; movmem(readpt, topt, 96); setlpt = &set1 .sObyte; 20 poke(segment, offset, setlpt, 98); offset += 98; } if (skipread) return(l); 25 else return(status); } r...................................................../ 30 ioerr(c) char *c; { printf(”/nSorry, there was an error I %s the file.”,c); 35 } /***......................*.........................**7 PAGE, 132 40 TITLE......********* flw DMA INTERFACE TEST PROGRAM 10/23/84“ 45 DATA SEGMENT WORD ’DATA'

50 DATA ENDS

;PAGE, 132 55 ; DMA EQU 0 ; DMA CONTROLLER IS AT IO PORT 0.

194874 44

DMABUF EQU 03000H

DMABUF EQU 02C0OH 5 ; » pgroup group prog prog segment byte public ’PROG’ assume cs:pgroup 10 ; ; begins ch 1 dma from 2c00:0 to 2c00:(83 * 98)d - wrap around mode.

15 dmaseton proc near public dmaseton push bp push es mov bx, DMABUF 20 mov es.bx mov bx,0 mov cx, 83 * 98 * 2 ; 2 buffers of 83*98 each, call DMA.ON pop es 25 pop bp ret dmaseton endp 30 ; ..........DMA CONTROL SOFTWARE .......................

35 BEVAT PROCEDURES OM DMA-BESTURINGSORGAAN CH1 TE INITIALISEREN VOOR UITVOER NAAR L.S DECODEERINTERFACEKAART, STOPT DMA-UITVOER EN WACHT VOOR HUIDIGE AFSPEELBUFFER OM TE WORDEN GELEEGD.

40 DMA-ON

STELT DMA KANAAL 1 OP VOOR 7,35 kHz OVERDRACHT VAN VIDEOSUBCODEBYTES NAAR L.S. DECODEERINTERFACEKAART. GEMODELLEERD NAAR PROC DMA-SET UP IN BIOS FLOPPY SCHIJFCODE.

INVOER: ES: BX HEEFT BEGINADRES VAN UITVOERBUFFERGEBIED.

45 CX HEEFT LENGTE VAN UITVOERBUFFERGEBIED

UITVOER: DMA BESTURINGSORGAAN WORDT GEÏNITIALISEERD EN DMA WORDT GESTART. AUTO INIT MODUS HERLAADT BEGINADRES WANNEER TELSTAND 0 IS.

50 DMA_ON PROC NEAR public DMA_ON

PUSH CX ; SAVE BUFFER SIZE CLI

OUT DMA+12, AL ; SET FIRST BYTE FF.

55 PUSH AX ; DELAY POP AX

MOV AL, 59H ; MODE BYTE. CH=1,READ.AUTO.INC.SINGLE

45 194874

OUT DMA+11, AL

MOV AX, ES ; ADDRESS SEGMENT MOV CL, 4 ROL AX, CL

5 MOV CH, AL ; HIGH NIBBLE OF ES TO CH AND AL, OFOH ; SEG LOW NIBB = 0 ADD AX, BX JNC J333 INC CH 10 J333:

OUT DMA+2, AL ; START ADDRESS LOW BYTE MOV AL, AH

OUT DMA+2, AL ; SEND HIGH BYTE MOV AL, CH ; PAGE REGISTER BITS 15 ANDAL, OFH

OUT 83H, AL ; SEND TO PAGE REGISTER POP CX ; GET BACK BUFFER SIZE DEC CX ; ONE LESS MOV AX, CX ; COUNT TO AX 20 OUT DMA+3, AL ; LOW BYTE OF COUNT MOV AL, AH

OUT DMA+3, AL ; SEND HIGH BYTE STI

MOV AL, 01

25 OUT DMA=10, AL ; ENABLE DMA TRANSFERS

· ........

ADDITION OF NEW CODE (MM) 30 mov dx.312h ; SET 310 AND 311 TO OFF in al,dx mov dx, 31 Oh ; PORT ADDRESS in al, dx ; SET U11-5 TO ENABLE 35 ; mov dx,311h in al,dx ret

40 DMA_ON ENDP DMA-OFF

45 STOPT DMA OP KANAAL 1 (VIDEOSUBCODE) DOOR INSTELLEN CH1 MASKERBI1 )

DMA.OFF PROC NEAR public DMA_OFF 50 MOVAL, 05H

OUT DMA+10, AL ; SET CH 1 MASK BIT

ADDITION OF NEW CODE (MM) t 55 mov dx,312h ; SET TO OFF (310 & 311) in al,dx 194874 46

mov dx, 31 Oh in al.dx mov dx,311h in al.dx 5 RET

DMA.OFF ENDP

TOGGLE PROC NEAR public TOGGLE 10 MOV DX.312H IN AL.DX RET

TOGGLE ENDP 15 ;

WAIT-INT

20 WACHT VOOR EEN VERANDERING IN HET BIT 15 VAN DE DMA VAN HET BESTURINGSORGAAN VAN HET UITVOERTELREGISTER (AANGEVENDE EEN BUFFERRANDKRUISING) Γ”’ ········· “*“** ·-*·····»·

WAITJNT PROC NEAR 25 public WAITJNT

CALL GET_DMA_COUNT ; GET VALUE OF DMA COUNT REGISTER SUB AX. 8134 ; WHEN COUNT IS < 32730 BUFF_LOW IS EMPTY JNC FINISH.LOW

30 FINISHJHIGH ; WAIT FOR COUNT > 32760 CALL GET_DMA_COUNT

SUB AX, 8134 ; LOOP UNTIL BIT 15 OF COUNT = 1 JC FINISH.HIGH RET ; BUFF.HIGH IS EMPTIED 35 ; FINISH.LOW:

CALL GET_DMA_COUNT SUB AX, 8134 JNC FINISH.LOW 40 RET

WAITJNT ENDP

45 ;

50 GET_DMA_COUNT

LEEST DE INHOUD VAN HET RESTERENDE TELREGISTER VAN DMA-KANAAL 1.

RETOURNEERT DE TELSTAND IN AX.

GET_DMA_COUNT PROC NEAR 55 TRY.AGAIN: OUT DMA+12, AL ; RESET FIRST/LAST BYTE FF.

PUSH AX

Claims (15)

47 194874 POP ΑΧ IN AL,DMA+3 ; READ LS BYTE IN AL, DMA+3 ; READ MS BYTE MOV CH, AL 5 ;READ AGAIN TO MAKE SURE OF STABLE READ IN AL, DMA+3 MOV CL.AL IN AL, DMA+3 ; HIGH BYTE CMP AL, CH

1. Stelsel voor het opslaan van MIDI-intormatie in subcode pakketten voor codering op een compactdisc met een hoofdkanaal ene en subcodekanaal, omvattende: 25 a) een computer met een direct toegankelijk geheugen, een processor en gekoppeld aan een opslag-orgaan; b) MIDI-bronorganen voor het opwekken van MIDI-signalen; c) eerste interface-organen gekoppeld aan de MIDI-bronorganen en de computer voor het omzetten van de MIDI-signalen in een vorm voor het laden in het geheugen om bereikt te worden door de processor; 30 d) programmeerorganen voor het sturen van de werking van de processor en het geheugen om de MIDI-gegevens in het geheugen om te zetten in een aantal subcodepakketten en het schrijven van subcodepakketten naar een opslagmedium in het opslagorgaan; e) tweede interface-organen voor het opzoeken van de subcodepakketten op het opslagmedium en voor het koppelen van een compactdisc-codeerorgaan voor het omzetten van de MIDI-gegevens in de 35 opgezochte subcodepakketten in elektrische signalen die bruikbaar zijn voor het compactdisc-codeerorgaan om de MIDI-gegevens in het subcodekanaal op de compactdisc te coderen.

2. Stelsel volgens conclusie 1, waarin de programmeerorganen omvatten: a) organen voor het opwekken van een subcodegegevensbestand dat een meervoud is van ten minste één subcodepakket in lengte en voor het plaatsen van een eerste MIDI-gebeurtenis in een vooraf 40 bepaalde positie in een subcodepakket in het subcodegegevensbestand gebaseerd op een vooraf bepaalde tijd zodat de eerste MIDI-gebeurtenis ten opzichte van een begin van audiogegevens in het hoofdkanaal geplaatst wordt, en voor het plaatsen van alle volgende MIDI-gebeurtenissen in de subcodepakketten gebaseerd op de vooraf bepaalde positie, zodat géén individuele MIDI-gebeurtenis zich uitstrekt over meer dan één subcodepakket; 45 b) organen voor het berekenen van de pariteit voor elk subcodepakket dat opgewekt is en waarin de MIDI-gebeurtenissen opgeslagen zijn volgens een vooraf bepaalde pariteitberekeningsstandaard.

3. Stelsel volgens conclusie 1, waarin de programmeerorganen omvatten: a) organen voor het opwekken van een tabel in het geheugen die MIDI-gebeurtenissen opgewekt door de MIDI-bron bevat en een tijd ten opzichte van de tijd waarop een aanvankelijke MIDI-gebeurtenis door 50 de MIDI-bron werd opwekt; b) organen voor het opwekken van een subcodegegevensbestand dat een meervoud van tien subcodepakketten in lengte is, voor het bereiken van de tabel en voor het plaatsen van de eerste MIDI-gebeurtenis in een vooraf bepaalde positie in een subcodepakket in het subcodegegevensbestand gebaseerd op de relatieve tijd, zodat de eerste MIDI-gebeurtenis synchroon is aan een MIDI-klok, en 55 voor het plaatsen van alle volgende MIDI-gebeurtenissen in de subcodepakketten gebaseerd op de vooraf bepaalde positie, zodat geen individuele MIDI-gebeurtenis zich uitstrekt over meer dan één subcodepakket; 194874 48 c) organen voor het berekenen van de pariteit voor elk subcodepakket dat opgewekt is en waarin de MIDI-gebeurtenissen zijn opgeslagen volgens een vooral bepaalde pariteitberekeningsstandaard.

4. Stelsel volgens conclusie 1, waarin de programmeerorganen omvatten: a) organen voor het opwekken van een tabel in het geheugen die MIDI-gebeurtenissen opgewekt door 5 de MIDI-bron bevat en een tijd ten opzichte van de tijd waarop een aanvankelijke MIDI-gebeurtenis door de MIDI-bron wordt opgewekt; b) organen voor het opwekken van een subcodegegevensbestand dat een meervoud is van ten minste één subcodepakket in lengte, voor het bereiken van de tabel en voor het plaatsen van een eerste MIDI-gebeurtenis in een vooral bepaalde positie in een subcodepakket in het subcodegegevensbestand 10 gebaseerd op de relatieve tijd, zodat de eerste MIDI-gebeurtenis synchroon met een MIDI-klok is, ,en voor het plaatsen van alle volgende MIDI-gebeurtenissen in de subcodepakketten gebaseerd op de vooraf bepaalde positie, zodat geen individuele MIDI-gebeurtenis zich uitstrekt over meer dan één subcodepakket; c) organen voor het berekenen van de pariteit voor elk subcodepakket dat opgewekt is en waarin de 15 MIDI-gebeurtenissen zijn opgeslagen volgens een vooraf bepaalde pariteitberekeningsstandaard.

5. Stelsel volgens conclusie 1 of 2, waarin de programmeerorganen veroorzaken dat tot aan 10 bytes MIDI-gegevens in elk subcodepakket opgeslagen worden.

6. Stelsel volgens conclusie 1 of 2, waarin de programmeerorganen veroorzaken dat tot aan 11 bytes MIDI-gegevens in elk subcodepakket opgeslagen worden.

7. Stelsel volgens conclusie 1 of 2, waarin de programmeerorganen veroorzaken dat tot aan 12 bytes MIDI-gegevens in elk subcodepakket opgeslagen worden.

8. Stelsel volgens conclusie 5, waarin de programmeerorganen garanderen dat niet meer dan 125 bytes MIDI-gegevens in twaalf opeenvolgende subcodepakketten opgeslagen worden.

9. Werkwijze voor het opslaan van MIDI-informatie in subcodepakketten voor codering op een compactdisc 25 met een hoofdkanaal en een subcodekanaal gebruikmakende van een computer met een direct toegankelijk geheugen, een processor en gekoppeld aan een opslagorgaan, waarbij de werkwijze de stappen bevat van: a) het opwekken van MlDI-signalen uit een MIDI-bron; b) het omzetten van de MIDI-signalen in een vorm voor het laden in het geheugen om bereikt te worden door de processor; 30 c) het sturen van de werking van de processor en het geheugen om de MIDI-gegevens in het geheugen om te zetten in een aantal subcodepakketten en het schrijven van de subcodepakketten naar een opslagmedium in het opslagorgaan; d) het opzoeken van de subcodepakketten op het opslagmedium en het omzetten van de MIDI-gegevens in de opgezochte subcodepakketten in elektrische signalen voor het coderen van de MIDI- 35 gegevens in het subcodekanaal op de compactdisc.

10. Werkwijze volgens conclusie 9, waarin de stap van het sturen de stappen bevat van: a) het opwekken van een subcodegegevensbestand dat een meervoud is van tien subcodepakketten in lengte en het plaatsen van een eerste MIDI-gebeurtenis in een vooraf bepaalde positie in een subcodepakket in het subcodegegevensbestand gebaseerd op een vooraf bepaalde tijd, zodat de eerste

40 MIDI-gebeurtenis ten opzichte van een begin van audiogegevens in het hoofdkanaal geplaatst is en het plaatsen van alle volgende MIDI-gebeurtenissen in de subcodepakketten gebaseerd op de vooraf bepaalde positie, zodat geen individuele MIDI-gebeurtenis zich uitstrekt over meer dan één subcodepakket; b) het berekenen van de pariteit voor elk subcodepakket dat opgewekt is en waarin de MIDI-45 gebeurtenissen zijn opgeslagen volgens een vooraf bepaalde pariteitberekeningsstandaard.

10 JNE TRY.AGAIN ; IF HIGH BYTE CHANGED- TRY AGAIN MOV AX, CX RET GET_DMA_COUNT ENDP 15 ; prog ends end 20

11. Werkwijze volgens conclusie 9, waarin de stap van het sturen de stappen omvat van: a) het opwekken van een tabel in het geheugen die de MIDI-gebeurtenissen opgewekt door de MIDI-bron bevat en een tijd ten opzichte van de tijd waarop een aanvankelijke MIDI-gebeurtenis door de MIDI-bron werd opgewekt; 50 b) het opwekken van een subcodegegevensbestand dat een meervoud is van tien subcodepakketten in lengte, het bereiken van de tabel en het plaatsen van een eerste MIDI-gebeurtenis in een vooraf bepaalde positie in een subcodepakket in het subcodegegevensbestand gebaseerd op de relatieve tijd, zodat de eerste MIDI-gebeurtenis synchroon is met een MIDI-klok en het plaatsen van alle volgende MIDI-gebeurtenissen in de subcodepakketten gebaseerd op de vooraf bepaalde positie, zodat geen 55 individuele MIDI-gebeurtenis zich uitstrekt over meer dan één subcodepakket; c) het berekenen van de pariteit van elk subcodepakket dat opgewekt is en waarin de MIDI-gebeurtenissen opgeslagen zijn volgens een vooraf bepaalde pariteitberekeningsstandaard. 49 194874

12. Werkwijze volgens conclusie 10 of 11, waarin de siap van het opwekken veroorzaakt aai tot aan 10 bytes MIDI-gegevens in elk subcodepakket opgeslagen worden.

13. Werkwijze volgens conclusie 10 of 11, waarin de stap van het opwekken veroorzaakt dat tot aan 11 bytes MIDI-gegevens in elk subcodepakket opgeslagen worden.

14. Werkwijze volgens conclusie 10 of 11, waarin de stap van het opwekken veroorzaakt dat tot aan 12 bytes MIDI-gegevens in elk subcodepakket opgeslagen worden.

15. Werkwijze volgens conclusie 12, waarin de stap van het opwekken garandeert dat niet meer dan 125 bytes MIDI-gegevens in twaalf opeenvolgende subcodepakketten opgeslagen worden. Hierbij 11 bladen tekening