cinelerra-5.1/guicast/units.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "bcwindowbase.inc"
  23 #include "units.h"
  24 #include "language.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <ctype.h>
  29
  30 float* DB::topower_base = 0;
  31 int* Freq::freqtable = 0;
  32
  33
  34 DB::DB(float infinitygain)
  35 {
  36         this->infinitygain = infinitygain;
  37         this->db = 0;
  38         this->topower = topower_base + -INFINITYGAIN * 10;
  39 }
  40
  41
  42 float DB::fromdb_table()
  43 {
  44         return db = topower[(int)(db*10)];
  45 }
  46
  47 float DB::fromdb_table(float db)
  48 {
  49         if(db > MAXGAIN) db = MAXGAIN;
  50         if(db <= INFINITYGAIN) return 0;
  51         return db = topower[(int)(db*10)];
  52 }
  53
  54 float DB::fromdb()
  55 {
  56         return pow(10, db/20);
  57 }
  58
  59 float DB::fromdb(float db)
  60 {
  61         return pow(10, db/20);
  62 }
  63
  64 // set db to the power given using a formula
  65 float DB::todb(float power)
  66 {
  67         float db;
  68         if(power > 0) {
  69                 db = 20 * log10(power);
  70                 if(db < -100) db = -100;
  71         }
  72         else
  73                 db = -100;
  74         return db;
  75 }
  76
  77
  78 Freq::Freq()
  79 {
  80         freq = 0;
  81 }
  82
  83 Freq::Freq(const Freq& oldfreq)
  84 {
  85         this->freq = oldfreq.freq;
  86 }
  87
  88 int Freq::fromfreq()
  89 {
  90         int i = 0;
  91         while( i<TOTALFREQS && freqtable[i]<freq ) ++i;
  92         return i;
  93 }
  94
  95 int Freq::fromfreq(int index)
  96 {
  97         int i = 0;
  98         while( i<TOTALFREQS && freqtable[i]<index ) ++i;
  99         return i;
 100 }
 101
 102 int Freq::tofreq(int index)
 103 {
 104         if(index >= TOTALFREQS) index = TOTALFREQS - 1;
 105         return freqtable[index];
 106 }
 107
 108 // frequency doubles for every OCTAVE slots.  OCTAVE must be divisible by 3
 109 // 27.5 is at i=1
 110 // 55 is at i=106
 111 // 110 is at i=211
 112 // 220 is at i=316
 113 // 440 is at i=421
 114 // 880 is at i=526
 115 double Freq::tofreq_f(double index)
 116 {
 117         if( index < 0.5 ) return 0;
 118         return 440.0 * pow(2, (double)(index - 421) / OCTAVE);
 119 }
 120 double Freq::fromfreq_f(double f)
 121 {
 122         if( f < 0.5 ) return 0;
 123         double result = log(f / 440) / log(2.0) * OCTAVE + 421;
 124         return result < 0 ? 0 : result;
 125 }
 126
 127 Freq& Freq::operator++()
 128 {
 129         if(freq < TOTALFREQS) ++freq;
 130         return *this;
 131 }
 132
 133 Freq& Freq::operator--()
 134 {
 135         if(freq > 0) --freq;
 136         return *this;
 137 }
 138
 139 int Freq::operator>(Freq &newfreq) { return freq > newfreq.freq; }
 140 int Freq::operator<(Freq &newfreq) { return freq < newfreq.freq; }
 141 Freq& Freq::operator=(const Freq &newfreq) { freq = newfreq.freq; return *this; }
 142 int Freq::operator=(const int newfreq) { freq = newfreq; return newfreq; }
 143 int Freq::operator!=(Freq &newfreq) { return freq != newfreq.freq; }
 144 int Freq::operator==(Freq &newfreq) { return freq == newfreq.freq; }
 145 int Freq::operator==(int newfreq) { return freq == newfreq; }
 146
 147
 148
 149 void Units::init()
 150 {
 151         DB::topower_base = new float[(MAXGAIN - INFINITYGAIN) * 10 + 1];
 152         float *topower = DB::topower_base + -INFINITYGAIN * 10;
 153         for(int i = INFINITYGAIN * 10; i <= MAXGAIN * 10; i++)
 154                 topower[i] = pow(10, (float)i / 10 / 20);
 155         topower[INFINITYGAIN * 10] = 0;   // infinity gain
 156
 157         Freq::freqtable = new int[TOTALFREQS + 1];
 158         for( int i=0; i<=TOTALFREQS; ++i )
 159                 Freq::freqtable[i] = Freq::tofreq_f(i);
 160 }
 161 void Units::finit()
 162 {
 163         delete [] DB::topower_base;  DB::topower_base = 0;
 164         delete [] Freq::freqtable;   Freq::freqtable = 0;
 165 }
 166
 167 // give text representation as time
 168 char* Units::totext(char *text, double seconds, int time_format,
 169                         int sample_rate, float frame_rate, float frames_per_foot,
 170                         double timecode_offset)
 171 {
 172         int64_t hour, feet, frame;
 173         int minute, second, thousandths;
 174
 175         switch(time_format) {
 176         case TIME_SECONDS: {
 177 // add 1.0e-6 to prevent round off truncation from glitching a bunch of digits
 178                 seconds = fabs(seconds) + 1.0e-6;
 179                 second = seconds;
 180                 seconds -= (int64_t)seconds;
 181                 thousandths = (int64_t)(seconds*1000) % 1000;
 182                 sprintf(text, "%04d.%03d", second, thousandths);
 183                 break; }
 184
 185         case TIME_HMS: {
 186                 seconds = fabs(seconds) + 1.0e-6;
 187                 hour = seconds/3600;
 188                 minute = seconds/60 - hour*60;
 189                 second = seconds - (hour*3600 + minute*60);
 190                 seconds -= (int64_t)seconds;
 191                 thousandths = (int64_t)(seconds*1000) % 1000;
 192                 sprintf(text, "%d:%02d:%02d.%03d",
 193                         (int)hour, minute, second, thousandths);
 194                 break; }
 195
 196         case TIME_HMS2: {
 197                 seconds = fabs(seconds) + 1.0e-6;
 198                 hour = seconds/3600;
 199                 minute = seconds/60 - hour*60;
 200                 second = seconds - (hour*3600 + minute*60);
 201                 sprintf(text, "%d:%02d:%02d", (int)hour, minute, second);
 202                 break; }
 203
 204         case TIME_HMS3: {
 205                 seconds = fabs(seconds) + 1.0e-6;
 206                 hour = seconds/3600;
 207                 minute = seconds/60 - hour*60;
 208                 second = seconds - (hour*3600 + minute*60);
 209                 sprintf(text, "%02d:%02d:%02d", (int)hour, minute, second);
 210                 break; }
 211
 212         case TIME_TIMECODE:
 213                 seconds += timecode_offset; // fall thru
 214         case TIME_HMSF: {
 215                 seconds = fabs(seconds) + 1.0e-6;
 216                 hour = seconds/3600;
 217                 minute = seconds/60 - hour*60;
 218                 second = seconds - (hour*3600 + minute*60);
 219                 seconds -= (int64_t)seconds;
 220 //              frame = round(frame_rate * (seconds-(int)seconds));
 221                 frame = frame_rate*seconds + 1.0e-6;
 222                 sprintf(text, "%01d:%02d:%02d:%02d", (int)hour, minute, second, (int)frame);
 223                 break; }
 224
 225         case TIME_SAMPLES: {
 226                 sprintf(text, "%09jd", to_int64(seconds * sample_rate));
 227                 break; }
 228
 229         case TIME_SAMPLES_HEX: {
 230                 sprintf(text, "%08jx", to_int64(seconds * sample_rate));
 231                 break; }
 232
 233         case TIME_FRAMES: {
 234                 frame = to_int64(seconds * frame_rate);
 235                 sprintf(text, "%06jd", frame);
 236                 break; }
 237
 238         case TIME_FEET_FRAMES: {
 239                 frame = to_int64(seconds * frame_rate);
 240                 feet = (int64_t)(frame / frames_per_foot);
 241                 sprintf(text, "%05jd-%02jd", feet,
 242                         (int64_t)(frame - feet * frames_per_foot));
 243                 break; }
 244
 245         case TIME_MS1: {
 246                 seconds = fabs(seconds) + 1.0e-6;
 247                 minute = seconds/60;
 248                 second = seconds - minute*60;
 249                 sprintf(text, "%d:%02d", minute, second);
 250                 break; }
 251
 252         case TIME_MS2: {
 253                 int sign = seconds >= 0 ? '+' : '-';
 254                 seconds = fabs(seconds) + 1.0e-6;
 255                 minute = seconds/60;
 256                 second = seconds - minute*60;
 257                 sprintf(text, "%c%d:%02d", sign, minute, second);
 258                 break; }
 259         default: {
 260                 *text = 0;
 261                 break; }
 262         }
 263         return text;
 264 }
 265
 266
 267 // give text representation as time
 268 char* Units::totext(char *text, int64_t samples, int samplerate,
 269                 int time_format, float frame_rate, float frames_per_foot,
 270                 double timecode_offset)
 271 {
 272         return totext(text, (double)samples/samplerate, time_format,
 273                 samplerate, frame_rate, frames_per_foot, timecode_offset);
 274 }
 275
 276 int64_t Units::get_int64(const char *&bp)
 277 {
 278         char string[BCTEXTLEN], *sp=&string[0];
 279         const char *cp = bp;
 280         for( int j=0; j<10 && isdigit(*cp); ++j ) *sp++ = *cp++;
 281         *sp = 0;  bp = cp;
 282         return atol(string);
 283 }
 284
 285 double Units::get_double(const char *&bp)
 286 {
 287         char string[BCTEXTLEN], *sp=&string[0];
 288         const char *cp = bp;
 289         for( int j=0; j<10 && isdigit(*cp); ++j ) *sp++ = *cp++;
 290         if( *cp == '.' ) {
 291                 *sp++ = *cp++;
 292                 for( int j=0; j<10 && isdigit(*cp); ++j ) *sp++ = *cp++;
 293         }
 294         *sp = 0;  bp = cp;
 295         return strtod(string,0);
 296 }
 297
 298 void Units::skip_seperators(const char *&bp)
 299 {
 300         const char *cp = bp;
 301         for( int j=0; j<10 && *cp && !isdigit(*cp); ++j ) ++cp;
 302         bp = cp;
 303 }
 304
 305 int64_t Units::fromtext(const char *text, int samplerate, int time_format,
 306                         float frame_rate, float frames_per_foot,
 307                         double timecode_offset)
 308 {
 309         int64_t hours, total_samples;
 310         int minutes, frames, feet;
 311         double seconds, total_seconds;
 312         int sign = 1;
 313
 314         switch(time_format) {
 315         case TIME_SECONDS: {
 316                 total_seconds = get_double(text);
 317                 break; }
 318
 319         case TIME_HMS:
 320         case TIME_HMS2:
 321         case TIME_HMS3: {
 322                 hours = get_int64(text);    skip_seperators(text);
 323                 minutes = get_int64(text);  skip_seperators(text);
 324                 seconds = get_double(text);
 325                 total_seconds = seconds + minutes*60 + hours*3600;
 326                 break; }
 327
 328         case TIME_TIMECODE:
 329         case TIME_HMSF: {
 330                 hours = get_int64(text);    skip_seperators(text);
 331                 minutes = get_int64(text);  skip_seperators(text);
 332                 seconds = get_int64(text);  skip_seperators(text);
 333                 frames = get_double(text);
 334                 total_seconds = frames/frame_rate + seconds + minutes*60 + hours*3600;
 335                 if( time_format == TIME_TIMECODE )
 336                         total_seconds -= timecode_offset;
 337                 break; }
 338
 339         case TIME_SAMPLES: {
 340                 return get_int64(text); }
 341
 342         case TIME_SAMPLES_HEX: {
 343                 sscanf(text, "%jx", &total_samples);
 344                 return total_samples; }
 345
 346         case TIME_FRAMES: {
 347                 total_seconds = get_double(text) / frame_rate;
 348                 break; }
 349
 350         case TIME_FEET_FRAMES: {
 351                 feet = get_int64(text);    skip_seperators(text);
 352                 frames = get_int64(text);
 353                 total_seconds = (feet*frames_per_foot + frames) / frame_rate;
 354                 break; }
 355
 356         case TIME_MS2: {
 357                 switch( *text ) {
 358                 case '+':  sign = 1;   ++text;  break;
 359                 case '-':  sign = -1;  ++text;  break;
 360                 } } // fall through
 361         case TIME_MS1: {
 362                 minutes = get_int64(text);   skip_seperators(text);
 363                 seconds = get_double(text);
 364                 total_seconds = sign * (seconds + minutes*60);
 365                 break; }
 366         default: {
 367                 total_seconds = 0;
 368                 break; }
 369         }
 370
 371         total_samples = total_seconds * samplerate;
 372         return total_samples;
 373 }
 374
 375 double Units::text_to_seconds(const char *text, int samplerate, int time_format,
 376                                 float frame_rate, float frames_per_foot,
 377                                 double timecode_offset)
 378 {
 379         return (double)fromtext(text, samplerate, time_format,
 380                 frame_rate, frames_per_foot, timecode_offset) / samplerate;
 381 }
 382
 383
 384
 385 const char *Units::timetype_toformat(int type)
 386 {
 387         switch( type ) {
 388         case TIME_HMS:          return TIME_HMS__STR;
 389         case TIME_HMSF:         return TIME_HMSF__STR;
 390         case TIME_SAMPLES:      return TIME_SAMPLES__STR;
 391         case TIME_SAMPLES_HEX:  return TIME_SAMPLES_HEX__STR;
 392         case TIME_FRAMES:       return TIME_FRAMES__STR;
 393         case TIME_FEET_FRAMES:  return TIME_FEET_FRAMES__STR;
 394         case TIME_HMS2:         return TIME_HMS2__STR;
 395         case TIME_HMS3:         return TIME_HMS3__STR;
 396         case TIME_SECONDS:      return TIME_SECONDS__STR;
 397         case TIME_MS1:          return TIME_MS1__STR;
 398         case TIME_MS2:          return TIME_MS2__STR;
 399         case TIME_TIMECODE:     return TIME_TIMECODE__STR;
 400         }
 401         return "(err)";
 402 }
 403
 404 int Units::timeformat_totype(const char *tcf)
 405 {
 406         if (!strcmp(tcf,TIME_SECONDS__STR)) return(TIME_SECONDS);
 407         if (!strcmp(tcf,TIME_HMS__STR)) return(TIME_HMS);
 408         if (!strcmp(tcf,TIME_HMS2__STR)) return(TIME_HMS2);
 409         if (!strcmp(tcf,TIME_HMS3__STR)) return(TIME_HMS3);
 410         if (!strcmp(tcf,TIME_HMSF__STR)) return(TIME_HMSF);
 411         if (!strcmp(tcf,TIME_TIMECODE__STR)) return(TIME_TIMECODE);
 412         if (!strcmp(tcf,TIME_SAMPLES__STR)) return(TIME_SAMPLES);
 413         if (!strcmp(tcf,TIME_SAMPLES_HEX__STR)) return(TIME_SAMPLES_HEX);
 414         if (!strcmp(tcf,TIME_FRAMES__STR)) return(TIME_FRAMES);
 415         if (!strcmp(tcf,TIME_FEET_FRAMES__STR)) return(TIME_FEET_FRAMES);
 416         return(-1);
 417 }
 418
 419
 420 float Units::toframes(int64_t samples, int sample_rate, float framerate)
 421 {
 422         return (double)samples/sample_rate * framerate;
 423 } // give position in frames
 424
 425 int64_t Units::toframes_round(int64_t samples, int sample_rate, float framerate)
 426 {
 427 // used in editing
 428         float result_f = (float)samples / sample_rate * framerate;
 429         int64_t result_l = (int64_t)(result_f + 0.5);
 430         return result_l;
 431 }
 432
 433 double Units::fix_framerate(double value)
 434 {
 435         if(value > 29.5 && value < 30)
 436                 value = (double)30000 / (double)1001;
 437         else if(value > 59.5 && value < 60)
 438                 value = (double)60000 / (double)1001;
 439         else if(value > 23.5 && value < 24)
 440                 value = (double)24000 / (double)1001;
 441         return value;
 442 }
 443
 444 double Units::atoframerate(const char *text)
 445 {
 446         double result = get_double(text);
 447         return fix_framerate(result);
 448 }
 449
 450
 451 int64_t Units::tosamples(double frames, int sample_rate, float framerate)
 452 {
 453         double result = frames/framerate * sample_rate;
 454         if(result - (int)result >= 1.0e-6 ) result += 1;
 455         return (int64_t)result;
 456 } // give position in samples
 457
 458
 459 float Units::xy_to_polar(int x, int y)
 460 {
 461         float angle = 0.;
 462         if(x > 0 && y <= 0)
 463                 angle = atan((float)-y / x) / (2*M_PI) * 360;
 464         else if(x < 0 && y <= 0)
 465                 angle = 180 - atan((float)-y / -x) / (2*M_PI) * 360;
 466         else if(x < 0 && y > 0)
 467                 angle = 180 - atan((float)-y / -x) / (2*M_PI) * 360;
 468         else if(x > 0 && y > 0)
 469                 angle = 360 + atan((float)-y / x) / (2*M_PI) * 360;
 470         else if(x == 0 && y < 0)
 471                 angle = 90;
 472         else if(x == 0 && y > 0)
 473                 angle = 270;
 474         else if(x == 0 && y == 0)
 475                 angle = 0;
 476         return angle;
 477 }
 478
 479 void Units::polar_to_xy(float angle, int radius, int &x, int &y)
 480 {
 481         if( angle < 0 )
 482                 angle += ((int)(-angle)/360 + 1) * 360;
 483         else if( angle >= 360 )
 484                 angle -= ((int)(angle)/360) * 360;
 485
 486         x = (int)(cos(angle / 360 * (2*M_PI)) * radius);
 487         y = (int)(-sin(angle / 360 * (2*M_PI)) * radius);
 488 }
 489
 490 int64_t Units::round(double result)
 491 {
 492         return (int64_t)(result < 0 ? result - 0.5 : result + 0.5);
 493 }
 494
 495 float Units::quantize10(float value)
 496 {
 497         int64_t temp = (int64_t)(value*10 + 0.5);
 498         return temp/10.;
 499 }
 500
 501 float Units::quantize(float value, float precision)
 502 {
 503         int64_t temp = (int64_t)(value/precision + 0.5);
 504         return temp*precision;
 505 }
 506
 507 int64_t Units::to_int64(double result)
 508 {
 509 // This must round up if result is one sample within ceiling.
 510 // Sampling rates below 48000 may cause more problems.
 511         return (int64_t)(result < 0 ? (result - 0.005) : (result + 0.005));
 512 }
 513
 514 const char* Units::print_time_format(int time_format, char *string)
 515 {
 516         const char *fmt = "Unknown";
 517         switch(time_format) {
 518         case TIME_HMS:         fmt = TIME_HMS_TEXT;                   break;
 519         case TIME_HMSF:        fmt = TIME_HMSF_TEXT;                  break;
 520         case TIME_SAMPLES:     fmt = TIME_SAMPLES_TEXT;               break;
 521         case TIME_SAMPLES_HEX: fmt = TIME_SAMPLES_HEX_TEXT;           break;
 522         case TIME_FRAMES:      fmt = TIME_FRAMES_TEXT;                break;
 523         case TIME_FEET_FRAMES: fmt = TIME_FEET_FRAMES_TEXT;           break;
 524         case TIME_HMS2:
 525         case TIME_HMS3:        fmt = TIME_HMS3_TEXT;                  break;
 526         case TIME_SECONDS:     fmt = TIME_SECONDS_TEXT;               break;
 527         case TIME_MS1:
 528         case TIME_MS2:         fmt = TIME_MS2_TEXT;                   break;
 529         case TIME_TIMECODE:    fmt = TIME_TIMECODE_TEXT;              break;
 530         }
 531         return strcpy(string,fmt);
 532 }
 533
 534 int Units::text_to_format(const char *string)
 535 {
 536         if(!strcmp(string, TIME_HMS_TEXT)) return TIME_HMS;
 537         if(!strcmp(string, TIME_HMSF_TEXT)) return TIME_HMSF;
 538         if(!strcmp(string, TIME_SAMPLES_TEXT)) return TIME_SAMPLES;
 539         if(!strcmp(string, TIME_SAMPLES_HEX_TEXT)) return TIME_SAMPLES_HEX;
 540         if(!strcmp(string, TIME_FRAMES_TEXT)) return TIME_FRAMES;
 541         if(!strcmp(string, TIME_FEET_FRAMES_TEXT)) return TIME_FEET_FRAMES;
 542         if(!strcmp(string, TIME_HMS3_TEXT)) return TIME_HMS3;
 543         if(!strcmp(string, TIME_SECONDS_TEXT)) return TIME_SECONDS;
 544         if(!strcmp(string, TIME_MS2_TEXT)) return TIME_MS2;
 545         if(!strcmp(string, TIME_TIMECODE_TEXT)) return TIME_TIMECODE;
 546         return TIME_HMS;
 547 }
 548
 549 char* Units::size_totext(int64_t bytes, char *text)
 550 {
 551         char string[BCTEXTLEN];
 552         static const char *sz[] = { "bytes", "KB", "MB", "GB", "TB" };
 553
 554         int i = (sizeof(sz) / sizeof(sz[0]));
 555         while( --i > 0 && bytes < ((int64_t)1 << (10*i)) );
 556
 557         if( i > 0 ) {
 558                 bytes >>= 10*(i-1);
 559                 int frac = bytes % 1000;
 560                 sprintf(string, "%jd", bytes/1000);
 561                 if( bytes > 1000 ) punctuate(string);
 562                 sprintf(text, "%s.%03d %s", string, frac, sz[i]);
 563         }
 564         else {
 565                 sprintf(string, "%jd", bytes);
 566                 if( bytes > 1000 ) punctuate(string);
 567                 sprintf(text, "%s %s", string, sz[i]);
 568         }
 569         return text;
 570 }
 571
 572
 573 #undef BYTE_ORDER
 574 #define BYTE_ORDER ((*(const uint32_t*)"a   ") & 0x00000001)
 575
 576 void* Units::int64_to_ptr(uint64_t value)
 577 {
 578         unsigned char *value_dissected = (unsigned char*)&value;
 579         void *result;
 580         unsigned char *data = (unsigned char*)&result;
 581
 582 // Must be done behind the compiler's back
 583         if(sizeof(void*) == 4) {
 584                 if(!BYTE_ORDER) {
 585                         data[0] = value_dissected[4];
 586                         data[1] = value_dissected[5];
 587                         data[2] = value_dissected[6];
 588                         data[3] = value_dissected[7];
 589                 }
 590                 else {
 591                         data[0] = value_dissected[0];
 592                         data[1] = value_dissected[1];
 593                         data[2] = value_dissected[2];
 594                         data[3] = value_dissected[3];
 595                 }
 596         }
 597         else {
 598                 data[0] = value_dissected[0];
 599                 data[1] = value_dissected[1];
 600                 data[2] = value_dissected[2];
 601                 data[3] = value_dissected[3];
 602                 data[4] = value_dissected[4];
 603                 data[5] = value_dissected[5];
 604                 data[6] = value_dissected[6];
 605                 data[7] = value_dissected[7];
 606         }
 607         return result;
 608 }
 609
 610 uint64_t Units::ptr_to_int64(void *ptr)
 611 {
 612         unsigned char *ptr_dissected = (unsigned char*)&ptr;
 613         int64_t result = 0;
 614         unsigned char *data = (unsigned char*)&result;
 615 // Don't do this at home.
 616         if(sizeof(void*) == 4) {
 617                 if(!BYTE_ORDER) {
 618                         data[4] = ptr_dissected[0];
 619                         data[5] = ptr_dissected[1];
 620                         data[6] = ptr_dissected[2];
 621                         data[7] = ptr_dissected[3];
 622                 }
 623                 else {
 624                         data[0] = ptr_dissected[0];
 625                         data[1] = ptr_dissected[1];
 626                         data[2] = ptr_dissected[2];
 627                         data[3] = ptr_dissected[3];
 628                 }
 629         }
 630         else {
 631                 data[0] = ptr_dissected[0];
 632                 data[1] = ptr_dissected[1];
 633                 data[2] = ptr_dissected[2];
 634                 data[3] = ptr_dissected[3];
 635                 data[4] = ptr_dissected[4];
 636                 data[5] = ptr_dissected[5];
 637                 data[6] = ptr_dissected[6];
 638                 data[7] = ptr_dissected[7];
 639         }
 640         return result;
 641 }
 642
 643 const char* Units::format_to_separators(int time_format)
 644 {
 645         switch(time_format) {
 646                 case TIME_SECONDS:     return "0000.000";
 647                 case TIME_HMS:         return "0:00:00.000";
 648                 case TIME_HMS2:        return "0:00:00";
 649                 case TIME_HMS3:        return "00:00:00";
 650                 case TIME_TIMECODE:
 651                 case TIME_HMSF:        return "0:00:00:00";
 652                 case TIME_SAMPLES:     return 0;
 653                 case TIME_SAMPLES_HEX: return 0;
 654                 case TIME_FRAMES:      return 0;
 655                 case TIME_FEET_FRAMES: return "00000-00";
 656                 case TIME_MS1:         return "0:00";
 657                 case TIME_MS2:         return "+0:00";
 658         }
 659         return 0;
 660 }
 661
 662 void Units::punctuate(char *string)
 663 {
 664         int sep = ',', len = strlen(string), commas = (len - 1) / 3;
 665         char *cp = string + len, *bp = cp + commas;
 666         *bp = 0;
 667         for( int k=3; cp < bp && bp > string; ) {
 668                 *--bp = *--cp;
 669                 if( --k > 0 ) continue;
 670                 *--bp = sep;  k = 3;
 671         }
 672 }
 673
 674 void Units::fix_double(double *x)
 675 {
 676         *x = *x;
 677 }
 678
 679