home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 June / MacFormat 25.iso / Shareware City / Applications / ZX Loader 1.0.4 / ZX Loader source / Application.c next >
Encoding:
C/C++ Source or Header  |  1995-02-26  |  47.3 KB  |  1,512 lines  |  [TEXT/MMCC]
  1.  
  2. /* -----    ZX Spectrum Tape Converter ---------------------------------------------
  3.             
  4.     This program reads ZX Spectrum program and data tapes and converts 
  5.     them into 'Tape' files for many ZX Spectrum emulators
  6.             
  7.     Final Release - Version 1.0.3
  8.             
  9. ***    Copyright (C) 1994-1995 Günter Woigk alias KIO !
  10.     snail mail:    Günter Woigk; Nürnberger Str. 79; 91052 Erlangen; Germany
  11.     e-mail:        ea215@fim.uni-erlangen.de
  12.             
  13.     01.07.94    started work                                            (KIO !)
  14.     25.11.94    killed my audio input with high voltage on protective ground
  15.                 virtually nothing is impossible!                        (KIO !)
  16.     17.12.94    last review - Bach composed masterpieces being deaf        (KIO !)
  17.     21.01.95    replaced old tape file format with .tap file format        (KIO !)
  18.     22.01.95    added code to set sound input to mono/8bit/22kHz        (KIO !)    
  19.     26.Feb.95    Metrowerk C version                                        (KIO !)
  20.  
  21. ***    This program is free software; you can redistribute it and/or modify
  22.     it under the terms of the GNU General Public License as published by
  23.     the Free Software Foundation; either version 2 of the License, or
  24.     (at your option) any later version.
  25.     
  26. ***    This program is distributed in the hope that it will be useful,
  27.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  28.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  29.     See the GNU General Public License for more details.
  30.  
  31.     You should have received a copy of the GNU General Public License
  32.     along with this program; if not, write to the Free Software
  33.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  34. */
  35.  
  36. #include    <ToolUtils.h>
  37. #include    <resources.h>
  38. #include    <soundinput.h>
  39. #include    <palettes.h>
  40. #include    <files.h>
  41. #include    <types.h>
  42. #include    <FixMath.h>
  43. #include    <quickdraw.h>
  44. #include    "kio.h"
  45. #include    "mem.h"
  46. #include    "application.h"
  47. #include    "eventloop.h"
  48. #include    "console.h"
  49.  
  50. // -----    General settings --------------------------------------------------
  51. short        verbose         = 1;    // verbosity
  52.  
  53. // -----    Settings for signal decoding -------------------------------------
  54. #define        minh            10        // min. length for 1/2 header period    (10)
  55. #define        maxh            17        // max. length for 1/2 header period    (16)
  56.  
  57. #define        mins            2        // min. length for 1/2 sync                (3)
  58. #define        maxs            9        // max. length for 1/2 sync                (9)
  59.  
  60. #define        min0            2        // min. length for 1/2 0-bit period        (3)
  61. #define        max0            9        // max. length for 1/2 0-bit period        (9)
  62.  
  63. #define        min1            6        // min. length for 1/2 1-bit periode    (6)
  64. #define        max1            16        // max. length for 1/2 1-bit periode    (14)
  65.  
  66. #define        mn                2        // minimal codable run length            (2)
  67. #define        mx                17        // mn+15
  68. #define        llsize            19        // mx+mn
  69.  
  70. // -----    The Spectrum window -----------------------------------------------
  71. short        show_spectrum     = true;
  72. WindowPtr    spectrumfenster    = nil;
  73. RgnHandle    borderRgn        = nil;
  74. RgnHandle    screenRgn        = nil;
  75. CGrafPtr    screenshot        = nil;
  76. Char*        spectrumbitmap    = nil;
  77. Boolean        flashing        = false;
  78. short        flashphase        = 0;
  79. short        borderstate        = 0;
  80. #define        spectrumID        129        // Resource ID of window
  81. short        hborder            = 32;    // 16*n; border left & right for spectrum window
  82. short        vborder            = 16;    // 16*n; border top & bottom for spectrum window
  83. long        idxp[512];                // konvertiert attr+flashing -> paper color index
  84. long        idxi[512];                // konvertiert attr+flashing -> ink color index
  85. RGBColor    rgb[16];                // rgb colors
  86.  
  87. // -----    Statistics window #1: Byte distribution -----------------------------------
  88. short        show_distribution     = 0;
  89. WindowPtr    bytedistributionwindow    = nil;
  90. #define        statistikID            130        // resource ID
  91. long         cnt[256];                     // for calculating
  92.  
  93. // -----    Statistics window #2: Run length distribution -----------------------------
  94. short        show_run_length     = 1;
  95. WindowPtr    runlengthwindow        = nil;
  96. #define        statistik2ID        131
  97. long        hi[llsize], lo[llsize];        // for calculating
  98.  
  99. // -----    Sound recording -----------------------------------------------------------
  100. short         plth_volume         = 1;    // play through volume
  101. short         auto_gain_control     = 0;    // automatic gain control ?
  102.  
  103. // -----    Used files ---------------------------------------------------------------
  104. FSSpec        soundfile;                    // AIFF File containing sound data
  105. FSSpec        rlesfile;                    // run legth encoded square wave sound
  106. FSSpec        tapefile;                    // segment header framed binary data
  107. FSSpec        logfile;
  108. short        soundID            = 0;
  109. short        tapeID            = 0;
  110. short        dataID            = 0;
  111.  
  112. short                 oDocNumTypes    = 2;        // number of file types to use for OPEN
  113. SFTypeList             oDocTypeList    = {'AIFF','RLES',0,0};    // list of file types 
  114.  
  115. // -----    "Local" Variables for LoadTape() -------------------------------------------
  116. Char        crc, *p, *d;                // used inside LoadTape()
  117. Char*         mh = nil;                    // Buffer for rle-Bytes to decode; inside LoadTape()
  118. Char*        dh = nil;                    // Buffer for decoded Bytes; inside LoadTape()
  119.  
  120. // -----    Event Loop ---------------------------------------------------------------
  121. Boolean     done            = false;    // done:=TRUE to QuitApplication()
  122. long        eventDelay        = 999;        // delay/60s until HandleNull() called
  123. RgnHandle    eventRegion        = nil;        // fence for HandleREGION() calls
  124. EventRecord    event;                        // event returned by WaitNextEvent
  125.  
  126. // ----- Menu bar -------------------------------------------------------------------
  127. short        mApple        =    128;    
  128. short            iAbout    =        1;        
  129. short            iHelp    =        2;
  130. short        mFile        =    129;
  131. short            iNew    =        1;
  132. short            iOpen    =        2;
  133. short             iSave    =        3;
  134. short            iClose    =        4;
  135. short            iPrint    =        99;
  136. short            iQuit    =        6;
  137. short        mEdit        =    130;    
  138. short            iUndo    =        1;
  139. short            iCut    =        3;
  140. short            iCopy    =        4;
  141. short            iPaste    =        5;
  142. short        mOptions    =    131;
  143.  
  144. // ----- et cetera ----------------------------------------------------------------
  145. #define        mem_magic        'KIO!'
  146.  
  147.  
  148. // ----- prototypes ---------------------------------------------------------------
  149. CloseAll();
  150. PrintNum ( long n )    ;
  151. ErrMsg ( Str255 s );
  152. long *Malloc ( Char **pp, long n );
  153. MFree ( Char **pp );
  154. AddItem ( MenuHandle m, Str255 eng, Str255 deu );
  155. InitSpectrumColors();
  156. RedrawFlashingColors();
  157. RedrawSpectrumscreen();
  158. RedrawSpectrumborder ();
  159. RefreshSpectrumfenster();
  160. CloseSpectrumWindow ();
  161. OpenSpectrumWindow();
  162. RefreshByteDistributionWindow();
  163. CloseStatistikfenster ();
  164. OpenByteDistributionWindow ( );
  165. CloseRunLengthWindow ();
  166. RefreshRunLengthWindow();
  167. OpenRunLengthWindow ( );
  168. HandleSomeMouseDown();
  169. RefreshWindows();
  170. DisplayScreenshot();
  171. Notify ( Str255 eng, Str255 ger );
  172. Short NextByte (Boolean v);
  173. ChangeBorder ( long n );
  174. LoadTape();
  175. RunLengthCompression();
  176.  
  177.  
  178. /* ********************************************************************** */
  179. /* ******************     S U B R O U T I N E S      ******************** */
  180. /* ********************************************************************** */
  181.  
  182.  
  183. // -----    Close all files -------------------------------------------------------
  184. CloseAll()
  185. {    if (soundID) { FSClose(soundID); soundID=0; };
  186.     if (tapeID) { FSClose(tapeID); tapeID=0; };
  187.     if (dataID) { FSClose(dataID); dataID=0; };
  188. }
  189.  
  190.  
  191. // -----    Print number ----------------------------------------------------------
  192. PrintNum ( long n )    
  193. {    Str255 s; 
  194.     NumToString ( n, s ); 
  195.     ConPrint(s,0); 
  196. }
  197.  
  198.  
  199. // -----    Print standard error message -------------------------------------------
  200. ErrMsg ( Str255 s )
  201. {    ConPrint("\pAn error occured: ","\pEin Fehler ist aufgetreten: ");
  202.     ConMsg(s,0);
  203. }
  204.  
  205.  
  206. // -----    Allocate n bytes and lock 'em ------------------------------------------
  207. //        pp -> Master pointer for memory block
  208. //        if *pp is not nil on entry, the old memory block will be released first
  209. long *Malloc ( Char **pp, long n )
  210. {    long **h; OSErr err;
  211.     if ( *pp != nil ) MFree(pp);
  212.     h = (long**)TempNewHandle(n+8, &err);
  213.     if ( h==nil || err ) return;            // Master pointer = *pp := nil
  214.     HLock ( (Handle)h );                    // don't move around
  215.     (*h)[0] = mem_magic;                    // private mem_hdr: magic
  216.     (*h)[1] = (long)h;                        // private mem_hdr: backpointer to handle
  217.     *pp = ((Char*)*h)+8;                    // Master pointer = *pp := address of buffer + 8
  218. }
  219.  
  220. // -----    Release memory block -------------------------------------------------
  221. //        pp -> Master pointer of the memory block
  222. MFree ( Char **pp )
  223. {    long *p;
  224.     if ( *pp == nil ) return;            // there's nothing
  225.     p = (*((long**)pp))-2;                // p -> private mem_hdr
  226.     *pp = nil;                            // clear pointer
  227.     if ( p[0] != mem_magic ) return;    // internal error !
  228.     p[0] = 0;                            // clear magic
  229.     DisposeHandle ( (Handle)p[1] );        // release memory
  230. }
  231.  
  232.  
  233. /* *************************************************************************** */
  234. /* ********************     A P P L I C A T I O N      *********************** */
  235. /* *************************************************************************** */
  236.  
  237.  
  238. AddItem ( MenuHandle m, Str255 eng, Str255 deu )
  239. {
  240.     if ( (german&&deu) || !eng ) AppendMenu ( m, deu );
  241.     else AppendMenu( m, eng );
  242. }
  243.  
  244. InitMenuBar ()
  245. {    MenuHandle am, fm, em, om;
  246.     am = NewMenu ( mApple, "\p\024" );
  247.     fm = NewMenu ( mFile, "\pFile" );
  248.     em = NewMenu ( mEdit, "\pEdit" );
  249.     om = NewMenu ( mOptions, "\pOptions" );
  250.     
  251.     AddItem         ( am, "\pAbout ZX Tape Loader ...","\pÜber den ZX Loader ..." );
  252.     AddResMenu    ( am, 'DRVR' );
  253.         
  254.     AddItem     ( fm, "\pRecord new sound/N",        "\pNeuen Sound aufnehmen/N" );
  255.     AddItem     ( fm, "\pOpen file/O",                "\pDatei öffnen/O" );
  256.     AddItem     ( fm, "\pSave file/S",                "\pDatei speichern/S" );
  257.     AddItem     ( fm, "\pClose top window/W",        "\pOberstes Fenster schließen/W" );
  258.     AppendMenu    ( fm, "\p-" );
  259.     AddItem        ( fm, "\pQuit/Q",                    "\pProgramm beenden/Q" );
  260.  
  261.     AddItem     ( om, "\pSpeaker off",                "\pLautsprecher aus" );
  262.     AddItem     ( om, "\pSpeaker on",                "\pLautsprecher ein" );
  263.     AppendMenu    ( om, "\p-" );
  264.     AddItem     ( om, "\pMaximum recording volume",    "\pMaximale Aufnahmelautstärke" );
  265.     AddItem     ( om, "\pAutomatic gain control",    "\pAutomatische Aussteuerung" );
  266.     AppendMenu    ( om, "\p-" );
  267.     AddItem     ( om, "\pShort protocol",            "\pKurzes Protokoll" );
  268.     AddItem     ( om, "\pMedium protocol",            "\pNormales Protokoll" );
  269.     AddItem     ( om, "\pLong protocol",            "\pAusführliches Protokoll" );
  270.     AppendMenu     ( om, "\p-" );
  271.     AddItem     ( om, "\pByte distribution window off",            "\pByteverteilungsstatistik aus" );
  272.     AddItem     ( om, "\pByte distribution window on",            "\pByteverteilungsstatistik ein" );
  273.     AppendMenu     ( om, "\p-" );
  274.     AddItem     ( om, "\pRun length distribution window off",    "\pPhasenlängenstatistik aus" );
  275.     AddItem     ( om, "\pRun length distribution window on",    "\pPhasenlängenstatistik ein" );
  276.     AppendMenu    ( om, "\p-" );
  277.     AddItem     ( om, "\pZX Spectrum window off",                "\pZX Spectrum Fenster aus" );
  278.     AddItem        ( om, "\pZX Spectrum window on",                "\pZX Spectrum Fenster ein" );
  279.  
  280.     InsertMenu ( am, 0 );
  281.     InsertMenu ( fm, 0 );
  282.     InsertMenu ( em, 0 );
  283.     InsertMenu ( om, 0 );
  284.     DrawMenuBar();
  285. }
  286.  
  287.  
  288. // =====    Quit program ======================================================
  289. HandleQUIT()            
  290. { 
  291.     done = 1; 
  292. }
  293.  
  294.  
  295. // =====    Initialize application ===================================================
  296. HandleINIT(long how)        // how = 'OAPP' or 'ODOC'
  297. {    
  298.     ConMsg("\p**** THE LONG AWAITED ZX SPECTRUM LOADER !",0);
  299.     ConMsg("\p**** Version 1.0 Copyright (c) 1994 G.Woigk",0);
  300.     ConNL();
  301.     ConMsg("\p**** Read in Your ZX Spectrum Tapes to Harddisk",        "\p**** Speichert ZX Spectrum Kassetten auf Harddisk");
  302.     ConMsg("\p**** Free for non commercial use & distribution",        "\p**** Frei für private Verwendung und Vertrieb");
  303.     ConNL();
  304.     ConMsg("\pThis program is free software; you can redistribute",0);
  305.     ConMsg("\pit and/or modify it under the terms of the GNU",0);
  306.     ConMsg("\pGeneral Public License as published by the Free",0);
  307.     ConMsg("\pSoftware Foundation; either version 2 of the",0);
  308.     ConMsg("\pLicense, or (at your option) any later version.",0);
  309.     ConNL();
  310.     ConMsg("\pThis program is distributed in the hope that it will",0);
  311.     ConMsg("\pbe useful, but WITHOUT ANY WARRANTY; without even",0);
  312.     ConMsg("\pthe implied warranty of MERCHANTABILITY or FITNESS",0);
  313.     ConMsg("\pFOR A PARTICULAR PURPOSE. See the GNU General Public",0);
  314.     ConMsg("\pLicense for more details.",0);
  315.     ConNL();
  316.     ConMsg("\pYou should have received a copy of the GNU General",0);
  317.     ConMsg("\pPublic License along with this program; if not,",0);
  318.     ConMsg("\pwrite to the Free Software Foundation, Inc.,",0);
  319.     ConMsg("\p675 Mass Ave, Cambridge, MA 02139, USA.",0);
  320.     ConNL();
  321.     ConMsg("\pGünter Woigk; Nürnberger Str. 79; D-91052 Erlangen",0);
  322.     ConMsg("\pe-mail: ea215@fim.uni-erlangen.de",0);
  323.     ConNL();
  324.     ConCrsr(true);
  325.  
  326.     HandleMENU(131,2);        // speaker := on
  327.     HandleMENU(131,4);        // volume := max
  328.     HandleMENU(131,8);        // verbosity := medium
  329.     HandleMENU(131,11);        // don't show byte distribution window
  330.     HandleMENU(131,15);        // show run length distribution window
  331.     HandleMENU(131,18);        // show Spectrum window
  332.  
  333.     InitSpectrumColors();
  334.     OpenSpectrumWindow();
  335. }
  336.  
  337.  
  338. // -----    Refresh window -----------------------------------------------
  339. HandleUPDATE(WindowPtr window)    
  340. {    
  341.     if (window==conWindow)                 return ConRfsh();
  342.     if (window==bytedistributionwindow)    return RefreshByteDistributionWindow();
  343.     if (window==runlengthwindow)         return RefreshRunLengthWindow();
  344.     if (window==spectrumfenster)        return RefreshSpectrumfenster();
  345. }
  346.  
  347.  
  348. // -----    Close top window ----------------------------------------------
  349. HandleCLOSE()    
  350. { 
  351.     if (FrontWindow()==conWindow)                return ConClose();
  352.     if (FrontWindow()==bytedistributionwindow)    return CloseStatistikfenster();
  353.     if (FrontWindow()==runlengthwindow)            return CloseRunLengthWindow();
  354.     if (FrontWindow()==spectrumfenster)            return CloseSpectrumWindow();
  355. }
  356.  
  357.  
  358. // -----    Null Event: Flash flashing colors ----------------------------------------
  359. HandleNULL()            
  360. {     static Long oldTick=0; Long tick;
  361.  
  362.     if ( !spectrumfenster || !spectrumbitmap || !flashing )     // nothing to do
  363.     {    eventDelay = 120;
  364.         return;
  365.     };
  366.     
  367.     tick=TickCount();
  368.     if ( tick >= oldTick+64 )
  369.     {    oldTick=tick;
  370.         RedrawFlashingColors();        
  371.         flashphase = 256 - flashphase;            // toggle  0  <->  256
  372.     };
  373.     eventDelay = 64 - (tick & 63);
  374. }
  375.  
  376. // -----    Open "Tape", "RLES" or "AIFF" file ------------------------------------
  377. HandleOPEN(FSSpec file)
  378. {     OSErr err; FInfo info; long i;
  379.  
  380.     ConPrint("\pOpen file: ","\pÖffne Datei: "); ConMsg(file.name,0);
  381.  
  382.     err = FSpGetFInfo ( &file, &info );
  383.     if (err) return ErrMsg("\pFSpGetFInfo()");
  384.  
  385.     CloseAll();
  386.     ConCrsr(false);                        // no cursor to indicate 'busy'
  387.  
  388.     if (info.fdType=='AIFF')            // Sound-File
  389.     {    soundfile = file; 
  390.         OpenByteDistributionWindow();
  391.         CloseAll();
  392.         RunLengthCompression();
  393.         CloseAll();
  394.     }
  395.     else if (info.fdType=='RLES')        // run length compressed square wave sound file
  396.     {    rlesfile = file;
  397.         CloseStatistikfenster();
  398.     }
  399.     else
  400.     {    ConMsg("\pThis cannot happen!",0);
  401.         ConCrsr(true);
  402.         return;
  403.     };
  404.         
  405.     OpenRunLengthWindow();
  406.     CloseAll();
  407.     LoadTape();
  408.     CloseAll();
  409.     ConNL();
  410.     ConCrsr(TRUE);
  411. }
  412.  
  413.  
  414. // -----    Handle menu selection -----------------
  415. HandleMENU ( long menu, long item ) 
  416. {    MenuHandle m;
  417.     if ( menu==mOptions ) 
  418.     {    m = GetMHandle(menu); if (!m) return;
  419.         switch (item)
  420.         {    case 1:    // Speaker off    
  421.             case 2:    // Speaker on    
  422.                 plth_volume = item-1; 
  423.                 CheckItem ( m, 1, !plth_volume ); 
  424.                 CheckItem ( m, 2, plth_volume ); 
  425.                 break;
  426.             case 4:    // max. volume
  427.             case 5:    // autom. gain control
  428.                 auto_gain_control = item-4;
  429.                 CheckItem ( m, 4, !auto_gain_control ); 
  430.                 CheckItem ( m, 5, auto_gain_control ); 
  431.                 break;
  432.             case 7:    /* verbose 0 */        
  433.             case 8:    /* verbose 1 */
  434.             case 9:    /* verbose 2 */        
  435.                 verbose = item-7;
  436.                 CheckItem ( m, 7, verbose==0 ); 
  437.                 CheckItem ( m, 8, verbose==1 ); 
  438.                 CheckItem ( m, 9, verbose==2 ); 
  439.                 break;
  440.             case 11:    /* hide byte distribution */
  441.                 CloseStatistikfenster();
  442.             case 12:    /* show byte distribution */    
  443.                 show_distribution = item-11;
  444.                 CheckItem ( m, 11, !show_distribution);
  445.                 CheckItem ( m, 12, show_distribution);
  446.                 break;
  447.             case 14:    /* hide run length distribution */
  448.                 CloseRunLengthWindow();
  449.             case 15:    /* show run length distribution */            
  450.                 show_run_length = item-14;
  451.                 CheckItem ( m, 14, !show_run_length);
  452.                 CheckItem ( m, 15, show_run_length);
  453.                 break;
  454.             case 17:    /* hide specci */        
  455.                 CloseSpectrumWindow();
  456.             case 18:    /* show speci */        
  457.                 show_spectrum = item-17; 
  458.                 CheckItem ( m,17,  !show_spectrum);
  459.                 CheckItem ( m,18, show_spectrum);
  460.                 break;
  461.         };
  462.         return;
  463.     };
  464. }
  465.  
  466.  
  467. // *********************************************************************
  468. //          Handling the Spectrum window
  469. // *********************************************************************
  470.  
  471.  
  472. // -----    Init Spectrum color tables ------------------------------------
  473. InitSpectrumColors()
  474. {    Short c,i;
  475.  
  476.     for ( i=0; i<16; i++ )                  // rgb tables
  477.     {    c=0xcccc; if (i>=8) c=0xffff;
  478.         rgb[i].blue      = (i&1) ? c : 0;
  479.         rgb[i].red       = (i&2) ? c : 0;
  480.         rgb[i].green = (i&4) ? c : 0;
  481.     };
  482.     
  483.     for ( i=0; i<128; i++ )
  484.     {    idxi[i]  =  idxi[i+128]  =  idxi[i+256]  =  idxp[i+384]  =  (i&7)+((i>>3)&8);    
  485.         idxp[i]  =  idxp[i+128]  =  idxp[i+256]  =  idxi[i+384]  =  (i>>3)&0xf;
  486.     };
  487. }
  488.  
  489.  
  490. // -----    Redraw flashing character positions -----------------------------------
  491. RedrawFlashingColors()
  492. {    short x,y,i,j; Char *attr; Pattern p; Rect r;
  493.     
  494.      if ( !spectrumfenster || !spectrumbitmap || !flashing ) return;        // nothing to do
  495.  
  496.     SetPort ( spectrumfenster );
  497.  
  498.     attr = spectrumbitmap+6144;
  499.     SetRect ( &r, hborder,vborder, hborder+8,vborder+8 );
  500.     for ( y=0; y<24; y++ )
  501.     {    for ( x=0; x<32; x++ )
  502.         {    if (*attr&0x80)
  503.             {    RGBForeColor ( rgb + idxi[flashphase+*attr] );        
  504.                 RGBBackColor ( rgb + idxp[flashphase+*attr] );    
  505.                 j = ((y&0x0007)<<5) + ((y&0x0018)<<8) + x;
  506.                 for ( i=0; i<8; i++ )
  507.                 {    p.pat[i] = spectrumbitmap[j];         
  508.                     j += 256;
  509.                 };
  510.                 FillRect ( &r, &p );
  511.             };
  512.             attr++; r.left+=8; r.right+=8;
  513.         };
  514.         r.left=hborder; r.right=hborder+8;
  515.         r.top+=8; r.bottom+=8;
  516.     };
  517. }
  518.  
  519.  
  520. // -----    Redraw the inner part of the Spectrum window --------------------------
  521. RedrawSpectrumscreen()
  522. {    short x,y,i,j; Char *attr; Pattern p; Rect r;
  523.         
  524.      if (!spectrumfenster) return;                // not open
  525.  
  526.     SetPort ( spectrumfenster );
  527.  
  528.     if (spectrumbitmap)                        // there's a picture to show
  529.     {    attr = spectrumbitmap+6144;
  530.         SetRect ( &r, hborder,vborder, hborder+8,vborder+8 );
  531.         for ( y=0; y<24; y++ )
  532.         {    for ( x=0; x<32; x++ )
  533.             {    RGBForeColor ( rgb + idxi[flashphase+*attr] );        
  534.                 RGBBackColor ( rgb + idxp[flashphase+*attr] );    
  535.                 j = ((y&0x0007)<<5) + ((y&0x0018)<<8) + x;
  536.                 for ( i=0; i<8; i++ )
  537.                 {    p.pat[i] = spectrumbitmap[j];         
  538.                     j += 256;
  539.                 };
  540.                 FillRect ( &r, &p );
  541.                 attr++; r.left+=8; r.right+=8;
  542.             };
  543.             r.left=hborder; r.right=hborder+8;
  544.             r.top+=8; r.bottom+=8;  
  545.         };
  546.     }
  547.     else
  548.     {
  549.         ForeColor ( whiteColor ); 
  550.         PaintRgn ( screenRgn );
  551.         ForeColor ( blackColor );  
  552.         BackColor ( whiteColor );
  553.         MoveTo ( hborder+1,vborder+190 );  
  554.         DrawString ( "\p(C) 1982 Sinclair Corporation");
  555.     };
  556. }
  557.  
  558.  
  559. // -----    Redraw Border of Spectrum window ----------------------------
  560. //        borderstate    0 = normal
  561. //                    1 = white        3 = red-white
  562. //                    2 = red            4 = blue-yellow
  563. RedrawSpectrumborder ()
  564. {    RgnHandle oldClipRgn;
  565.     Rect border, box;
  566.     short i;
  567.         
  568.     if (!spectrumfenster) return;        // window not open
  569.  
  570.     SetPort(spectrumfenster);
  571.     oldClipRgn=NewRgn();
  572.     GetClip(oldClipRgn);
  573.     SetClip(borderRgn);
  574.     border = spectrumfenster->portRect;
  575.         
  576.     switch (borderstate)
  577.     {    case 1:    // search header indicator
  578.             ForeColor ( whiteColor ); 
  579.             PaintRect ( &border ); 
  580.             break;
  581.         case 2:    // blips detect indicator
  582.             ForeColor ( redColor );
  583.             PaintRect ( &border ); 
  584.             break;
  585.         case 3:    // header indicator
  586.             ForeColor ( redColor );
  587.             PaintRect ( &border ); 
  588.             ForeColor ( whiteColor );
  589.             box=border;
  590.             for ( i=1; i<border.bottom; i+=9 )
  591.             {    box.top=i;box.bottom=i+4;
  592.                 PaintRect ( &box );
  593.             };
  594.             break;
  595.         case 4:    // data indicator
  596.             ForeColor (yellowColor );
  597.             PaintRect ( &border ); 
  598.             ForeColor ( blueColor );
  599.             box=border;
  600.             for ( i=1; i<border.bottom; i+=4 )
  601.             {    box.top=i;box.bottom=i+2;
  602.                 PaintRect ( &box );
  603.             };
  604.             break;
  605.         default:    // normal border
  606.             if (spectrumbitmap)        // fit border to picture
  607.             {    Char* attr, a,b,c,d; 
  608.                 attr = spectrumbitmap+6144;
  609.                 a = attr[0]&0x78;
  610.                 b = attr[31]&0x78;
  611.                 c = attr[672]&0x78;
  612.                 d = attr[703]&0x78;
  613.                 if ( a==b || a==c || a==d ) {}
  614.                 else    if ( b==c || b==d ) a=b;
  615.                 else    if ( c==d ) a=c;
  616.                 RGBForeColor ( rgb + (a>>3) );
  617.                 PaintRect ( &border ); 
  618.             }
  619.             else                    // default border = default paper = white
  620.             {    ForeColor ( whiteColor ); 
  621.                 PaintRect ( &border ); 
  622.             };
  623.             break;
  624.     };
  625.  
  626.     SetClip ( oldClipRgn );
  627.     DisposeRgn(oldClipRgn);
  628. }
  629.  
  630.  
  631. // -----    Update ZX Spectrum window ------------------------------------
  632. RefreshSpectrumfenster()
  633. {    
  634.     RedrawSpectrumscreen();
  635.     RedrawSpectrumborder();
  636. }
  637.  
  638.  
  639. // -----    Close window -------------------------------------------------
  640. //            if a picture is valid, it's not discarded, only the window is closed
  641. CloseSpectrumWindow ()
  642. {    
  643.     if (spectrumfenster)
  644.     {    DisposeWindow ( spectrumfenster ); 
  645.         spectrumfenster=nil;
  646.     };
  647. }
  648.  
  649.  
  650. // -----    Open ZX Spectrum window ----------------------------------------
  651. //        Opens the window only, if checked in menu (default)
  652. //        If a valid picture is present, it will be displayed
  653. //        If already open, it stays open in any case
  654. OpenSpectrumWindow()
  655. {    Rect mybox,border,screen; short i;
  656.     
  657.     borderstate=0; 
  658.  
  659.     if (!show_spectrum) return;                    // option not checked in menu
  660.  
  661.     if (!borderRgn) borderRgn = NewRgn();
  662.     if (!screenRgn) screenRgn = NewRgn();
  663.     if ( ! (screenRgn && borderRgn) ) return;    // memory low
  664.  
  665.     if (!spectrumfenster)
  666.     {    spectrumfenster = GetNewCWindow ( spectrumID, nil, (WindowPtr)-1 );
  667.         if (!spectrumfenster) return ConMsg("\pCannot open the ZX Spectrum window","\pFehler beim Öffnen des ZX Spectrumfensters");
  668.         hborder = ((spectrumfenster->portRect.right-256)/16)*8; if (hborder<=0) hborder=8;
  669.         vborder = ((spectrumfenster->portRect.bottom-192)/16)*8; if (vborder<=0) vborder=8;
  670.         SizeWindow ( spectrumfenster, 256+2*hborder, 192+2*vborder, true );
  671.         ShowWindow ( spectrumfenster );
  672.     };
  673.  
  674.     SetPort ( spectrumfenster );
  675.     GetFNum("\pMonaco",&i);
  676.     TextFont(i);
  677.     TextMode(srcCopy);
  678.     TextSize(9);
  679.     
  680.     screen=border=spectrumfenster->portRect;
  681.     InsetRect ( &screen, hborder, vborder );
  682.     RectRgn ( screenRgn, &screen );
  683.     RectRgn ( borderRgn, &border );
  684.     XorRgn ( borderRgn, screenRgn, borderRgn );
  685.  
  686.     RedrawSpectrumborder();
  687.     RedrawSpectrumscreen();
  688. }
  689.  
  690.  
  691. // =====    Handling the byte distribution window ======================================
  692.  
  693.  
  694. // -----    Refresh byte distribution window -----------------------------------------
  695. RefreshByteDistributionWindow()
  696. {    short x,y; long mxm;
  697.     
  698.     if (!bytedistributionwindow) return;
  699.     
  700.     SetPort(bytedistributionwindow);
  701.     EraseRect ( &bytedistributionwindow->portRect );
  702.  
  703.     mxm=0;
  704.     for (x=0; x<256; x++)  if (cnt[x]>mxm) mxm = cnt[x];
  705.     mxm/=100; if (mxm<=0) return;
  706.     
  707.     for (x=0; x<256; x++)
  708.     {    MoveTo(x+3,118);
  709.         LineTo(x+3,118-cnt[x]/mxm);
  710.     };
  711. }
  712.  
  713.  
  714. // -----    Close byte distribution window ---------------------------------------------
  715. //            statistical data is not discarded, only the window is closed
  716. CloseStatistikfenster ()
  717. {
  718.     if (bytedistributionwindow) 
  719.     {     DisposeWindow ( bytedistributionwindow ); 
  720.         bytedistributionwindow=nil; 
  721.     };
  722. }
  723.  
  724.  
  725. // -----    Calculate and display new byte distribution statistic ------------------------
  726. //            source is soundfile
  727. OpenByteDistributionWindow ( )
  728. {    OSErr err; long i,j, len, n;
  729.     char buffer[10000];
  730.     Rect mybox;
  731.     
  732.     if (!show_distribution) return;                // not selected
  733.     
  734.     if (!bytedistributionwindow)
  735.     {    bytedistributionwindow = GetNewWindow ( statistikID, nil, (WindowPtr)-1 );
  736.         if (!bytedistributionwindow) return ConMsg("\pCannot open the byte distribution window","\pFehler beim Öffnen des Byteverteilungsfensters");
  737.         SizeWindow(bytedistributionwindow, 262,120,true);
  738.         ShowWindow(bytedistributionwindow);
  739.     };
  740.  
  741.     ConMsg ("\pByte distribution is calculated...","\pByteverteilungsstatistik wird erzeugt.");
  742.     
  743.     for ( i=0; i<256; i++ ) cnt[i]=0;
  744.     RefreshByteDistributionWindow();                // Erase the window
  745.     
  746.     err = FSpOpenDF ( &soundfile, fsCurPerm, &soundID );
  747.     if (err) soundID=0;
  748.     if (err) return ErrMsg("\pFSpOpenDF()");
  749.  
  750.     err = GetEOF ( soundID, &len );
  751.     if (err) return ErrMsg("\pGetEOF()");
  752.  
  753.     for ( i=0; i<=len; i+=10000 )
  754.     {    n=10000;
  755.         err = FSRead ( soundID, &n, buffer );
  756.         if ( (err==eofErr) & (i+n==len) ) err=noErr;
  757.         if (err) return ErrMsg("\pFSRead()");
  758.         for ( j=0; j<n; j++ ) cnt[buffer[j]+128]++;
  759.         RefreshWindows();
  760.     }
  761.     
  762.     RefreshByteDistributionWindow();
  763. }
  764.  
  765.  
  766. // =====    Handling the run length distribution window ==============================
  767.  
  768.  
  769. // -----    Close run length distribution window -------------------------------------------------
  770. //            actual data is not discarded, only the window is closed!
  771. CloseRunLengthWindow ()
  772. {
  773.     if (runlengthwindow) 
  774.     {     DisposeWindow ( runlengthwindow ); 
  775.         runlengthwindow=nil; 
  776.     };
  777. }
  778.  
  779.  
  780. // -----    Refresh run length distribution window -----------------------------------------
  781. RefreshRunLengthWindow()
  782. {    short x,y; long mxm; Rect mybox; short hscale, vscale;
  783.     
  784.     if (!runlengthwindow) return;            // window not open
  785.     
  786.     SetPort ( runlengthwindow );
  787.     EraseRect ( &runlengthwindow->portRect );
  788.  
  789.     hscale=256/llsize; vscale=55;
  790.     
  791.     mxm=0;
  792.     for (x=0; x<llsize; x++)  { if (hi[x]>mxm) mxm = hi[x];  if (lo[x]>mxm) mxm = lo[x]; };
  793.     mxm/=vscale;  if (mxm<=0) return;
  794.         
  795.     for (x=0; x<llsize; x++)
  796.     {    SetRect ( &mybox, 3+x*hscale, 60-1-((hi[x]+mxm/2)/mxm), 2+(x+1)*hscale, 60+2+((lo[x]+mxm/2)/mxm) );
  797.         InvertRect ( &mybox );
  798.     };
  799.     SetRect ( &mybox,  3, 60-1, 2+llsize*hscale, 60 );
  800.     EraseRect ( &mybox );
  801.     SetRect ( &mybox,  3, 60+1, 2+llsize*hscale, 60+2 );
  802.     EraseRect ( &mybox );
  803. }
  804.  
  805.  
  806. // -----    Calculate and display new run length distribution statistic ------------------------
  807. //            source is rlesfile
  808. OpenRunLengthWindow ( )
  809. {    OSErr err; long i,j,k, len, n;
  810.     Char buffer[10000];
  811.     Rect mybox;
  812.     
  813.     if (!show_run_length) return;                        // not selected in menu
  814.     
  815.     if (!runlengthwindow)
  816.     {    runlengthwindow = GetNewWindow ( statistik2ID, nil, (WindowPtr)-1 );
  817.         if (!runlengthwindow) return ConMsg("\pCannot open run length distribution window","\pFehler beim Öffnen des Lauflängenfensters");
  818.         SizeWindow(runlengthwindow, 262,120,true);
  819.         ShowWindow(runlengthwindow);
  820.     };
  821.  
  822.     ConMsg ("\pRun length distribution is calculated...","\pLauflängenstatistik wird erzeugt.");
  823.     
  824.     for ( i=0; i<llsize; i++ ) hi[i]=lo[i]=0;
  825.     RefreshRunLengthWindow();                // clear window
  826.     
  827.     err = FSpOpenDF ( &rlesfile, fsCurPerm, &tapeID );
  828.     if (err) tapeID=0;
  829.     if (err) return ErrMsg("\pFSpOpenDF()");
  830.  
  831.     err = GetEOF ( tapeID, &len );
  832.     if (err) return ErrMsg("\pGetEOF()");
  833.  
  834.     for ( i=0; i<len; i+=10000 )
  835.     {    n=10000;
  836.         err = FSRead ( tapeID, &n, buffer );
  837.         if ( (err==eofErr) & (i+n==len) ) err=noErr;
  838.         if (err) return ErrMsg("\pFSRead()");
  839.         
  840.         for ( j=0; j<n; )
  841.         {    k = buffer[j++];
  842.             hi[(k>>4)+mn] += 1;
  843.             lo[(k&0x0f)+mn] +=1;
  844.         };
  845.         
  846.         RefreshWindows();
  847.     }
  848.         
  849.     RefreshRunLengthWindow();
  850. }
  851.  
  852.  
  853. // ==========================================================================================
  854.  
  855.  
  856. // -----    Handle some mouse down events --------------------------------
  857. HandleSomeMouseDown()
  858. {    WindowPtr    window;
  859.     long            where;
  860.     where = FindWindow ( event.where, &window );
  861.     switch (where)
  862.     {
  863. //    case inMenuBar:        HandleMenuSelection ( MenuSelect( event.where ) );        return;
  864.     case inMenuBar:        SysBeep(4711);                                            return;
  865.     case inDrag:        DragWindow ( window, event.where, &qd.screenBits.bounds );    return;
  866.     case inSysWindow:    SystemClick ( &event, window );                            return;
  867.     case inGoAway:        HandleCLOSE();                                            return;
  868.     case inGrow:        HandleGROW();                                            return;
  869.     case inZoomIn:        HandleZOOMIN();                                            return;
  870.     case inZoomOut:        HandleZOOMOUT();                                        return;
  871.     case inContent:        SelectWindow (window); HandleINCONTENT();                return;
  872.     case inDesk:        HandleINDESK();                                            return;
  873.     };
  874. }
  875.  
  876.  
  877. // -----    Refresh windows if neccessary ----------------------------------
  878. RefreshWindows()
  879. {    while ( WaitNextEvent(mDownMask|mUpMask|updateMask|activMask|osMask,&event,0,eventRegion) )
  880.     {    switch (event.what)
  881.         {
  882. //        case kHighLevelEvent:    AEProcessAppleEvent(&event);        break;    
  883.         case mouseDown:            HandleSomeMouseDown();                 break;
  884. //        case autoKey:            HandleAUTOKEY(event.message&0x0ff); break;
  885. /*        case keyDown:
  886.             if (event.modifiers&cmdKey)
  887.                 {    selection = MenuKey(event.message&0x0ff);
  888.                     if (HiWord(selection)) 
  889.                     {     HandleMenuSelection( selection );
  890.                         break;
  891.                     }
  892.                 }
  893.             HandleKEYDOWN (event.message&0x0ff); 
  894.             break;
  895. */
  896.         case activateEvt:    
  897.             SetPort ( (WindowPtr)event.message );
  898.             if (event.modifiers&activeFlag)    
  899.                 HandleACTIVATE   ();         // window activated  
  900.             else    HandleDEACTIVATE ();    // window deactivated
  901.             break; 
  902.  
  903.         case updateEvt:    
  904.             BeginUpdate ( (WindowPtr)event.message );
  905.             HandleUPDATE((WindowPtr)event.message);
  906.             EndUpdate   ( (WindowPtr)event.message ); 
  907.             break;
  908.             
  909.         case osEvt:                
  910.             if (event.message & 0x01000000 ) 
  911.                 if ( event.message & 0x00000001 ) 
  912.                     SetCursor(&qd.arrow),HandleRESUME();     // application re-activated 
  913.                 else    HandleSUSPEND();                     // application de-activated
  914.             if ((event.message & 0xFF000000)==0xFA000000)
  915.                 HandleREGION();                                // mouse leaves eventRegion
  916.             break;
  917.  
  918.         };
  919.     };
  920. }
  921.  
  922.  
  923. // ------ Check new data in buffer for screen$ and if so, display it
  924. DisplayScreenshot()
  925. {    Char *p,*e, *ph, *pd;
  926.     Short slen;
  927.     long len;
  928.     Char *cp,*ep; long blklen,blkadr;
  929.     
  930.     if ( !dh ) return;                // no data buffer
  931.     if ( !spectrumfenster ) return;    // window not open
  932.     
  933.     p = dh+4;                        // scan start
  934.     e = *(Char**)dh;                // scan end
  935.     ph = nil;                        // ptr -> header block
  936.     pd = nil;                        // ptr -> data block
  937.     
  938.     while (p<e)
  939.     {    ph=pd;
  940.         pd=p;
  941.         slen = *p + *(p+1)*256 -2; 
  942.         p += slen ? slen+4 : 0x10004;
  943.     };
  944.     
  945.     if (ph==nil) return;                // no header block found
  946.     
  947.     slen = *ph + *(ph+1)*256 -2;
  948.     if ( slen < 17 ) return;            // min. length for header: type+17byte+crc = 19 byte
  949.     cp = ph+2;                            // cp -> type
  950.     if ( *cp!=0 || *(cp+1)!=3 ) return;    // not a code header
  951.     
  952.     blklen = *(cp+12) + (*(cp+13)<<8);    // length of data block
  953.     if (!blklen) blklen = 0x10000;
  954.     blkadr = *(cp+14) + (*(cp+15)<<8);    // original address of data block
  955.     
  956.     if (  (blklen!=6912)  &&  ( (blkadr+blklen<0x4000) || (blkadr>=23296) ) )  return;
  957.     if (blklen==6912) blkadr=0x4000;    // sometimes they've saved it from anywhere in memory
  958.     
  959. // This is a header for data, that might contain a screen$
  960.  
  961.     slen = *pd + *(pd+1)*256 -2;    
  962.     if ( slen < blklen ) return;    // mismatch between data and header block
  963.     cp = pd+2;                        // cp -> type
  964.     if ( *cp!=255) return;            // not a data block!
  965.  
  966. // Anything seems to be all right ...
  967.  
  968.     cp = cp+1;                        // cp points to effective data
  969.     if (blkadr<0x4000)  {  blklen-=(0x4000-blkadr); cp += (0x4000-blkadr); blkadr=0x4000;  };
  970.     if (blkadr+blklen > 23296) blklen = 23296-blkadr;
  971.     if (blklen<=0) return;            // this cannot happen
  972.  
  973.     Malloc ( &spectrumbitmap, 6912 );
  974.     if (!spectrumbitmap) return;                    // out of memory
  975.     memset ( spectrumbitmap, 0, 6144 );                // default pixel
  976.     memset ( spectrumbitmap+6144, 0x38, 768);        // default attribute
  977.  
  978.     memcpy ( spectrumbitmap + blkadr - 0x4000, cp, blklen );    // and overwrite
  979.  
  980.     cp=spectrumbitmap+6144;                            // flashing required ?
  981.     ep=spectrumbitmap+6912;
  982.     flashing=false;
  983.     eventDelay=120;
  984.     while ( cp<ep )
  985.     {    if ( *cp++&0x80 ) 
  986.         {     if ( (*(cp-1)&0x07)==((*(cp-1))>>3)&0x07 )
  987.                 *(cp-1) &=0x7f;                        // don't flash same colors
  988.             else
  989.             {    flashing=true; eventDelay=60; break;     };
  990.         };
  991.     }
  992.     
  993.     RedrawSpectrumscreen();
  994. }
  995.  
  996.  
  997. Notify ( Str255 eng, Str255 ger )
  998. {    
  999.     ConNL();
  1000.     PrintNum(p-mh);
  1001.     ConTab(); 
  1002.     ConPrint(eng,ger);
  1003. }
  1004.  
  1005.  
  1006. Short NextByte (Boolean v)
  1007. {    register Char b1,b2; short i,c;
  1008.     c=0;
  1009.     for (i=0;i<8;i++)
  1010.     {    b1=*p++;        // get 1/2 nibble
  1011.         b2=*p++;        // get 2/2 nibble
  1012.         if (b1>max1 || b2>max1) { if (v) Notify("\p••••• Phase too long!","\p••••• Flanke zu lang!"); return(-1); };
  1013.         if (b1<min0 || b2<min0)  {  if (v) Notify("\p••••• Phase too short!","\p••••• Flanke zu kurz!"); return(-1);  };
  1014.         if (b1<=max0 && b2<=max0)  c = c+c;
  1015.         else if (b1>=min1 && b2>=min1)  c = c+c+1;
  1016.         else 
  1017.         {    if (v) Notify("\p••••• Long and short phase for same bit!","\p••••• Kurze und lange Flanke für gleiches Bit!");
  1018.             return(-1);
  1019.         };
  1020.     };
  1021.     crc ^= c;            // update checksum
  1022.     *d++=c;                // and store byte in buffer
  1023.     return(c);
  1024. }
  1025.  
  1026.  
  1027. ChangeBorder ( long n )
  1028. {
  1029.     borderstate=n;
  1030.     RedrawSpectrumborder();
  1031.     Delay ( 15, &n );            // for your eyes only ...
  1032.     RefreshWindows();            // don't get nervous !
  1033. }
  1034.  
  1035.  
  1036. // -----    Convert RLES -> Tape ----------------------------------------------
  1037. LoadTape()
  1038. {    OSErr err; long i,n,len; Char *q, c; short b, typ; Short slen;
  1039.     Short expect=0;
  1040.     Char    hdr[17];
  1041.     Char * dsp;
  1042.     
  1043.     ConMsg ("\pPrograms are loaded.","\pProgramme werden geladen.");
  1044.     MFree ( &spectrumbitmap ); 
  1045.     OpenSpectrumWindow();
  1046.  
  1047.     err = FSpOpenDF ( &rlesfile, fsCurPerm, &tapeID );
  1048.     if (err) tapeID=0;
  1049.     if (err) return ErrMsg("\pFSpOpenDF()");
  1050.  
  1051.     err = GetEOF ( tapeID, &len );
  1052.     if (err) return ErrMsg("\pGetEOF()");
  1053.  
  1054.     Malloc ( &mh, len*2 );
  1055.     if ( !mh )  return ConMsg("\pNo memory available!","\pKein Speicher mehr frei!");
  1056.     
  1057.     Malloc ( &dh, 200 + len/7 );   // benötigt werden: len/8 + gesamtgröße aller segmentköpfe
  1058.     if ( !dh ) MFree (&mh);
  1059.     if ( !dh ) return ConMsg("\pNo memory available!","\pKein Speicher mehr frei!");
  1060.     
  1061. // ----- Read source file and prepare    
  1062.     n=len;  err = FSRead ( tapeID, &n, mh+len );
  1063.     if ( (err==eofErr) & (n==len) ) err=noErr;
  1064.     if (err) 
  1065.     {     ErrMsg("\pFSRead()"); 
  1066.         MFree ( &mh ); MFree ( &dh );
  1067.         return; 
  1068.     };
  1069.  
  1070.     p = mh;
  1071.     q = p + len;
  1072.     
  1073.     for ( i=0; i<len; i++ )
  1074.     {    *p++ = ( *q >> 4 ) + 2;
  1075.         *p++ = ( *q++ & 0x0f ) + 2;
  1076.     };
  1077.  
  1078. // ----- prepare destination buffer
  1079.     dsp = dh+4;                    // data segment pointer
  1080.     *(Char**)dh=dsp;            // end of data pointer
  1081.  
  1082. // ----- let's do it! ---------------------------------------------------
  1083.     p = mh;             // read pointer
  1084.     q = p+len+len;        // end pointer
  1085.  
  1086.     while (p<q)
  1087.     {    
  1088. nh:        ChangeBorder(1);            // we are looking for a header !
  1089.         if (verbose>=2) { ConNL(); Notify("\p      Looking for header","\p      Suche Vorspann"); };
  1090. nhx:    p++;
  1091.         if (p>=q) break;
  1092.         for (i=0; i<88; i++,p++ ) if (*p>maxh || *p<minh) break; 
  1093.         if (i<88) goto nhx;
  1094.         
  1095.         ChangeBorder(2);            // blips ... check it !
  1096.         for (i=0; i<444; i++,p++ ) if (*p>maxh || *p<minh) break;
  1097.         if (i<444) goto nh;
  1098.         
  1099.         ChangeBorder(3);            // we've got it !
  1100.         if (verbose>=2) { Notify("\p      Header ... ","\p      Vorspann ... "); };
  1101.         while ( *p<=maxh && *p>=minh && p<q ) p++;  
  1102.         
  1103.         if (*p>maxh) { if (verbose) { Notify("\p      Header: Period too long",    "\p      Fangsequenz: Periode zu lang"); }; goto nh; };
  1104.         if (*p>maxs) { if (verbose) { Notify("\p      Sync 1/2 too long",        "\p      Sync 1/2 zu lang"); goto nh; };};
  1105.         if (*p<mins) { if (verbose) { Notify("\p      Sync 1/2 too short",        "\p      Sync 1/2 zu kurz"); goto nh; };};    p++;
  1106.         if (*p>maxs) { if (verbose) { Notify("\p      Sync 2/2 too long",        "\p      Sync 2/2 zu lang"); goto nh; };};
  1107.         if (*p<mins) { if (verbose) { Notify("\p      Sync 2/2 too short",        "\p      Sync 2/2 zu kurz"); goto nh; };};    p++;
  1108.         if (verbose>=2) { Notify("\p      Sync pulse ... ","\p      Syncimpuls ... "); };
  1109.         
  1110.         crc = 0;  d = dsp+2;
  1111.         typ=NextByte(true);          // read Block Type
  1112.         if (typ<0) goto nh; 
  1113.         ChangeBorder(4);        
  1114.  
  1115.         if (typ!=0) goto ld;            // load data
  1116.  
  1117. // Header
  1118.         if (expect)  { Notify("\p••••• The data block wasn't found!","\p••••• Der Datenblock wurde nicht gefunden!");};
  1119.         expect=0;
  1120.         ConNL();Notify("\p***** HEADER",0); 
  1121.         for (i=0; i<=16; i++ )  {  hdr[i]=b=NextByte(true); if (b<0) goto nl;  };
  1122.         
  1123.         typ = *hdr; *hdr=10; for (i=1;i<=10;i++) if (hdr[i]<32) hdr[i]='?';
  1124.         
  1125.         switch (typ)
  1126.         {    case 0:        Notify("\p      Basic program",            "\p      Programmdatei"); break;
  1127.             case 1:        Notify("\p      Number array",            "\p      Zahlenarray"); break;
  1128.             case 2:        Notify("\p      Text array",            "\p      Textarray"); break;
  1129.             case 3:        Notify("\p      Code or Screen$",        "\p      Code oder Screen$"); break;
  1130.             default:    Notify("\p      Illegal header ID",        "\p      Ungültiger Headertyp");
  1131.                         Notify("\p>>>>> Loading data as Long Header", "\p>>>>> Lade Daten als Long Header");
  1132.                     i=1;expect=0;goto ldx;
  1133.         };
  1134.         
  1135.         if (hdr[1]==255)    Notify("\p      unnamed", "\p      ohne Namen");
  1136.         else    {              Notify("\p      Name: ",0); ConPrint(hdr,0);  };
  1137.         
  1138.         Notify ("\p      File length: ","\p      Dateilänge: "); PrintNum(hdr[11]+((Short)hdr[12]<<8)); 
  1139.         
  1140.         if ( typ==0 && verbose )
  1141.         {    if ( hdr[14]<0x0080 )  
  1142.             {    Notify ("\p      Autostart at line: ","\p      Autostart ab Zeile: "); PrintNum(hdr[13]+((Short)hdr[14]<<8)); 
  1143.             };
  1144.             Notify ("\p      Program length without data: ","\p      Programmlänge ohne Daten: ");  
  1145.             PrintNum(hdr[15]+((Short)hdr[16]<<8)); 
  1146.         };
  1147.         
  1148.         if ( (typ==1 || typ==2) && verbose )
  1149.         {    
  1150.         };
  1151.         
  1152.         if ( typ==3 && verbose )
  1153.         {    Notify ("\p      Original address of data: ", "\p      Originallage der Daten: "); 
  1154.             PrintNum(hdr[13]+((Short)hdr[14]<<8)); 
  1155.         };
  1156.         
  1157.         b=NextByte(true); if(b<0) goto nl;
  1158.         if (crc) 
  1159.         {     Notify("\p••••• Checksum wrong","\p••••• Prüfsumme stimmt nicht"); 
  1160.             b=NextByte(false); if (b<0) goto nl;
  1161.             b=NextByte(false); if (b<0) goto nl;
  1162.             Notify("\p>>>>> Long Header ... loading proceeds !","\p>>>>> Long Header ... lade weiter !");
  1163.             i=20;        // number of bytes already read
  1164.             expect=0;    // no read end marker
  1165.             goto ldx;     // read "headerless"
  1166.         };
  1167.         Notify("\p+++++ Checksum ok","\p+++++ Prüfsumme ok");
  1168.         expect=hdr[11]+((Short)hdr[12]<<8);
  1169.         b=NextByte(false); if (b<0) goto nl;
  1170.         b=NextByte(false); if (b<0) goto nl;
  1171.         Notify("\p>>>>> Long Header ... loading proceeds !","\p>>>>> Long Header ... lade weiter !");
  1172.         i=20;            // number of bytes already read
  1173.         expect=18;        // last read end marker
  1174.         goto ldx;        // read "headerless"
  1175.         
  1176. // Data
  1177. ld:        
  1178.         if (typ!=255) { ConNL();Notify("\p$$$$$ UNDEFINED TYPE: ","\p$$$$$ UNDEFINIERTER TYP: "); PrintNum(typ); ConNL(); };
  1179.         if (expect)
  1180.         {    ConNL(); Notify("\p***** DATA","\p***** DATEN");
  1181.             for ( i=0; i<expect && p<q; i++ )
  1182.             {    b=NextByte(true); if (b<0) { expect=0; goto nl; };
  1183.             };
  1184.             b=NextByte(true); if (b<0) { expect=0; goto nl; };
  1185.             if (crc) {     Notify("\p••••• Checksum wrong","\p••••• Prüfsumme stimmt nicht"); expect=0; }
  1186.             else         Notify("\p+++++ Checksum ok","\p+++++ Prüfsumme ok");
  1187.             b=NextByte(false); if (b<0) { expect=0;goto nl;};
  1188.             b=NextByte(false); if (b<0) { expect=0;goto nl;};
  1189.             Notify("\p>>>>> Long Data ... loading proceeds !","\p>>>>> Long Data ... lade weiter !");
  1190.             i=i+2;
  1191.             goto ldx;
  1192.         }
  1193.         else
  1194.         {    ConNL(); Notify("\p***** HEADERLESS DATA","\p***** HEADERLOSE DATEN");
  1195.             for ( i=0; p<q; i++ )
  1196.             {    
  1197. ldx:                b=NextByte(!expect); if (b<0) break;
  1198.                 if (crc==0) 
  1199.                 {    if (verbose>=2) ConPrint("\p ((crc==0)) ",0);
  1200.                     expect=i;
  1201.                 };
  1202.             };
  1203.             Notify ("\p      File length: ","\p      Dateilänge: "); PrintNum(i-1);
  1204.             if (expect==0)  {  Notify("\p••••• Checksum wrong!","\p••••• Prüfsumme stimmt nicht!"); goto nl;  };
  1205.             if (i-1==expect) 
  1206.             {    Notify ("\p+++++ Checksum ok","\p+++++ Prüfsumme ok");
  1207.             }
  1208.             else
  1209.             {    Notify ("\p      Last OK for checksum at: ","\p      Letztes ok für die Prüfsumme: "); PrintNum(expect); 
  1210.                 Notify ("\p••••• Probably unusable!","\p••••• Vermutlich fehlerhaft!");
  1211.             };
  1212.             expect=0;
  1213.             goto nl;
  1214.         };
  1215.         
  1216. // ----- update segment header
  1217. nl:        len = d-(dsp+2);
  1218.         if (len<3)                        // all blocks contain at least 3 bytes: 1*type+1*data+1*crc !!!
  1219.         {    Notify ("\p••••• Block contains no data (skipped)","\p••••• Block enthält keine Daten (übersprungen)");
  1220.             d = dsp+2;
  1221.             continue;
  1222.         };
  1223.         if (len>=0x10002) 
  1224.         {    Notify ("\p••••• Block longer than 0x10000 bytes","\p••••• Block länger als 0x10000 Bytes");
  1225.             len=0x10002;
  1226.             d=dsp+0x10004;
  1227.         };
  1228.         *dsp = len;                        // big endian byte order !!!
  1229.         *(dsp+1) = len>>8;                // .tap format was invented on PC clowns !
  1230.         *(Char**)dh = dsp = d;
  1231.         d += 2;
  1232.         DisplayScreenshot();
  1233.     };
  1234.  
  1235.     Notify("\p----- End of tape -----","\p----- Ende des Bandes -----"); ConNL();
  1236.  
  1237.     MFree ( &mh ); 
  1238.     ChangeBorder(0);    
  1239.     
  1240. // ----- write to destination file (type: 'Tape')
  1241.  
  1242.     ConTab();ConMsg("\p      Writing tape file","\p      Schreibe Banddatei");
  1243.     tapefile=rlesfile;
  1244.     if ( *tapefile.name>=5 )
  1245.     {    if ( memcmp ( tapefile.name+*tapefile.name-4, ".rles", 5 ) == 0 ) *tapefile.name -=5;
  1246.         else if ( memcmp ( tapefile.name+*tapefile.name-4, ".RLES", 5 )  == 0 ) *tapefile.name -=5;
  1247.     }
  1248.     if (*tapefile.name>25) *tapefile.name=25;
  1249.     while (tapefile.name[*tapefile.name]==' ') *tapefile.name -= 1;
  1250.     memcpy ( tapefile.name+*tapefile.name+1, " .tape", 6 );
  1251.     *tapefile.name += 6;
  1252.  
  1253.     err = FSpCreate ( &tapefile, 'ZXSP', 'Tape', 0 );    // 'ZXSP' == ID of ZX Spectrum Emulator
  1254.     if (err=dupFNErr) err=noErr;    // ignore file already exists
  1255.     if (err) return ErrMsg("\pFSpCreate()");
  1256.  
  1257.     err = FSpOpenDF ( &tapefile, fsCurPerm, &dataID );
  1258.     if (err=eofErr) err=noErr;
  1259.     if (err) return ErrMsg("\pFSpOpenDF()");
  1260.  
  1261.     err = SetEOF ( dataID, 0 );        // clear tape
  1262.     if (err) return ErrMsg("\pSetEOF()");
  1263.     
  1264.     len = *(Char**)dh-(dh+4);
  1265.     err = FSWrite ( dataID, &len, dh+4 );
  1266.     if (err) return ErrMsg("\pFSWrite()");
  1267. }
  1268.  
  1269.  
  1270. // -----    Convert Sound -> RLES ---------------------------------------------
  1271. //
  1272. RunLengthCompression()
  1273. {    OSErr err; long i,j,k, len, n,m; short whatsup; Char *z;
  1274.     char buffer[10000]; Char rll[10000];
  1275.     short hysterese = 2;
  1276.     Rect mybox;
  1277.     
  1278.     ConMsg ("\pRun length compression in progress...","\pLauflängenkompression wird durchgeführt.");
  1279.     
  1280.     err = FSpOpenDF ( &soundfile, fsCurPerm, &soundID );
  1281.     if (err) return ErrMsg("\pFSpOpenDF()");
  1282.  
  1283.     err = GetEOF ( soundID, &len );
  1284.     if (err) return ErrMsg("\pGetEOF()");
  1285.  
  1286.     rlesfile=soundfile;
  1287.     if ( *rlesfile.name>=5 )
  1288.     {    if ( memcmp ( rlesfile.name+*rlesfile.name-4, ".aiff", 5 ) == 0 ) *rlesfile.name -=5;
  1289.         else if ( memcmp ( rlesfile.name+*rlesfile.name-4, ".AIFF", 5 )  == 0 ) *rlesfile.name -=5;
  1290.     }
  1291.     if (*rlesfile.name>25) *rlesfile.name=25;
  1292.     while (rlesfile.name[*rlesfile.name]==' ') *rlesfile.name -= 1;
  1293.     memcpy ( rlesfile.name+*rlesfile.name+1, " .rles", 6 );
  1294.     *rlesfile.name += 6;
  1295.  
  1296.     err = FSpCreate ( &rlesfile, 'ZXSp', 'RLES', 0 );
  1297.     if (err=dupFNErr) err=noErr;    // ignore file already exists
  1298.     if (err) return ErrMsg("\pFSpCreate()");
  1299.  
  1300.     err = FSpOpenDF ( &rlesfile, fsCurPerm, &tapeID );
  1301.     if (err=eofErr) err=noErr;
  1302.     if (err) return ErrMsg("\p(FSpOpenDF)");
  1303.  
  1304.     err = SetEOF ( tapeID, 0 );        // clear tape
  1305.     if (err) return ErrMsg("\p(SetEOF)");
  1306.     
  1307.  
  1308.     k=1;whatsup='hi';z=rll;
  1309.     for ( i=0; i<len; i+=10000 )
  1310.     {    n=10000;
  1311.         err = FSRead ( soundID, &n, buffer );
  1312.         if ( (err==eofErr) & (i+n==len) ) err=noErr;
  1313.         if (err) return ErrMsg("\p(FSRead)");
  1314.         
  1315.         for ( j=0; j<n; )
  1316.         {    if (whatsup=='hi')
  1317.             {    while ( j<n && buffer[j]>=-hysterese ) { j++; k++; };
  1318.                 if ( j<n )  {  if ( k>mx) k=mx; if (k<mn) k=mn; *z=(k-mn)<<4 ; whatsup='lo'; k=0; };
  1319.             };
  1320.             if (whatsup=='lo')
  1321.             {    while ( j<n && buffer[j]<=hysterese ) { j++; k++; };
  1322.                 if ( j<n )  {  if ( k>mx) k=mx; if (k<mn) k=mn; *z+=k-mn; if(*z) z++; whatsup='hi'; k=0; };
  1323.             };
  1324.             if ( (z==rll+10000) || (i+j==len) ) 
  1325.             {    m=z-rll;
  1326.                 err = FSWrite ( tapeID, &m, rll );
  1327.                 if (err) return ErrMsg("\p(FSWrite)");
  1328.                 z=rll;
  1329.             };
  1330.         };
  1331.         
  1332.         RefreshWindows();
  1333.     }
  1334.         
  1335. }
  1336.  
  1337.  
  1338. // -----    record new sound to file and then open & convert this file
  1339. //
  1340. HandleNEW()                    
  1341. {    OSErr err; Point corner;
  1342.     StandardFileReply reply;
  1343.     long    inRefNum;
  1344.     short    channels;
  1345.     short    sample_size;
  1346.     Fixed    sample_rate;    short i; Short n,m;
  1347.     
  1348.     ConMsg ( "\pRead data from tape","\pDaten von Kassette lesen" );
  1349.  
  1350.     if (german)    StandardPutFile ( "\pName für die Sound-Zieldatei", "\pZXSpectrum .aiff", &reply );
  1351.     else        StandardPutFile ( "\pName for the sound file", "\pZXSpectrum .aiff", &reply );
  1352.     if (!reply.sfGood) return ConMsg("\p*** Breaked ***","\p*** Abgebrochen ***");
  1353.     soundfile = reply.sfFile;
  1354.  
  1355.     ConPrint("\pDestination file: ","\pZieldatei: ");ConMsg(soundfile.name,0);
  1356.  
  1357.     if ( !reply.sfReplacing )
  1358.     {    err = FSpCreate ( &soundfile, 'ZXSp', 'AIFF', 0 );
  1359.         if (err) return ErrMsg("\p(FSpCreate)");
  1360.     };
  1361.     
  1362.     err = FSpOpenDF ( &soundfile, fsCurPerm, &soundID );
  1363.     if (err=eofErr) err=noErr;
  1364.     if (err) soundID=0;
  1365.     if (err) return ErrMsg("\p(FSpOpenDF)");
  1366.  
  1367.     err = SPBOpenDevice ( "\p", siWritePermission, &inRefNum );        
  1368.     if (!err)  
  1369.     {    err = SPBSetDeviceInfo ( inRefNum, 'plth', (Ptr)&plth_volume );    
  1370.         if (err) ConMsg("\pSet play through volume failed",0);
  1371.         
  1372.         err = SPBSetDeviceInfo ( inRefNum, 'agc ', (Ptr)&auto_gain_control );    
  1373.         if (err) ConMsg("\pSet automatic gain control failed",0);
  1374.         
  1375.         err = SPBGetDeviceInfo ( inRefNum, 'chan', (Ptr)&channels );            
  1376.         if (err) ConMsg("\pGet number of channels failed",0);
  1377.         else
  1378.         {    if (channels==1) 
  1379.             {    if (verbose==2) ConMsg("\pNumber of channels is mono",0);
  1380.             }
  1381.             else
  1382.             {    if (verbose) ConMsg("\pSetting device to mono",0);
  1383.                 channels=1;
  1384.                 err = SPBSetDeviceInfo ( inRefNum, 'chan', (Ptr)&channels );
  1385.                 if (err) ConMsg("\pSetting to mono failed",0);
  1386.             };
  1387.         };
  1388.         
  1389.         err = SPBGetDeviceInfo ( inRefNum, 'ssiz', (Ptr)&sample_size );            
  1390.         if (err) ConMsg("\pGet sample size failed",0);
  1391.         else
  1392.         {    if (sample_size==8)
  1393.             {    if (verbose==2) ConMsg("\pSample size is 8 bit",0);
  1394.             }
  1395.             else
  1396.             {    if (verbose) ConMsg("\pSetting sample size to 8 bit",0);
  1397.                 sample_size=8;
  1398.                 err = SPBSetDeviceInfo ( inRefNum, 'ssiz', (Ptr)&sample_size );    
  1399.                 if (err) ConMsg("\pFailed to set sample size",0);
  1400.             };
  1401.         };
  1402.         
  1403.         err = SPBGetDeviceInfo ( inRefNum, 'srat', (Ptr)&sample_rate );            
  1404.         if (err) ConMsg("\pGet sample rate failed",0);
  1405.         else
  1406.         {    if ((FixRound(sample_rate)>=21000) && (FixRound(sample_rate)<=23000))
  1407.             {    if (verbose==2) ConMsg("\pSample rate is 22 kHz",0);
  1408.             }
  1409.             else
  1410.             {    struct { short cnt; Fixed **table; } sample_rate_list;
  1411.                 
  1412.                 if (verbose) ConMsg("\pSetting sample rate to 22 kHz",0);
  1413.                 err = SPBGetDeviceInfo ( inRefNum, 'srav', (Ptr)&sample_rate_list );    
  1414.                 if (err) ConMsg("\pGetting sample rate list failed",0);
  1415.                 else
  1416.                 {    if (sample_rate_list.cnt)
  1417.                     {    if (verbose==2) ConMsg("\p[list of discrete sampling rates]",0);
  1418.                         for (i=n=0;i<sample_rate_list.cnt;i++)
  1419.                         {    m=FixRound((*sample_rate_list.table)[i]);
  1420.                             if (m<20050) n=m; else { if ((20050-n)<(m-20050)) m=n; break; };
  1421.                         };
  1422.                         sample_rate = Long2Fix(m);
  1423.                     }
  1424.                     else
  1425.                     {    if (verbose==2) ConMsg("\p[range of sampling rates]",0);
  1426.                         sample_rate = Long2Fix(22000);
  1427.                     };
  1428.                     DisposHandle((Handle)sample_rate_list.table);
  1429.                     err = SPBSetDeviceInfo ( inRefNum, 'srat', (Ptr)&sample_rate );    
  1430.                     if (err) ConMsg("\pFailed to set sample rate",0);
  1431.                 
  1432.                     err = SPBGetDeviceInfo ( inRefNum, 'srat', (Ptr)&sample_rate );            
  1433.                     if (err) ConMsg("\pGet sampling rate failed",0);
  1434.                     else
  1435.                     if ((FixRound(sample_rate)>=21000) && (FixRound(sample_rate)<=23000))
  1436.                     {    if (verbose==2) ConMsg("\pSample rate is 22 kHz",0);
  1437.                     }
  1438.                     else
  1439.                         ConMsg("\pSample rate is •not• 22 kHz",0);
  1440.                 };
  1441.             };
  1442.         };        
  1443.         
  1444.         SPBCloseDevice ( inRefNum );
  1445.     }
  1446.     else ConMsg("\pFailed to initialize the sound input device","\pDer Toneingang konnte nicht parametriert werden");
  1447.  
  1448.     RefreshWindows();
  1449.     corner.v=40;
  1450.     corner.h=40;
  1451.     err = SndRecordToFile ( nil, corner, 'best', soundID );
  1452.     if (err)
  1453.     {    CloseAll();
  1454.         if (err==userCanceledErr) return ConMsg("\p*** Breaked ***","\p*** Abgebrochen ***");
  1455.         else return ErrMsg("\p(SndRecordToFile)");
  1456.     };
  1457.     
  1458.     HandleOPEN ( soundfile );
  1459. }
  1460.  
  1461.  
  1462. // ============================================================================
  1463. // ============================================================================
  1464. // ============================================================================
  1465. // ============================================================================
  1466. // ============================================================================
  1467.  
  1468.  
  1469. HandleSAVE()                // save top window to disk
  1470. {    short n;
  1471.     n = Alert ( 128, nil );
  1472.     if (n==-1) ConMsg("\pResource 'ALRT' 128 is missing.","\pRessource 'ALRT' 128 fehlt.");
  1473. }
  1474.  
  1475. HandleKEYDOWN(Char key) 
  1476. {     
  1477. //     8 = Backspace        28 = Cursor left
  1478. //     9 = Tab            29 = Cursor right
  1479. //    13 = Return            30 = Cursor up
  1480. //                        31 = Cursor down
  1481. }
  1482.  
  1483. HandlePRINT()            { }    // print top window
  1484.  
  1485. HandleACTIVATE()        { }    // window 'thePort' activated
  1486. HandleDEACTIVATE()        { }    // window 'thePort' deactivated
  1487. HandleINCONTENT()        { }     // in FrontWindow()
  1488.  
  1489. HandleZOOMOUT()          { }    // in FrontWindow()
  1490. HandleZOOMIN()           { }    // in FrontWindow()
  1491. HandleGROW()             { }    // in FrontWindow()
  1492.  
  1493. HandleUNDO()            { }    // 'Edit' menu
  1494. HandleCUT()                { }    // 'Edit' menu
  1495. HandleCOPY()            { }    // 'Edit' menu
  1496. HandlePASTE()            { }    // 'Edit' menu
  1497.  
  1498. // ***** not so often needed ***************************************
  1499.  
  1500. HandleAUTOKEY(Char key)    { HandleKEYDOWN(key); }
  1501. HandleMOUSEUP()             { }
  1502. HandleKEYUP(Char key)    { } // global event enabling needed !!
  1503. HandleDISK()            { }    // Disk inserted (( ejected? ))
  1504. HandleINDESK()           { } // this should never happen
  1505. HandleDRIVER()             { }    // used by system tasks only
  1506. HandleAPP3()            { }    // application event
  1507.  
  1508. HandleREGION()            { }    // mouse leaves 'eventRegion'
  1509. HandleSUSPEND()            { }    // application is juggled out
  1510. HandleRESUME()            { }    // application is juggled in
  1511.  
  1512.