home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / SoundAndMusic / Hyperupic / Hyperupic.app / HyperupicGen.m < prev    next >
Text File  |  1992-08-20  |  29KB  |  1,581 lines
  1. #import "HyperupicGen.h"
  2.  
  3.  
  4. @implementation HyperupicGen
  5.  
  6. + create {
  7.  
  8.     id         newInstance;
  9.  
  10.     newInstance = [ self new ];
  11.     return newInstance;
  12. }
  13.  
  14. - init {
  15.  
  16.     [super init];
  17.     [self setDefaults];
  18.     status = IDLE;    
  19.  
  20.     openReq = [OpenPanel new];
  21.     openMapReq = [OpenPanel new];
  22.     openTableReq = [OpenPanel new];
  23.     saveReq = [SavePanel new];
  24.  
  25.     return self;
  26. }
  27.  
  28. - setDefaults {
  29.  
  30.   interp = 256;
  31.   srate = 44100.;
  32.   pi = 4 * atan(1.);
  33.   twopi = 8 * atan(1.);
  34.   ampref = 1.;
  35.   synt = 0.;
  36.   freqcon = 100.;
  37.   freqdiff = 50.;
  38.   tablesize = Default_Osc_Size;
  39.   x = -1;
  40.   y = -1;
  41.   xstart = -1;
  42.   xend = -1;
  43.   ystart = -1;
  44.   yend = -1;
  45.   srrand(76914020);
  46.   gotImage = NO;
  47.   gotMapFile = NO;
  48.   gotTableFile = NO;
  49.   oscilTable = NO;
  50.   savedSoundFile = YES;
  51.   gotSoundFileName = NO;
  52.   oscInit = NO;
  53.   adjusted = NO;
  54.   strcpy( harmsText, ".7 0 .2 0 .1\0" );
  55.   mapper = @selector(mapRGB);
  56.   dimension = @selector(genNorm);
  57.   display = @selector(displayMinMax);
  58.   coordinate = @selector(setYcoor);
  59.   spread = @selector(genHarmSeries);
  60.   minmax = @selector(mmHarmSeries);
  61.   osctable = @selector(setOscCos);
  62.  
  63.   return self;
  64. }
  65.  
  66. - (float) howFar {
  67.  
  68.   return howfar;
  69. }
  70.  
  71. - (int) xval {
  72.   return x;
  73. }
  74.  
  75. - (int) yval {
  76.   return y;
  77. }
  78.  
  79. - (int) xstartVal {
  80.   return xstart;
  81. }
  82.  
  83. - (int) ystartVal {
  84.   return ystart;
  85. }
  86.  
  87. - (int) xendVal {
  88.   return xend;
  89. }
  90.  
  91. - (int) yendVal {
  92.   return yend;
  93. }
  94.  
  95.  
  96. - setHarmsText: sender {
  97.  
  98.   strcpy( harmsText, [sender stringValue] );
  99.   return self;
  100. }
  101.  
  102. - setxVal: sender {
  103.  
  104.   int grabber;
  105.  
  106.   if ( (grabber = [sender intValue]) > 0 )
  107.  
  108.   xend = x = grabber;
  109.   xstart = 0;
  110.   return self;
  111. }
  112.  
  113. - setyVal: sender {
  114.  
  115.   int grabber;
  116.  
  117.   if ( (grabber = [sender intValue]) > 0 )
  118.  
  119.   yend = y = grabber;
  120.   ystart = 0;
  121.   return self;
  122. }
  123.  
  124. - setxstartVal: sender {
  125.  
  126.   int    grabber;
  127.  
  128.   if ( (grabber = [sender intValue]) > 0 && grabber < x )
  129.   xstart = grabber;
  130.   return self;
  131. }
  132.  
  133. - setystartVal: sender {
  134.  
  135.   int    grabber;
  136.  
  137.   if ( (grabber = [sender intValue]) > 0 && grabber < y )
  138.   ystart = grabber;
  139.   return self;
  140. }
  141.  
  142. - setxendVal: sender {
  143.  
  144.   int    grabber;
  145.  
  146.   if ( (grabber = [sender intValue]) > 0 && grabber < x )
  147.   xend = grabber;
  148.   return self;
  149. }
  150.  
  151. - setyendVal: sender {
  152.  
  153.   int    grabber;
  154.  
  155.   if ( (grabber = [sender intValue]) > 0 && grabber < y )
  156.   yend = grabber;
  157.   return self;
  158. }
  159.  
  160. - (int) getStatus {
  161.  
  162.   return status;
  163. }
  164.  
  165. - (float) getBigee {
  166.  
  167.   return bigee;
  168. }
  169.  
  170. - (float) getDuration {
  171.  
  172.   return duration;
  173. }
  174.  
  175. - (float) adjustFrequency {
  176.  
  177.   if (adjusted == YES) {
  178.     adjusted = NO;
  179.     return (freqcon /= srate / (float) tablesize);
  180.   }
  181.   else {
  182.     adjusted = YES;
  183.     return (freqcon *= srate / (float) tablesize);
  184.   }
  185. }
  186.  
  187. - pause {
  188.  
  189.   status = PAUSED;
  190.   return self;
  191. }
  192.  
  193. - snuff {
  194.  
  195.   status = DYING;
  196.   [self resume];
  197.   return self;
  198. }
  199.  
  200. - resume    //  Gets called from the other thread
  201.  
  202. {
  203.   kern_return_t        ec;
  204.   msg_header_t     msg =   {0,
  205.                          TRUE,
  206.                          sizeof(msg_header_t),
  207.                          MSG_TYPE_NORMAL,
  208.                          0};
  209.  
  210.     if (status == IDLE && appToObjPort != PORT_NULL)
  211.       return nil;
  212.  
  213.     msg.msg_local_port = PORT_NULL;
  214.     msg.msg_remote_port = appToObjPort;
  215.     ec = msg_send(&msg, SEND_TIMEOUT, 0);
  216.  
  217. // huh? (look below)
  218.     if (ec == SEND_TIMED_OUT); 
  219.  
  220.     return self;
  221. }
  222.  
  223.  
  224. - _waitForMessage {    // David Jaffe's pause thread gift
  225.  
  226.   struct {
  227.       msg_header_t header;
  228.       char data[MSG_SIZE_MAX];
  229.   } msg;
  230.  
  231.   status = PAUSED;
  232.  
  233.   (void)port_allocate(task_self(), &appToObjPort);
  234.   msg.header.msg_size = MSG_SIZE_MAX;
  235.   msg.header.msg_local_port = appToObjPort;
  236.   (void)msg_receive(&msg.header, MSG_OPTION_NONE,0);
  237.   (void)port_deallocate(task_self(),appToObjPort);
  238.   appToObjPort = PORT_NULL;
  239.   
  240.   if (status != DYING)
  241.     status = RUNNING;
  242.  
  243.   return self;
  244. }
  245.  
  246. - setXcoor {
  247.  
  248.   N = xend - xstart;
  249.   return self;
  250. }
  251.  
  252. - setYcoor {
  253.  
  254.   N = yend - ystart;
  255.   return self;
  256. }
  257.  
  258. - displayFreqs: sender {
  259.  
  260.   if ( x < 0 || y < 0 ) {
  261.     NXRunAlertPanel("The Beach Boys","Heavens to Murgatroyd! Need coordinates!",
  262.             "okie",NULL,NULL,NULL);
  263.     return nil;
  264.   }
  265.  
  266.   [self perform:display];
  267.   return self;
  268. }
  269.  
  270. - displayAll {
  271.  
  272.   int        i,
  273.         length;
  274.   char        bonk[1024];
  275.   static NXRect wRect = {{120.0, 100.0},{150.0,325.0}};
  276.  
  277.   [self allocateDataspace];
  278.  
  279.   [self perform:coordinate];
  280.   [self perform:spread];
  281.  
  282.   freqDisplay = [[TextView alloc] initFrame:&wRect];
  283.   [[freqDisplay window] setDelegate:self];
  284.   [freqDisplay setTitle:"Frequencies"];
  285.  
  286.   if ( (wRect.origin.x < 20.0) || (wRect.origin.y < 20.0) ) {
  287.     wRect.origin.x = 120.0;
  288.     wRect.origin.y = 100.0;
  289.   }
  290.   else
  291.     NXOffsetRect(&wRect, 20.0, -20.0);
  292.  
  293.   for ( i=0; i < N; i++ ) {
  294.     sprintf(bonk," %3f\n", *(freqs+i));
  295.     length = [freqDisplay textLength];
  296.     [freqDisplay setSel:length :length];
  297.     [freqDisplay replaceSel:bonk];
  298.   }
  299.  
  300.   return self;
  301. }
  302.  
  303. - displayMinMax {
  304.  
  305.   int        length;
  306.   char        bonk[1024];
  307.   static NXRect wRect = {{250.0, 300.0},{200.0,100.0}};
  308.  
  309.   [self perform:coordinate];
  310.   [self perform:minmax];
  311.  
  312.   freqDisplay = [[TextView alloc] initFrame:&wRect];
  313.   [[freqDisplay window] setDelegate:self];
  314.   [freqDisplay setTitle:"Frequency Extrema"];
  315.  
  316.   if ( (wRect.origin.x < 20.0) || (wRect.origin.y < 20.0) ) {
  317.     wRect.origin.x = 120.0;
  318.     wRect.origin.y = 100.0;
  319.   }
  320.   else
  321.     NXOffsetRect(&wRect, 20.0, -20.0);
  322.  
  323.  
  324.     sprintf(bonk,"minimum:\n%6f\n", mm.min);
  325.     length = [freqDisplay textLength];
  326.     [freqDisplay setSel:length :length];
  327.     [freqDisplay replaceSel:bonk];
  328.  
  329.     sprintf(bonk,"\nmaximum:\n%6f\n", mm.max);
  330.     length = [freqDisplay textLength];
  331.     [freqDisplay setSel:length :length];
  332.     [freqDisplay replaceSel:bonk];
  333.  
  334.   return self;
  335. }
  336.  
  337.  
  338. - (char *) getImagePath {
  339.  
  340.   return imageFile;
  341. }
  342.  
  343. - (char *) getMapPath {
  344.  
  345.   return mapFile;
  346. }
  347.  
  348. - (char *) getTablePath {
  349.  
  350.   return tableFile;
  351. }
  352.  
  353.  
  354. - (char *) getSoundPath {
  355.  
  356.   return soundFile;
  357. }
  358.  
  359. - (BOOL) getGotImage {
  360.  
  361.   return gotImage;
  362. }
  363.  
  364. - (BOOL) getGotMapFile {
  365.  
  366.   return gotMapFile;
  367. }
  368.  
  369. - (BOOL) getGotTableFile {
  370.  
  371.   return gotTableFile;
  372. }
  373.  
  374. - (BOOL) getOscilTable {
  375.  
  376.   return oscilTable;
  377. }
  378.  
  379. - (BOOL) getSavedSoundFile {
  380.  
  381.   return savedSoundFile;
  382. }
  383.  
  384. - setImagePath: sender {
  385.  
  386.   strcpy( imageFile, [sender stringValue]);
  387.   [self openImage];
  388.   return self;
  389. } 
  390.  
  391.  
  392. - setMapPath: sender {
  393.  
  394.   strcpy( mapFile, [sender stringValue]);
  395.   [self openMapFile];
  396.   return self;
  397. } 
  398.  
  399. - setTablePath: sender {
  400.  
  401.   strcpy( tableFile, [sender stringValue]);
  402.   [self openTableFile];
  403.   return self;
  404. } 
  405.  
  406. - ampref: sender {
  407.     ampref = [sender doubleValue];
  408.     return self;
  409. }
  410.  
  411. - time: sender {
  412.     interp = [sender intValue];
  413.     return self;
  414. }
  415.  
  416. - freqcon: sender {
  417.     freqcon = (float) [sender doubleValue];
  418.     return self;
  419. }
  420.  
  421. - freqdiff: sender {
  422.     freqdiff = (float) [sender doubleValue];
  423.     return self;
  424. }
  425.  
  426. - samplingRate: sender {
  427.     srate = (float) [sender doubleValue];
  428.     return self;
  429. }
  430.  
  431. - setSeed: sender {
  432.     seed = [sender intValue];
  433.     return self;
  434. }
  435.  
  436. - setSynt: sender {
  437.  
  438.   synt = [sender doubleValue];
  439.   return self;
  440. }
  441.  
  442. - openRequest:sender
  443. {
  444.  
  445.   static const char *const types[] = {NULL, NULL};
  446.  
  447.   [openReq setTitle:"looking for an Image file"];
  448.   if ([openReq runModalForTypes:types]) {
  449.     strcpy(imageFile, [openReq filename]);
  450.     [self openImage];
  451.   }
  452.   return self;
  453. }
  454.  
  455. - openMapRequest:sender
  456. {
  457.   static const char *const types[] = {NULL, NULL};
  458.  
  459.   [openMapReq setTitle:"looking for a Mapping file"];
  460.   if ([openReq runModalForTypes:types]) {
  461.     strcpy(mapFile, [openReq filename]);
  462.     if ( ![self openMapFile] )
  463.       return nil;
  464.   }
  465.   return self;
  466. }
  467.  
  468. - openTableRequest: sender
  469. {
  470.   static const char *const types[] = {NULL, NULL};
  471.  
  472.   [openTableReq setTitle:"looking for an oscillator Table file"];
  473.   if ([openReq runModalForTypes:types]) {
  474.     strcpy(tableFile, [openReq filename]);
  475.     if ( ![self openTableFile] )
  476.       return nil;
  477.   }
  478.   return self;
  479. }
  480.  
  481.  
  482. - saveRequest:sender
  483. {
  484.  
  485.   if (savedSoundFile == YES)
  486.     return self;
  487.  
  488.     if (gotSoundFileName == NO)
  489.       [self saveInRequest:sender];
  490.     else
  491.       [self writeSound];
  492.  
  493.     return self;
  494. }
  495.  
  496. - saveInRequest:sender
  497. {
  498.     
  499.   [saveReq setTitle:"looking to be Saved!"];
  500.   [saveReq setRequiredFileType:""];
  501.   if ( ![saveReq runModal] )
  502.     return nil;
  503.  
  504.   strcpy(soundFile, [saveReq filename]);
  505.   gotSoundFileName = YES;
  506.  
  507.   [self writeSound];
  508.  
  509.   return self;
  510. }
  511.  
  512.  
  513. - openImage {
  514.  
  515.   NXColorSpace    cs;
  516.  
  517.   if (pict != nil) {
  518.     [pict free];
  519.     gotImage = NO;
  520.   }
  521.  
  522.   pict = [[NXBitmapImageRep alloc] initFromFile:imageFile];
  523.  
  524.   if (pict == nil) {
  525.     NXRunAlertPanel("Oral Hygiene",
  526.             "Lame user error.  Couldn't open your imagined file.",
  527.             "okie",NULL,NULL,NULL);
  528.     return nil;
  529.   }
  530.  
  531.   if ( (cs = [pict colorSpace]) != NX_RGBColorSpace ) {
  532.     NXRunAlertPanel("Roman Polanski","Retreat! Your image is not RGB approved!",
  533.                         "okie",NULL,NULL,NULL);
  534.     return nil;
  535.   }
  536.  
  537.   if ( ( [pict bitsPerPixel]) != 24 ) {
  538.     NXRunAlertPanel("Doris Day","Heavens to Murgatroyd!  Use a 24-bit image!",
  539.                        "dokie",NULL,NULL,NULL);
  540.     return nil;
  541.   }
  542.   
  543.   pictdata = [pict data];
  544.   xend = x = [pict pixelsWide];
  545.   yend = y = [pict pixelsHigh];
  546.   xstart = ystart = 0;
  547.  
  548.   gotImage = YES;  
  549.  
  550.   return self;
  551. }
  552.  
  553.  
  554. - openMapFile {
  555.  
  556.   int    i;
  557.   FILE    *fp;
  558.  
  559.   if ( mapFunk.data != NULL ) {
  560.     free( mapFunk.data );
  561.     gotMapFile = NO;
  562.   }
  563.  
  564.   mapFunk.elms = Max_Table_Size;
  565.   mapFunk.data = (float *) space( Max_Table_Size, sizeof(float) );
  566.   
  567.   if ( (fp = fopen( mapFile, "r" )) == NULL ) {
  568.     NXRunAlertPanel("Hamburger Helper","Lame user error. Couldn't open map file.",
  569.             "okie",NULL,NULL,NULL);
  570.     return nil;
  571.   }
  572.   i = 0;
  573.   while ( (fread(mapFunk.data+i, sizeof(float), 1, fp)) != 0 && 
  574.      i < Max_Table_Size )
  575.     ++i;
  576.   mapFunk.elms = (i-1);
  577.  
  578.   gotMapFile = YES;
  579.  
  580.   return self;
  581. }
  582.  
  583.  
  584. - openTableFile {
  585.  
  586.   int    i;
  587.   FILE    *fp;
  588.  
  589.   if ( oscTable.data != NULL ) {
  590.     free( oscTable.data );
  591.     gotTableFile = NO;
  592.   }
  593.  
  594.   oscTable.elms = Max_Osc_Size;
  595.   oscTable.data = (float *) space( Max_Osc_Size, sizeof(float) );
  596.   
  597.   if ( (fp = fopen( tableFile, "r" )) == NULL ) {
  598.     NXRunAlertPanel("The Free Market is Fucked",
  599.             "Egad! Couldn't open oscillator table!",
  600.             "dokie",NULL,NULL,NULL);
  601.     return nil;
  602.   }
  603.   i = 0;
  604.   while ( (fread(oscTable.data+i, sizeof(float), 1, fp)) != 0 && 
  605.      i < Max_Osc_Size )
  606.     ++i;
  607.   oscTable.elms = (i-1);
  608.   oscTable.data = (float *) realloc( oscTable.data, i * sizeof(float) );
  609.  
  610.   if (oscilTable == YES)
  611.     tablesize = i - 1;
  612.  
  613.   gotTableFile = YES;
  614.  
  615.   return self;
  616. }
  617.  
  618.  
  619. - allocSound {
  620.  
  621.   int    width = 2,
  622.     size;
  623.  
  624.   size = interp * maxtime;
  625.   soundPoint = 0;
  626.   bigee = 0.;
  627.   duration = 0.;
  628.  
  629.   if ( sfh != NULL )
  630.     SNDFree(sfh);
  631.  
  632.   SNDAlloc( &sfh, (size*width), SND_FORMAT_LINEAR_16, (int) srate, 1, 0);
  633.   SNDGetDataPointer(sfh, (char **)&soundData, &size, &width );
  634.  
  635.   return self;          
  636. }
  637.  
  638. - writeSound {
  639.  
  640.   int err;
  641.  
  642.   err = SNDWriteSoundfile( soundFile, sfh );
  643.  
  644.   if (err != SND_ERR_NONE) {
  645.     NXRunAlertPanel("Oedipa Maas","Gadzooks! Couldn't write your sound file!",
  646.                         "okie",NULL,NULL,NULL);
  647.     return nil;
  648.   }
  649.   
  650.   if (status == IDLE)
  651.     savedSoundFile = YES;
  652.  
  653.   return self;
  654. }
  655.  
  656. - playSound: sender {
  657.  
  658.   SNDStartPlaying(sfh, 1, 0, 1, NULL, NULL);
  659.   return self;
  660. }
  661.  
  662. - stopPlaying: sender {
  663.  
  664.   SNDStop(1);
  665.   return self;
  666. }
  667.  
  668. - allocateDataspace {
  669.  
  670.     if ( ozone != NULL )
  671.       NXDestroyZone(ozone);
  672.  
  673.     ozone = NXCreateZone( 3 * (N + interp) * 
  674.         sizeof(float), vm_page_size, 0 );
  675.  
  676.     freqs = (float *) zspace( ozone, N+1, sizeof(float) );
  677.     channel = (float *) zspace( ozone, N<<1+1, sizeof(float) );
  678.     output = (float *) zspace( ozone, interp+1, sizeof(float) );
  679.  
  680.     return self;
  681. }
  682.  
  683. - reverseMapping: sender {
  684.  
  685.   int    i,
  686.     elms;
  687.   float    safety;
  688.  
  689.   if (gotMapFile == NO) {
  690.     NXRunAlertPanel("Encephalitis","Lordy Lordy! Load amplitude map file first!",
  691.                         "dokie",NULL,NULL,NULL);
  692.     return nil;
  693.   }
  694.   
  695.   elms = mapFunk.elms;
  696.   for ( i=0; i < (elms>>1); i++ ) {
  697.     safety = *(mapFunk.data+i);
  698.     *(mapFunk.data+i) = *(mapFunk.data+(elms-1)-i);
  699.     *(mapFunk.data+(elms-1)-i) = safety;
  700.   }
  701.  
  702.   return self;
  703. }
  704.  
  705. - runGen {
  706.  
  707.   status = RUNNING;
  708.   oscInit = NO;
  709.   srrand(seed);
  710.   howfar = 0.;
  711.  
  712. // call selected generation method
  713.  
  714.   if ( [self perform:dimension] ) {
  715.     SNDStop(1);
  716.     NXBeep();
  717.   }
  718.   status = IDLE;
  719.  
  720.   return self;
  721. }
  722.  
  723. - genNorm {
  724.  
  725.   int    cnt;
  726.  
  727.   N = yend - ystart;        // set number of frequency amplitude pairs
  728.   ampscale = ampref / (float) N;
  729.   maxtime = xend;
  730.   [self allocSound];
  731.   savedSoundFile = NO;
  732.   [self allocateDataspace];
  733.   [self perform:spread];    // create frequency axis values
  734.  
  735. // main loop (iterate for each value of axis)
  736.   
  737.   for ( timedim = xstart; timedim < maxtime; timedim++ ) {
  738.  
  739.     timeinc = timedim * Bytes_Per_Pixel;
  740.     // check for death or pause
  741.     if (status > 2)  {
  742.       if (status == PAUSED)
  743.     [self _waitForMessage];
  744.       else {
  745.     if (status == DYING)
  746.       return nil;
  747.       }
  748.     }
  749.  
  750. // increment along time axis
  751.  
  752.     cnt = (N-1);
  753.     for ( freqdim = ystart; freqdim < yend; freqdim++ ) {
  754.       datainc = cnt * x * Bytes_Per_Pixel;
  755.       *(channel+(freqdim<<1)+1) = *(freqs+freqdim);
  756.       [self perform:mapper];
  757.       cnt--;
  758.     }
  759.  
  760.     if ( ![self oscbank] )
  761.       return nil;
  762.  
  763.     [self writeoutput];
  764.     howfar = ((float) timedim - xstart) / ((float) maxtime - xstart);
  765.   }
  766.   return self;
  767. }
  768.  
  769. - genRotNorm {
  770.  
  771.   int    cnt;
  772.  
  773.   N = xend - xstart;        // set number of frequency amplitude pairs  
  774.   ampscale = ampref / (float) N;
  775.   maxtime = yend;
  776.   [self allocSound];
  777.   savedSoundFile = NO;
  778.   [self allocateDataspace];
  779.   [self perform:spread];    // create frequency axis values
  780.  
  781. // main loop (iterate for each value of axis)
  782.   
  783.   for ( timedim = (ystart * x * Bytes_Per_Pixel); 
  784.     timedim < (maxtime * x * Bytes_Per_Pixel); 
  785.     timedim += (x * Bytes_Per_Pixel) ) {
  786.  
  787.     timeinc = timedim;
  788.     // check for death or pause
  789.     if (status > 2)  {
  790.       if (status == PAUSED)
  791.     [self _waitForMessage];
  792.       else {
  793.     if (status == DYING)
  794.       return nil;
  795.       }
  796.     }
  797.  
  798. // increment along time axis
  799.  
  800.     cnt = 0;
  801.     for ( freqdim = xstart; freqdim < xend; freqdim++ ) {
  802.       datainc = freqdim * Bytes_Per_Pixel;
  803.       *(channel+(freqdim<<1)+1) = *(freqs+freqdim);
  804.       [self perform:mapper];
  805.       cnt++;
  806.     }
  807.  
  808.     if ( ![self oscbank] )
  809.       return nil;
  810.  
  811.     [self writeoutput];
  812.     howfar = ( (float) (timedim / (x * Bytes_Per_Pixel)) - ystart ) 
  813.         / ((float) maxtime - ystart);
  814.   }
  815.  
  816.   return self;
  817. }
  818.  
  819. - genRetro {
  820.  
  821.   int    cnt;
  822.  
  823.   N = yend - ystart;        // set number of frequency amplitude pairs
  824.   ampscale = ampref / (float) N;
  825.   maxtime = xend;
  826.   [self allocSound];
  827.   savedSoundFile = NO;
  828.   [self allocateDataspace];
  829.   [self perform:spread];    // create frequency axis values
  830.  
  831. // main loop (iterate for each value of axis)
  832.   
  833.   for ( timedim=(maxtime-1); timedim >= xstart; timedim-- ) {
  834.  
  835.     timeinc = timedim * Bytes_Per_Pixel;    
  836.     // check for death or pause
  837.     if (status > 2)  {
  838.       if (status == PAUSED)
  839.     [self _waitForMessage];
  840.       else {
  841.     if (status == DYING)
  842.       return nil;
  843.       }
  844.     }
  845.  
  846. // increment along time axis
  847.  
  848.     cnt = (N-1);
  849.     for ( freqdim = ystart; freqdim < yend; freqdim++ ) {
  850.       datainc = cnt * x * Bytes_Per_Pixel;
  851.       *(channel+(freqdim<<1)+1) = *(freqs+freqdim);
  852.       [self perform:mapper];
  853.       cnt--;
  854.     }
  855.  
  856.     if ( ![self oscbank] )
  857.       return nil;
  858.  
  859.     [self writeoutput];
  860.  
  861.     howfar = ( (float) (maxtime-1) - timedim ) / 
  862.               ((float) (maxtime-1) - xstart);
  863.   }
  864.   return self;
  865. }
  866.  
  867. - genRotRetro {
  868.  
  869.   int    cnt;
  870.  
  871.   N = xend - xstart;        // set number of frequency amplitude pairs  
  872.   ampscale = ampref / (float) N;
  873.   maxtime = yend;
  874.   [self allocSound];
  875.   savedSoundFile = NO;
  876.   [self allocateDataspace];
  877.   [self perform:spread];    // create frequency axis values
  878.  
  879. // main loop (iterate for each value of axis)
  880.   
  881.   for ( timedim = ( (maxtime-1) * x * Bytes_Per_Pixel); 
  882.     timedim >= ystart * x * Bytes_Per_Pixel;
  883.     timedim -= (x * Bytes_Per_Pixel) ) {
  884.  
  885.     timeinc = timedim;
  886.     // check for death or pause
  887.     if (status > 2)  {
  888.       if (status == PAUSED)
  889.     [self _waitForMessage];
  890.       else {
  891.     if (status == DYING)
  892.       return nil;
  893.       }
  894.     }
  895.  
  896. // increment along time axis
  897.  
  898.     cnt = 0;
  899.     for ( freqdim = xstart; freqdim < xend; freqdim++ ) {
  900.       datainc = freqdim * Bytes_Per_Pixel;
  901.       *(channel+(freqdim<<1)+1) = *(freqs+freqdim);
  902.       [self perform:mapper];
  903.       cnt++;
  904.     }
  905.  
  906.     if ( ![self oscbank] )
  907.       return nil;
  908.  
  909.     [self writeoutput];
  910.     howfar = ( (float) (maxtime-1) - (timedim / (x * Bytes_Per_Pixel)) )
  911.               / ((float) (maxtime-1) - ystart);
  912.   }
  913.  
  914.   return self;
  915. }
  916.  
  917.  
  918. - genNormInv {
  919.  
  920.   int    cnt;
  921.  
  922.   N = yend - ystart;         // set number of frequency amplitude pairs
  923.   ampscale = ampref / (float) N;
  924.   maxtime = xend;
  925.   [self allocSound];
  926.   savedSoundFile = NO;
  927.   [self allocateDataspace];
  928.   [self perform:spread];    // create frequency axis values
  929.  
  930. // main loop (iterate for each value of axis)
  931.   
  932.   for ( timedim=xstart; timedim < maxtime; timedim++ ) {
  933.  
  934.     timeinc = timedim * Bytes_Per_Pixel;
  935.     // check for death or pause
  936.     if (status > 2)  {
  937.       if (status == PAUSED)
  938.     [self _waitForMessage];
  939.       else {
  940.     if (status == DYING)
  941.       return nil;
  942.       }
  943.     }
  944.  
  945. // increment along time axis
  946.  
  947.     cnt = (N-1);
  948.     for ( freqdim = ystart; freqdim < yend; freqdim++ ) {
  949.       datainc = cnt * x * Bytes_Per_Pixel;
  950.       *(channel+(freqdim<<1)+1) = *(freqs+cnt);
  951.       [self perform:mapper];
  952.       cnt--;
  953.     }
  954.  
  955.     if ( ![self oscbank] )
  956.       return nil;
  957.  
  958.     [self writeoutput];
  959.     howfar = ( (float) timedim - xstart ) / ((float) maxtime - xstart);
  960.   }
  961.   return self;
  962. }
  963.  
  964. - genRotNormInv {
  965.  
  966.   int    cnt;
  967.  
  968.   N = xend - xstart;        // set number of frequency amplitude pairs  
  969.   ampscale = ampref / (float) N;
  970.   maxtime = yend;
  971.   [self allocSound];
  972.   savedSoundFile = NO;
  973.   [self allocateDataspace];
  974.   [self perform:spread];    // create frequency axis values
  975.  
  976. // main loop (iterate for each value of axis)
  977.   
  978.   for ( timedim = (ystart * x * Bytes_Per_Pixel);
  979.        timedim < (maxtime * x * Bytes_Per_Pixel); 
  980.        timedim += (x * Bytes_Per_Pixel) ) {
  981.  
  982.     timeinc = timedim;
  983.     // check for death or pause
  984.     if (status > 2)  {
  985.       if (status == PAUSED)
  986.     [self _waitForMessage];
  987.       else {
  988.     if (status == DYING)
  989.       return nil;
  990.       }
  991.     }
  992.  
  993. // increment along time axis
  994.  
  995.     cnt = 0;
  996.     for ( freqdim = xstart; freqdim < xend; freqdim++ ) {
  997.       datainc = freqdim * Bytes_Per_Pixel;
  998.       *(channel+(freqdim<<1)+1) = *(freqs + ( (x-1) - freqdim ));
  999.       [self perform:mapper];
  1000.       cnt++;
  1001.     }
  1002.  
  1003.     if ( ![self oscbank] )
  1004.       return nil;
  1005.  
  1006.     [self writeoutput];
  1007.     howfar = ( ((float) timedim / (x * Bytes_Per_Pixel)) - ystart ) /
  1008.               ((float) maxtime - ystart);
  1009.   }
  1010.  
  1011.   return self;
  1012. }
  1013.  
  1014. - genRetroInv {
  1015.  
  1016.   int    cnt;
  1017.  
  1018.   N = yend - ystart;        // set number of frequency amplitude pairs
  1019.   ampscale = ampref / (float) N;
  1020.   maxtime = xend;
  1021.   [self allocSound];
  1022.   savedSoundFile = NO;
  1023.   [self allocateDataspace];
  1024.   [self perform:spread];    // create frequency axis values
  1025.  
  1026. // main loop (iterate for each value of axis)
  1027.   
  1028.   for ( timedim=(maxtime-1); timedim >= xstart; timedim-- ) {
  1029.  
  1030.     timeinc = timedim * Bytes_Per_Pixel;
  1031.     // check for death or pause
  1032.     if (status > 2)  {
  1033.       if (status == PAUSED)
  1034.     [self _waitForMessage];
  1035.       else {
  1036.     if (status == DYING)
  1037.       return nil;
  1038.       }
  1039.     }
  1040.  
  1041. // increment along time axis
  1042.  
  1043.     cnt = (N-1);
  1044.     for ( freqdim = ystart; freqdim < yend; freqdim++ ) {
  1045.       datainc = cnt * x * Bytes_Per_Pixel;
  1046.       *(channel+(freqdim<<1)+1) = *(freqs+cnt);
  1047.       [self perform:mapper];
  1048.       cnt--;
  1049.     }
  1050.  
  1051.  
  1052.     if ( ![self oscbank] )
  1053.       return nil;
  1054.  
  1055.     [self writeoutput];
  1056.     howfar = ( (float) (maxtime-1) - timedim ) / 
  1057.         ((float) (maxtime-1) - xstart);
  1058.   }
  1059.   return self;
  1060. }
  1061.  
  1062. - genRotRetroInv {
  1063.  
  1064.   int    cnt;
  1065.  
  1066.   N = xend - xstart;        // set number of frequency amplitude pairs  
  1067.   ampscale = ampref / (float) N;
  1068.   maxtime = yend;
  1069.   [self allocSound];
  1070.   savedSoundFile = NO;
  1071.   [self allocateDataspace];
  1072.   [self perform:spread];    // create frequency axis values
  1073.  
  1074. // main loop (iterate for each value of axis)
  1075.   
  1076.   for ( timedim = ( (maxtime-1) * x * Bytes_Per_Pixel);
  1077.        timedim >= ystart * x * Bytes_Per_Pixel;
  1078.        timedim -= (x * Bytes_Per_Pixel) ) {
  1079.  
  1080.     timeinc = timedim;
  1081.     // check for death or pause
  1082.     if (status > 2)  {
  1083.       if (status == PAUSED)
  1084.     [self _waitForMessage];
  1085.       else {
  1086.     if (status == DYING)
  1087.       return nil;
  1088.       }
  1089.     }
  1090.  
  1091. // increment along time axis
  1092.  
  1093.     cnt = 0;
  1094.     for ( freqdim = xstart; freqdim < xend; freqdim++ ) {
  1095.       datainc = freqdim * Bytes_Per_Pixel;
  1096.       *(channel+(freqdim<<1)+1) = *(freqs + ( (x-1) - freqdim ));
  1097.       [self perform:mapper];
  1098.       cnt++;
  1099.     }
  1100.  
  1101.     if ( ![self oscbank] )
  1102.       return nil;
  1103.  
  1104.     [self writeoutput];
  1105.     howfar = ( (float) (maxtime-1) - (timedim / (x * Bytes_Per_Pixel)) )
  1106.           / ((float) maxtime - ystart);
  1107.   }
  1108.  
  1109.   return self;
  1110. }
  1111.  
  1112.  
  1113. - genHarmSeries {
  1114.  
  1115.   int    i;
  1116.  
  1117.   for ( i=0; i<N; i++ )
  1118.     *(freqs+i) = freqcon + (freqdiff * i);
  1119.  
  1120.   return self;
  1121. }
  1122.  
  1123. - genScale {
  1124.  
  1125.   int    i;
  1126.  
  1127.   *freqs = freqcon;
  1128.   for ( i=1; i<N; i++ )
  1129.     *(freqs+i) = *(freqs+i-1) * freqdiff;
  1130.  
  1131.   return self;
  1132. }
  1133.  
  1134. - mmHarmSeries {
  1135.  
  1136.   mm.min = freqcon;
  1137.   mm.max = (N-1) * freqdiff + freqcon;
  1138.   return self;
  1139. }
  1140.  
  1141. - mmScale {
  1142.  
  1143.   mm.min = freqcon;
  1144.   mm.max = pow(freqdiff, (N-1)) * freqcon;
  1145.   return self;
  1146. }
  1147.  
  1148. - mapRGB {
  1149.  
  1150.   static float    scaler = 766.0;
  1151.  
  1152.   *(channel+(freqdim<<1)) = *(mapFunk.data + (int) ( ( (float) ( 
  1153.     (int) ( *(pictdata+datainc+timeinc) ) + 
  1154.     (int) ( *(pictdata+datainc+timeinc+1) ) +
  1155.     (int) ( *(pictdata+datainc+timeinc+2) )) / scaler ) * 
  1156.     (float) mapFunk.elms ));
  1157.  
  1158.   return self;
  1159. }
  1160.  
  1161. - mapR {
  1162.  
  1163.   static float    scaler = 256.0;
  1164.  
  1165.   *(channel+(freqdim<<1)) = *(mapFunk.data + (int) ( ( (float) ( 
  1166.     (int) ( *(pictdata+datainc+timeinc) )) / scaler ) * 
  1167.     (float) mapFunk.elms ));
  1168.  
  1169.   return self;
  1170. }
  1171.  
  1172. - mapG {
  1173.  
  1174.   static float    scaler = 256.0;
  1175.  
  1176.   *(channel+(freqdim<<1)) = *(mapFunk.data + (int) ( ( (float) ( 
  1177.     (int) ( *(pictdata+datainc+timeinc+1) )) / scaler ) * 
  1178.     (float) mapFunk.elms ));
  1179.  
  1180.   return self;
  1181. }
  1182.  
  1183. - mapB {
  1184.  
  1185.   static float    scaler = 256.0;
  1186.  
  1187.   *(channel+(freqdim<<1)) = *(mapFunk.data + (int) ( ( (float) ( 
  1188.     (int) ( *(pictdata+datainc+timeinc+2) )) / scaler ) * 
  1189.     (float) mapFunk.elms ));
  1190.  
  1191.   return self;
  1192. }
  1193.  
  1194. - mapRG {
  1195.  
  1196.   static float    scaler = 511.0;
  1197.  
  1198.   *(channel+(freqdim<<1)) = *(mapFunk.data + (int) ( ( (float) ( 
  1199.     (int) ( *(pictdata+datainc+timeinc) ) + 
  1200.     (int) ( *(pictdata+datainc+timeinc+1) )) / scaler ) * 
  1201.     (float) mapFunk.elms ));
  1202.  
  1203.   return self;
  1204. }
  1205.  
  1206. - mapRB {
  1207.  
  1208.   static float    scaler = 511.0;
  1209.  
  1210.   *(channel+(freqdim<<1)) = *(mapFunk.data + (int) ( ( (float) ( 
  1211.     (int) ( *(pictdata+datainc+timeinc) ) + 
  1212.     (int) ( *(pictdata+datainc+timeinc+2) )) / scaler ) * 
  1213.     (float) mapFunk.elms ));
  1214.  
  1215.   return self;
  1216. }
  1217.  
  1218. - mapGB {
  1219.  
  1220.   static float    scaler = 511.0;
  1221.  
  1222.   *(channel+(freqdim<<1)) = *(mapFunk.data + (int) ( ( (float) ( 
  1223.     (int) ( *(pictdata+datainc+timeinc+1) ) +
  1224.     (int) ( *(pictdata+datainc+timeinc+2) )) / scaler ) * 
  1225.     (float) mapFunk.elms ));
  1226.  
  1227.   return self;
  1228. }
  1229.  
  1230. - selectGenHarmSeries: sender {
  1231.  
  1232.   spread = @selector(genHarmSeries);
  1233.   minmax = @selector(mmHarmSeries);
  1234.   return self;
  1235. }
  1236.  
  1237. - selectGenScale: sender {
  1238.  
  1239.   spread = @selector(genScale);
  1240.   minmax = @selector(mmScale);
  1241.   return self;
  1242. }
  1243.  
  1244. - selectDisplayAll: sender {
  1245.  
  1246.   display = @selector(displayAll);
  1247.   return self;
  1248. }
  1249.  
  1250. - selectDisplayMinMax: sender {
  1251.  
  1252.   display = @selector(displayMinMax);
  1253.   return self;
  1254. }
  1255.  
  1256. - selectXcoor: sender {
  1257.   
  1258.   coordinate = @selector(setXcoor);
  1259.   return self;
  1260. }
  1261.  
  1262. - selectYcoor: sender {
  1263.   
  1264.   coordinate = @selector(setYcoor);
  1265.   return self;
  1266. }
  1267.  
  1268.  
  1269. - selectGenNorm: sender {
  1270.  
  1271.   dimension = @selector(genNorm);
  1272.   return self;
  1273. }
  1274.  
  1275. - selectGenRetro: sender {
  1276.  
  1277.   dimension = @selector(genRetro);
  1278.   return self;
  1279. }
  1280.  
  1281. - selectGenRotNorm: sender {
  1282.  
  1283.   dimension = @selector(genRotNorm);
  1284.   return self;
  1285. }
  1286.  
  1287. - selectGenRotRetro: sender {
  1288.  
  1289.   dimension = @selector(genRotRetro);
  1290.   return self;
  1291. }
  1292.  
  1293. - selectGenNormInv: sender {
  1294.  
  1295.   dimension = @selector(genNormInv);
  1296.   return self;
  1297. }
  1298.  
  1299. - selectGenRetroInv: sender {
  1300.  
  1301.   dimension = @selector(genRetroInv);
  1302.   return self;
  1303. }
  1304.  
  1305. - selectGenRotNormInv: sender {
  1306.  
  1307.   dimension = @selector(genRotNormInv);
  1308.   return self;
  1309. }
  1310.  
  1311. - selectGenRotRetroInv: sender {
  1312.  
  1313.   dimension = @selector(genRotRetroInv);
  1314.   return self;
  1315. }
  1316.  
  1317. - selectMapR: sender {
  1318.  
  1319.   mapper = @selector(mapR);
  1320.   return self;
  1321. }
  1322.  
  1323. - selectMapG: sender {
  1324.  
  1325.   mapper = @selector(mapG);
  1326.   return self;
  1327. }
  1328.  
  1329. - selectMapB: sender {
  1330.  
  1331.   mapper = @selector(mapB);
  1332.   return self;
  1333. }
  1334.  
  1335. - selectMapRG: sender {
  1336.  
  1337.   mapper = @selector(mapRG);
  1338.   return self;
  1339. }
  1340.  
  1341. - selectMapRB: sender {
  1342.  
  1343.   mapper = @selector(mapRB);
  1344.   return self;
  1345. }
  1346.  
  1347. - selectMapGB: sender {
  1348.  
  1349.   mapper = @selector(mapGB);
  1350.   return self;
  1351. }
  1352.  
  1353. - selectMapRGB: sender {
  1354.  
  1355.   mapper = @selector(mapRGB);
  1356.   return self;
  1357. }
  1358.  
  1359. - writeoutput
  1360. {
  1361.   int   i;
  1362.  
  1363.   for ( i=0; i < interp; i++ ) {
  1364.     if (fabs( (*(output+i) *= ampscale) ) > bigee)
  1365.       bigee = fabs( *(output+i) );
  1366.     *(soundData + soundPoint + i) = (short) (32767. * *(output+i));
  1367.   }
  1368.   soundPoint += interp;
  1369.   duration = (float) soundPoint / srate;
  1370.  
  1371.   return self;
  1372. }
  1373.  
  1374. - selectOscCos: sender {
  1375.  
  1376.   if (status != IDLE)
  1377.     return nil;
  1378.  
  1379.   oscilTable = NO;
  1380.   tablesize = Default_Osc_Size;
  1381.   osctable = @selector(setOscCos);
  1382.   return self;
  1383. }
  1384.  
  1385.  
  1386. - selectOscComplex: sender {
  1387.  
  1388.   int    i,
  1389.       grabber;
  1390.  
  1391.   float    hoax;
  1392.   char    *doink;
  1393.  
  1394.   if (status != IDLE)
  1395.     return nil;
  1396.  
  1397.   oscilTable = NO;
  1398.  
  1399.   doink = (char *) space( 8192, sizeof(char) );
  1400.  
  1401.   strcpy( doink, harmsText );
  1402.  
  1403.   harms.data = (float *) space( Max_Harm, sizeof(float) );
  1404.   tablesize = Default_Osc_Size;
  1405.  
  1406.   i = 0;
  1407.   while ( i < Max_Harm ) {
  1408.     if ( (grabber = sscanf(doink, "%f", &hoax)) == 0 || grabber == EOF)
  1409.       break;
  1410.     *(harms.data+i) = hoax;
  1411.     ++i;
  1412.     if ( (doink = index( doink, ' ' )) == NULL )
  1413.       break;
  1414.     while ( isspace(*doink) )
  1415.       doink++;
  1416.   } 
  1417.   harms.elms = i;
  1418.  
  1419.   osctable = @selector(setOscComplex);
  1420.  
  1421.   return self;
  1422. }
  1423.  
  1424. - selectOscTable: sender {
  1425.  
  1426.   if (status != IDLE)
  1427.     return nil;
  1428.  
  1429.   tablesize = oscTable.elms - 1;
  1430.   oscilTable = YES;
  1431.   osctable = @selector(setOscTable);
  1432.   return self;
  1433. }
  1434.  
  1435. - setOscCos {
  1436.  
  1437.   int    i;
  1438.   float twopioL = twopi / tablesize;
  1439.  
  1440.   for ( i = 0; i < tablesize+1; i++ )
  1441.     *(table+i) = cos( twopioL*i );
  1442.  
  1443.   return self;
  1444. }
  1445.  
  1446. - setOscComplex {
  1447.  
  1448.   int    i,j;
  1449.   float twopioL = twopi / tablesize;
  1450.  
  1451.   for ( i=0; i < tablesize+1; i++ )
  1452.     *(table+i) = cos( twopioL*i );
  1453.  
  1454.   for ( j=2; j <= harms.elms; j++ ) {
  1455.     for ( i=0; i < tablesize+1; i++ )
  1456.       *(table+i) += cos( j*twopioL*i );
  1457.   }
  1458.  
  1459.   return self;
  1460. }
  1461.  
  1462. - setOscTable {
  1463.  
  1464.   int    i;
  1465.  
  1466.   if (gotTableFile == NO) {
  1467.     return nil;
  1468.   }
  1469.  
  1470.   tablesize = oscTable.elms - 1;
  1471.  
  1472.   for ( i=0; i < tablesize+1; i++ )
  1473.     *(table+i) = *(oscTable.data + i);
  1474.  
  1475.   return self;
  1476. }
  1477.  
  1478.  
  1479. - oscbank
  1480. {
  1481.  
  1482.   static float     Iinv,
  1483.         *lastamp,
  1484.         *lastfreq,
  1485.         *index,
  1486.            Pinc;
  1487.   int         i,j,
  1488.         amp,
  1489.         freq;
  1490.  
  1491. /* first pass: allocate memory to hold previous values
  1492.    of amplitude and frequency for each channel, the table
  1493.    index for each oscillator, and the table itself; also
  1494.    compute constants */
  1495.  
  1496.   if ( oscInit == NO ) {
  1497.  
  1498.     if ( funzone != NULL )
  1499.       NXDestroyZone(funzone);
  1500.  
  1501.     if (oscilTable == YES)
  1502.       tablesize = oscTable.elms - 1;
  1503.     
  1504.     funzone = NXCreateZone( 3 * (N + interp) * 
  1505.                sizeof(float), vm_page_size, 0 );
  1506.     
  1507.     lastamp = (float *) zspace( funzone, N+1, sizeof(float) );
  1508.     lastfreq = (float *) zspace( funzone, N+1, sizeof(float) );
  1509.     index = (float *) zspace( funzone, N+1, sizeof(float) );
  1510.     table = (float *) zspace( funzone, tablesize+1, sizeof(float) );
  1511.     
  1512.     for ( i = 0; i < N+1; i++ ) {
  1513.       *(lastamp+i) = *(lastfreq+i) = 0.;
  1514.       *(index+i) = prand() * (float) tablesize;
  1515.     }
  1516.  
  1517.     if ( ![self perform:osctable] )
  1518.       return nil;
  1519.  
  1520.     Iinv = 1. / interp;
  1521.     Pinc = ( (float) tablesize ) / srate;
  1522.  
  1523.     oscInit = YES;
  1524.   }
  1525.  
  1526.   for ( i = 0; i < interp; i++ )
  1527.     *(output+i) = 0.;
  1528.  
  1529. /* for each channel, compute I samples using linear
  1530.    interpolation on the amplitude and frequency
  1531.    control values */
  1532.  
  1533.     for ( i=0; i < N; i++ ) {
  1534.  
  1535.       register float     a,
  1536.             ainc,
  1537.             f,
  1538.             finc,
  1539.             address;
  1540.  
  1541.       freq = ( amp = ( i << 1 ) ) + 1;
  1542.       if ( *(channel+amp) < synt )     /* skip the little ones */
  1543.     continue;
  1544.  
  1545.       *(channel+freq) *= Pinc;
  1546.       finc = ( *(channel+freq) - ( f = *(lastfreq+i) ) ) * Iinv;
  1547.       
  1548.       ainc = ( *(channel+amp) - ( a = *(lastamp+i) ) ) * Iinv;
  1549.       address = *(index+i);
  1550.       
  1551. /* accumulate the I samples from each oscillator into
  1552.    output array O (initially assumed to be zero);
  1553.    f is frequency in Hz scaled by oscillator increment
  1554.    factor and pitch (Pinc); a is amplitude; */
  1555.  
  1556.       for ( j=0; j < interp; j++ ) {
  1557.     *(output+j) += a * *(table + ( (int) address ));
  1558.     address += f;
  1559.     
  1560.     while ( address >= (float) tablesize )
  1561.       address -= (float) tablesize;
  1562.     
  1563.     while ( address < 0. )
  1564.       address += (float) tablesize;
  1565.     
  1566.     a += ainc;
  1567.     f += finc;
  1568.       } 
  1569.  
  1570. /* save current values for next iteration */
  1571.  
  1572.       *(lastfreq+i) = *(channel+freq);
  1573.       *(lastamp+i) = *(channel+amp);
  1574.       *(index+i) = address;
  1575.     }
  1576.  
  1577.     return self;
  1578. }
  1579.  
  1580. @end
  1581.