home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1995 August / NEBULA.mdf / SourceCode / MiscKit1.2.6 / Palettes / MiscSoundPalette / MiscSoundUtil.subproj / MiscSoundTracker.m < prev    next >
Encoding:
Text File  |  1994-05-27  |  9.7 KB  |  554 lines
  1. #import "MiscSoundTracker.h"
  2. #import <stdio.h>
  3.  
  4. @implementation MiscSoundTracker
  5.  
  6. // KNOWN BUGS:  NeXT's sound object does not release sampling rate information
  7. // properly.  Hence, the tracker cannot get seconds information correctly,
  8. // when recording, and so must rely on a preset default for its sampling
  9. // rate in returning seconds.
  10.  
  11. // also, samples do not keep up with pausing.
  12.  
  13.  
  14.  
  15. // timed entry procedure for periodically updating
  16.  
  17. DPSTimedEntryProc SOUNDTRACKER_update_tracker
  18.     (DPSTimedEntry teNum,double now, void* the_tracker)
  19.     {
  20.     MiscSoundTracker* temp_tracker=(MiscSoundTracker*) the_tracker;
  21.     [temp_tracker update];
  22.     return (void*) NULL;
  23.     }
  24.  
  25.  
  26.  
  27.  
  28. - init
  29.     {
  30.     [super init];
  31.     running=NO;
  32.     default_sampling_rate=SOUNDTRACKER_DEFAULT_SAMPLING_RATE;
  33.     send_type=SOUNDTRACKER_SEND_TYPE_SAMPLES;
  34.     refresh=SOUNDTRACKER_TIMED_ENTRY_SPEED;
  35.     teNum=0;
  36.     //printf ("Init\n");
  37.     return self;
  38.     }
  39.  
  40. - awake
  41.     {
  42.     [super awake];
  43.     teNum=0;
  44.     //printf ("Awake\n");
  45.     return self;
  46.     }
  47.  
  48.  
  49. - update
  50.     {
  51.     //printf("Updating\n");
  52.     if (target!=NULL)
  53.         {
  54.         //printf ("Target Not Null\n");
  55.         if (send_type==SOUNDTRACKER_SEND_TYPE_SAMPLES||
  56.             send_type==SOUNDTRACKER_SEND_TYPE_MUTE||
  57.             send_type==SOUNDTRACKER_SEND_TYPE_DEEMPHASIS)
  58.             {
  59.             //printf ("Sending Take Message\n");
  60.             if (![target respondsTo:@selector(takeIntValueFrom:)])
  61.                  return NULL;
  62.             [target takeIntValueFrom:self];
  63.             }
  64.         else if (send_type==SOUNDTRACKER_SEND_TYPE_RATIO||
  65.                 send_type==SOUNDTRACKER_SEND_TYPE_PERCENT)
  66.             {
  67.             int status=[sound status];
  68.             if (status==NX_SoundRecording||
  69.                 status==NX_SoundRecordingPaused)
  70.                 {
  71.                 [self clearTarget];
  72.                 }
  73.             else
  74.                 {
  75.                 if (![target respondsTo:@selector(takeFloatValueFrom:)])
  76.                     return NULL;
  77.                 [target takeFloatValueFrom:self];
  78.                 }
  79.             }
  80.         else if (send_type==SOUNDTRACKER_SEND_TYPE_SECONDS||
  81.                 send_type==SOUNDTRACKER_SEND_TYPE_LEFT||
  82.                 send_type==SOUNDTRACKER_SEND_TYPE_RIGHT||
  83.                 send_type==SOUNDTRACKER_SEND_TYPE_MONO)
  84.             {
  85.             if (![target respondsTo:@selector(takeFloatValueFrom:)])
  86.                  return NULL;
  87.             [target takeFloatValueFrom:self];
  88.             }
  89.         else printf ("SOUNDTRACKER Error:  No Send Type\n");
  90.         }
  91.     return self;
  92.     }
  93.  
  94.  
  95. - setRefresh:(float) number_seconds
  96.     {
  97.     if (number_seconds>0)
  98.         {
  99.         refresh=number_seconds;
  100.         if (teNum) 
  101.             {
  102.             DPSRemoveTimedEntry(teNum);
  103.             teNum=DPSAddTimedEntry(refresh, 
  104.                 (DPSTimedEntryProc) SOUNDTRACKER_update_tracker,
  105.                 (void*) self, (int) NX_RUNMODALTHRESHOLD);
  106.             }
  107.         }
  108.     return self;
  109.     }
  110.     
  111. - free
  112.     {
  113.     if (output_device!=NULL) [output_device free];
  114.     return [super free];
  115.     }
  116.  
  117.  
  118. - setSound:this_sound_or_soundview
  119.     {
  120.     sound=this_sound_or_soundview;
  121.     return self;
  122.     }
  123.  
  124.  
  125. - sound
  126.     {
  127.     return sound;
  128.     }
  129.  
  130. - setDefaultSamplingRate:(float) this_rate
  131.     {
  132.     if (this_rate!=0.0) default_sampling_rate=this_rate;
  133.     return self;
  134.     }
  135.     
  136. - setTarget:this_target
  137.     {
  138.     target=this_target;
  139.     return self;
  140.     }
  141.  
  142.  
  143. - target
  144.     {
  145.     return target;
  146.     }
  147.  
  148.  
  149. - run
  150.     {
  151.     running=YES;
  152.     if (!teNum) teNum=DPSAddTimedEntry(refresh, 
  153.             (DPSTimedEntryProc) SOUNDTRACKER_update_tracker,
  154.             (void*) self, (int) NX_RUNMODALTHRESHOLD);
  155.     return self;
  156.     }
  157.  
  158.  
  159. - stop
  160.     {
  161.     running=NO;
  162.     if (teNum) DPSRemoveTimedEntry(teNum);
  163.     teNum=0;
  164.     return self;
  165.     }
  166.  
  167.  
  168. - sendSamples
  169.     {
  170.     send_type=SOUNDTRACKER_SEND_TYPE_SAMPLES;
  171.     return self;
  172.     }
  173.  
  174.  
  175. - sendSeconds
  176.     {
  177.     send_type=SOUNDTRACKER_SEND_TYPE_SECONDS;
  178.     return self;
  179.     }
  180.  
  181.  
  182. - sendRatio
  183.     {
  184.     send_type=SOUNDTRACKER_SEND_TYPE_RATIO;
  185.     return self;
  186.     }
  187.     
  188. - sendPercent
  189.     {
  190.     send_type=SOUNDTRACKER_SEND_TYPE_PERCENT;
  191.     return self;
  192.     }
  193.     
  194. - sendLeft
  195.     {
  196.     send_type=SOUNDTRACKER_SEND_TYPE_LEFT;
  197.     return self;
  198.     }
  199.     
  200.  
  201. - sendRight
  202.     {
  203.     send_type=SOUNDTRACKER_SEND_TYPE_RIGHT;
  204.     return self;
  205.     }
  206.     
  207.  
  208. - sendMono
  209.     {
  210.     send_type=SOUNDTRACKER_SEND_TYPE_MONO;
  211.     return self;
  212.     }
  213.     
  214.  
  215. - sendMute
  216.     {
  217.     send_type=SOUNDTRACKER_SEND_TYPE_MUTE;
  218.     return self;
  219.     }
  220.     
  221. - sendDeemphasis
  222.     {
  223.     send_type=SOUNDTRACKER_SEND_TYPE_DEEMPHASIS;
  224.     return self;
  225.     }
  226.  
  227. - sendLeftPeak
  228.     {
  229.     send_type=SOUNDTRACKER_SEND_TYPE_LEFT_PEAK;
  230.     return self;
  231.     }
  232.  
  233. - sendRightPeak
  234.     {
  235.     send_type=SOUNDTRACKER_SEND_TYPE_RIGHT_PEAK;
  236.     return self;
  237.     }
  238.     
  239. - sendMonoPeak
  240.     {
  241.     send_type=SOUNDTRACKER_SEND_TYPE_MONO_PEAK;
  242.     return self;
  243.     }
  244.  
  245. - (float) floatValue    
  246.     {
  247.     if (send_type==SOUNDTRACKER_SEND_TYPE_SECONDS)
  248.         {
  249.         if (sound!=NULL)
  250.             {
  251.             if ([sound isKindOf:[Sound class]])
  252.                 {
  253.                 float n=[sound samplingRate];
  254.                 //printf ("%f\n",n);
  255.                 if (n==0.0) n=default_sampling_rate;
  256.                 return ((float)[sound samplesProcessed])/n;
  257.                 }
  258.             else if ([sound isKindOf:[SoundView class]])
  259.                 {
  260.                 id snd1=[sound soundBeingProcessed];
  261.                 float n=[snd1 samplingRate];
  262.                 //printf ("%f\n",n);
  263.                 if (n==0.0) n=default_sampling_rate;
  264.                 return ((float)[snd1 samplesProcessed])/n;
  265.                 }
  266.             }
  267.         }
  268.     else if (send_type==SOUNDTRACKER_SEND_TYPE_RATIO)
  269.         {
  270.         if (sound!=NULL)
  271.             {
  272.             if ([sound isKindOf:[Sound class]])
  273.                 {
  274.                 //int status=[sound status];  // no use right now
  275.                                     
  276.                 return ((float)[sound samplesProcessed])/
  277.                     ((float)[sound sampleCount]);
  278.                 }
  279.             else if ([sound isKindOf:[SoundView class]])
  280.                 {
  281.                 id snd1=[sound soundBeingProcessed];
  282.                 //int status=[snd1 status];  // no use right now
  283.                     
  284.                 return ((float)[snd1 samplesProcessed])/
  285.                     ((float)[snd1 sampleCount]);
  286.                 }
  287.             }
  288.         }
  289.     else if (send_type==SOUNDTRACKER_SEND_TYPE_PERCENT)
  290.         {
  291.         if (sound!=NULL)
  292.             {
  293.             if ([sound isKindOf:[Sound class]])
  294.                 {
  295.                 //int status=[sound status];  // no use right now
  296.                                     
  297.                 return ((float)[sound samplesProcessed])/
  298.                     ((float)[sound sampleCount])*100;
  299.                 }
  300.             else if ([sound isKindOf:[SoundView class]])
  301.                 {
  302.                 id snd1=[sound soundBeingProcessed];
  303.                 //int status=[snd1 status];  // no use right now
  304.                     
  305.                 return ((float)[snd1 samplesProcessed])/
  306.                     ((float)[snd1 sampleCount])*100;
  307.                 }
  308.             }
  309.         }
  310.     else if (send_type==SOUNDTRACKER_SEND_TYPE_LEFT)
  311.         {
  312.         float l,r;
  313.         [Sound getVolume:&l:&r];
  314.         return l;
  315.         }
  316.     else if (send_type==SOUNDTRACKER_SEND_TYPE_RIGHT)
  317.         {
  318.         float l,r;
  319.         [Sound getVolume:&l:&r];
  320.         return r;
  321.         }
  322.     else if (send_type==SOUNDTRACKER_SEND_TYPE_MONO)
  323.         {
  324.         float l,r;
  325.         [Sound getVolume:&l:&r];
  326.         return (l+r)/2.0;
  327.         }
  328.     else if (send_type==SOUNDTRACKER_SEND_TYPE_LEFT_PEAK)
  329.         {
  330.         float l,r;
  331.         
  332.         // try to grab resources
  333.         if (output_device==NULL) output_device=[[NXSoundOut alloc] init];
  334.         
  335.         if (output_device!=NULL)
  336.             {
  337.             [output_device getPeakLeft:&l right:&r];
  338.             return l;
  339.             }
  340.         // else...return -1.0 as shown below
  341.         }
  342.     else if (send_type==SOUNDTRACKER_SEND_TYPE_RIGHT_PEAK)
  343.         {
  344.         float l,r;
  345.         
  346.         // try to grab resources
  347.         if (output_device==NULL) output_device=[[NXSoundOut alloc] init];
  348.         
  349.         if (output_device!=NULL)
  350.             {
  351.             [output_device getPeakLeft:&l right:&r];
  352.             return r;
  353.             }
  354.         // else...return -1.0 as shown below
  355.         }
  356.     else if (send_type==SOUNDTRACKER_SEND_TYPE_MONO_PEAK)
  357.         {
  358.         float l,r;
  359.         
  360.         // try to grab resources
  361.         if (output_device==NULL) output_device=[[NXSoundOut alloc] init];
  362.         
  363.         if (output_device!=NULL)
  364.             {
  365.             [output_device getPeakLeft:&l right:&r];
  366.             return (l+r)/2.0;
  367.             }
  368.         // else...return -1.0 as shown below
  369.         }
  370.  
  371.     else printf ("SOUNDTRACKER Error:  Wrong send type for floatValue\n");
  372.     return -1.0;
  373.     }
  374.  
  375.  
  376. - (int) intValue    
  377.     {
  378.     //printf ("Okay\n");
  379.     if (send_type==SOUNDTRACKER_SEND_TYPE_SAMPLES)
  380.         {
  381.         if (sound!=NULL)
  382.             {
  383.             if ([sound isKindOf:[Sound class]])
  384.                 {
  385.                 return [sound samplesProcessed];
  386.                 }
  387.             else if ([sound isKindOf:[SoundView class]])
  388.                 {
  389.                 id snd1=[sound soundBeingProcessed];
  390.                 return [snd1 samplesProcessed];
  391.                 }
  392.             }
  393.         }
  394.     else if (send_type==SOUNDTRACKER_SEND_TYPE_MUTE)
  395.         {
  396.         return (int) [Sound isMuted];
  397.         }
  398.     else if (send_type==SOUNDTRACKER_SEND_TYPE_DEEMPHASIS)
  399.         {
  400.         // try to grab resources
  401.         if (output_device==NULL) output_device=[[NXSoundOut alloc] init];
  402.         
  403.         if (output_device!=NULL)
  404.             {
  405.             return (int) [output_device doesDeemphasize];
  406.             }
  407.         else return NO;
  408.         }
  409.     else printf ("SOUNDTRACKER Error:  Wrong send type for intValue\n");
  410.     return -1;
  411.     }
  412.  
  413.  
  414. - setVolumeTo:sender    
  415.     {
  416.     float l,r,x;
  417.     [Sound getVolume:&l:&r];
  418.     if (! [sender respondsTo:@selector(floatValue)]) return NULL;
  419.     x=[sender floatValue];
  420.     if (x<0||x>1) return NULL;
  421.     if (send_type==SOUNDTRACKER_SEND_TYPE_LEFT) [Sound setVolume:x:r];
  422.     if (send_type==SOUNDTRACKER_SEND_TYPE_RIGHT) [Sound setVolume:l:x];
  423.     if (send_type==SOUNDTRACKER_SEND_TYPE_MONO) [Sound setVolume:x:x];
  424.     return self;
  425.     }
  426.  
  427.  
  428. - setMuteTo:sender    
  429.     {
  430.     int x;
  431.     if (! [sender respondsTo:@selector(intValue)]) return NULL;
  432.     x=[sender intValue];
  433.     if (x!=0) x=1;
  434.     [Sound setMute:(BOOL)x];
  435.     return self;
  436.     }
  437.  
  438. - setDeemphasisTo:sender    
  439.     {
  440.     int x;
  441.     if (! [sender respondsTo:@selector(intValue)]) return NULL;
  442.     x=[sender intValue];
  443.     if (x!=0) x=1;
  444.     
  445.     // try to grab resources
  446.     if (output_device==NULL) output_device=[[NXSoundOut alloc] init];
  447.     
  448.     if (output_device!=NULL)
  449.         {
  450.         [output_device setDeemphasis:x];
  451.         }
  452.     return self;
  453.     }
  454.  
  455.  
  456. - run:sender
  457.     {
  458.     return [self run];
  459.     }
  460.  
  461.  
  462. - stop:sender
  463.     {
  464.     return [self stop];
  465.     }
  466.  
  467.  
  468. - sendSamples:sender
  469.     {
  470.     return [self sendSamples];
  471.     }
  472.  
  473.  
  474. - sendSeconds:sender
  475.     {
  476.     return [self sendSeconds];
  477.     }
  478.  
  479.  
  480. - sendRatio:sender
  481.     {
  482.     return [self sendRatio];
  483.     }
  484.  
  485. - sendPercent:sender
  486.     {
  487.     return [self sendPercent];
  488.     }
  489.  
  490. - sendLeft:sender
  491.     {
  492.     return [self sendLeft];
  493.     }
  494.  
  495. - sendRight:sender
  496.     {
  497.     return [self sendRight];
  498.     }
  499.  
  500. - sendMono:sender
  501.     {
  502.     return [self sendMono];
  503.     }
  504.  
  505. - sendMute:sender
  506.     {
  507.     return [self sendMute];
  508.     }
  509.     
  510. - sendDeemphasis:sender
  511.     {
  512.     return [self sendDeemphasis];
  513.     }
  514.     
  515. - sendLeftPeak:sender
  516.     {
  517.     return [self sendLeftPeak];
  518.     }
  519.     
  520. - sendRightPeak:sender
  521.     {
  522.     return [self sendRightPeak];
  523.     }    
  524.     
  525. - sendMonoPeak:sender
  526.     {
  527.     return [self sendMonoPeak];
  528.     }
  529.  
  530. - read:(NXTypedStream*) stream
  531.     {
  532.     [super read:stream];
  533.     NXReadTypes(stream,"cif", &running,&send_type,&refresh);
  534.     return self;
  535.     }
  536.  
  537. - write:(NXTypedStream*) stream
  538.     {
  539.     [super write:stream];
  540.     NXWriteTypes(stream,"cif", &running,&send_type,&refresh);
  541.     return self;
  542.     }
  543.  
  544. - clearTarget
  545.     {
  546.     if ([target respondsTo:@selector(setStringValue:)])
  547.         {
  548.         [target setStringValue:""];
  549.         }
  550.     else [target setIntValue:0];
  551.     return self;
  552.     }
  553.  
  554. @end