ST-Ecke: Grossartig - Eine Echtzeitlupe im Selbstbau
Nachdem wir, ST-spezifisch gesehen, durch unsere Bildungsserie in den letzten Monaten eine kleine Pause eingelegt haben, kommen wir in dieser Ausgabe wieder zu den Wurzeln des STs zurück. Nach langer Tips & Tricks-Abstinenz haben wir uns etwas ganz Trickreiches ausgedacht und veröffentlichen hier eine LUPE, die in Echtzeit einen Ausschnitt des STs auf den vollen Bildschirm vergrößert. Dabei gehen wir nicht nur auf den Algorithmus der Lupe ein, sondern wagen uns auch an diverse Interrupts wie Maus, VBL und das XBIOS. Lassen Sie sich überraschen…
Zu allererst
Bitte haben Sie keine Furcht vor dem langen Listing, das sie vielleicht abtippen müßten. Da ich selbst ein Gegner davon bin (Wer tippt beispielsweise seitenlange DATA-Zeilen ab?), überlegte ich lange, ob wir dieses Listing veröffentlichen sollten. Wir taten es nun unter dem Aspekt, daß man, durch die Vielfalt der angesprochenen Problemlösungen, sehr gut daraus lernen kann, weil es genau dokumentiert ist und in dieser ST-Ecke erklärt wird. Ich möchte auch Assembleranfänger dazu aufrufen, sich dieses Programm unter den Nagel zu reißen, denn man findet ein paar sehr interessante Tricks und lernt dabei die etwas unbekannteren Befehle wie TAS oder MOVEP kennen. Sollten Sie das Programm tatsächlich auch verwenden, finden Sie wie immer den Quellcode sowie das ausführbare Programm auf der Monatsdiskette. Der Assemblercode wurde übrigens für den Metacomco-Assembler geschrieben, ist aber leicht auf den Digital-Research-Assembler umsetzbar. Trotzdem werden wir in Zukunft auch wieder zu kleineren Listings zurückkommen.
Aller guten Dinge sind drei
Sie werden im Laufe der ST-Ecke mitbekommen, daß einige Zeiger des Betriebssystems (XBIOS, Maus und VBL) ganz legal verbogen werden, um die Lupe sauber mit möglichst vielen Programmen laufen zu lassen. Genau diese eigenen Routinen sind neben den eigentlichen Lupenroutinen sehr interessant und sollen ausführlich erklärt werden - aber gehen wir vom Start des Programms aus:
Nicht so habgierig
Wird ein Programm gestartet, reserviert das GEMDOS prinzipiell erst einmal jeglichen Speicher (man kann ja nie genug kriegen), der dann bis auf den tatsächlich vom Programm benötigten wieder freigegeben werden muß. Da wir natürlich nicht den gesamten Speicher benötigen, berechnen wir die Länge unseres Programmes (inklusive Datenbereich) und übergeben das der GEMDOS-Routine M_SHRINK, die den reservierten Speicherblock auf die gewünschte Länge reduziert. Gesagt, getan, beginnen wir mit den weiteren Vorarbeiten: Cursor ausschalten, Copyright über unsere kleine einfache Routine CONOUT ausgeben.
A Kind of Magic
Als nächstes verbiegen wir die Maus-Interruptserviceroutine, deren Adresse sich in einer Struktur befindet, die wir über XBIOS’ KBDVBASE() erfahren können (siehe ST-Ecke ‘Der ST läßt das Mausen nicht...’). Ander 16. Stelle (Byte) steht der Vektor der Mausroutine. Direkt vor unserer eigenen Maus-Interruptserviceroutine steht eine ‘magic number’. Eine solche magische Nummer dient dazu, ganz spezielle Dinge (hier unsere eigene Mausroutine) eindeutig zu identifizieren. Bemerken wir, daß vor der aktuellen Mausroutine diese Nummer steht, so wissen wir, daß dies unsere Routine ist, die Lupe also schon einmal vorher gestartet wurde, und wir verabschieden uns sang- und klanglos. (Eine ähnliche und etwas ausführlichere Methode befindet sich am Beginn der VBL-Routine, aber dies erklären wir im Zusammenhang mit jener Routine.) War es der erste Start der Lupe, speichern wir den Einsprung der alten Mausroutine und fügen unsere Adresse ein.
Der kleine Unterschied
Ohne allzuviel vorwegzunehmen und zu verraten (der Trick mit der Lupe wird erst unten enthüllt), möchte ich hier den Unterschied zwischen der physikalischen und logischen Bildadresse kurz erläutern. Bei der physikalischen Adresse handelt es sich um die Anfangsadresse des Speicherbereichs, den Sie tatsächlich auch auf Ihrem Monitor zu sehen bekommen. Interessanterweise muß das aber nicht unbedingt die Adresse sein, die auch die Routinen benutzen, wenn zum Beispiel eine Linie gezogen oder ein Text geschrieben wird, was im allgemeinen über GEM und damit über LINE-A geschieht. Diese Routinen greifen nämlich auf die logische Bildadresse zu, so daß sie zum Beispiel in einen Bildbereich vom Programm aus zeichnen können, ohne daß es der Benutzer bemerkt. Nachdem dann Ihr Bild fertig ist, ändern Sie Ihre logische zur physikalischen Adresse. Klar, nicht? Da für unsere Lupe das Bild interessant ist, welches ursprünglich (also bevor es unsere nette Lupe gab) auf dem Bildschirm zu sehen war, holen wir uns die physikalische Adresse über PHYSBASE und speichern diese zwischen. Mit den nächsten Zeilen setzen wir die Adressen für unsere Bildspeicher. Die Lupe benötigt zwei Bildschirmspeicher: warum und wieso, das erfahren Sie unten, und deshalb wollen wir auch zunächst die Unterroutine create table außen vor lassen (obwohl ich glaube, daß den ersten Lesern schon langsam ein Licht aufgeht, wie die Lupe vielleicht funktionieren könnte).
Startposition
Im Laufe des Programms greifen wir auf die Mauskoordinaten zu, um zu wissen, welcher Teil des Bildschirms um die Maus vergrößert werden soll. Dazu bekommen wir (siehe unten) relative Koordinaten vom Tastaturprozessor geliefert. Wir holen uns am Anfang über die AES-Routine graf_mkstate die momentanen absoluten Mauskoordinaten als Anfangskoordinaten und addieren im Mausinterrupt die relativen Koordinaten, da wir die AES-Routine im Interrupt nicht aufrufen können. Um auf graf_mkstate zugreifen zu können, haben wir uns natürlich als Applikation anzumelden.
Eine super Sache
Damit alles so richtig sauber funktioniert, müssen wir uns in den Vertical-Blank-Interrupt und in den XBIOS-TRAP einhängen. Ganz kurz für alle Einsteiger: Während der Monitor den Bildschirm darstellt, rast der Elektronenstrahl im Zickzack immer von rechts nach links und dabei langsam nach unten (siehe auch Bildwerkstatt ATARI ST 12/88 von Jörg Drücker und Alexander Beller). Ist er unten angekommen, wird er ausgeschaltet (Dunkeltastung) und rast wieder von der rechten unteren in die linke obere Ecke. In dieser Zeit, die man ‘vertical blank’ nennt, hat der Rechner Zeit, einige Dinge zu tun und bietet die Möglichkeit, ein paar kleine Routinen, die sich fein säuberlich anmelden, immer zu diesem Zeitpunkt auszuführen. Voraussetzung ist, daß die Gesamtheit aller VBL-Routinen die Zeit des VBL nicht überschreitet. Unsere Lupe ist eines dieser Programme und klinkt sich daher in die Kette der Programme ein. (Wie Sie unten sehen, werden wir sogar dafür sorgen, daß wir nur alle vier VBL-Aufrufe tatsächlich etwas tun, um den Rechner nicht allzusehr zu belasten.) Um uns in die Liste der Routinen einzutragen, die aufgerufen werden sollen, müssen wir auf eine Adresse zugreifen, die im vom Prozessor geschützten Speicherbereich liegt, was nur im SUPERVISOR-Modus geschehen darf. Falls der Benutzer die physikalische Bildschirmadresse ändert, wird er dies über eine XBIOS-Routine machen. Damit auch wir dies mitbekommen, hängen wir uns zusätzlich in den XBIOS-Einsprung, womit wir eine weitere Adresse im geschützten Speicherbereich ändern müssen. Das Ausführen der Routine INSTAL im Supervisormodus erreichen wir durch die Routine SUPEXEC des XBIOS.
ADE
Nach der Initialisierung aller Vektoren legen wir eine kleine Pause ein und verabschieden uns dann... aber halt: Wie Sie sicherlich schon erkannt haben, handelt es sich bei unserer Lupe um ein Programm, das resident im Speicher verankert wird und daher am Ende der Initialisierung nicht wieder entfernt werden darf. Dazu teilen wir dem Betriebssystem mit, welcher Speicherbereich nach dem Verlassen des Programms im Speicher liegenbleiben soll. Nachdem wir dies mit KEEP_PROCESS über GEMDOS getan haben, verabschiedet sich unser Programm endgültig, denn es wird ja nur ab und an gebraucht, nämlich dann, wenn ein VBL-Interrupt auftritt, die Maus angesprochen wird oder der Benutzer die physikalische Bildschirmadresse ändert.
Der XBIOS-TRAP
Schauen wir uns zunächst den XBIOS-Trap an. Alle Betriebssystemfunktionen werden über eine softgesteuerte Unterbrechung, einen sogenannten TRAP ausgelöst, dem wiederum eine Nummer zugeordnet wird. So hat zum Beispiel GEMDOS die Nummer 1 (TRAP #1), BIOS die Nummer 13 und XBIOS die 14. Die Adressen der daraufhin ausgeführten Routinen befinden sich ab Adresse $80 (plus Nummer, mal 4). Die Parameter der Routinen werden so auf den Stack gelegt, daß der letzte Parameter als erstes auf den Stack kommt. Die Nummer der Routine (SUPEXEC hat beispielsweise die Nummer $26) steht als letzter Parameter als Wort auf dem Stack. Nachdem die Routine durchgeführt worden ist, werden das Statusregister und der Programmzähler, die zuvor gerettet worden waren, wiederhergestellt, die Parameter befinden sich aber immer noch auf dem Stack, so daß der Stackpointer korrigiert werden muß. Wichtig ist, daß wir prüfen, ob das Programm, das den XBIOS-TRAP ausgelöst hat, im Supervisor-Modus war oder nicht, denn abhängig davon liegen die Parameter auf dem Supervisor- oder Userstack. Nachdem wir dies in unserer Routine durch Testen eines Bits im Statusregister geklärt haben, schauen wir, ob die Routinen PHYSBASE oder SETSCREEN vom Benutzer aufgerufen worden sind. Ist dies der Fall - dies erkennen wir an der Funktionsnummer -, merken wir uns den Parameter, der die physikalische Bildschirmadresse enthält und speichern ihn in der Variablen Physbase ab. Da man mit SETSCREEN auch andere Werte setzen und das Setzen eines bestimmten Parameters durch -1 verhindern kann, prüfen wir diese Tatsache zuvor ab. Danach springen wir in die Original-XBIOS-TRAP-Routine, was wir uns in der Initialisierung durch das Retten der Originaladresse in XBIOS VEC ermöglicht haben.
Mäuschen hab’ acht...
Wichtig für unsere Lupe ist es zu wissen, an welcher Stelle sich die Maus befindet. Zu diesem Zweck hängen wir uns in den Mausvektor. Was passiert nun in der Mausroutine, und wie können wir sie für unsere Zwecke nutzen? Im ATARI ST befindet sich ein eigener kleiner Prozessor (ein 6803 der MOTOROLA-6800-Familie, seines Zeichens Single-Chip-Processor), der für die Unterstützung der Tastatur, der Maus und des Joysticks zuständig ist. Die Kommunikation mit dem Rest der Welt geschieht über Interrupts und Pakete. Dadurch, daß die Maus durch einen Interrupt zur Ausführung kommt, funktioniert sie praktisch immer, auch dann, wenn die Floppy oder Harddisk angesprochen wird. [Bewegen Sie einmal auf dem PC (IBM & Co) die Maus, während ein Diskettenzugriff läuft: Zunächst passiert nichts, und nach dem Zugriff holt die Maus das Versäumte nach...] Wenn nun ein solcher Interrupt ausgelöst wird, sendet der Chip ein Datenpaket von 3 Bytes, die wie folgt definiert sind:
Header: Die gesetzten Bits des Wertes $F8 (11111000) kennzeichnen, daß es sich um ein Mauspaket handelt. Die beiden unteren Bits zeigen zusätzlich an, welche der beiden Tasten gedrückt worden sind. Daher muß man, um das Mauspaket zu erkennen, mit den Werten $f8 bis $fb rechnen.
DeltaX: relative X-Mausposition, die vorzeichenbehaftet ist und damit zwischen -128 und +127 liegt
DeltaY: relative Y-Mausposition; auch dieser Wert liegt zwischen -128 und + 127.
Die Adresse des Mauspakets steht beim Einsprung in die Mausserviceroutine im Register A0! In unserer Mausroutine fragen wir auf den eben angesprochenen Header ab und speichern die beiden relativen Koordinaten, welche wir gleich zu unseren internen absoluten addieren. Dabei ist aber zu beachten, daß wir unsere absoluten Koordinaten nicht überschreiten - deshalb wird auf die entsprechenden Grenzen abgefragt. Das wäre auch schon fast alles, was es zu unserer Mausroutine zu sagen gäbe. Nebenbei: Es wäre übrigens ein leichtes, in diese Routine eine Verdoppelung der Mausgeschwindigkeit (sogenannte QUICKMOUSE) zu implementieren - man müßte nur die relativen Mauswerte manipulieren. Aber denken Sie daran, daß dies geschehen muß, bevor Sie selbst mit den Koordinaten arbeiten, denn auch unsere eigene Lupe soll diese Verdoppelung mitbekommen. Dies ist übrigens auch der Grund dafür, daß eine vorhandene Quickmouse-Utility vor der Lupe geladen werden muß, denn wenn die Mauskoordinaten nach dem Aufruf der Lupe verdoppelt werden, bemerkt dies die Lupe nicht, und die ST-internen Absolutkoordinaten der Maus laufen doppelt so schnell wie die unserer Lupe.
Statussymbole
Sicherlich ist es nicht wünschenswert, die ganze Zeit mit der Lupe zu arbeiten. Deshalb wurde ein Umschalter für die unterschiedlichen Modi (normal, 2fach-, 4fach-...Vergrößerung) eingebaut. Das Umschalten geschieht über die Tastenkombination ALTERNATE-SHIFT-SHIFT, welche wir natürlich im Programm irgendwie abfragen müssen. Der Status dieser Tasten ist als Bits kodiert in einer bestimmten Adresse zu finden - und genau damit beginnt das Problem. In älteren TOS-Versionen (vor 1.2) wurde diese Adresse nicht bekanntgegeben, so daß sich viele Programmierer auf die Suche begaben und eine Adresse fanden, in der der Status zu finden ist: $E1B. Wie das Leben so spielt, wurde diese NICHT-dokumentierte Adresse von ATARI ab der TOS-Version 1.2 geändert. Aber dafür gibt es ab sofort eine saubere Methode, die Adresse herauszubekommen, was aber, es sei noch einmal erwähnt, erst ab TOS-Version 1.2 funktioniert. An der Adresse $4f2 findet man die Adresse der Systemvariablen _sysbase, die auf den sogenannten Betriebssystemheader zeigt, in dem allerlei interessante Informationen zu finden sind. Da uns zwei Einträge interessieren, möchte ich ihn in Listing 1 vollständig als Struktur aufführen.
Aus dieser Struktur greifen wir uns zwei Einträge heraus: zum einen os_version und zum anderen kbshift. In os_version schauen wir nach, ob es sich um ein Betriebssystem handelt, das die Versionsnummer 1.2 oder folgende hat. Ist dies der Fall, befindet sich im Header unter kbshift die Adresse des Tastaturstatus’, die wir dann in unserem Programm benutzen. Ist die Versionsnummer kleiner, greifen wir auf die schon oben erwähnte Adresse $E1B zu. Wenn nun die Tasten ALTERNATE-SHIFT-SHIFT gedrückt werden, überprüfen wir das in jedem VBL-Interrupt und verwerten dies, indem wir einen Modus-Zähler erhöhen. Es ist allerdings wahrscheinlich, daß wir das Drücken und Wiederloslassen nicht in einer 70stel (oder 50stel) Sekunde schaffen, so daß der Zähler mehrfach erhöht werden würde, was natürlich nicht passieren darf! Wir merken uns den Status der Tasten des letzten VBLs und vergleichen ihn mit dem momentanen. Waren die Tasten im letzten VBL gedrückt, und der momentane Status ist jetzt gelöscht, sind die Tasten losgelassen worden, und wir erhöhen unseren Modus. Dieses Verfahren ist in seiner Art recht häufig anwendbar, deshalb sollten Sie es sich etwas genauer anschauen. Sie finden es in der Routine GET_MODE.
typedef struct {
int os_entry; /* Einsprungadresse ins Betriebssystem */
int os_version; /* Betriebssystemversion */
long os_start; /* Startadresse des OS-Codes */
long os_base; /* Anfangsadresse des Betriebssystems */
long os_memboot; /* Beginn des freien Speichers */
long os_shell; /* Shell */
long os_magic; /* Zeiger auf GEM-magic-Variable ->$8765432 */
long os_gendat; /* Erstellungsdatum des TOS im BCD-Format */
int os_palmode /* unterstes Bit gesetzt bedeutet PAL, sonst NTSC */
int os_gendatg; /* Erstellungsdatum im GEMDOS-Format */
/* folgende Einträge sind erst ab Version 1.2 des TOS verfügbar ! */
long *_root; /* Zeiger auf Speicherblockliste(->GEMDOS INTERN
Sonderheft oder ST-Computer 9/87 - Alex Esser */
long kbshift; /* Zeiger auf Adresse, die Tastaturstatus enthält */
PD **_run; /* Zeiger auf PD des aktuellen Prozesses */
}SYSHDR;
Listing 1: Struktur des Betriebssystemheaders
Unter der Lupe
Jetzt habe ich Sie aber lange genug neugierig gemacht! Da wir alle Vorarbeit geleistet haben, kommen wir endlich zur Hauptsache: der Lupe. Sie ist in verschiedenen Vergrößerungsstufen (und Auflösungen) realisiert worden. Da aber der Trick beziehungsweise das Schema der schnellen Vergrößerung praktisch dasselbe ist, wollen wir nur die Vierfach-Monochrom-Vergrößerung erklären.
CPU-Schonung
Wenn die VBL-Routine angesprungen wird, prüft sie zunächst in der Systemvariablen _flock, die an der Adresse $43e liegt, nach, ob momentan ein Zugriff auf die Harddisk oder die Floppy (auf gut deutsch: DMA-Betrieb) vorliegt. Ist dies der Fall, verabschiedet sie sich, um einen solchen Peripheriezugriff nicht zu behindern. Andernfalls zählt sie einen Zähler bis zum Wert REPEAT hoch, der hier auf 4 gesetzt ist. Hat der Zähler den Wert erreicht, wird die Lupe aktiviert, so daß sie nur alle vier VBL-Einsprünge aktiv wird. Wie Sie beim Benutzen der Lupe feststellen werden, reicht das völlig aus, und wir belasten die CPU nicht allzu stark. Außerdem überprüfen wir unsere Auflösung, um die richtige Lupe einzusetzen. In GET_RES wird zusätzlich noch überprüft, ob unser(!) Vektor der Mausroutine noch gesetzt ist, oder ob das Betriebssystem nicht vielleicht seinen eigenen Vektor darübergeschrieben hat. Zeigt der Vektor wieder ins ROM, schreiben wir einfach unsere Adresse wieder hinein. Und nun geht’s in die Lupe...
Prinzipiell beruht die Lupe darauf, daß sie den darzustellenden Bildschirm (also den an der physikalischen Adresse) in einer modifizierten Form an einen anderen Speicherplatz kopiert und dann den Videochip (liebevoll SHIFTER genannt) dazu veranlaßt, nicht den Speicher der physikalischen Adresse, sondern nun unseren Speicher darzustellen. Wie das funktionieren soll, wo doch die physikalische Adresse die Adresse ist, die dargestellt wird? Es ist ganz einfach: Das Betriebssystem benutzt diese ‘physikalische Adresse' nur als Zwischenspeicher, wirklich maßgebend ist die Adresse, die im VIDEO-SHIFTER (dem Grafik-Chip des ST) steht. Vor jeder VBL schaut das Betriebssystem nach, ob sich der Wert in der physikalischen Adresse geändert hat. In diesem Fall schreibt es die neuen Werte in den Chip. Nur, was das Betriebssystem kann, können wir schon lange, oder? Wir schreiben also, nachdem wir unser modifiziertes Bild aufgebaut haben, in den Grafik-Chip des ST unsere Adresse. Das Schöne dabei ist, daß das Betriebssystem davon nichts bemerkt, denn seine physikalische Adresse hat sich ja nicht geändert, und somit schreiben alle Routinen brav weiterhin an die Originaladresse.
| vorher (1 Byte) | nachher (4 Bytes) |
|---|---|
| 00000000 | 00000000 00000000 00000000 00000000 |
| 00000001 | 00000000 00000000 00000000 00001111 |
| 00000010 | 00000000 00000000 00000000 11110000 |
| 00100101 | 00000000 11110000 00001111 00001111 |
| 10111010 | 11110000 11111111 11110000 11110000 |
| 11111111 | 11111111 11111111 11111111 11111111 |
Tabelle 1: Beispiele der vierfachen Dehnung
Größenwahn
Nachdem wir nun eine Möglichkeit gefunden haben, einen anderen Speicherbereich auf dem Monitor sichtbar zu machen als den, in den das laufende Programm schreibt, müssen wir noch eine Möglichkeit finden, möglichst schnell unseren Speicher mit dem Inhalt des Originalbildes zu füllen. Allerdings wäre das ja relativ langweilig, denn wir hätten damit nichts gewonnen. Wir wollen das Bild ja modifiziert oder, genauer, ausschnittsvergrößert darstellen. Beachten Sie, daß es dabei wirklich darauf ankommt, schnell zu sein, denn die VBL-Routine darf nicht ewig dauern. Wie also bringt man mit möglichst wenig Aufwand eine rasend schnelle Vergrößerung hin? Wir wollen uns das Prinzip in der monochromen Darstellung anhand der Vierfach-Vergrößerung anschauen. In der monochromen Auflösung wird ein Bildpunkt in einem Bit verschlüsselt. Acht Bildpunkte haben in einem Byte und die 640 Punkte einer Zeile haben in 80 Bytes Platz. Führen wir eine vierfache Vergrößerung durch, so bedeutet das, daß ein Punkt vier Bildpunkte in der Breite und Höhe hat, so daß er durch 4 Bits in einem Byte repräsentiert wird und über 4 Zeilen geht. Das wiederum bedingt, daß wir nur ein Viertel des Bildschirms gleichzeitig darstellen können (was bei einer vierfachen Vergrößerung zugegebenermaßen nicht weiter verwunderlich ist). Stellen wir uns einmal vor, der Punkt an der Koordinaten 0,0 wäre gesetzt und der an der Koordinate 1,0 nicht, so hätte das entsprechende Byte im Originalbild folgende Bitbelegung:
10xxxxxx: 1=gesetzt, 0=gelöscht, x=nicht angegeben.
Vergrößern wir auf das Vierfache, ist ein Punkt 4 Bits breit, so daß die beiden Punkte nun ein Byte ausfüllen, was jetzt folgendermaßen aussieht: 11110000. Wichtig ist, daß auch die Bytes in den drei Zeilen darunter genauso ausschauen, denn unser Punkt ist ja nicht nur viermal so breit, sondern auch viermal so hoch! Gut, das Prinzip der Vergrößerung ist praktisch verstanden: Wir müssen ein Bit auf vier Bits ausdehnen und eine Zeile auf vier. Nun ist das einzelne Setzen von Bits bei einem Umfang von 640x400 Punkten viel zu langsam, und wir müssen uns eine andere Idee ausdenken. Jedes Byte wird bei der Vierfach Vergrößerung auf vier Bytes gedehnt, wobei es 256 Möglichkeiten eines Bytes gibt. Zur Verdeutlichung möchten wir ein paar Beispiele der Dehnungen darstellen (siehe Tabelle 1).
Vergrößern wir unser Ausgangsbild, müßten wir für jedes Byte eine Dehnung durchführen und diese dann in das Zielbild kopieren. Aber wir können uns die Sache vereinfachen, indem wir die schon gedehnten Werte in einer Tabelle stehen haben. Stellen Sie sich die Tabelle wie die meiner Beispiele vor, nur mit dem Unterschied, daß sie vollständig ist und damit 256 Einträge à vier Bytes hat. Wenn ich beispielsweise das Byte mit dem Wert 50 habe, hole ich mir aus dem 50. Tabelleneintrag den schon gedehnten, vier Bytes langen Wert heraus, was praktisch keinen Rechenaufwand bedeutet, und kopiere ihn schnell in mein Zielbild. Das mache ich, ausgehend von der aktuellen X-Koordinate, mit zwanzig Bytes des Ausgangsbildes (Wir können nur 20*8 Bildpunkte darstellen, siehe oben.) und gehe zur nächsten Zeile des Quellbildes. Diese Zeile findet sich im Zielbild vierfach vergrößert vier Zeilen unter der letzten erzeugten Zeile. Haben wir alle Zeilen erzeugt, befinden sich noch Lücken zwischen den Zeilen des Zielbildes - wir haben ja nur eine Zeile erzeugt, also sind die drei dazwischen noch nicht gefüllt. Diese müssen wir nur noch von der Zeile obendrüber kopieren, wobei man durch einen besonderen Assemblertrick 40 Bytes auf einmal (!) kopieren kann!
Die Realisierung
Die Tabellen werden erst während des Programmablaufes erzeugt, was in der Routine Create_table geschieht. Den genauen Ablauf dieser vertrackten Routinen möchte ich hier nicht schildern, allerdings habe ich für diejenigen, die der Algorithmus interessiert, die Dokumentation einer Tabellenerstellung besonders ausführlich gestaltet. Eine Verständnisfrage zu den Tabellen: Wie groß ist ein Eintrag einer Tabelle für den Vergrößerungsfaktor 8, und wie würde der Eintrag für den Byte wert $73 aussehen? (Erst überlegen:) Die Tabelle hat natürlich eine Eintragslänge pro Wert von acht Bytes und der Wert $73 (01110011) würde folgendermaßen aussehen:
00000000 11111111 11111111 11111111
00000000 00000000 11111111 11111111
Das Erstellen der 8er-Tabelle ist also sehr einfach, da ein Byte entweder nur ganz gefüllt oder gelöscht einem Bit entspricht.
Schauen wir uns nun als Beispiel ZOOM_4 an, und bitte nehmen Sie sich für den nächsten Abschnitt etwas Zeit. Schauen Sie sich beim Lesen tatsächlich auch den Assemblercode an und versuchen Sie, ihn zu verstehen. Zunächst prüfen und setzen wir die Koordinaten des Lupenfensters. Danach holen wir die Adresse unserer Tabelle und setzen die Anzahl der zu kopierenden Zeilen auf 100 (400/4=100). Der Algorithmus besteht prinzipiell aus zwei Schleifen ineinander: Die äußere Schleife sorgt für hundert Zeilen (dbra,d7,zoom_41), die innere für die zwanzig Bytes einer Zeile (dbra d6, zoom_42), wobei immer zwei Bytes in einem Durchgang bearbeitet werden.
Das Erzeugen einer vergrößerten Zeile
Bei Label ZOOM_42 holen wir uns zwei Bytes aus dem Originalbild. Bitte beachten Sie, daß die momentane X-Koordinate nicht unbedingt auf einer Bytegrenze liegen muß, deshalb werden die Bits auf die Wortgrenze geschoben. Durch das Schieben stehen die Bits nun im oberen Wort des Langworts, so daß wir diese wieder durch den swap-Befehl hinuntertransportieren müssen. Zunächst bearbeiten wir das obere Byte, indem wir es um 8 Bits nach unten verschieben. Danach benutzen wir es als Index in unsere Tabelle, wobei wir es wieder mit vier multiplizieren müssen. (Jeder Eintrag ist vier Bytes lang.) Da eine Multiplikation mit 4 einem zweifachen Schieben nach links gleichkommt, können wir das achtfache Schieben nach rechts und das 2fache nach links zu einer Operation ‘6faches Schieben nach rechts’ zusammenfassen. Jetzt interessieren uns nur Werte von 0 bis 1024 (so lang ist unsere Tabelle) und zu diesem Zweck, blenden wir alle oberen Bits aus. Mit move.l 0(a2,d3.w),(a1)+ addieren wir zu der Tabellenadresse in a2 den Index in d3 (und 0), holen uns aus dieser Adresse unseren gedehnten Wert und schreiben ihn an die Zieladresse in a1. Das gleiche Spielchen führen wir nun mit dem zweiten im unteren Teil des Wortes befindlichen Byte durch, nur mit dem Unterschied, daß wir es vorher nicht um acht Stellen nach unten schieben, sondern um zwei Stellen nach oben (mal 4). Interessant ist, daß die Multiplikation hierdurch die zweifache Addition mit sich selbst durchgeführt wird: Das ist schneller als ein zweifaches Schieben nach oben (links)! Haben wir die 20 Bytes hinter uns gebracht, ist die Zeile im Zielbild voll; bis zum Anfang des nächsten Bytes des Quellbildes fehlen aber noch 60 Bytes, die wir zur Quellbildadresse hinzuaddieren - im Zielbild überspringen wir die nächsten drei Zeilen(3*80), da wir diese am Ende durch ein reines Kopieren ergänzen. Sind nun alle 100 Zeilen vergrößert übertragen, wissen wir, daß im Zielbild immer noch Lücken zwischen den einzelnen Zeilen bestehen, die wir durch folgenden Assemblertrick sehr schnell zu füllen wissen:
Das Geheimnis des schnellen Kopierens
Es ist hinreichend bekannt, daß der MC68000-Prozessor, trotz seines wirklich variantenreichen Befehlssatzes, keinen Befehl zum Verschieben oder Kopieren von großen Blöcken besitzt. Es gibt aber einen Trick, mit dem man 40 Bytes auf einmal (ehrlich gesagt, in zwei Schritten) kopieren kann. Der Befehl 'movem.l' ist der eigentlich dazu gedacht, eine Reihe von Registern auf einen Schlag abzuspeichern und wieder zu retten. Nun ist jedes Register 4 Bytes lang, und man kann es so einrichten, daß man 10 Register entbehrlich macht. Dadurch liest man mit ‘movem.l (a0)+, d0-d5/a3-a6' von der gewünschten Adresse a0 in die Register d0-d5 und a3-a6 auf einmal 40 Bytes ein und erhöht dabei a0 automatisch um vierzig. Abgespeichert werden die Bytes wieder mit dem komplementären Befehl ‘movem.l d0-d5,a3-a6,Adresse'. Um nun die drei freigebliebenen Zeilen zeilenweise nacheinander zu füllen, kopieren wir die Bytes mit diesem Trick sehr schnell, indem wir zur Zielzeile noch jeweils einen Offset von 40, 40+80 oder 40+160 addieren. Normalerweise würde man vermuten, daß man 80, 160 und 240 addierte, da aber der erste movem.l das a0-Register schon um vierzig erhöht hat, müssen wir vierzig vom Offset abziehen.
Zwei ist besser als Eins
Wenn Sie das Listing betrachten, werden Sie bemerken, daß das Programm mit zwei Bildschirmspeichern arbeitet und diese immer umschaltet. Das hat den Vorteil, daß man immer in den Speicher schreibt, den der Benutzer gerade nicht sieht. Daher bekommt er keine Kopierarbeiten zu sehen, und das Bild beginnt nicht zu flackern.
Das Ding mit der gespaltenen Adresse
Zum Schluß möchte ich Sie noch auf eine besondere Sache hinweisen. Oben wurde schon erwähnt, daß die Lupe im VBL die Bildschirmadresse im VIDEO-Shifter setzt. Die Adressen der BYTES dafür liegen an der Stelle $FF8201 und $FF8203. Jeder, der sich ein bißchen mehr auskennt, wird zwei Dinge bemerken: Erstens sind es nur zwei Bytes (für eine drei-Byte-Adresse), und zweitens liegen sie zu allem Unglück auch noch auf einer ungeraden Adresse. Das Problem der zwei Bytes erklärt sich, daß es beim ST nur möglich ist, den Bildschirm auf einer Adreßgrenze von 256 Bytes anfangen zu lassen. Das heißt, daß $FF8201 für das High-Byte und $FF8203 für das Mid-Byte der Adresse verantwortlich ist. Das Low-Byte wird vom Shifter automatisch intern auf Null gesetzt. Wären die Adressen nun auf der gerade Adresse zu finden, könnte man recht einfach die Werte hineinschreiben. Für den hier vorliegenden Fall bieten wir Ihnen eine in QUICK zu findende, elegante Lösung mit den Befehl ‘movep’ an, der auf einmal die beiden Bytes eines Wortes mit einem Byte Abstand in den Speicher schreibt und das, bei einem Offset von Eins, sogar an eine ungerade Adresse.
XBRA
Wie schon erwähnt, haben wir eine weitere Möglichkeit in unser Programm eingebaut, an der wir erkennen können, ‘daß wir wir sind’. Vor dem eigentlichen Einsprung der VBL-Routine steht eine Struktur von drei mal vier Bytes. Im ersten Eintrag steht der Name XBRA, an dem man die Struktur erkennen kann. Im zweiten Eintrag findet sich der Name des Programms, das sich in die VBL eingeklinkt hat, wobei der Name aber nur vier Buchstaben lang sein darf. Im dritten Eintrag haben wir die Adresse, die ursprünglich als Einsprung in die VBL-Programmliste gegolten hat. Durch diese Struktur wäre es sogar einem anderen Programm möglich, unsere Routine wieder auszuhängen, indem sie unsere neue Adresse mit der in XBRA zu findenden Adresse überschreibt: Dadurch wären wir einfach aus der Kette entfernt worden.
Ich hoffe, daß wir Ihnen mit dieser Lupe einen kleinen Einblick in die vielfältigen Möglichkeiten des STs gegeben haben, und daß Sie von dem einen oder anderen Trick etwas lernen konnten. Lassen Sie sich nicht entmutigen, falls Sie Teile nicht verstanden haben, sondern lesen Sie sich den einen oder anderen Absatz ein weiteres Mal vor und schauen Sie Sie sich dazu die passende Stelle im Listing an. Und vergessen Sie nicht, die Lupe auch mal auszuprobieren: Es lohnt sich ganz bestimmt, versprochen....
Stefan Höhn, Alexander Beller
*************************************************
*
*
* REALTIME MAGNIFIER
*
*
* Written by Alexander Beller
*
* (C) Copyright by IMAGIC Grafik
*
*
*************************************************
GEMDOS: equ 1 * Trapvektor GEMDOS
BIOS: equ 13 * Trapvektor BIOS
XBIOS: equ 14 * Trapvektor XBIOS
PRINT_LINE: equ $09 * GEMDOS Funktionen
KEEP_PROCESS: equ $31
M_SHRINK: equ $4A
GET_PHYSBASE: equ $02 * XBIOS Funktionen
GET_RESOLUTION: equ $04
SET_SCREEN: equ $05
SET_CURSOR: equ $15
GET_KBDVBASE: equ $22
GO_SUPER: equ $26
REPEAT: equ 4 * Wiederholfrequenz für
* * den Bildaufbau im VBL
*************************************************
PROGRAM_START:
move.l 4 (sp),a6
lea USER_STACK,sp * Eigenen STACK installieren
*
pea (USER_STACK-BSS_START)+(TEXT_END-PROGRAM_START)+256
pea (a6)
clr.w -(sp)
move.w #M_SHRINK,-(sp) * Nicht benötigten Speicher
trap #GEMDOS * ans System zurückgeben
lea 12(sp),sp
*
*****************************************
*
clr.l -(sp)
move.w #SET_CURSOR,-(sp) * Cursor ausschalten
trap #XBIOS
addq.l #6,sp
*
pea MESSAGE(pc) * Copyright ausgeben
bsr CONOUT
*****************************************
*
move.w #GET_KBDVBASE,-(sp) * Adresse der
trap #XBIOS * Tastatur-Vektortabelle holen
addq.l #2,sp
move.l d0,a0
*
lea KBDVBASE(pc),a1
move.l a0,(a1)+ * Adresse der Vektortabelle sichern
move.l 16(a0),a2 * Aktueller Mausinterruptvektor
*
cmpi.l #$02101968,-4(a2) * Magic-Number vor der Maus-Routine?
beq EXIT * Dann ist Lupe schon installiert
*
*****************************************
*
move.l a2,(a1)+ * Alten Mausvektor sichern
move.l #NEW_MOUSE,16(a0) * Neuen Mausvektor setzen
*
move.w #GET_PHYSBASE,-(sp) * Physikalische Bildschirm
trap #XBIOS * adresse holen
addq.l #2,sp
move.l d0,PHYSBASE
*
move.l #FLIPSCR_1+255,d0 * Basisadresse von Bild 1/2
clr.b d0 * auf einer 256-Byte-Grenze
move.l d0,FLIPBASE_1 * Adresse von Bild1 setzen
add.l d0,FLIPBASE_2 * Adresse von Bild2 setzen
*
bsr APP_INIT * Application anmelden
bsr GRAF_MKSTATE * Mausposition holen
bsr CREATE_TABLE * Tabellen erstellen
pea INSTAL(pc) * Supervisor-Unterprogramm aufrufen
move.w #GO_SUPER,-(sp) * (XBIOS- u.VBL-Vektor umleiten)
trap #XBIOS
addq.l #6,sp
*
bsr PAUSE * Pause einlegen und danach
* * Programm resident beenden
clr.w -(sp)
pea (BSS_END-BSS_START)+(TEXT_END-PROGRAM_START)+256
move.w #KEEP_PROCESS,-(sp)
trap #GEMDOS
*
*****************************************
*
EXIT: bsr PAUSE * Pause einlegen
*
clr.w -(sp) * Programm verlassen
trap #GEMDOS
*
*****************************************
*
* XBIOS-Trap
*
*****************************************
*
NEW_XBIOS:
lea 6(sp),a0 * Zeiger auf SUPERVISOR-Parameter
move.w (a0),d0 * Funktionsnummer vom SSP holen
*
btst #5,(sp) * Aufruf vom SUPERVISOR?
bne.s SVR_CALL * Ja... .
*
move.l usp,a0 * Nein, Zeiger auf USER-Parameter
move.w (a0),d0 * Funktionsnummer vom USP holen
*
SVR_CALL:
cmpi.w #GET_PHYSBASE,d0 * Funktion GET_PHYSBASE?
beq.s F_PHYSBASE * Ja...
cmpi.w #SET_SCREEN,d0 * Funktion SET_SCREEN?
beq.s F_SETSCREEN * Ja...
*
SYS_XBIOS:
move.l XBIOS_VEC(pc),-(sp) * Zum SYSTEMTRAP springen
rts
*
F_PHYSBASE:
move.l PHYSBASE(pc),d0 * Adresse des Hintergrundbildes
rte * zurückliefern
*
F_SETSCREEN:
move.l 6(a0),d0 * Soll Physbase umgesetzt werden?
bmi.s SYS_XBIOS * Nein...
*
move.l d0,PHYSBASE * Neuen Zeiger sichern
move.w #-1,6(a0) * Physbase NICHT umsetzen
bra.s SYS_XBIOS
*
*****************************************
*
* VBL Interrupt
*
*****************************************
*
XBRA:
dc.b 'xbra' * gross oder KLEIN?
dc.l 04031965
XBRA_VBL:
dc.l NEW_VBL * Adresse des eigenen VBL
*
NEW_VBL:
movem.l d0-d2/a0-a2,-(sp) * Register retten
*
move.l $45E,d0 * Screenzeiger gesetzt:
beq.s NO_SCREENPTR * Nein...
*
clr.l $45E * Screenzeiger löschen
move.l d0,PHYSBASE * und neuen Bildvektor übernehmen
*
NO_SCREENPTR:
tst.w $43E * Wenn Floppy oder Harddisk aktiv, dann
bne.s GO_SYSTEM * nichts weiter tun
*
bsr GET_MODE * Modus holen
*
bsr.s GET_RES * Auflösung holen
*
lea COUNTER(pc),a0 * Zähleradresse
subq.w #1,(a0) * Countdown abgelaufen'
bpl.s GO_SYSTEM * Nein....
*
move.w #REPEAT,(a0) * Zähler neuladen
*
bsr.s LUPE * Bild aufbauen
*
GO_SYSTEM:
movem.l (sp)+,d0-d2/a0-a2 * Register laden
*
move.l VBL_VEC(pc),-(sp) * Weiter mit dem System-VBL
rts
*
*****************************************
*
GET_RES:
moveq #3,d0 * Komplett neu
and.b $FFFF8260,d0 * Auflösung in d0 und sichern
*
cmp.w RESOLUTION(pc),d0
beq.s CMP_MOUSE
*
move.w d0,RESOLUTION
clr.b MODE
*
CMP_MOUSE:
lea NEW_MOUSE(pc),a1 * Adresse der eigenen Routine
*
move.l KBDVBASE(pc),a0 * Wurde Mausvektor umgesetzt?
move.l 16(a0),d0 * Aktuellen Vektor holen
*
cmp.l a1,d0 * Mit eigenem Vektor vergleichen
beq.s NO_CHANGE * Ist noch der alte...
*
moveq #23,d1
btst d1,d0
beq.s NO_CHANGE * Wenn nicht, dann alles so lassen...
*
move.l d0,KBDVBASE+4 * Vektor sichern
move.l a1,16(a0) * Eig. Vektor setzen
*
NO_CHANGE:
rts
*
*****************************************
*
LUPE:
move.l PHYSBASE(pc),a0 * Hintergrundbild
move.l FLIPBASE_1(pc),a1 * Aktuelles Zielbild
*
move.b MODE(pc),d0 * Modus holen
beq QUICK * Keine Vergrösserung
*
movem.l d3-d7/a3-a6,-(sp) * Register retten
*
pea LUPE_END(pc) * Return-Adresse auf den Stack
* erleichtert das bedingte Rufen
* von Unterprogrammen
*
move.w RESOLUTION(pc),d1 * Auflösung holen
*
beq ZOOM_LOW * Niedere Auflösung
*
subq.w #1,d1 * Mittlere Auflösung
beq ZOOM_MEDIUM
*
subq.b #1,d0 * High-Res Faktor 8
beq ZOOM_8
*
subq.b #1,d0 * High-Res Faktor 4
beq ZOOM_4
*
bra ZOOM_2 * High-Res Faktor 2
*
*
LUPE_END:
move.l FLIPBASE_1(pc),d1 * Bildadressen tauschen
move.l FLIPBASE_2(pc),d0
movem.l d0-d1,FLIPBASE_1
*
movea.w #$8200,a1 * Adresse setzen
lsr.l #8,d1
movep.w d1,1(a1)
*
movem.l (sp)+,d3-d7/a3-a6 * Register laden
rts
*
*****************************************
*
ZOOM_8:
moveq #40,d2 * Aus der Grösse des Lupenfensters
moveq #25,d3 * wird der Zeiger ins Hintergrund-
move.w #559,d4 * bild berechnet
move.w #349,d5
bsr CALC_SCRPTR
*
adda.w d0,a0 * Offsets auf die Adresse des
adda.w d1,a0 * Hintergrundbildes addieren
*
lea BUFFER_8,a2 * Zeiger auf Tabelle
move.w #255*8,d5 * Maske für den Tabellenindex
moveq #49,d7 * 50 Zeilen pro
* * Bildschirm
ZOOM_81:
moveq #4,d6 * 5 Words pro Zeile
*
ZOOM_82:
move.l (a0),d0 * Daten aus Hintergrundbild holen
addq.l #2,a0 * Stets 2 Bytes pro Durchgang
*
rol.l d2,d0 * Bytes auf Wortgrenze shiften
swap d0 * Bytes nach "unten" holen
move.w d0,d1 * Ergebnis sichern
*
lsr.w #5,d0 * Byte 1 nach "rechts" schieben
* * und mit 8 multiplizierend Index
*
and.w d5,d0 * Index maskieren
move.l 0(a2,d0.w),(a1)+ * Langwort 1 aus Tabelle holen
move.l 4(a2,d0.w),(a1)+ * Langwort 2 aus Tabelle holen
*
lsl.w #3,d1 * Byte 2*8 -> Index
*
and.w d5,d1 * Index maskieren
move.l 0(a2,d1.w),(a1)+ * Langwort 1 aus Tabelle holen
move.l 4(a2,d1.w),(a1)+ * Langwort 2 aus Tabelle holen
*
dbra d6,ZOOM_82 * Nächst. Word bearbeiten
*
lea 70(a0),a0 * Zeiger auf die jeweils
lea 7*80(a1),a1 * nächste Zeilen setzen
*
dbra d7,ZOOM_81 * Nächst.Zeile
* * bearbeiten
*****************************************
*
move.l FLIPBASE_1(pc),a0 * Zieladresse
moveq #49,d7 * 100 Abschnitte à 4 Zeilen
*
*
*
FILL_10:
moveq #1,d6 * 2 x 40 Bytes pro Zeile
*
FILL_11:
movem.l (a0)+,d0-d5/a3-a6 * 40 Bytes nach unten kopieren
movem.l d0-d5/a3-a6,40(a0)
movem.l d0-d5/a3-a6,40+80(a0)
movem.l d0-d5/a3-a6,40+160(a0)
movem.l d0-d5/a3-a6,40+240(a0)
movem.l d0-d5/a3-a6,40+320(a0)
movem.l d0-d5/a3-a6,40+400(a0)
movem.l d0-d5/a3-a6,40+480(a0)
dbra d6,FILL_11
*
lea 7*80 (a0),a0 * Zeiger auf nächste Zeile setzen
dbra d7,FILL_10 * und weiter...
*
rts
*
*****************************************
ZOOM_4:
moveq #80,d2 * Aus der Grösse des Lupenfensters
moveq #50,d3 * wird der Zeiger ins Hintergrund-
move.w #479,d4 * bild berechnet
move.w #299,d5
bsr CALC_SCRPTR
*
adda.w d0,a0 * Offsets auf die Adresse des
adda.w d1,a0 * Hintergrundbildes addieren
*
lea BUFFER_4,a2 * Zeiger auf Tabelle
moveq #99,d7 * Anzahl Zeilen
move.w #4*255,d1 * Maske für Tab.index
moveq #6,d5 * Konstante
*
ZOOM_41:
moveq #9,d6 * 10 Words pro Zeile
*
ZOOM_42:
move.l (a0),d0 * Daten aus Hintergrundbild holen
addq.l #2,a0 * Stets 2 Bytes pro Schleife
*
rol.l d2,d0 * Bytes: Wortgrenze shiften
swap d0 * Bytes nach "unten" bringen
*
move.w d0,d3 * Byte 1 "rechts" schieben
ror.w d5,d3 * mal 4 -> Index
and.w d1,d3 * Index maskieren
move.l 0(a2,d3.w),(a1)+ * Langwort aus Tabelle holen
*
add.w d0,d0
add.w d0,d0
and.w d1,d0 * 2. Byte holen
move.l 0(a2,d0.w),(a1)+ * Langwort aus Tabelle holen
*
dbra d6,ZOOM_42
*
lea 60(a0),a0
lea 240(a1),a1
*
dbra d7,ZOOM_41
*
*****************************************
*
move.l FLIPBASE_1(pc),a0 * Zieladresse
moveq #99,d7 * 100 Abschnitte zu 4 Zeilen
*
FILL_2:
movem.l (a0)+,d0-d5/a3-a6 * 40 Bytes nach unten kopieren
movem.l d0-d5/a3-a6,40(a0)
movem.l d0-d5/a3-a6,40+80(a0)
movem.l d0-d5/a3-a6,40+160(a0)
*
movem.l (a0)+,d0-d5/a3-a6 * 40 Bytes nach unten kopieren
movem.l d0-d5/a3-a6,40(a0)
movem.l d0-d5/a3-a6,40+80(a0)
movem.l d0-d5/a3-a6,40+160(a0)
*
lea 3*80(a0),a0 * Zeiger auf nächste Zeile
dbra d7,FILL_2 * und weiter...
*
rts
*
*****************************************
*
ZOOM_2:
move.w #160,d2 * Hohe Auflösung Faktor 2
moveq #100,d3 * Alles neu ....
move.w #319,d4
move.w #199,d5
bsr CALC_SCRPTR
*
adda.w d0,a0 * Offsets auf Adresse vom
adda.w d1,a0 * Hintergrundbild addieren
*
lea 80(a1),a2
lea BUFFER_2,a3
*
move.w #199,d7 * Anzahl Zeilen
move.w #$1FE,d1 * Maske
moveq #7,d5 * Konstante
*
ZOOM_21:
moveq #19,d6 * 20 Words pro Zeile
move.w (a0)+,d0 * Erstes Word holen
*
ZOOM_22:
swap d0
move.w (a0)+,d0 * Sourcedaten holen
move.l d0,d4 * Daten in d0 erhalten
*
lsl.l d2,d4 * Word zurechtshiften
swap d4 * Zweites Byte in Byte 4
* * Erstes Byte in Byte 3
*
move.w d4,d3 * Erstes Byte holen
lsr.w d5,d3
and.w d1,d3
move.w 0(a3,d3.w),d3
move.w d3,(a1)+
move.w d3,(a2)+
*
add.w d4,d4
and.w d1,d4 * Zweites Byte holen
move.w 0(a3,d4.w),d4
move.w d4,(a1)+
move.w d4,(a2)+
*
dbra d6,ZOOM_22
*
lea 40-2(a0),a0
lea 80(a1),a1
lea 80(a2),a2
*
dbra d7,ZOOM_21
*
rts
*
*****************************************
*
ZOOM_MEDIUM:
move.w #160,d2 * Mittlere Auflösung Faktor 2
moveq #50,d3
move.w #639-2*160,d4
moveq #199-2*50,d5
bsr CALC_SCRPTR
*
add.w d1,d1 * Offsets an mittlere
add.w d0,d0 * Auflösung anpassen
add.w d0,d1 * Offsets auf Adresse vom
adda.w d1,a0 * Hintergrundbild addieren
*
lea 160(a1),a2 * Zeiger auf Hintergrundzeile+1
lea BUFFER_2,a3 * Tabellenzeiger
*
moveq #99,d7 * Anzahl Zeilen
move.w #$1FE,d1 * Maske
moveq #7,d5 * Konstante
*
ME2_10:
moveq #19,d6 * 20 Words pro Zeile
*
ME2_20:
moveq #1,d0 * 2 Planes bearbeiten
*
ME2_21:
move.w (a0)+,d4 * Sourcedaten holen
swap d4
move.w 2(a0),d4
*
lsl.l d2,d4 * Word zurechtshiften
swap d4 * Zweites Byte in Byte 4
* * Erstes Byte in Byte 3
*
move.w d4,d3 * Erstes Byte holen
lsr.w d5,d3
and.w d1,d3
move.w 0(a3,d3.w),d3
move.w d3,(a1)+
move.w d3,(a2)+
*
add.w d4,d4
and.w d1,d4 * Zweites Byte holen
move.w 0(a3,d4.w),d4
move.w d4,2(a1)
move.w d4,2(a2)
*
dbra d0,ME2_21
*
addq.l #4,a1
addq.l #4,a2
*
dbra d6,ME2_20
*
lea 80(a0),a0 * Zeiger auf die jeweils nächsten
lea 160(a1),a1 * Zeilen setzen
lea 160(a2),a2
*
dbra d7,ME2_10
*
rts
*
*****************************************
*
ZOOM_LOW:
moveq #80,d2 * Low-Res Faktor 2
moveq #50,d3
move.w #319-2*80,d4
moveq #199-2*50,d5
bsr CALC_SCRPTR
*
add.w d1,d1 * Offsets an niedere
lsl.w #2,d0 * Auflösung anpassen
add.w d0,d1 * Offsets auf Adresse des
adda.w d1,a0 * Hintergrundbildes addieren
*
lea 160(a1),a2
lea BUFFER_2,a3
*
moveq #99,d7 * Anzahl Zeilen-1
move.w #$1FE,d1 * Maske
moveq #7,d5 * Konstante
*
LO2_10:
moveq #9,d6 * 10 Words pro Zeile
*
LO2_20:
moveq #3,d0 * 4 Planes bearbeiten
*
LO2_21:
move.w (a0)+,d4 * Sourcedaten holen
swap d4
move.w 6(a0),d4
*
lsl.l d2,d4 * Word zurechtshiften
swap d4 * Zweites Byte in Byte 4
* * Erstes Byte in Byte 3
*
move.w d4,d3 * Erstes Byte holen
lsr.w d5,d3
and.w d1,d3
move.w 0(a3,d3.w),d3
move.w d3,(a1)+
move.w d3,(a2)+
*
add.w d4,d4
and.w d1,d4 * Zweites Byte holen
move.w 0(a3,d4.w),d4
move.w d4,6(a1)
move.w d4,6(a2)
dbra d0,LO2_21 * Nächste Einzelplane bearbeiten
*
addq.l #8,a1
addq.l #8,a2
dbra d6,LO2_20 * Nächste 4 Planes bearbeiten
*
lea 80(a0),a0 * Zeiger auf nächste
lea 160(a1),a1 * Zeilen setzen
lea 160(a2),a2
*
dbra d7,LO2_10
*
rts
*
*****************************************
*
QUICK:
movea.w #$8200,a1 * Hardwareadresse
move.l a0,d0 * Hintergrundbild
*
lsr.l #8,d0
movep.w d0,1(a1) * Bildadresse setzen
*
rts
*
*****************************************
*
CALC_SCRPTR:
movem.w MOUSE_POS(pc),d0-d1 * Mausposition holen
*
sub.w d2,d0 * Linke Lupenkante
bpl.s CHECK_1 * Ok....
moveq #0,d0
*
CHECK_1:
sub.w d3,d1 * Obere Lupenkante
bpl.s CHECK_2 * Ok....
moveq #0,d1
*
CHECK_2:
cmp.w d4,d0 * Rechte Lupenkante
bls.s CHECK_3 * Ok....
move.w d4,d0
*
CHECK_3:
cmp.w d5,d1 * Untere Pixelkante
bls.s CHECK_4 * Ok....
move.w d5,d1
*
CHECK_4:
moveq #15,d2 * Offset in Punkten auf die nächste links
and.w d0,d2 * liegende Wortgrenze
*
lsr.w #4,d0 * Offset in Bytes auf Wortgrenze
add.w d0,d0
mulu #80,d1 * Offset in Bytes/Zeile
rts
*****************************************
*
* In der nächsten Routine wird der Status
* der Tasten abgefragt.
* Entsprechend der Tasten und der Auflösung
* wird daraufhin umgeschaltet.
* Bei Farbe werden die Vektoren neu gesetzt, da
* sie beim Reset' überschrieben werden!
*
GET_MODE:
move.l SHIFT_ADDR(pc),a0 * Shiftstatus
moveq #%01101011,d0 * Wichtige Tasten ausmaskieren
and.b (a0),d0
*
cmpi.b #%1011,d0 * SHIFT-SHIFT-ALTERNATE?
bne.s MODE_END * Nein...
*
tas.b KEY_FLAG * War bereits gedrückt?
bne.s MODE_RTS * Ja... .
*
move.b MODE(pc),d0 * Modus wechseln
subq.b #1,d0 * (Nur möglich falls das Key-Flag
bpl.s SET_MODE * gelöscht war)
*
*gespeicherte Auflösung und Max-Wert für Mode holen
move.w RESOLUTION(pc),d1 * Auflösung
move.b MAXMODE(pc,d1.w),d0 * Maximalwert je Auflösung
*
SET_MODE:
move.b d0,MODE * Neuen Modus setzen
rts * Key-Flag bleibt
*
MODE_END:
clr.b KEY_FLAG * Flag löschen
* * Tasten losgelassen
MODE_RTS:
rts
*
MAXMODE:
dc.b 1 * Max.Modus in niedriger Auflösung
dc.b 1 * Max.Modus in mittlerer Auflösung
dc.b 3 * Max.Modus in hoher Auflösung
dc.b 0 * -
*
*****************************************
*
CONOUT:
movem.l a0-a2/d0-d2,-(sp) * Register retten
*
move.l 28(sp),-(sp) * Textadresse
move.w #PRINT_LINE,-(sp)
trap #GEMDOS
addq.l #6,sp
*
movem.l (sp)+,a0-a2/d0-d2 * Register laden
*
move.l (sp)+,(sp) * Return-Adresse setzen!
rts
*
*****************************************
*
dc.l $02101968 * Magic Number
*
NEW_MOUSE:
movem.l d0-d3/a0-a1,-(sp) * Register retten
*
move.b (a0)+,d0 * Ist es ein Mauspaket?!
cmpi.b #$f8,d0
bcs.s END_MOUSE * Nein...
cmpi.b #$fc,d0
bcc.s END_MOUSE * Nein...
*
move.w #319,d2 * Mausgrenzen je nach Auflösung
move.w #199,d3
move.w RESOLUTION(pc),d0 * Auflösung
beq.s CHK_MOUSE * War niedere
*
move.w #639,d2
subq.w #1,d0
beq.s CHK_MOUSE * War mittlere
*
move.w #399,d3 * War hohe
*
CHK_MOUSE:
move.b (a0)+,d0 * Hole relative Mausbewegung x
move.b (a0)+,d1 * und y
*
lea MOUSE_POS(pc),a1 * Addiere Mausbewegung
ext.w d0 * auf Mauskoordinaten, prüfe
ext.w d1 * auf Bildschirmgrenzen
*
add.w (a1),d0 * xpos := xpos + rx
bpl.s MS_1
moveq #0,d0 * if xpos < 0,xpos = 0 1
*
MS_1:
cmp.w d2,d0 * Abfrage anders
bls.s MS_2
move.w d2,d0 * if xpos > xmax,xpos = xmax
*
MS_2:
add.w 2(a1),d1 * ypos := ypos + ry
bpl.s MS_3
moveq #0,d1 * if ypos < 0 then ypos * 0
*
MS_3:
cmp.w d3,d1 * Abfrage anders
bls.s MS_4
move.w d3,d1 * if ypos > ymax then ypos = ymax
*
MS_4:
move.w d0,(a1)+ * Neue Mausposition sichern
move.w d1,(a1)+
*
END_MOUSE:
movem.l (sp)+,d0-d3/a0-a1 * Register laden
* * und weiter mit altem Mausinterrupt
move.l KBDVBASE+4(pc),-(sp)
rts
*
*****************************************
*
CREATE_TABLE:
lea BUFFER_2,a0 * Tabelle für Faktor 2 berechnen
moveq #0,d0
*
MAKE_20:
move.b d0,d1
moveq #7,d7 * 8 Bits pro Byte
*
MAKE_21:
move.b d1,d3 * Aus einem Byte ein Word machen
add.b d1,d1 * 2 x dasselbe Bit testen u. setzen
addx.w d2,d2
add.b d3,d3
addx.w d2,d2
dbra d7,MAKE_21
*
move.w d2,(a0)+
*
addq.b #1,d0
bne.s MAKE_20
*
*******************************************
*
lea BUFFER_4,a0 * Tabelle berechnen (Faktor 4)
moveq #-16,d4 * Maske Nibble links
moveq #15,d5 * Maske Nibble rechts
moveq #0,d0 * Startbyte
*
MAKE_40:
move.b d0,d1 * Aktuelles Byte in d1 bearbeiten
moveq #3,d7 * 4 mal 2 Bits /Byte
*
MAKE_41:
add.b d1,d1 * Mache aus 2 Bits
scs d2 * ein Byte
and.b d4,d2
add.b d1,d1
scs d3
and.b d5,d3
or.b d2,d3
move.b d3,(a0)+
dbra d7,MAKE_41
*
addq.b #1,d0 * Bis alle 256 Bytes
bne.s MAKE_40 * durchgearbeitet sind
*
*****************************************
*
lea BUFFER_8,a0 * Tabelle für Faktor 8
moveq #0,d0 * Startbyte
*
MAKE_80:
move.b d0,d1 * Aktuelles Byte in d1 bearbeiten
moveq #7,d2 * 8 Bits pro Byte
*
MAKE_81: add.b d1,d1 * aus Bit Byte machen
scs (a0)+
dbra d2,MAKE_81
*
addq.b #1,d0 * Bis alle 256 Bytes
bne.s MAKE_80 * bearbeitet wurden
*
rts
*
*****************************************
*
INSTAL:
moveq #3,d0 * Auflösung sichern
and.b $FFFF8260,d0
move.w d0,RESOLUTION
move.l $70,VBL_VEC * VBL-Vektor umleiten
move.l #NEW_VBL,$70
*
move.l $B8,XBIOS_VEC * XBIOS umleiten
move.l #NEW_XBIOS,$B8
*
*
*
move.l $4F2,d0 * Pointer auf Sysbase
beq.s UNDEF * Falls Null, dann direkt $E1B setzen
* * (Zur Sicherheit falls Adresse = 0)
*
move.l d0,a0
move.l 36(a0),a1 * Adresse des Kbdshift-Status
* * ab Tos-Version 1.2
*
cmpi.w #$0102,2(a0) * Tos-Version älter als 1.2?
bcc.s TOS_12 * Ja...
*
UNDEF:
move.w #$ElB,a1 * Sonst Ram-Adresse direkt setzen
*
TOS_12:
move.l a1,SHIFT_ADDR * Adresse sichern
*
rts
*
*****************************************
*
GRAF_MKSTATE:
lea CTRL_ARRAY,a0
*
move.w #79,(a0)+
clr.w (a0)+
move.w #5,(a0)+
clr.l (a0)
*
subq.l #6,a0
*
move.l #AES_DATA,d1 * graf_mkstate
move.w #$C8,d0
trap #2
*
move.l AES_DATA+12(pc),a0 * int_out
move.l 2(a0),MOUSE_POS * mouse x,y
*
rts
*
*****************************************
*
APP_INIT:
moveq #10,d0
bsr AES_CALL
*
rts
*
*****************************************
*
APP_EXIT: * Abmelden der
moveq #19,d0 * Applikation
bsr AES_CALL * AES aufrufen
*
rts
*
*****************************************
*
AES_CALL:
lea CTRL_ARRAY,a 0
*
move.w d0,(a0)+
clr.w (a0)+
move.w #1,(a0)+
clr.l (a0)
*
subq.l #6,a0
*
move.l #AES_DATA,d1
move.w #$C8,d0
trap #2
*
rts
*
*****************************************
*
PAUSE:
moveq #30,d0 * Warteschleife
*
WAITLOOP:
dbra d1,WAITLOOP * Prozessor beschäftigen
dbra d0,WAITLOOP
*
rts
*
**********************************************
*
* data
*
**********************************************
*
KBDVBASE: dc.l -1 * Vektortabelle-Adresse
dc.l -1 * Gesicherter Maus-Vektor
*
MOUSE_POS: dc.w 639 * Initialdaten Mausposition
dc.w 399
*
FLIPBASE_1: dc.l -1 * Basisadresse Bild 1
FLIPBASE_2: dc.l 32000 * Bild 2- Bild_l+32000
PHYSBASE: dc.l -1 * Hintergrund-Bildschirm
*
XBIOS_VEC: dc.l -1 * XBIOS-Adresse
VBL_VEC: dc.l -1 * VBL-Adresse
SHIFT_ADDR: dc.l -1 * Tastaturstatus-Adresse
*
RESOLUTION: dc.w -1 * Auflösung
COUNTER: dc.w REPEAT * Countdown f.Bildaufbau
*
AES_DATA: dc.l CTRL_ARRAY
dc.l AES_GLOBAL
dc.l CTRL_INT_IN
dc.l CTRL_INT_OUT
dc.l CTRL_ADDR_IN
dc.l CTRL_ADDR_OUT
*
AES_GLOBAL: dc.w 0
dc.w 0
dc.w 0
dc.l $02101968
ds.l 5
*
MODE: dc.b 0 * Vergrösserung aus
KEY_FLAG: dc.b 0 * Flag "Tasten werden gedrückt gehalten"
*
MESSAGE: dc.b $1b,'E',10
dc.b 'R E A L T I M E M A G N I F I E R',10,10,10,13
dc.b ' Written by Alexander Beller',10,10,13
dc.b ' (C) 1988 by IMAGIC Grafik',0
ds.w 0
TEXT_END:
**********************************************
*
bss
*
**********************************************
BSS_START:
BUFFER_2: ds.b 256*2 *
BUFFER_4: ds.b 256*4 * Platz für Tabellen
BUFFER_8: ds.b 256*8
CTRL_ARRAY: ds.w 10
CTRL_INT_IN: ds.w 128
CTRL_INT_OUT: ds.w 128
CTRL_ADDR_IN: ds.l 128
CTRL_ADDR_OUT: ds.l 128
FLIPSCR_1: ds.b 32256 * Bildspeicher 1
FLIPSCR_2: ds.b 32000 * Bildspeicher 2
BSS_END: ds.b 0 * Ende des residenten Teils
ds.b 2048 * Programm-Stack
USER_STACK: ds.b 0
**********************************************
end