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.10 2003/01/21 11:23:09 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.10 2003/01/21 11:23:09 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   while ((c = getopt (argc, argv, "rqvdph")) != -1) {
 102     switch (c) {
 103     case 'r':
 104         std::cout << "Version " << g_szIdStr << std::endl;
 105         break;
 106     case 'q':
 107       g_quiet = true;
 108       break;
 109     case 'v':
 110       g_verbose = true;
 111       break;
 112     case 'd':
 113       g_debug = true;
 114       break;
 115     case 'p':
 116       play = true;
 117       break;
 118     case 'h':
 119       usage (argv[0]);
 120       return (0);
 121     case '?':
 122     default:
 123         usage(argv[0]);
 124         return (1);
 125       }
 126     }
 127   argc -= optind;
 128   argv += optind;
 129   if (argc > 3) {
 130       std::cerr << "Too many parameters\n";
 131       usage (argv[0]);
 132       return (1);
 133     }
 134
 135   char wdq_fname[MAX_INPUT_STR];
 136   if (argc >= 1)
 137       strncpy (wdq_fname, argv [1], MAX_INPUT_STR);
 138   else {
 139     std::cout << "Enter input WinDAQ filename: ";
 140       std::cin.getline (wdq_fname, MAX_INPUT_STR);
 141     }
 142
 143     char channel_buf [MAX_INPUT_STR];
 144     if (argc >= 2)
 145       strncpy (channel_buf, argv[2], MAX_INPUT_STR);
 146     else {
 147       std::cout << "Enter channel number: ";
 148       std::cin.getline (channel_buf, MAX_INPUT_STR);
 149     }
 150
 151     char *channel_endptr;
 152     int channel = static_cast<int>(strtol (channel_buf, &channel_endptr, 10));
 153     if (*channel_endptr != 0) {
 154       std::ostringstream os;
 155       os << "Error: Channel " << channel_buf << " is not an integer";
 156       error_msg (os.str().c_str());
 157       usage (argv[0]);
 158       return (1);
 159     }
 160
 161     char wav_fname[MAX_INPUT_STR];
 162     if (argc >= 3)
 163       strncpy (wav_fname, argv[3], MAX_INPUT_STR);
 164     else {
 165       std::cout << "Enter output wav filename: ";
 166       std::cin.getline (wav_fname, MAX_INPUT_STR);
 167     }
 168
 169     if (! wdq2wav (wdq_fname, channel, wav_fname))
 170       return 1;
 171
 172     return 0;
 173 }
 174
 175 bool
 176 wdq2wav (const char* wdq_fname, const int channel, const char *wav_fname)
 177 {
 178   WindaqFile wdq (wdq_fname);
 179
 180   if (! wdq.ReadHeader()) {
 181     if (wdq.m_error.size()) {
 182       std::ostringstream os;
 183       os << "Error reading file " << wdq_fname << ": " << wdq.m_error.c_str();
 184       error_msg (os.str().c_str());
 185     } else {
 186       std::ostringstream os;
 187       os << "Error reading file " << wdq_fname;
 188       error_msg (os.str().c_str());
 189     }
 190     return false;
 191   }
 192   if (! g_quiet || g_verbose || g_debug) {
 193     std::ostringstream os1;
 194     os1 << "File " << wdq_fname;
 195     info_msg (os1.str().c_str());
 196     std::ostringstream os2;
 197     time_t time = wdq.m_time_acq_start;
 198     struct tm* tm = gmtime (&time);
 199     os2 << "  Time File Creation: " << asctime(tm);
 200     info_msg_sans_newline (os2.str().c_str());
 201     std::ostringstream os3;
 202     time = wdq.m_time_acq_stop;
 203     tm = gmtime (&time);
 204     os3 << "  Time File Written: " << asctime(tm);
 205     info_msg_sans_newline (os3.str().c_str());
 206     std::ostringstream os4;
 207     os4 << "  Samples: " << wdq.m_nSamples <<
 208       ", Channels: " << wdq.m_nChannels <<
 209       ", Sample Rate: " << wdq.m_sample_rate;
 210     info_msg (os4.str().c_str());
 211   }
 212
 213   WindaqChannel wdq_channel (wdq, channel);
 214   if (! wdq_channel.m_valid) {
 215     error_msg ("Error reading data from channel");
 216     return false;
 217   }
 218
 219   if (! g_quiet || g_verbose || g_debug) {
 220     std::ostringstream os1;
 221     os1 << "Channel " << channel;
 222     info_msg (os1.str().c_str());
 223     std::ostringstream os2;
 224     os2 << "  Units: " << wdq_channel.m_units.c_str();
 225     info_msg (os2.str().c_str());
 226     std::ostringstream os3;
 227     os3 << "  Raw minimum: " << wdq_channel.m_min_raw_data <<
 228       ", maximum: " << wdq_channel.m_max_raw_data;
 229     info_msg (os3.str().c_str());
 230   }
 231   if (g_debug) {
 232     std::ostringstream os4;
 233     os4 << "  Scaled minimum: " << wdq_channel.m_min_scaled_data <<
 234       ", maximum: " << wdq_channel.m_max_scaled_data;
 235     info_msg (os4.str().c_str());
 236     std::ostringstream os5;
 237     os5 << "  Slope " <<  wdq_channel.m_slope <<
 238       ", Intercept " <<  wdq_channel.m_intercept;
 239     info_msg (os5.str().c_str());
 240   }
 241
 242   WavFile wav (wdq_channel, wav_fname);
 243
 244   if (! wav.m_valid) {
 245     error_msg ("Error extracting wav from channel");
 246     return false;
 247   }
 248
 249   if (! wav.WriteFile ()) {
 250     error_msg ("Error writing file");
 251     return false;
 252   }
 253
 254   return true;
 255 }
 256
 257
 258 WindaqFile::WindaqFile (const char* fname)
 259   : m_fd(0), m_nChannels(0), m_nSamples(0), m_sample_rate(0), m_valid(false),
 260     m_strFile (fname)
 261 {
 262 }
 263
 264 WindaqFile::~WindaqFile ()
 265 {
 266   if (m_fd != 0)
 267     close (m_fd);
 268 }
 269
 270 bool read_int2 (int fd, unsigned short int& n)
 271 {
 272   unsigned char tmp1;
 273   unsigned int tmp2;
 274   if (read (fd, &tmp1, 1) != 1)
 275     return false;
 276   tmp2 = tmp1;
 277   if (read (fd, &tmp1, 1) != 1)
 278     return false;
 279   n = tmp2 + (tmp1 * 256);
 280 }
 281
 282 bool read_int4 (int fd, unsigned int& n)
 283 {
 284   unsigned int tmp4;
 285   unsigned short int tmp2;
 286   if (! read_int2 (fd, tmp2))
 287     return false;
 288   tmp4 = tmp2;
 289   if (! read_int2 (fd, tmp2))
 290     return false;
 291   n = tmp4 + (tmp2 * 65536);
 292 }
 293
 294 bool
 295 WindaqFile::ReadHeader ()
 296 {
 297   unsigned short int tmp2;
 298
 299   m_valid = false;
 300   if ((m_fd = open (m_strFile.c_str(), O_RDONLY)) < 0) {
 301     m_error = "Unable to open file";
 302     return false;
 303   }
 304
 305   lseek (0, 0, SEEK_SET);
 306   if (! read_int2 (m_fd, tmp2))
 307     return false;
 308
 309   m_nChannels = tmp2 & 0x1f;
 310   m_sr_denom = (tmp2 & 0x7fff) >> 5;
 311   m_sr_numer = (tmp2 & 0x8000) << 1;
 312
 313   if (! read_int2 (m_fd, tmp2))
 314     return false;
 315
 316   m_sr_numer |= tmp2;
 317   m_sample_rate = (double) m_sr_numer / (double) (m_sr_denom * m_nChannels);
 318
 319   if (! read_int2 (m_fd, tmp2))
 320     return false;
 321
 322   m_channel_offset = tmp2 & 0xFF;
 323   m_nBytes_channel_header = tmp2 >> 8;
 324
 325   if (! read_int2 (m_fd, m_nHeader_bytes))
 326     return false;
 327
 328   if (! read_int4 (m_fd, m_nData_bytes))
 329     return false;
 330
 331   m_nSamples = (m_nData_bytes / m_nChannels) / 2;
 332
 333   lseek (m_fd, 36, SEEK_SET);
 334   if (! read_int4 (m_fd, m_time_acq_start))
 335     return false;
 336
 337   if (! read_int4 (m_fd, m_time_acq_stop))
 338     return false;
 339
 340   // Verify Windaq signature
 341   lseek (m_fd, m_nHeader_bytes - 2, SEEK_SET);
 342   if (! read_int2 (m_fd, tmp2))
 343     return false;
 344
 345   if (tmp2 != 0x8001) {
 346     std::ostringstream os;
 347     m_error = "File is not a valid WinDAQ file";
 348     return false;
 349   }
 350
 351   m_valid = true;
 352   return true;
 353 }
 354
 355
 356 WindaqChannel::WindaqChannel (WindaqFile& wdq, const int channel)
 357   : r_wdq(wdq), m_data(0), m_slope(0), m_intercept (0), m_channel(channel),
 358     m_valid(false)
 359 {
 360   if (wdq.m_valid) {
 361     if (channel >= 1 && channel <= wdq.m_nChannels) {
 362       m_valid = true;
 363       read_channel_data();
 364     } else {
 365       std::ostringstream os;
 366       os << "Channel " << channel << " is invalid, valid range 1-" <<
 367         wdq.m_nChannels;
 368       error_msg (os.str().c_str());
 369     }
 370   }
 371 }
 372
 373 WindaqChannel::~WindaqChannel ()
 374 {
 375   if (m_data)
 376     delete m_data;
 377 }
 378
 379 bool get_float8 (int fd, double& f)
 380 {
 381   unsigned char buf[8];
 382   if (read (fd, &buf, 8) != 8)
 383     return false;
 384
 385 #ifdef BIG_ENDIAN
 386   unsigned char c;
 387   c = buf[0]; buf[0] = buf[7]; buf[7] = c;
 388   c = buf[1]; buf[1] = buf[6]; buf[6] = c;
 389   c = buf[2]; buf[2] = buf[5]; buf[5] = c;
 390   c = buf[3]; buf[3] = buf[4]; buf[4] = c;
 391 #endif
 392
 393   double* p = reinterpret_cast<double*>(buf);
 394   f = *p;
 395 }
 396
 397 bool
 398 WindaqChannel::read_channel_data ()
 399 {
 400   unsigned short int tmp2;
 401   unsigned int tmp4;
 402   double float8;
 403
 404   int fd = r_wdq.m_fd;
 405
 406   if (! m_valid)
 407     return false;
 408
 409   m_data = new signed short int [r_wdq.m_nSamples * 2];
 410
 411   lseek (fd, r_wdq.m_channel_offset + 8 +
 412          (m_channel - 1) * r_wdq.m_nBytes_channel_header,
 413          SEEK_SET);
 414   if (! get_float8 (fd, m_slope))
 415     return false;
 416
 417   if (get_float8 (fd, m_intercept))
 418     return false;
 419
 420   char units[7];
 421   units[6] = 0;
 422   if (read (fd, units, 6) != 6) {
 423     error_msg ("Error reading file");
 424     return false;
 425   }
 426   m_units = units;
 427
 428   unsigned int row_bytes = 2 * r_wdq.m_nChannels;
 429   signed short int sample_row [row_bytes];
 430
 431   signed short int* psample = &sample_row[m_channel - 1];
 432
 433   lseek (fd, r_wdq.m_nHeader_bytes, SEEK_SET);
 434   long int i;
 435   signed short int data_max, data_min;
 436   for (i = 0; i < r_wdq.m_nSamples; i++) {
 437     if (read (fd, sample_row, row_bytes) != row_bytes) {
 438       std::ostringstream os;
 439       os << "Error reading file at " << i;
 440       error_msg (os.str().c_str());
 441       return false;
 442     }
 443     signed short int v = *psample;
 444
 445 #ifdef BIG_ENDIAN
 446     unsigned char* p = reinterpret_cast<unsigned char*>(&v);
 447     unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
 448 #endif
 449
 450     signed short int value = v >> 2;
 451     m_data[i] = value;
 452
 453     if (i == 0) {
 454       data_max = value;
 455       data_min = value;
 456     } else {
 457       if (value > data_max)
 458         data_max = value;
 459       else if (value < data_min)
 460         data_min = value;
 461     }
 462   }
 463
 464   m_max_raw_data = data_max;
 465   m_min_raw_data = data_min;
 466   m_max_scaled_data = (m_slope * data_max) + m_intercept;
 467   m_min_scaled_data = (m_slope * data_min) + m_intercept;
 468
 469   return true;
 470 }
 471
 472
 473 WavFile::WavFile (WindaqChannel& wdq_channel, const char* fname)
 474   : m_valid(false), m_data(0), m_nSamples(0), m_strFile(fname), m_fd(0)
 475 {
 476   if (wdq_channel.m_valid) {
 477     m_nSamples = wdq_channel.r_wdq.m_nSamples;
 478     m_nChannels = 1;
 479     m_nBitsPerSample = 16;
 480     m_nBytesPerSample = 2;
 481     m_rate = wdq_channel.r_wdq.m_sample_rate;
 482
 483     double data_offset = -wdq_channel.m_min_scaled_data;
 484     double data_scale = 0.;
 485     if (wdq_channel.m_max_scaled_data != wdq_channel.m_min_scaled_data)
 486       data_scale = 65535. / (wdq_channel.m_max_scaled_data -
 487                              wdq_channel.m_min_scaled_data);
 488
 489     if (g_debug) {
 490       std::ostringstream os;
 491       os << "  Wav data_scale: " << data_scale << ", data_offset: " << data_offset;
 492       info_msg (os.str().c_str());
 493     }
 494
 495     unsigned int nHeaderBytes = 44;
 496     m_nFileBytes = nHeaderBytes + m_nSamples * m_nBytesPerSample;
 497
 498     unsigned int nHeaderShortInts = nHeaderBytes / sizeof(signed short int);
 499
 500     m_data = new signed short int [m_nSamples + nHeaderShortInts];
 501     signed short int* input = wdq_channel.m_data;
 502     signed short int* output = &m_data[nHeaderShortInts];
 503     double slope = wdq_channel.m_slope;
 504     double intercept = wdq_channel.m_intercept;
 505
 506     if (! fill_header ())
 507       return;
 508
 509     long int i;
 510     for (i = 0; i < m_nSamples; i++) {
 511       double value = input[i];
 512       value = (slope * value) + intercept;
 513       value = (value + data_offset) * data_scale;
 514       value += 0.5 - 32768;
 515       signed short int v = static_cast<signed short int>(value);
 516 #ifdef BIG_ENDIAN
 517       unsigned char* p = reinterpret_cast<unsigned char*>(&v);
 518       unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
 519 #endif
 520       output[i] = v;
 521     }
 522   }
 523
 524   m_valid = true;
 525 }
 526
 527
 528 WavFile::~WavFile ()
 529 {
 530   if (m_fd != 0)
 531     close (m_fd);
 532
 533   if (m_data != NULL)
 534     delete m_data;
 535 }
 536
 537 void
 538 put_int4 (char* p, unsigned int n)
 539 {
 540   *p = n & 0xFF;
 541   *(p+1) = 0xFF & (n >> 8);
 542   *(p+2) = 0xFF & (n >> 16);
 543   *(p+3) = 0xFF & (n >> 24);
 544 }
 545
 546 void
 547 put_int2 (char* p, unsigned short int n)
 548 {
 549   *p = n & 0xFF;
 550   *(p+1) = 0xFF & (n >> 8);
 551 }
 552
 553 bool
 554 WavFile::fill_header ()
 555 {
 556   char* pData = reinterpret_cast<char*> (m_data);
 557   unsigned long data_bytes = m_nSamples * m_nBytesPerSample * m_nChannels;
 558
 559   strncpy (pData, "RIFF", 4);
 560
 561   // Length of file after 8 byte header
 562   put_int4 (pData + 4, 36 + data_bytes);
 563
 564   strncpy (pData + 8, "WAVEfmt ", 8);
 565
 566   // Length of header block
 567   put_int4 (pData + 16, 0x10);
 568
 569   // Always 1
 570   put_int2 (pData + 20, 1);
 571
 572   /* Number of channels */
 573   put_int2 (pData + 22, m_nChannels);
 574
 575   // Sample Rate
 576   put_int4 (pData + 24, static_cast<int> (m_rate + 0.5));
 577
 578   // Bytes per second
 579   put_int4 (pData + 28, static_cast<int> (m_rate * m_nBytesPerSample + 0.5));
 580
 581   // Bytes per sample
 582   put_int2 (pData + 32, m_nBytesPerSample * m_nChannels);
 583
 584   // Bits per sample
 585   put_int2 (pData + 34, m_nBitsPerSample);
 586
 587   strncpy (pData + 36, "data", 4);
 588
 589   put_int4 (pData + 40, data_bytes);
 590
 591   return true;
 592 }
 593
 594 bool
 595 WavFile::WriteFile ()
 596 {
 597   unsigned short int tmp2;
 598   unsigned int tmp4;
 599
 600   if (! m_valid)
 601     return false;
 602
 603   if (m_fd == 0)
 604     if ((m_fd = open (m_strFile.c_str(), O_WRONLY | O_TRUNC | O_CREAT,
 605                       S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == 0) {
 606       std::ostringstream os;
 607       os << "Error opening output file " << m_strFile.c_str();
 608       error_msg (os.str().c_str());
 609       return false;
 610     }
 611
 612   lseek (m_fd, 0, SEEK_SET);
 613   if (write (m_fd, m_data, m_nFileBytes) != m_nFileBytes) {
 614     error_msg ("Error writing file");
 615     return false;
 616   }
 617
 618   if (close (m_fd) < 0)
 619     error_msg ("Error closing output file");
 620
 621   m_fd = 0;
 622   return true;
 623 }
 624
 625
 626
 627