home *** CD-ROM | disk | FTP | other *** search
/ Geek 6 / Geek-006.iso / linux / video / xmovie-1.5.3.tar.gz / xmovie-1.5.3.tar / xmovie-1.5.3 / guicast / units.C < prev    next >
C/C++ Source or Header  |  2000-11-29  |  9KB  |  432 lines
  1. #include "units.h"
  2. #include <stdlib.h>
  3.  
  4. float* DB::topower = 0;
  5. int* Freq::freqtable = 0;
  6.  
  7. DB::DB(float infinitygain)
  8. {
  9.     this->infinitygain = infinitygain;
  10.     if(!topower)
  11.     {
  12.         int i;
  13.         float value;
  14.  
  15.         // db to power table
  16.         topower = new float[(MAXGAIN - INFINITYGAIN) * 10 + 1];
  17.         topower += -INFINITYGAIN * 10;
  18.         for(i = INFINITYGAIN * 10; i <= MAXGAIN * 10; i++)
  19.         {
  20.             topower[i] = pow(10, (float)i / 10 / 20);
  21.             
  22. //printf("%f %f\n", (float)i/10, topower[i]);
  23.         }
  24.         topower[INFINITYGAIN * 10] = 0;   // infinity gain
  25.     }
  26.     db = 0;
  27. }
  28.  
  29. float DB::fromdb_table() 
  30. { 
  31.     return db = topower[(int)(db * 10)]; 
  32. }
  33.  
  34. float DB::fromdb_table(float db) 
  35. { 
  36.     if(db > MAXGAIN) db = MAXGAIN;
  37.     if(db <= INFINITYGAIN) return 0;
  38.     return db = topower[(int)(db * 10)]; 
  39. }
  40.  
  41. float DB::fromdb()
  42. {
  43.     return pow(10, db / 20);
  44. }
  45.  
  46. float DB::fromdb(float db)
  47. {
  48.     return pow(10, db / 20);
  49. }
  50.  
  51. // set db to the power given using a formula
  52. float DB::todb(float power)
  53. {
  54.     float db;
  55.     if(power == 0) 
  56.         db = -100;
  57.     else 
  58.     {
  59.         db = (float)(20 * log10(power));
  60.         if(db < -100) db = -100;
  61.     }
  62.     return db;
  63. }
  64.  
  65.  
  66. Freq::Freq()
  67. {
  68.     if(!freqtable)
  69.     {
  70.           int i;
  71.  
  72.         freqtable = new int[TOTALFREQS + 1];
  73.           double freq = 28;  // starting frequency
  74.           long scale = 60;   // some number divisable by three
  75.  
  76.           freqtable[0] = 0;
  77.           for(i = 1; i <= TOTALFREQS; i++)
  78.           {
  79.             freqtable[i] = (int)freq;
  80.             freq = freq + freq / scale;
  81.           }
  82.     }
  83.     freq = 0;
  84. }
  85.  
  86. Freq::Freq(const Freq& oldfreq)
  87. {
  88.     this->freq = oldfreq.freq;
  89. }
  90.  
  91. int Freq::fromfreq() 
  92. {
  93.     int i;
  94.  
  95.       for(i = 0; i < TOTALFREQS && freqtable[i] < freq; i++)
  96.         ;
  97.       return(i);
  98. };
  99.  
  100. int Freq::fromfreq(int index) 
  101. {
  102.     int i;
  103.  
  104.       for(i = 0; i < TOTALFREQS && freqtable[i] < index; i++)
  105.         ;
  106.       return(i);
  107. };
  108.  
  109. int Freq::tofreq(int index) 
  110. { 
  111.     freq = freqtable[index]; 
  112.     return freq; 
  113. }
  114.  
  115. Freq& Freq::operator++() 
  116. {
  117.     if(freq < TOTALFREQS) freq++;
  118.     return *this;
  119. }
  120.     
  121. Freq& Freq::operator--()
  122. {
  123.     if(freq > 0) freq--;
  124.     return *this;
  125. }
  126.     
  127. int Freq::operator>(Freq &newfreq) { return freq > newfreq.freq; }
  128. int Freq::operator<(Freq &newfreq) { return freq < newfreq.freq; }
  129. Freq& Freq::operator=(const Freq &newfreq) { freq = newfreq.freq; return *this; }
  130. int Freq::operator=(const int newfreq) { freq = newfreq; return newfreq; }
  131. int Freq::operator!=(Freq &newfreq) { return freq != newfreq.freq; }
  132. int Freq::operator==(Freq &newfreq) { return freq == newfreq.freq; }
  133. int Freq::operator==(int newfreq) { return freq == newfreq; }
  134.  
  135. char* Units::totext(char *text, 
  136.             double seconds, 
  137.             int time_format, 
  138.             int sample_rate, 
  139.             float frame_rate, 
  140.             float frames_per_foot)    // give text representation as time
  141. {
  142.     int hour, minute;
  143.     long frame, feet;
  144.  
  145.     switch(time_format)
  146.     {
  147.         case TIME_HMS:
  148.         {
  149.             float second;
  150.  
  151.               hour = (int)(seconds / 3600);
  152.               minute = (int)(seconds / 60 - hour * 60);
  153.               second = (float)seconds - (long)hour * 3600 - (long)minute * 60;
  154.               sprintf(text, "%d:%d:%.3f", hour, minute, second);
  155.             return text;
  156.         }
  157.           break;
  158.         
  159.         case TIME_HMS2:
  160.         {
  161.             float second;
  162.  
  163.               hour = (int)(seconds / 3600);
  164.               minute = (int)(seconds / 60 - hour * 60);
  165.               second = (float)seconds - (long)hour * 3600 - (long)minute * 60;
  166.               sprintf(text, "%d:%02d:%02d", hour, minute, (int)second);
  167.             return text;
  168.         }
  169.           break;
  170.  
  171.         case TIME_HMSF:
  172.         {
  173.             int second;
  174.  
  175.               hour = (int)(seconds / 3600);
  176.               minute = (int)(seconds / 60 - hour * 60);
  177.               second = (int)(seconds - hour * 3600 - minute * 60);
  178.               frame = (long)(frame_rate * 
  179.                     (float)((float)seconds - (long)hour * 3600 - (long)minute * 60 - second))
  180.                     ;
  181.               sprintf(text, "%01d:%02d:%02d:%02ld", hour, minute, second, frame);
  182.             return text;
  183.         }
  184.             break;
  185.             
  186.         case TIME_SAMPLES:
  187.               sprintf(text, "%ld", (long)(seconds * sample_rate + 0.5));
  188.             break;
  189.         
  190.         case TIME_SAMPLES_HEX:
  191.               sprintf(text, "%x", (long)(seconds * sample_rate + 0.5));
  192.             break;
  193.         
  194.         case TIME_FRAMES:
  195.             frame = (long)(seconds * frame_rate + 0.5);
  196.             sprintf(text, "%ld", frame);
  197.             return text;
  198.             break;
  199.         
  200.         case TIME_FEET_FRAMES:
  201.             frame = (long)(seconds * frame_rate + 0.5);
  202.             feet = (long)(frame / frames_per_foot);
  203.             sprintf(text, "%ld-%ld", feet, (long)(frame - feet * frames_per_foot));
  204.             return text;
  205.             break;
  206.     }
  207.     return text;
  208. }
  209.  
  210.  
  211. char* Units::totext(char *text, 
  212.         long samples, 
  213.         int samplerate, 
  214.         int time_format, 
  215.         float frame_rate,
  216.         float frames_per_foot)
  217. {
  218.     return totext(text, (double)samples / samplerate, time_format, samplerate, frame_rate, frames_per_foot);
  219. }    // give text representation as time
  220.  
  221. long Units::fromtext(char *text, 
  222.             int samplerate, 
  223.             int time_format, 
  224.             float frame_rate,
  225.             float frames_per_foot)
  226. {
  227.     long hours, minutes, frames, total_samples, i, j;
  228.     long feet;
  229.     float seconds;
  230.     char string[256];
  231.     
  232.     switch(time_format)
  233.     {
  234.         case 0:
  235. // get hours
  236.             i = 0;
  237.             j = 0;
  238.             while(text[i] >=48 && text[i] <= 57 && j < 10) string[j++] = text[i++];
  239.             string[j] = 0;
  240.             hours = atol(string);
  241. // get minutes
  242.             j = 0;
  243. // skip separator
  244.             while((text[i] < 48 || text[i] > 57) && text[i] != 0) i++;
  245.             while(text[i] >=48 && text[i] <= 57 && j < 10) string[j++] = text[i++];
  246.             string[j] = 0;
  247.             minutes = atol(string);
  248.             
  249. // get seconds
  250.             j = 0;
  251. // skip separator
  252.             while((text[i] < 48 || text[i] > 57) && text[i] != 0) i++;
  253.             while((text[i] == '.' || (text[i] >=48 && text[i] <= 57)) && j < 10) string[j++] = text[i++];
  254.             string[j] = 0;
  255.             seconds = atof(string);
  256.             
  257.             total_samples = (long)(((float)seconds + minutes*60 + hours*3600) * samplerate);
  258.             return total_samples;
  259.             break;
  260.  
  261.         case 1:
  262. // get hours
  263.             i = 0;
  264.             j = 0;
  265.             while(text[i] >=48 && text[i] <= 57 && j < 10) string[j++] = text[i++];
  266.             string[j] = 0;
  267.             hours = atol(string);
  268.             
  269. // get minutes
  270.             j = 0;
  271. // skip separator
  272.             while((text[i] < 48 || text[i] > 57) && text[i] != 0) i++;
  273.             while(text[i] >=48 && text[i] <= 57 && j < 10) string[j++] = text[i++];
  274.             string[j] = 0;
  275.             minutes = atol(string);
  276.             
  277. // get seconds
  278.             j = 0;
  279. // skip separator
  280.             while((text[i] < 48 || text[i] > 57) && text[i] != 0) i++;
  281.             while(text[i] >=48 && text[i] <= 57 && j < 10) string[j++] = text[i++];
  282.             string[j] = 0;
  283.             seconds = atof(string);
  284.             
  285. // skip separator
  286.             while((text[i] < 48 || text[i] > 57) && text[i] != 0) i++;
  287. // get frames
  288.             j = 0;
  289.             while(text[i] >=48 && text[i] <= 57 && j < 10) string[j++] = text[i++];
  290.             string[j] = 0;
  291.             frames = atol(string);
  292.             
  293.             total_samples = (long)(((float)frames / frame_rate + seconds + minutes*60 + hours*3600) * samplerate);
  294.             return total_samples;
  295.             break;
  296.  
  297.         case 2:
  298.             return atol(text);
  299.             break;
  300.         
  301.         case 3:
  302.             sscanf(text, "%x", &total_samples);
  303.             return total_samples;
  304.         
  305.         case 4:
  306.             return (long)(atof(text) / frame_rate * samplerate);
  307.             break;
  308.         
  309.         case 5:
  310. // Get feet
  311.             i = 0;
  312.             j = 0;
  313.             while(text[i] >=48 && text[i] <= 57 && text[i] != 0 && j < 10) string[j++] = text[i++];
  314.             string[j] = 0;
  315.             feet = atol(string);
  316.  
  317. // skip separator
  318.             while((text[i] < 48 || text[i] > 57) && text[i] != 0) i++;
  319.  
  320. // Get frames
  321.             j = 0;
  322.             while(text[i] >=48 && text[i] <= 57 && text[i] != 0 && j < 10) string[j++] = text[i++];
  323.             string[j] = 0;
  324.             frames = atol(string);
  325.             return (long)(((float)feet * frames_per_foot + frames) / frame_rate * samplerate);
  326.             break;
  327.     }
  328.     return 0;
  329. }
  330.  
  331. double Units::text_to_seconds(char *text, 
  332.                 int samplerate, 
  333.                 int time_format, 
  334.                 float frame_rate, 
  335.                 float frames_per_foot)
  336. {
  337.     return (double)fromtext(text, samplerate, time_format, frame_rate, frames_per_foot) / samplerate;
  338. }
  339.  
  340.  
  341.  
  342.  
  343.  
  344.  
  345. float Units::toframes(long samples, int sample_rate, float framerate) 
  346. { 
  347.     return (float)samples / sample_rate * framerate; 
  348. } // give position in frames
  349.  
  350. long Units::toframes_round(long samples, int sample_rate, float framerate) 
  351. {
  352. // used in editing
  353.     float result_f = (float)samples / sample_rate * framerate; 
  354.     long result_l = (long)(result_f + 0.5);
  355.     return result_l;
  356. }
  357.  
  358. long Units::tosamples(float frames, int sample_rate, float framerate) 
  359. { 
  360.     float result = (frames / framerate * sample_rate);
  361.     
  362.     if(result - (int)result) result += 1;
  363.     return (long)result;
  364. } // give position in samples
  365.  
  366.  
  367. float Units::xy_to_polar(int x, int y)
  368. {
  369.     float angle;
  370.     if(x > 0 && y <= 0)
  371.     {
  372.         angle = atan((float)-y / x) / (2 * M_PI) * 360;
  373.     }
  374.     else
  375.     if(x < 0 && y <= 0)
  376.     {
  377.         angle = 180 - atan((float)-y / -x) / (2 * M_PI) * 360;
  378.     }
  379.     else
  380.     if(x < 0 && y > 0)
  381.     {
  382.         angle = 180 - atan((float)-y / -x) / (2 * M_PI) * 360;
  383.     }
  384.     else
  385.     if(x > 0 && y > 0)
  386.     {
  387.         angle = 360 + atan((float)-y / x) / (2 * M_PI) * 360;
  388.     }
  389.     else
  390.     if(x == 0 && y < 0)
  391.     {
  392.         angle = 90;
  393.     }
  394.     else
  395.     if(x == 0 && y > 0)
  396.     {
  397.         angle = 270;
  398.     }
  399.     else
  400.     if(x == 0 && y == 0)
  401.     {
  402.         angle = 0;
  403.     }
  404.  
  405.     return angle;
  406. }
  407.  
  408. void Units::polar_to_xy(float angle, int radius, int &x, int &y)
  409. {
  410.     while(angle < 0) angle += 360;
  411.  
  412.     x = (int)(cos(angle / 360 * (2 * M_PI)) * radius);
  413.     y = (int)(-sin(angle / 360 * (2 * M_PI)) * radius);
  414. }
  415.  
  416. long Units::round(double result)
  417. {
  418.     return (long)(result < 0 ? result - 0.5 : result + 0.5);
  419. }
  420.  
  421. float Units::quantize10(float value)
  422. {
  423.     long temp = (long)(value * 10 + 0.5);
  424.     value = (float)temp / 10;
  425.     return value;
  426. }
  427.  
  428.  
  429.  
  430.  
  431.  
  432.