d50fb015c833c85514026d54207f6bc485123689
[xscreensaver] / hacks / apple2.c
1 /* xscreensaver, Copyright (c) 1998-2010 Jamie Zawinski <jwz@jwz.org>
2  *
3  * Permission to use, copy, modify, distribute, and sell this software and its
4  * documentation for any purpose is hereby granted without fee, provided that
5  * the above copyright notice appear in all copies and that both that
6  * copyright notice and this permission notice appear in supporting
7  * documentation.  No representations are made about the suitability of this
8  * software for any purpose.  It is provided "as is" without express or
9  * implied warranty.
10  *
11  * Apple ][ CRT simulator, by Trevor Blackwell <tlb@tlb.org>
12  * with additional work by Jamie Zawinski <jwz@jwz.org>
13  */
14
15 #include <math.h>
16 #include "screenhackI.h"
17 #include "apple2.h"
18
19 #ifdef HAVE_XSHM_EXTENSION
20 #include "xshm.h"
21 #endif
22
23 #define DEBUG
24
25 /*
26  * Implementation notes
27  *
28  * The A2 had 3 display modes: text, lores, and hires. Text was 40x24, and it
29  * disabled color in the TV. Lores gave you 40x48 graphics blocks, using the
30  * same memory as the text screen. Each could be one of 16 colors. Hires gave
31  * you 280x192 pixels. Odd pixels were blue or purple, and even pixels were
32  * orange or green depending on the setting of the high bit in each byte.
33  *
34  * The graphics modes could also have 4 lines of text at the bottom. This was
35  * fairly unreadable if you had a color monitor.
36  *
37  * Each mode had 2 different screens using different memory space. In hires
38  * mode this was sometimes used for double buffering, but more often the lower
39  * screen was full of code/data and the upper screen was used for display, so
40  * you got random garbage on the screen.
41  *
42  * The text font is based on X's standard 6x10 font, with a few tweaks like
43  * putting a slash across the zero.
44  *
45  * To use this, you'll call apple2(display, window, duration,
46  * controller) where the function controller defines what will happen.
47  * See bsod.c and apple2-main.c for example controllers. The
48  * controller function gets called whenever the machine ready to start
49  * something new. By setting sim->printing or sim->typing, it'll be
50  * busy for some time spitting characters out one at a time. By
51  * setting *next_actiontime+=X.X, it'll pause and just update the screen
52  * for that long before calling the controller function again.
53  *
54  * By setting stepno to A2CONTROLLER_DONE, the loop will end. It will also end
55  * after the time specified by the delay parameter. In either case, it calls
56  * the controller with stepno==A2CONTROLLER_FREE to allow it to release any
57  * memory.
58  *
59  * The void* apple2_sim_t::controller_data is for the use of the controller.
60  * It will be initialize to NULL, and the controller can store its own state
61  * there.
62  *
63  */
64
65 void
66 a2_scroll(apple2_state_t *st)
67 {
68   int i;
69   st->textlines[st->cursy][st->cursx] |= 0xc0;     /* turn off cursor */
70
71   for (i=0; i<23; i++) {
72     memcpy(st->textlines[i],st->textlines[i+1],40);
73   }
74   memset(st->textlines[23],0xe0,40);
75 }
76
77 static void
78 a2_printc_1(apple2_state_t *st, char c, int scroll_p)
79 {
80   st->textlines[st->cursy][st->cursx] |= 0xc0; /* turn off blink */
81
82   if (c == '\n')                      /* ^J == NL */
83     {
84       if (st->cursy==23)
85         {
86           if (scroll_p)
87             a2_scroll(st);
88         }
89       else
90         {
91           st->cursy++;
92         }
93       st->cursx=0;
94     }
95   else if (c == 014)                  /* ^L == CLS, Home */
96     {
97       a2_cls(st);
98       a2_goto(st,0,0);
99     }
100   else if (c == '\t')                 /* ^I == tab */
101     {
102       a2_goto(st, st->cursy, (st->cursx+8)&~7);
103     }
104   else if (c == 010)                  /* ^H == backspace */
105     {
106       st->textlines[st->cursy][st->cursx]=0xe0;
107       a2_goto(st, st->cursy, st->cursx-1);
108     }
109   else if (c == '\r')                 /* ^M == CR */
110     {
111       st->cursx=0;
112     }
113   else
114     {
115       st->textlines[st->cursy][st->cursx]=c ^ 0xc0;
116       st->cursx++;
117       if (st->cursx==40) {
118         if (st->cursy==23) {
119           if (scroll_p)
120             a2_scroll(st);
121         } else {
122           st->cursy++;
123         }
124         st->cursx=0;
125       }
126     }
127
128   st->textlines[st->cursy][st->cursx] &= 0x7f; /* turn on blink */
129 }
130
131 void
132 a2_printc(apple2_state_t *st, char c)
133 {
134   a2_printc_1(st, c, 1);
135 }
136
137 void
138 a2_printc_noscroll(apple2_state_t *st, char c)
139 {
140   a2_printc_1(st, c, 0);
141 }
142
143
144 void
145 a2_prints(apple2_state_t *st, char *s)
146 {
147   while (*s) a2_printc(st, *s++);
148 }
149
150 void
151 a2_goto(apple2_state_t *st, int r, int c)
152 {
153   if (r > 23) r = 23;
154   if (c > 39) r = 39;
155   st->textlines[st->cursy][st->cursx] |= 0xc0; /* turn off blink */
156   st->cursy=r;
157   st->cursx=c;
158   st->textlines[st->cursy][st->cursx] &= 0x7f; /* turn on blink */
159 }
160
161 void
162 a2_cls(apple2_state_t *st)
163 {
164   int i;
165   for (i=0; i<24; i++) {
166     memset(st->textlines[i],0xe0,40);
167   }
168 }
169
170 void
171 a2_clear_gr(apple2_state_t *st)
172 {
173   int i;
174   for (i=0; i<24; i++) {
175     memset(st->textlines[i],0x00,40);
176   }
177 }
178
179 void
180 a2_clear_hgr(apple2_state_t *st)
181 {
182   int i;
183   for (i=0; i<192; i++) {
184     memset(st->hireslines[i],0,40);
185   }
186 }
187
188 void
189 a2_invalidate(apple2_state_t *st)
190 {
191 }
192
193 void
194 a2_poke(apple2_state_t *st, int addr, int val)
195 {
196
197   if (addr>=0x400 && addr<0x800) {
198     /* text memory */
199     int row=((addr&0x380)/0x80) + ((addr&0x7f)/0x28)*8;
200     int col=(addr&0x7f)%0x28;
201     if (row<24 && col<40) {
202       st->textlines[row][col]=val;
203       if (!(st->gr_mode&(A2_GR_HIRES)) ||
204           (!(st->gr_mode&(A2_GR_FULL)) && row>=20)) {
205       }
206     }
207   }
208   else if (addr>=0x2000 && addr<0x4000) {
209     int row=(((addr&0x1c00) / 0x400) * 1 +
210              ((addr&0x0380) / 0x80) * 8 +
211              ((addr&0x0078) / 0x28) * 64);
212     int col=((addr&0x07f)%0x28);
213     if (row<192 && col<40) {
214       st->hireslines[row][col]=val;
215       if (st->gr_mode&A2_GR_HIRES) {
216       }
217     }
218   }
219 }
220
221 void
222 a2_hplot(apple2_state_t *st, int hcolor, int x, int y)
223 {
224   int highbit,run;
225
226   highbit=((hcolor<<5)&0x80) ^ 0x80; /* capture bit 2 into bit 7 */
227
228   if (y<0 || y>=192 || x<0 || x>=280) return;
229
230   for (run=0; run<2 && x<280; run++) {
231     unsigned char *vidbyte = &st->hireslines[y][x/7];
232     unsigned char whichbit=1<<(x%7);
233     int masked_bit;
234
235     *vidbyte = (*vidbyte & 0x7f) | highbit;
236
237     /* use either bit 0 or 1 of hcolor for odd or even pixels */
238     masked_bit = (hcolor>>(1-(x&1)))&1;
239
240     /* Set whichbit to 1 or 0 depending on color */
241     *vidbyte = (*vidbyte & ~whichbit) | (masked_bit ? whichbit : 0);
242
243     x++;
244   }
245 }
246
247 void
248 a2_hline(apple2_state_t *st, int hcolor, int x1, int y1, int x2, int y2)
249 {
250   int dx,dy,incx,incy,x,y,balance;
251
252   /* Bresenham's line drawing algorithm */
253
254   if (x2>=x1) {
255     dx=x2-x1;
256     incx=1;
257   } else {
258     dx=x1-x2;
259     incx=-1;
260   }
261   if (y2>=y1) {
262     dy=y2-y1;
263     incy=1;
264   } else {
265     dy=y1-y2;
266     incy=-1;
267   }
268
269   x=x1; y=y1;
270
271   if (dx>=dy) {
272     dy*=2;
273     balance=dy-dx;
274     dx*=2;
275     while (x!=x2) {
276       a2_hplot(st, hcolor, x, y);
277       if (balance>=0) {
278         y+=incy;
279         balance-=dx;
280       }
281       balance+=dy;
282       x+=incx;
283     }
284     a2_hplot(st, hcolor, x, y);
285   } else {
286     dx*=2;
287     balance=dx-dy;
288     dy*=2;
289     while (y!=y2) {
290       a2_hplot(st, hcolor, x, y);
291       if (balance>=0) {
292         x+=incx;
293         balance-=dy;
294       }
295       balance+=dx;
296       y+=incy;
297     }
298     a2_hplot(st, hcolor, x, y);
299   }
300 }
301
302 void
303 a2_plot(apple2_state_t *st, int color, int x, int y)
304 {
305   int textrow=y/2;
306   unsigned char byte;
307
308   if (x<0 || x>=40 || y<0 || y>=48) return;
309
310   byte=st->textlines[textrow][x];
311   if (y&1) {
312     byte = (byte&0xf0) | (color&0x0f);
313   } else {
314     byte = (byte&0x0f) | ((color&0x0f)<<4);
315   }
316   st->textlines[textrow][x]=byte;
317 }
318
319 void
320 a2_display_image_loading(apple2_state_t *st, unsigned char *image,
321                          int lineno)
322 {
323   /*
324     When loading images,it would normally just load the big binary
325     dump into screen memory while you watched. Because of the way
326     screen memory was laid out, it wouldn't load from the top down,
327     but in a funny interleaved way. You should call this with lineno
328     increasing from 0 thru 191 over a period of a few seconds.
329   */
330
331   int row=(((lineno / 24) % 8) * 1 +
332            ((lineno / 3 ) % 8) * 8 +
333            ((lineno / 1 ) % 3) * 64);
334
335   memcpy (st->hireslines[row], &image[row * 40], 40);
336 }
337
338 /*
339   Simulate plausible initial memory contents for running a program.
340 */
341 void
342 a2_init_memory_active(apple2_sim_t *sim)
343 {
344   int i,j,x,y,c;
345   int addr=0;
346   apple2_state_t *st=sim->st;
347
348   while (addr<0x4000) {
349     int n;
350
351     switch (random()%4) {
352     case 0:
353     case 1:
354       n=random()%500;
355       for (i=0; i<n && addr<0x4000; i++) {
356         unsigned char rb=((random()%6==0 ? 0 : random()%16) |
357                    ((random()%5==0 ? 0 : random()%16)<<4));
358         a2_poke(st, addr++, rb);
359       }
360       break;
361
362     case 2:
363       /* Simulate shapes stored in memory. We use the font since we have it.
364          Unreadable, since rows of each character are stored in consecutive
365          bytes. It was typical to store each of the 7 possible shifts of
366          bitmaps, for fastest blitting to the screen. */
367       x=random()%(sim->text_im->width);
368       for (i=0; i<100; i++) {
369         for (y=0; y<8; y++) {
370           c=0;
371           for (j=0; j<8; j++) {
372             c |= XGetPixel(sim->text_im, (x+j)%sim->text_im->width, y)<<j;
373           }
374           a2_poke(st, addr++, c);
375         }
376         x=(x+1)%(sim->text_im->width);
377       }
378       break;
379
380     case 3:
381       if (addr>0x2000) {
382         n=random()%200;
383         for (i=0; i<n && addr<0x4000; i++) {
384           a2_poke(st, addr++, 0);
385         }
386       }
387       break;
388
389     }
390   }
391 }
392
393
394 #if 1  /* jwz: since MacOS doesn't have "6x10", I dumped this font to an XBM...
395         */
396
397 #include "images/apple2font.xbm"
398
399 static void
400 a2_make_font(apple2_sim_t *sim)
401 {
402   Pixmap text_pm = XCreatePixmapFromBitmapData (sim->dpy, sim->window,
403                                                 (char *) apple2_font_bits,
404                                                 apple2_font_width,
405                                                 apple2_font_height,
406                                                 1, 0, 1);
407   if (apple2_font_width != 64*7) abort();
408   if (apple2_font_height != 8) abort();
409   sim->text_im = XGetImage(sim->dpy, text_pm, 0, 0, 
410                            apple2_font_width, apple2_font_height,
411                            ~0L, ZPixmap);
412   XFreePixmap(sim->dpy, text_pm);
413 }
414
415 #else /* 0 */
416
417 /* This table lists fixes for characters that differ from the standard 6x10
418    font. Each encodes a pixel, as (charindex*7 + x) + (y<<10) + (value<<15)
419    where value is 0 for white and 1 for black. */
420 static const unsigned short a2_fixfont[] = {
421   /* Fix $ */  0x8421, 0x941d,
422   /* Fix % */  0x8024, 0x0028, 0x8425, 0x0426, 0x0825, 0x1027, 0x1426, 0x9427,
423                0x1824, 0x9828,
424   /* Fix * */  0x8049, 0x8449, 0x8849, 0x0c47, 0x0c48, 0x0c4a, 0x0c4b, 0x9049,
425                0x9449, 0x9849,
426   /* Fix , */  0x9057, 0x1458, 0x9856, 0x1857, 0x1c56,
427   /* Fix . */  0x1465, 0x1864, 0x1866, 0x1c65,
428   /* Fix / */  0x006e, 0x186a,
429   /* Fix 0 */  0x8874, 0x8c73, 0x9072,
430   /* Fix 1 */  0x0878, 0x1878, 0x187c,
431   /* Fix 5 */  0x8895, 0x0c94, 0x0c95,
432   /* Fix 6 */  0x809f, 0x8c9c, 0x109c,
433   /* Fix 7 */  0x8ca4, 0x0ca5, 0x90a3, 0x10a4,
434   /* Fix 9 */  0x08b3, 0x8cb3, 0x98b0,
435   /* Fix : */  0x04b9, 0x08b8, 0x08ba, 0x0cb9, 0x90b9, 0x14b9, 0x18b8, 0x18b9,
436                0x18ba, 0x1cb9,
437   /* Fix ; */  0x04c0, 0x08bf, 0x08c1, 0x0cc0, 0x90c0, 0x14c1, 0x98bf, 0x18c0,
438                0x1cbf,
439   /* Fix < */  0x80c8, 0x00c9, 0x84c7, 0x04c8, 0x88c6, 0x08c7, 0x8cc5, 0x0cc6,
440                0x90c6, 0x10c7,
441                0x94c7, 0x14c8, 0x98c8, 0x18c9,
442   /* Fix > */  0x80d3, 0x00d4, 0x84d4, 0x04d5, 0x88d5, 0x08d6, 0x8cd6, 0x0cd7,
443                0x90d5, 0x10d6,
444                0x94d4, 0x14d5, 0x98d3, 0x18d4,
445   /* Fix @ */  0x88e3, 0x08e4, 0x8ce4, 0x98e5,
446   /* Fix B */  0x84ef, 0x04f0, 0x88ef, 0x08f0, 0x8cef, 0x90ef, 0x10f0, 0x94ef,
447                0x14f0,
448   /* Fix D */  0x84fd, 0x04fe, 0x88fd, 0x08fe, 0x8cfd, 0x0cfe, 0x90fd, 0x10fe,
449                0x94fd, 0x14fe,
450   /* Fix G */  0x8116, 0x0516, 0x9916,
451   /* Fix J */  0x0129, 0x012a, 0x052a, 0x852b, 0x092a, 0x892b, 0x0d2a, 0x8d2b,
452                0x112a, 0x912b,
453                0x152a, 0x952b, 0x992a,
454   /* Fix M */  0x853d, 0x853f, 0x093d, 0x893e, 0x093f,
455   /* Fix Q */  0x915a, 0x155a, 0x955b, 0x155c, 0x195b, 0x995c, 0x1d5c,
456   /* Fix V */  0x8d7b, 0x0d7c, 0x0d7e, 0x8d7f, 0x917b, 0x117c, 0x117e, 0x917f,
457   /* Fix [ */  0x819e, 0x81a2, 0x859e, 0x899e, 0x8d9e, 0x919e, 0x959e, 0x999e,
458                0x99a2,
459   /* Fix \ */  0x01a5, 0x19a9,
460   /* Fix ] */  0x81ac, 0x81b0, 0x85b0, 0x89b0, 0x8db0, 0x91b0, 0x95b0, 0x99ac,
461                0x99b0,
462   /* Fix ^ */  0x01b5, 0x05b4, 0x05b6, 0x09b3, 0x89b5, 0x09b7, 0x8db4, 0x8db6,
463                0x91b3, 0x91b7,
464   /* Fix _ */  0x9db9, 0x9dbf,
465   0,
466 };
467
468 static void
469 a2_make_font(apple2_sim_t *sim)
470 {
471   /*
472     Generate the font. It used a 5x7 font which looks a lot like the standard X
473     6x10 font, with a few differences. So we render up all the uppercase
474     letters of 6x10, and make a few tweaks (like putting a slash across the
475     zero) according to fixfont.
476    */
477
478   int i;
479   const char *def_font="6x10";
480   XFontStruct *font;
481   Pixmap text_pm;
482   GC gc;
483   XGCValues gcv;
484
485   font = XLoadQueryFont (sim->dpy, def_font);
486   if (!font) {
487     fprintf(stderr, "%s: can't load font %s\n", progname, def_font);
488     abort();
489   }
490
491   text_pm=XCreatePixmap(sim->dpy, sim->window, 64*7, 8, 1);
492
493   memset(&gcv, 0, sizeof(gcv));
494   gcv.foreground=1;
495   gcv.background=0;
496   gcv.font=font->fid;
497   gc=XCreateGC(sim->dpy, text_pm, GCFont|GCBackground|GCForeground, &gcv);
498
499   XSetForeground(sim->dpy, gc, 0);
500   XFillRectangle(sim->dpy, text_pm, gc, 0, 0, 64*7, 8);
501   XSetForeground(sim->dpy, gc, 1);
502   for (i=0; i<64; i++) {
503     char c=32+i;
504     int x=7*i+1;
505     int y=7;
506     if (c=='0') {
507       c='O';
508       XDrawString(sim->dpy, text_pm, gc, x, y, &c, 1);
509     } else {
510       XDrawString(sim->dpy, text_pm, gc, x, y, &c, 1);
511     }
512   }
513
514 # if 0
515   for (i=0; a2_fixfont[i]; i++) {
516     XSetForeground (sim->dpy, gc, (a2_fixfont[i]>>15)&1);
517     XDrawPoint(sim->dpy, text_pm, gc, a2_fixfont[i]&0x3ff,
518               (a2_fixfont[i]>>10)&0xf);
519   }
520   XWriteBitmapFile(sim->dpy, "/tmp/a2font.xbm", text_pm, 64*7, 8, -1, -1);
521 # endif
522
523   sim->text_im = XGetImage(sim->dpy, text_pm, 0, 0, 64*7, 8, ~0L, ZPixmap);
524   XFreeGC(sim->dpy, gc);
525   XFreePixmap(sim->dpy, text_pm);
526
527   for (i=0; a2_fixfont[i]; i++) {
528     XPutPixel(sim->text_im, a2_fixfont[i]&0x3ff,
529               (a2_fixfont[i]>>10)&0xf,
530               (a2_fixfont[i]>>15)&1);
531   }
532 }
533
534 #endif /* 0 */
535
536 apple2_sim_t *
537 apple2_start(Display *dpy, Window window, int delay,
538              void (*controller)(apple2_sim_t *sim,
539                                 int *stepno,
540                                 double *next_actiontime))
541 {
542   apple2_sim_t *sim;
543
544   sim=(apple2_sim_t *)calloc(1,sizeof(apple2_sim_t));
545   sim->dpy = dpy;
546   sim->window = window;
547   sim->delay = delay;
548   sim->controller = controller;
549
550   sim->st = (apple2_state_t *)calloc(1,sizeof(apple2_state_t));
551   sim->dec = analogtv_allocate(dpy, window);
552   sim->inp = analogtv_input_allocate();
553
554   sim->reception.input = sim->inp;
555   sim->reception.level = 1.0;
556
557   sim->prompt=']';
558
559   if (random()%4==0 && !sim->dec->use_cmap && sim->dec->use_color && sim->dec->visbits>=8) {
560     sim->dec->flutter_tint=1;
561   }
562   else if (random()%3==0) {
563     sim->dec->flutter_horiz_desync=1;
564   }
565   sim->typing_rate = 1.0;
566
567   analogtv_set_defaults(sim->dec, "");
568   sim->dec->squish_control=0.05;
569   analogtv_setup_sync(sim->inp, 1, 0);
570
571
572   a2_make_font(sim);
573
574   sim->stepno=0;
575   a2_goto(sim->st,23,0);
576
577   if (random()%2==0) sim->basetime_tv.tv_sec -= 1; /* random blink phase */
578   sim->next_actiontime=0.0;
579
580   sim->curtime=0.0;
581   sim->next_actiontime=sim->curtime;
582   sim->controller (sim, &sim->stepno, &sim->next_actiontime);
583
584 # ifdef GETTIMEOFDAY_TWO_ARGS
585   gettimeofday(&sim->basetime_tv, NULL);
586 # else
587   gettimeofday(&sim->basetime_tv);
588 # endif
589
590   return sim;
591 }
592
593 int
594 apple2_one_frame (apple2_sim_t *sim)
595 {
596     double blinkphase;
597     int i;
598     int textrow;
599
600     if (sim->stepno==A2CONTROLLER_DONE)
601       goto DONE;  /* when caller says we're done, be done, dammit! */
602
603     {
604       struct timeval curtime_tv;
605 # ifdef GETTIMEOFDAY_TWO_ARGS
606       struct timezone tzp;
607       gettimeofday(&curtime_tv, &tzp);
608 # else
609       gettimeofday(&curtime_tv);
610 # endif
611       sim->curtime=(curtime_tv.tv_sec - sim->basetime_tv.tv_sec) +
612         0.000001*(curtime_tv.tv_usec - sim->basetime_tv.tv_usec);
613       if (sim->curtime > sim->dec->powerup)
614         sim->dec->powerup=sim->curtime;
615     }
616
617     blinkphase=sim->curtime/0.8;
618
619     /* The blinking rate was controlled by 555 timer with a resistor/capacitor
620        time constant. Because the capacitor was electrolytic, the flash rate
621        varied somewhat between machines. I'm guessing 1.6 seconds/cycle was
622        reasonable. (I soldered a resistor in mine to make it blink faster.) */
623     i=sim->st->blink;
624     sim->st->blink=((int)blinkphase)&1;
625     if (sim->st->blink!=i && !(sim->st->gr_mode&A2_GR_FULL)) {
626       int downcounter=0;
627       /* For every row with blinking text, set the changed flag. This basically
628          works great except with random screen garbage in text mode, when we
629          end up redrawing the whole screen every second */
630       int row, col;
631       for (row=(sim->st->gr_mode ? 20 : 0); row<24; row++) {
632         for (col=0; col<40; col++) {
633           int c=sim->st->textlines[row][col];
634           if ((c & 0xc0) == 0x40) {
635             downcounter=4;
636             break;
637           }
638         }
639         if (downcounter>0) {
640           downcounter--;
641         }
642       }
643     }
644
645     if (sim->curtime >= sim->delay)
646       sim->stepno = A2CONTROLLER_DONE;
647
648     if (sim->printing) {
649       int nlcnt=0;
650       while (*sim->printing) {
651         if (*sim->printing=='\001') { /* pause */
652           sim->printing++;
653           break;
654         }
655         else if (*sim->printing=='\n') {
656           a2_printc(sim->st,*sim->printing);
657           sim->printing++;
658           nlcnt++;
659           if (nlcnt>=2) break;
660         }
661         else {
662           a2_printc(sim->st,*sim->printing);
663           sim->printing++;
664         }
665       }
666       if (!*sim->printing) sim->printing=NULL;
667     }
668     else if (sim->curtime >= sim->next_actiontime) {
669       if (sim->typing) {
670
671         int c;
672         /* If we're in the midst of typing a string, emit a character with
673            random timing. */
674         c =*sim->typing;
675         if (c==0) {
676           sim->typing=NULL;
677         }
678         else {
679           sim->typing++;
680           a2_printc(sim->st, c);
681           if (c=='\r' || c=='\n') {
682             sim->next_actiontime = sim->curtime;
683           }
684           else if (c==010) {
685             sim->next_actiontime = sim->curtime + 0.1;
686           }
687           else {
688             sim->next_actiontime = (sim->curtime +
689                                (((random()%1000)*0.001 + 0.3) *
690                                 sim->typing_rate));
691           }
692         }
693       } else {
694         sim->next_actiontime = sim->curtime;
695
696         sim->controller (sim, &sim->stepno, &sim->next_actiontime);
697
698         if (sim->stepno==A2CONTROLLER_DONE) {
699
700         DONE:
701           sim->stepno=A2CONTROLLER_FREE;
702           sim->controller (sim, &sim->stepno, &sim->next_actiontime);
703
704           XClearWindow(sim->dpy, sim->window);
705
706           /* free sim */
707           /* This is from a2_make_font */
708           free(sim->text_im->data);
709           sim->text_im->data = 0;
710           XDestroyImage(sim->text_im);
711
712           /* And free else */
713           analogtv_release(sim->dec);
714           free(sim->st);
715           free(sim->inp);
716           free(sim);
717
718           return 0;
719         }
720
721       }
722     }
723
724
725     analogtv_setup_sync(sim->inp, sim->st->gr_mode? 1 : 0, 0);
726     analogtv_setup_frame(sim->dec);
727
728     for (textrow=0; textrow<24; textrow++) {
729       int row;
730       for (row=textrow*8; row<textrow*8+8; row++) {
731
732         /* First we generate the pattern that the video circuitry shifts out
733            of memory. It has a 14.something MHz dot clock, equal to 4 times
734            the color burst frequency. So each group of 4 bits defines a color.
735            Each character position, or byte in hires, defines 14 dots, so odd
736            and even bytes have different color spaces. So, pattern[0..600]
737            gets the dots for one scan line. */
738
739         signed char *pp=&sim->inp->signal[row+ANALOGTV_TOP+4][ANALOGTV_PIC_START+100];
740
741         if ((sim->st->gr_mode&A2_GR_HIRES) &&
742             (row<160 || (sim->st->gr_mode&A2_GR_FULL))) {
743           int col;
744
745           /* Emulate the mysterious pink line, due to a bit getting
746              stuck in a shift register between the end of the last
747              row and the beginning of this one. */
748           if ((sim->st->hireslines[row][0] & 0x80) &&
749               (sim->st->hireslines[row][39]&0x40)) {
750             pp[-1]=ANALOGTV_WHITE_LEVEL;
751           }
752
753           for (col=0; col<40; col++) {
754             unsigned char b=sim->st->hireslines[row][col];
755             int shift=(b&0x80)?0:1;
756
757             /* Each of the low 7 bits in hires mode corresponded to 2 dot
758                clocks, shifted by one if the high bit was set. */
759             for (i=0; i<7; i++) {
760               pp[shift+1] = pp[shift] = (((b>>i)&1)
761                                          ?ANALOGTV_WHITE_LEVEL
762                                          :ANALOGTV_BLACK_LEVEL);
763               pp+=2;
764             }
765           }
766         }
767         else if ((sim->st->gr_mode&A2_GR_LORES) &&
768                  (row<160 || (sim->st->gr_mode&A2_GR_FULL))) {
769           int col;
770           for (col=0; col<40; col++) {
771             unsigned char nib=((sim->st->textlines[textrow][col] >> (((row/4)&1)*4))
772                         & 0xf);
773             /* The low or high nybble was shifted out one bit at a time. */
774             for (i=0; i<14; i++) {
775               *pp = (((nib>>((col*14+i)&3))&1)
776                      ?ANALOGTV_WHITE_LEVEL
777                      :ANALOGTV_BLACK_LEVEL);
778               pp++;
779             }
780           }
781         }
782         else {
783           int col;
784           for (col=0; col<40; col++) {
785             int rev;
786             int c=sim->st->textlines[textrow][col]&0xff;
787             /* hi bits control inverse/blink as follows:
788                0x00: inverse
789                0x40: blink
790                0x80: normal
791                0xc0: normal */
792             rev=!(c&0x80) && (!(c&0x40) || sim->st->blink);
793
794             for (i=0; i<7; i++) {
795               unsigned long pix=XGetPixel(sim->text_im,
796                                           ((c&0x3f)^0x20)*7+i,
797                                           row%8);
798               pp[1] = pp[2] = ((pix^rev)
799                                ?ANALOGTV_WHITE_LEVEL
800                                :ANALOGTV_BLACK_LEVEL);
801               pp+=2;
802             }
803           }
804         }
805       }
806     }
807     analogtv_init_signal(sim->dec, 0.02);
808     analogtv_reception_update(&sim->reception);
809     analogtv_add_signal(sim->dec, &sim->reception);
810     analogtv_draw(sim->dec);
811  
812     return 1;
813 }
814
815
816 #if 0
817 void
818 a2controller_test(apple2_sim_t *sim, int *stepno, double *next_actiontime)
819 {
820   int row,col;
821
822   switch(*stepno) {
823   case 0:
824     a2_invalidate(sim->st);
825     /*
826       For testing color rendering. The spec is:
827       red grn blu
828       0  black       0   0   0
829       1  red       227  30  96
830       2  dk blue    96  78 189
831       3  purple    255  68 253
832       4  dk green    0 163  96
833       5  gray      156 156 156
834       6  med blue   20 207 253
835       7  lt blue   208 195 255
836       8  brown      96 114   3
837       9  orange    255 106  60
838       10 grey      156 156 156
839       11 pink      255 160 208
840       12 lt green   20 245  60
841       13 yellow    208 221 141
842       14 aqua      114 255 208
843       15 white     255 255 255
844     */
845     sim->st->gr_mode=A2_GR_LORES;
846     for (row=0; row<24; row++) {
847       for (col=0; col<40; col++) {
848         sim->st->textlines[row][col]=(row&15)*17;
849       }
850     }
851     *next_actiontime+=0.4;
852     *stepno=99;
853     break;
854
855   case 99:
856     if (sim->curtime > 10) *stepno=-1;
857     break;
858   }
859 }
860 #endif