318 lines
13 KiB
C
318 lines
13 KiB
C
/* SPDX-License-Identifier: GPL-3.0-or-later
|
|
* Sound Lab: ordinary 6809/Disk BASIC guest. No emulator-private API.
|
|
* Audio routing uses the existing GPL VCC Plus SSC SDK unchanged.
|
|
*/
|
|
#include <cmoc.h>
|
|
#include <coco.h>
|
|
#include <decbfile.h>
|
|
#include <vcc/ssc.h>
|
|
#include "vectors.h"
|
|
#include "build.h"
|
|
|
|
#define LOG_CAPACITY 1536
|
|
/* PCLEAR1 reserves the one unused PMODE page at $0E00..$13FF.
|
|
* Sound Lab is text-only; using that page leaves ample native stack space. */
|
|
#define logbuf ((char *)0x0E00)
|
|
static char linebuf[180], note[49];
|
|
static unsigned used, records, checksum, runno=1, route, transmitted, elapsed;
|
|
static unsigned saved_used, saved_records, saved_checksum;
|
|
static unsigned char saved_complete, have_checkpoint;
|
|
static unsigned char disk_mode, created, aborted, timedout, before, after, busy_seen;
|
|
static unsigned char disk_error, group, target, video, model;
|
|
static unsigned attempt;
|
|
static DECBDrive drives[1];
|
|
static DECBFile report;
|
|
static char filename[13];
|
|
static const char *targets[]={"VCCPLUS","REAL_COCO","MISTER"};
|
|
static const char *models[]={"COCO3","COCO2_64K","UNKNOWN_64K"};
|
|
|
|
/* Unlike a C volatile expression, each call really reads the bus once. */
|
|
asm unsigned char raw_status(void) { asm { ldb $FF7E } }
|
|
asm unsigned ticks(void) { asm { ldd $0112 } }
|
|
asm void put_byte(unsigned char value) { asm { ldb 3,s
|
|
stb $FF7E } }
|
|
|
|
static unsigned crc_byte(unsigned crc, unsigned char c)
|
|
{
|
|
unsigned char bit;
|
|
crc ^= (unsigned)c << 8;
|
|
for(bit=0;bit<8;++bit) crc=(crc&0x8000)?(crc<<1)^0x1021:crc<<1;
|
|
return crc;
|
|
}
|
|
|
|
static void record(const char *s)
|
|
{
|
|
unsigned n=strlen(s), i;
|
|
if(used+n+2>=LOG_CAPACITY) return; /* Caller reserves one full case. */
|
|
for(i=0;i<n;++i) { logbuf[used++]=s[i]; checksum=crc_byte(checksum,s[i]); }
|
|
logbuf[used++]='\r'; checksum=crc_byte(checksum,'\r');
|
|
logbuf[used++]='\n'; checksum=crc_byte(checksum,'\n');
|
|
++records;
|
|
}
|
|
|
|
static unsigned char key(void)
|
|
{
|
|
unsigned char c;
|
|
do c=inkey(); while(!c);
|
|
return (unsigned char)toupper(c);
|
|
}
|
|
|
|
static void header(const char *title)
|
|
{
|
|
cls(0); printf("SOUND LAB %s\n%s\n\n",SOUNDLAB_BUILD,title);
|
|
}
|
|
|
|
static void make_name(void) { sprintf(filename,"SND%04u.TXT",runno); }
|
|
|
|
static unsigned char reserve_report(void)
|
|
{
|
|
unsigned char err;
|
|
while(runno<=9999) {
|
|
make_name();
|
|
err=decb_createSectorFile(&report,0,filename,DECB_TYPE_ASCII_TEXT,DECB_FORMAT_ASCII);
|
|
if(err==DECB_OK) { created=1; return decb_closeSectorFile(&report); }
|
|
if(err!=DECB_ERR_ALREADY_EXISTS) return err;
|
|
++runno;
|
|
}
|
|
return DECB_ERR_OUT_OF_SPACE;
|
|
}
|
|
|
|
/* Rewrites only the file reserved by this run, never an existing report.
|
|
* RAM remains authoritative after an I/O failure. Close flushes FAT+directory.
|
|
* No disk I/O occurs while a test is producing sound.
|
|
*/
|
|
static void footer_text(char *footer,unsigned char complete,unsigned count,unsigned crc)
|
|
{
|
|
unsigned n;
|
|
sprintf(footer,"ENDRUN=%04u COMPLETE=%s RECORD_COUNT=%u CHECKSUM_CRC16=%04X",
|
|
runno,complete?"YES":"NO",count,crc);
|
|
n=strlen(footer); footer[n++]='\r'; footer[n++]='\n'; footer[n]=0;
|
|
}
|
|
|
|
static unsigned char save_report(unsigned char complete)
|
|
{
|
|
char footer[110];
|
|
unsigned length, index, offset, i, n;
|
|
unsigned char sector[256], err;
|
|
unsigned sectors;
|
|
dword file_size;
|
|
if(!disk_mode) return 0;
|
|
if(!created) { err=reserve_report(); if(err) return err; }
|
|
footer_text(footer,complete,records,checksum);
|
|
length=used+strlen(footer);
|
|
err=decb_openSectorFile(&report,0,filename); if(err) return err;
|
|
if(have_checkpoint) {
|
|
footer_text(footer,saved_complete,saved_records,saved_checksum);
|
|
if(decb_getOpenFileSize(&report,§ors,&file_size)==255 || file_size!=(dword)(saved_used+strlen(footer))) return 250;
|
|
for(index=0,offset=0;offset<file_size;++index) {
|
|
err=decb_readSector(&report,sector,index); if(err) return err;
|
|
n=(unsigned)file_size-offset; if(n>256) n=256;
|
|
for(i=0;i<n;++i) if(sector[i]!=(unsigned char)((offset+i<saved_used)?logbuf[offset+i]:footer[offset+i-saved_used])) return 250;
|
|
offset+=n;
|
|
}
|
|
footer_text(footer,complete,records,checksum);
|
|
}
|
|
for(index=0,offset=0;offset<length;++index) {
|
|
n=length-offset; if(n>256) n=256;
|
|
memset(sector,0,256);
|
|
for(i=0;i<n;++i) sector[i]=(offset+i<used)?logbuf[offset+i]:footer[offset+i-used];
|
|
err=decb_writeSector(&report,sector,index);
|
|
if(err) { decb_closeSectorFile(&report); return err; }
|
|
offset+=n;
|
|
}
|
|
err=decb_setNumBytesUsedInLastSector(&report,n);
|
|
if(!err) err=decb_closeSectorFile(&report);
|
|
if(!err) { saved_used=used; saved_records=records; saved_checksum=checksum; saved_complete=complete; have_checkpoint=1; }
|
|
return err;
|
|
}
|
|
|
|
static void begin_report(void)
|
|
{
|
|
used=records=0; checksum=0xFFFF;
|
|
created=have_checkpoint=0;
|
|
if(disk_mode) disk_error=reserve_report();
|
|
make_name();
|
|
record("FORMAT=SOUNDLAB-1");
|
|
sprintf(linebuf,"RUN=%04u TARGET=%s BUILD_ID=%s VECTOR_SET_CRC16=%04X",runno,targets[target],SOUNDLAB_BUILD,SOUND_VECTOR_SET_CRC16); record(linebuf);
|
|
sprintf(linebuf,"MODEL=%s VIDEO=%s SPEED=NORMAL_USER_CONFIRMED",models[model],video?"PAL":"NTSC"); record(linebuf);
|
|
record("CARTRIDGE=USER_CONFIRMED_NO_AUTODETECTION");
|
|
record("MPI_SLOT=USER_CONFIGURED_NO_BANK_SWITCH");
|
|
record("TIMING=VSYNC_TICKS_NOT_AUDIO_SAMPLES");
|
|
record("ANALOG_LIMITS=MEASURE_BASELINE");
|
|
if(disk_mode && !disk_error) disk_error=save_report(0);
|
|
}
|
|
|
|
/* A tick deadline AND independent iteration bound; X interrupts a wait.
|
|
* No claim that an idle bit proves a cartridge is present or audible.
|
|
*/
|
|
static unsigned char ready_write(unsigned char value)
|
|
{
|
|
unsigned start=ticks();
|
|
unsigned long polls=0;
|
|
unsigned char status;
|
|
for(;;) {
|
|
status=raw_status();
|
|
if(status&0x80) { put_byte(value); ++transmitted; return 1; }
|
|
if((unsigned)(ticks()-start)>=180 || ++polls>=150000UL) { timedout=1; return 0; }
|
|
if((polls&255)==0 && toupper(inkey())=='X') { aborted=1; return 0; }
|
|
}
|
|
}
|
|
|
|
static void settle(const SoundVector *v)
|
|
{
|
|
unsigned start=ticks(), d;
|
|
unsigned long polls=0;
|
|
unsigned char status;
|
|
for(;;) {
|
|
status=raw_status();
|
|
d=ticks()-start;
|
|
if(v->wait_mask && (status&v->wait_mask)!=v->wait_mask) busy_seen=1;
|
|
if(d>=v->hold_ticks && (!v->wait_mask || ((status&v->wait_mask)==v->wait_mask && (busy_seen || d>=45)))) break;
|
|
if(d>=1800 || ++polls>=1500000UL) { timedout=1; break; }
|
|
if((polls&255)==0 && toupper(inkey())=='X') { aborted=1; break; }
|
|
}
|
|
elapsed=ticks()-start;
|
|
}
|
|
|
|
static void stop_case(void)
|
|
{
|
|
if(aborted || timedout) ssc_reset(); /* Partial packets require reset. */
|
|
else if(!ready_write(0)) ssc_reset(); /* Manual: stop speech + sound. */
|
|
}
|
|
|
|
static void get_note(void)
|
|
{
|
|
unsigned char c, n=0;
|
|
printf("NOTE (48 CHARS, ENTER ENDS):\n");
|
|
while((c=key())!='\r') {
|
|
if(c==8 && n) { --n; putchar(8); }
|
|
else if(c>=32 && c<=126 && c!='\\' && n<48) { note[n++]=c; putchar(c); }
|
|
}
|
|
note[n]=0;
|
|
}
|
|
|
|
static unsigned char run_case(const SoundVector *v)
|
|
{
|
|
unsigned i, sent;
|
|
unsigned char answer;
|
|
unsigned repeat;
|
|
const char *human, *automatic;
|
|
do {
|
|
if(used>LOG_CAPACITY-450) {
|
|
if(!disk_mode) {
|
|
printf("RAM REPORT FULL. PHOTOGRAPH IT.\nX MENU / C CLEAR FOR NEXT RUN\n");
|
|
if(key()!='C') return 0;
|
|
}
|
|
disk_error=save_report(1);
|
|
if(disk_error) { printf("REPORT FULL. SAVE FIRST.\n"); key(); return 0; }
|
|
++runno; begin_report();
|
|
}
|
|
repeat=attempt++;
|
|
header(v->id);
|
|
ssc_reset(); /* Declared per-case baseline; never inherited timer state. */
|
|
printf("%s\n\n%s\n\nX: PANIC / RETURN TO MENU\n",v->title,v->prompt);
|
|
printf("\nENTER TO PLAY / X MENU\n");
|
|
do answer=key(); while(answer!='\r' && answer!='X');
|
|
if(answer=='X') return 0;
|
|
printf("PLAYING...\n");
|
|
transmitted=elapsed=0; aborted=timedout=busy_seen=0;
|
|
before=raw_status();
|
|
for(i=0;i<v->length;++i) if(!ready_write(v->tx[i])) break;
|
|
sent=transmitted;
|
|
if(!aborted && !timedout) settle(v);
|
|
after=raw_status();
|
|
stop_case();
|
|
header(v->id);
|
|
printf("ATTEMPT %u CRC %04X TX %u/%u\nSTATUS %02X > %02X TICKS %u\n%s\n\n",
|
|
repeat,v->crc16,sent,v->length,before,after,elapsed,aborted?"ABORTED":timedout?"TIMEOUT / RESET":"AUTO: OBSERVED ONLY");
|
|
printf("H HEARD W WRONG\nN NO SOUND U UNSURE\nR REPEAT S SKIP\nT ADD NOTE X MENU\n\n");
|
|
note[0]=0;
|
|
do { answer=key(); if(answer=='T') get_note(); }
|
|
while(!strchr("HWNURSX",answer));
|
|
human=answer=='H'?"HEARD":answer=='W'?"WRONG":answer=='N'?"NO_SOUND":answer=='U'?"UNSURE":answer=='S'?"SKIPPED":"NOT_OBSERVED";
|
|
automatic=timedout?"TIMEOUT":aborted&&!sent?"NOT_RUN":"OBSERVED";
|
|
sprintf(linebuf,"CASE=%s VECTOR_CRC16=%04X AUTO=%s HUMAN=%s",v->id,v->crc16,automatic,human); record(linebuf);
|
|
sprintf(linebuf,"TX_COUNT=%u TX_EXPECTED=%u TICKS=%u STATUS_BEFORE=%02X STATUS_AFTER=%02X BUSY_SEEN=%s",sent,v->length,elapsed,before,after,busy_seen?"YES":"NO"); record(linebuf);
|
|
record("PRELUDE=RESET_01_00 TIMER=RESET_DEFAULT");
|
|
sprintf(linebuf,"ABORTED=%s CLEANUP=%s REPEAT=%u",aborted?"YES":"NO",(aborted||timedout)?"RESET":"00",repeat); record(linebuf);
|
|
sprintf(linebuf,"NOTE_LENGTH=%u",strlen(note)); record(linebuf);
|
|
sprintf(linebuf,"NOTE=%s",note); record(linebuf);
|
|
sprintf(linebuf,"ENDCASE=%s",v->id); record(linebuf);
|
|
disk_error=save_report(0);
|
|
if(disk_error) { printf("DISK ERROR %u: RAM RETAINED\n",disk_error); key(); }
|
|
if(answer=='X') return 0;
|
|
} while(answer=='R');
|
|
return 1;
|
|
}
|
|
|
|
static void show_report(void)
|
|
{
|
|
unsigned offset=0, rows;
|
|
header("FROZEN REPORT");
|
|
while(offset<used) {
|
|
cls(0); rows=0;
|
|
while(offset<used && rows<11) {
|
|
unsigned col=0;
|
|
while(offset<used && logbuf[offset]!='\r' && col<30) { putchar(logbuf[offset++]); ++col; }
|
|
if(offset<used && logbuf[offset]=='\r') offset+=2;
|
|
putchar('\n'); ++rows;
|
|
}
|
|
printf("\nRUN %04u %s\nANY KEY NEXT / X MENU",runno,filename);
|
|
if(key()=='X') break;
|
|
}
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
unsigned i;
|
|
unsigned char choice;
|
|
width(32);
|
|
header("WELCOME, LISTENER");
|
|
printf("NORMAL SPEED, 64K+, DISK BASIC\nSSC RAM/BUFFERS WILL BE RESET.\nLOW SPEAKER VOLUME TO START.\n\n1 VCC PLUS 2 REAL COCO\n3 MISTER\n");
|
|
do choice=key(); while(choice<'1'||choice>'3'); target=choice-'1';
|
|
header("SETUP");
|
|
printf("1 COCO 3 2 COCO 2 3 OTHER\n");
|
|
do choice=key(); while(choice<'1'||choice>'3'); model=choice-'1';
|
|
printf("N NTSC / P PAL\n"); do choice=key(); while(choice!='N'&&choice!='P'); video=choice=='P';
|
|
printf("\nD SAVE REPORTS TO THIS FD0\nM SCREEN ONLY / NO DISK I/O\nUSE A DISPOSABLE DISK COPY!\n");
|
|
do choice=key(); while(choice!='D'&&choice!='M'); disk_mode=choice=='D';
|
|
if(disk_mode) {
|
|
disk_error=decb_init(drives,1);
|
|
if(!disk_error) disk_error=decb_registerDrive(0);
|
|
if(disk_error) disk_mode=0;
|
|
}
|
|
route=ssc_route_audio();
|
|
ssc_reset();
|
|
begin_report();
|
|
for(;;) {
|
|
header("MAIN MENU");
|
|
printf("1 MEET THE ROBOT\n2 GUIDED LISTENING LAB\n3 ENGINEERING (OPT IN)\n4 CHOOSE A CASE\n5 VIEW RAM REPORT\n6 RETRY SAVE\nQ SAVE AND QUIT TO BASIC\n\nRUN %04u %s\n%s\n",runno,filename,!disk_mode?"SCREEN ONLY":disk_error?"DISK ERROR / RAM RETAINED":"REPORT SAVED BETWEEN CASES");
|
|
choice=key();
|
|
if(choice=='Q') {
|
|
disk_error=save_report(1);
|
|
if(disk_error) { printf("SAVE FAILED. X DISCARD OR RETRY\n"); if(key()!='X') continue; }
|
|
break;
|
|
}
|
|
if(choice=='5') { show_report(); continue; }
|
|
if(choice=='6') { disk_error=save_report(0); continue; }
|
|
if(choice=='4') {
|
|
char id[16]; unsigned char n=0,c;
|
|
header("CHOOSE CASE"); printf("CASE ID (UPPERCASE), ENTER:\n");
|
|
while((c=key())!='\r') if(n<15 && ((c>='A'&&c<='Z')||(c>='0'&&c<='9')||c=='-')) { id[n++]=c; putchar(c); }
|
|
id[n]=0;
|
|
for(i=0;i<SOUND_VECTOR_COUNT;++i) if(!strcmp(id,sound_vectors[i].id)) { run_case(&sound_vectors[i]); break; }
|
|
if(i==SOUND_VECTOR_COUNT) { printf("\nUNKNOWN CASE. SEE MANIFEST.\n"); key(); }
|
|
continue;
|
|
}
|
|
if(choice<'1'||choice>'3') continue;
|
|
group=(unsigned char)(1<<(choice-'1'));
|
|
if(group==4) { header("ENGINEERING"); printf("MANY LOUD/REPEATED EXAMPLES.\nLOWER VOLUME. Y CONTINUE\n"); if(key()!='Y') continue; }
|
|
for(i=0;i<SOUND_VECTOR_COUNT;++i) if(sound_vectors[i].group&group) if(!run_case(&sound_vectors[i])) break;
|
|
}
|
|
ssc_reset();
|
|
ssc_restore_audio(route);
|
|
if(disk_mode) decb_shutdown();
|
|
cls(0); printf("SOUND LAB FINISHED\nREPORT %s\n",disk_mode?(const char *)filename:"SCREEN ONLY");
|
|
return 0;
|
|
}
|