wdq2wav.cpp

   1 /*****************************************************************************
   2 ** FILE IDENTIFICATION
   3 **
   4 **   Name:          wdq2wav.cpp
   5 **   Purpose:       Converts a channel of WinDAQ file to .WAV format
   6 **   Programmer:    Kevin Rosenberg <kevin@rosenberg.net>
   7 **   Date Started:  Jan 2003
   8 **
   9 **  Copyright (c) 2003 Kevin Rosenberg
  10 **
  11 **  $Id: wdq2wav.cpp,v 1.11 2003/01/21 11:45:38 kevin Exp $
  12 **
  13 **  This program is free software; you can redistribute it and/or modify
  14 **  it under the terms of the GNU General Public License (version 2) as
  15 **  published by the Free Software Foundation.
  16 **
  17 **  This program is distributed in the hope that it will be useful,
  18 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 **  GNU General Public License for more details.
  21 **
  22 **  You should have received a copy of the GNU General Public License
  23 **  along with this program; if not, write to the Free Software
  24 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25 ******************************************************************************/
  26
  27 #include <wdq2wav.h>
  28
  29 const char* g_szIdStr = "$Id: wdq2wav.cpp,v 1.11 2003/01/21 11:45:38 kevin Exp $";
  30
  31 bool g_quiet = false;
  32 bool g_verbose = false;
  33 bool g_debug = false;
  34
  35 void
  36 error_msg (const char *msg)
  37 {
  38   std::cerr << msg << "\n";
  39 }
  40
  41 void
  42 info_msg (const char* msg)
  43 {
  44   std::cout << msg << "\n";
  45 }
  46
  47 void
  48 info_msg_sans_newline (const char* msg)
  49 {
  50   std::cout << msg;
  51 }
  52
  53 const char*
  54 fileBasename (const char* filename)
  55 {
  56   const char* p = strrchr (filename, '/');
  57   return (p ? p + 1 : filename);
  58 }
  59
  60 char *
  61 str_rm_tail (char *str, const char* const charlist)
  62 {
  63   int i;
  64
  65   for (i = strlen(str) - 1; i >= 0; i--)
  66     if (strchr (charlist, str[i]) != NULL)
  67       str[i] = 0;
  68     else
  69       break;            /* found non-specified char, all done */
  70
  71   return (str);
  72 }
  73
  74 char *
  75 str_wrm_tail (char *str)
  76 {
  77   return (str_rm_tail(str, "\b\t\n\r"));
  78 }
  79
  80
  81 void
  82 usage (const char* progname)
  83 {
  84   std::cout << "usage: " << fileBasename (progname) << " [OPTIONS] <wdq-file> <channel-number> <wav-file>\n";
  85   std::cout << "OPTIONS\n";
  86   std::cout << "  -p    Play channel through audio system\n";
  87   std::cout << "  -q    Supress all messages\n";
  88   std::cout << "  -v    Verbose mode\n";
  89   std::cout << "  -d    Debug mode\n";
  90   std::cout << "  -r    Print program version\n";
  91   std::cout << "  -h    Print this help message\n";
  92 }
  93
  94
  95 int
  96 main (int argc, char *argv[])
  97 {
  98   int c;
  99   bool play = false;
 100
 101   const char* progname = argv[0];
 102
 103   while ((c = getopt (argc, argv, "rqvdph")) != -1) {
 104     switch (c) {
 105     case 'r':
 106         std::cout << "Version " << g_szIdStr << std::endl;
 107         break;
 108     case 'q':
 109       g_quiet = true;
 110       break;
 111     case 'v':
 112       g_verbose = true;
 113       break;
 114     case 'd':
 115       g_debug = true;
 116       break;
 117     case 'p':
 118       play = true;
 119       break;
 120     case 'h':
 121       usage (progname);
 122       return (0);
 123     case '?':
 124     default:
 125         usage (progname);
 126         return (1);
 127       }
 128     }
 129   argc -= optind;
 130   argv += optind;
 131   if (argc > 3) {
 132       std::cerr << "Too many parameters\n";
 133       usage (progname);
 134       return (1);
 135     }
 136
 137   char wdq_fname[MAX_INPUT_STR];
 138   if (argc >= 1)
 139       strncpy (wdq_fname, argv [0], MAX_INPUT_STR);
 140   else {
 141     std::cout << "Enter input WinDAQ filename: ";
 142       std::cin.getline (wdq_fname, MAX_INPUT_STR);
 143     }
 144
 145     char channel_buf [MAX_INPUT_STR];
 146     if (argc >= 2)
 147       strncpy (channel_buf, argv[1], MAX_INPUT_STR);
 148     else {
 149       std::cout << "Enter channel number: ";
 150       std::cin.getline (channel_buf, MAX_INPUT_STR);
 151     }
 152
 153     char *channel_endptr;
 154     int channel = static_cast<int>(strtol (channel_buf, &channel_endptr, 10));
 155     if (*channel_endptr != 0) {
 156       std::ostringstream os;
 157       os << "Error: Channel " << channel_buf << " is not an integer";
 158       error_msg (os.str().c_str());
 159       usage (progname);
 160       return (1);
 161     }
 162
 163     char wav_fname[MAX_INPUT_STR];
 164     if (argc >= 3)
 165       strncpy (wav_fname, argv[2], MAX_INPUT_STR);
 166     else {
 167       std::cout << "Enter output wav filename: ";
 168       std::cin.getline (wav_fname, MAX_INPUT_STR);
 169     }
 170
 171     if (! wdq2wav (wdq_fname, channel, wav_fname))
 172       return 1;
 173
 174     return 0;
 175 }
 176
 177 bool
 178 wdq2wav (const char* wdq_fname, const int channel, const char *wav_fname)
 179 {
 180   WindaqFile wdq (wdq_fname);
 181
 182   if (! wdq.ReadHeader()) {
 183     if (wdq.m_error.size()) {
 184       std::ostringstream os;
 185       os << "Error reading file " << wdq_fname << ": " << wdq.m_error.c_str();
 186       error_msg (os.str().c_str());
 187     } else {
 188       std::ostringstream os;
 189       os << "Error reading file " << wdq_fname;
 190       error_msg (os.str().c_str());
 191     }
 192     return false;
 193   }
 194   if (! g_quiet || g_verbose || g_debug) {
 195     std::ostringstream os1;
 196     os1 << "File " << wdq_fname;
 197     info_msg (os1.str().c_str());
 198     std::ostringstream os2;
 199     time_t time = wdq.m_time_acq_start;
 200     struct tm* tm = gmtime (&time);
 201     os2 << "  Time File Creation: " << asctime(tm);
 202     info_msg_sans_newline (os2.str().c_str());
 203     std::ostringstream os3;
 204     time = wdq.m_time_acq_stop;
 205     tm = gmtime (&time);
 206     os3 << "  Time File Written: " << asctime(tm);
 207     info_msg_sans_newline (os3.str().c_str());
 208     std::ostringstream os4;
 209     os4 << "  Samples: " << wdq.m_nSamples <<
 210       ", Channels: " << wdq.m_nChannels <<
 211       ", Sample Rate: " << wdq.m_sample_rate;
 212     info_msg (os4.str().c_str());
 213   }
 214
 215   WindaqChannel wdq_channel (wdq, channel);
 216   if (! wdq_channel.m_valid) {
 217     error_msg ("Error reading data from channel");
 218     return false;
 219   }
 220
 221   if (! g_quiet || g_verbose || g_debug) {
 222     std::ostringstream os1;
 223     os1 << "Channel " << channel;
 224     info_msg (os1.str().c_str());
 225     std::ostringstream os2;
 226     os2 << "  Units: " << wdq_channel.m_units.c_str();
 227     info_msg (os2.str().c_str());
 228     std::ostringstream os3;
 229     os3 << "  Raw minimum: " << wdq_channel.m_min_raw_data <<
 230       ", maximum: " << wdq_channel.m_max_raw_data;
 231     info_msg (os3.str().c_str());
 232   }
 233   if (g_debug) {
 234     std::ostringstream os4;
 235     os4 << "  Scaled minimum: " << wdq_channel.m_min_scaled_data <<
 236       ", maximum: " << wdq_channel.m_max_scaled_data;
 237     info_msg (os4.str().c_str());
 238     std::ostringstream os5;
 239     os5 << "  Slope " <<  wdq_channel.m_slope <<
 240       ", Intercept " <<  wdq_channel.m_intercept;
 241     info_msg (os5.str().c_str());
 242   }
 243
 244   WavFile wav (wdq_channel, wav_fname);
 245
 246   if (! wav.m_valid) {
 247     error_msg ("Error extracting wav from channel");
 248     return false;
 249   }
 250
 251   if (! wav.WriteFile ()) {
 252     error_msg ("Error writing file");
 253     return false;
 254   }
 255
 256   return true;
 257 }
 258
 259
 260 WindaqFile::WindaqFile (const char* fname)
 261   : m_fd(0), m_nChannels(0), m_nSamples(0), m_sample_rate(0), m_valid(false),
 262     m_strFile (fname)
 263 {
 264 }
 265
 266 WindaqFile::~WindaqFile ()
 267 {
 268   if (m_fd != 0)
 269     close (m_fd);
 270 }
 271
 272 bool read_int2 (int fd, unsigned short int& n)
 273 {
 274   unsigned char tmp1;
 275   unsigned int tmp2;
 276   if (read (fd, &tmp1, 1) != 1)
 277     return false;
 278   tmp2 = tmp1;
 279   if (read (fd, &tmp1, 1) != 1)
 280     return false;
 281
 282   n = tmp2 + (tmp1 * 256);
 283   return true;
 284 }
 285
 286 bool read_int4 (int fd, unsigned int& n)
 287 {
 288   unsigned int tmp4;
 289   unsigned short int tmp2;
 290   if (! read_int2 (fd, tmp2))
 291     return false;
 292   tmp4 = tmp2;
 293   if (! read_int2 (fd, tmp2))
 294     return false;
 295
 296   n = tmp4 + (tmp2 * 65536);
 297   return true;
 298 }
 299
 300 bool
 301 WindaqFile::ReadHeader ()
 302 {
 303   unsigned short int tmp2;
 304
 305   m_valid = false;
 306   if ((m_fd = open (m_strFile.c_str(), O_RDONLY)) < 0) {
 307     m_error = "Unable to open file";
 308     return false;
 309   }
 310
 311   lseek (0, 0, SEEK_SET);
 312   if (! read_int2 (m_fd, tmp2))
 313     return false;
 314
 315   m_nChannels = tmp2 & 0x1f;
 316   m_sr_denom = (tmp2 & 0x7fff) >> 5;
 317   m_sr_numer = (tmp2 & 0x8000) << 1;
 318
 319   if (! read_int2 (m_fd, tmp2))
 320     return false;
 321
 322   m_sr_numer |= tmp2;
 323   m_sample_rate = (double) m_sr_numer / (double) (m_sr_denom * m_nChannels);
 324
 325   if (! read_int2 (m_fd, tmp2))
 326     return false;
 327
 328   m_channel_offset = tmp2 & 0xFF;
 329   m_nBytes_channel_header = tmp2 >> 8;
 330
 331   if (! read_int2 (m_fd, m_nHeader_bytes))
 332     return false;
 333
 334   if (! read_int4 (m_fd, m_nData_bytes))
 335     return false;
 336
 337   m_nSamples = (m_nData_bytes / m_nChannels) / 2;
 338
 339   lseek (m_fd, 36, SEEK_SET);
 340   if (! read_int4 (m_fd, m_time_acq_start))
 341     return false;
 342
 343   if (! read_int4 (m_fd, m_time_acq_stop))
 344     return false;
 345
 346   // Verify Windaq signature
 347   lseek (m_fd, m_nHeader_bytes - 2, SEEK_SET);
 348   if (! read_int2 (m_fd, tmp2))
 349     return false;
 350
 351   if (tmp2 != 0x8001) {
 352     std::ostringstream os;
 353     m_error = "File is not a valid WinDAQ file";
 354     return false;
 355   }
 356
 357   m_valid = true;
 358   return true;
 359 }
 360
 361
 362 WindaqChannel::WindaqChannel (WindaqFile& wdq, const int channel)
 363   : r_wdq(wdq), m_data(0), m_slope(0), m_intercept (0), m_channel(channel),
 364     m_valid(false)
 365 {
 366   if (wdq.m_valid) {
 367     if (channel >= 1 && channel <= wdq.m_nChannels) {
 368       if (read_channel_data())
 369         m_valid = true;
 370     } else {
 371       std::ostringstream os;
 372       os << "Channel " << channel << " is invalid, valid range 1-" <<
 373         wdq.m_nChannels;
 374       error_msg (os.str().c_str());
 375     }
 376   }
 377 }
 378
 379 WindaqChannel::~WindaqChannel ()
 380 {
 381   if (m_data)
 382     delete m_data;
 383 }
 384
 385 bool get_float8 (int fd, double& f)
 386 {
 387   unsigned char buf[8];
 388   if (read (fd, &buf, 8) != 8)
 389     return false;
 390
 391 #if WORDS_BIG_ENDIAN
 392   unsigned char c;
 393   c = buf[0]; buf[0] = buf[7]; buf[7] = c;
 394   c = buf[1]; buf[1] = buf[6]; buf[6] = c;
 395   c = buf[2]; buf[2] = buf[5]; buf[5] = c;
 396   c = buf[3]; buf[3] = buf[4]; buf[4] = c;
 397 #endif
 398
 399   f = *(reinterpret_cast<double*>(buf));
 400
 401   return true;
 402 }
 403
 404 bool
 405 WindaqChannel::read_channel_data ()
 406 {
 407   unsigned short int tmp2;
 408   unsigned int tmp4;
 409
 410   int fd = r_wdq.m_fd;
 411
 412   m_data = new signed short int [r_wdq.m_nSamples * 2];
 413
 414   lseek (fd, r_wdq.m_channel_offset + 8 +
 415          (m_channel - 1) * r_wdq.m_nBytes_channel_header,
 416          SEEK_SET);
 417   if (! get_float8 (fd, m_slope))
 418     return false;
 419
 420   if (! get_float8 (fd, m_intercept))
 421     return false;
 422
 423   char units[7];
 424   units[6] = 0;
 425   if (read (fd, units, 6) != 6) {
 426     error_msg ("Error reading file");
 427     return false;
 428   }
 429   m_units = units;
 430
 431   unsigned int row_bytes = 2 * r_wdq.m_nChannels;
 432   signed short int sample_row [row_bytes];
 433
 434   signed short int* psample = &sample_row[m_channel - 1];
 435
 436   lseek (fd, r_wdq.m_nHeader_bytes, SEEK_SET);
 437   long int i;
 438   signed short int data_max, data_min;
 439   for (i = 0; i < r_wdq.m_nSamples; i++) {
 440     if (read (fd, sample_row, row_bytes) != row_bytes) {
 441       std::ostringstream os;
 442       os << "Error reading file at " << i;
 443       error_msg (os.str().c_str());
 444       return false;
 445     }
 446     signed short int v = *psample;
 447
 448 #if WORDS_BIG_ENDIAN
 449     unsigned char* p = reinterpret_cast<unsigned char*>(&v);
 450     unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
 451 #endif
 452
 453     signed short int value = v >> 2;
 454     m_data[i] = value;
 455
 456     if (i == 0) {
 457       data_max = value;
 458       data_min = value;
 459     } else {
 460       if (value > data_max)
 461         data_max = value;
 462       else if (value < data_min)
 463         data_min = value;
 464     }
 465   }
 466
 467   m_max_raw_data = data_max;
 468   m_min_raw_data = data_min;
 469   m_max_scaled_data = (m_slope * data_max) + m_intercept;
 470   m_min_scaled_data = (m_slope * data_min) + m_intercept;
 471
 472   return true;
 473 }
 474
 475
 476 WavFile::WavFile (WindaqChannel& wdq_channel, const char* fname)
 477   : m_valid(false), m_data(0), m_nSamples(0), m_strFile(fname), m_fd(0)
 478 {
 479   if (wdq_channel.m_valid) {
 480     m_nSamples = wdq_channel.r_wdq.m_nSamples;
 481     m_nChannels = 1;
 482     m_nBitsPerSample = 16;
 483     m_nBytesPerSample = 2;
 484     m_rate = wdq_channel.r_wdq.m_sample_rate;
 485
 486     double data_offset = -wdq_channel.m_min_scaled_data;
 487     double data_scale = 0.;
 488     if (wdq_channel.m_max_scaled_data != wdq_channel.m_min_scaled_data)
 489       data_scale = 65535. / (wdq_channel.m_max_scaled_data -
 490                              wdq_channel.m_min_scaled_data);
 491
 492     if (g_debug) {
 493       std::ostringstream os;
 494       os << "  Wav data_scale: " << data_scale << ", data_offset: " << data_offset;
 495       info_msg (os.str().c_str());
 496     }
 497
 498     unsigned int nHeaderBytes = 44;
 499     m_nFileBytes = nHeaderBytes + m_nSamples * m_nBytesPerSample;
 500
 501     unsigned int nHeaderShortInts = nHeaderBytes / sizeof(signed short int);
 502
 503     m_data = new signed short int [m_nSamples + nHeaderShortInts];
 504     signed short int* input = wdq_channel.m_data;
 505     signed short int* output = &m_data[nHeaderShortInts];
 506     double slope = wdq_channel.m_slope;
 507     double intercept = wdq_channel.m_intercept;
 508
 509     if (! fill_header ())
 510       return;
 511
 512     long int i;
 513     for (i = 0; i < m_nSamples; i++) {
 514       double value = input[i];
 515       value = (slope * value) + intercept;
 516       value = (value + data_offset) * data_scale;
 517       value += 0.5 - 32768;
 518       signed short int v = static_cast<signed short int>(value);
 519 #if WORDS_BIG_ENDIAN
 520       unsigned char* p = reinterpret_cast<unsigned char*>(&v);
 521       unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
 522 #endif
 523       output[i] = v;
 524     }
 525   }
 526
 527   m_valid = true;
 528 }
 529
 530
 531 WavFile::~WavFile ()
 532 {
 533   if (m_fd != 0)
 534     close (m_fd);
 535
 536   if (m_data != NULL)
 537     delete m_data;
 538 }
 539
 540 void
 541 put_int4 (char* p, unsigned int n)
 542 {
 543   *p = n & 0xFF;
 544   *(p+1) = 0xFF & (n >> 8);
 545   *(p+2) = 0xFF & (n >> 16);
 546   *(p+3) = 0xFF & (n >> 24);
 547 }
 548
 549 void
 550 put_int2 (char* p, unsigned short int n)
 551 {
 552   *p = n & 0xFF;
 553   *(p+1) = 0xFF & (n >> 8);
 554 }
 555
 556 bool
 557 WavFile::fill_header ()
 558 {
 559   char* pData = reinterpret_cast<char*> (m_data);
 560   unsigned long data_bytes = m_nSamples * m_nBytesPerSample * m_nChannels;
 561
 562   strncpy (pData, "RIFF", 4);
 563
 564   // Length of file after 8 byte header
 565   put_int4 (pData + 4, 36 + data_bytes);
 566
 567   strncpy (pData + 8, "WAVEfmt ", 8);
 568
 569   // Length of header block
 570   put_int4 (pData + 16, 0x10);
 571
 572   // Always 1
 573   put_int2 (pData + 20, 1);
 574
 575   /* Number of channels */
 576   put_int2 (pData + 22, m_nChannels);
 577
 578   // Sample Rate
 579   put_int4 (pData + 24, static_cast<int> (m_rate + 0.5));
 580
 581   // Bytes per second
 582   put_int4 (pData + 28, static_cast<int> (m_rate * m_nBytesPerSample + 0.5));
 583
 584   // Bytes per sample
 585   put_int2 (pData + 32, m_nBytesPerSample * m_nChannels);
 586
 587   // Bits per sample
 588   put_int2 (pData + 34, m_nBitsPerSample);
 589
 590   strncpy (pData + 36, "data", 4);
 591
 592   put_int4 (pData + 40, data_bytes);
 593
 594   return true;
 595 }
 596
 597 bool
 598 WavFile::WriteFile ()
 599 {
 600   unsigned short int tmp2;
 601   unsigned int tmp4;
 602
 603   if (! m_valid)
 604     return false;
 605
 606   if (m_fd == 0)
 607     if ((m_fd = open (m_strFile.c_str(), O_WRONLY | O_TRUNC | O_CREAT,
 608                       S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == 0) {
 609       std::ostringstream os;
 610       os << "Error opening output file " << m_strFile.c_str();
 611       error_msg (os.str().c_str());
 612       return false;
 613     }
 614
 615   lseek (m_fd, 0, SEEK_SET);
 616   if (write (m_fd, m_data, m_nFileBytes) != m_nFileBytes) {
 617     error_msg ("Error writing file");
 618     return false;
 619   }
 620
 621   if (close (m_fd) < 0)
 622     error_msg ("Error closing output file");
 623
 624   m_fd = 0;
 625   return true;
 626 }
 627
 628
 629
 630