src/Sound/morse.cxx

   1 // morse.cxx -- Morse code generation class
   2 //
   3 // Written by Curtis Olson, started March 2001.
   4 //
   5 // Copyright (C) 2001  Curtis L. Olson - curt@flightgear.org
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #include "morse.hxx"
  25
  26
  27 static const char alphabet[26][4] = {
  28     { DI, DAH, end, end },      /* A */
  29     { DA, DI, DI, DIT },        /* B */
  30     { DA, DI, DA, DIT },        /* C */
  31     { DA, DI, DIT, end },       /* D */
  32     { DIT, end, end, end },     /* E */
  33     { DI, DI, DA, DIT },        /* F */
  34     { DA, DA, DIT, end },       /* G */
  35     { DI, DI, DI, DIT },        /* H */
  36     { DI, DIT, end, end },      /* I */
  37     { DI, DA, DA, DAH },        /* J */
  38     { DA, DI, DAH, end },       /* K */
  39     { DI, DA, DI, DIT },        /* L */
  40     { DA, DAH, end, end },      /* M */
  41     { DA, DIT, end, end },      /* N */
  42     { DA, DA, DAH, end },       /* O */
  43     { DI, DA, DA, DIT },        /* P */
  44     { DA, DA, DI, DAH },        /* Q */
  45     { DI, DA, DIT, end },       /* R */
  46     { DI, DI, DIT, end },       /* S */
  47     { DAH, end, end, end },     /* T */
  48     { DI, DI, DAH, end },       /* U */
  49     { DI, DI, DI, DAH },        /* V */
  50     { DI, DA, DAH, end },       /* W */
  51     { DA, DI, DI, DAH },        /* X */
  52     { DA, DI, DA, DAH },        /* Y */
  53     { DA, DA, DI, DIT }         /* Z */
  54 };
  55
  56
  57 // constructor
  58 FGMorse::FGMorse() {
  59 }
  60
  61 // destructor
  62 FGMorse::~FGMorse() {
  63 }
  64
  65
  66 // allocate and initialize sound samples
  67 bool FGMorse::init() {
  68     int i, j;
  69
  70     // Make DIT
  71     for ( i = 0; i < TRANSITION_BYTES; ++i ) {
  72         float level = ( sin( (double) i * 2.0 * M_PI / (8000.0 / FREQUENCY)) )
  73             * ((double)i / TRANSITION_BYTES) / 2.0 + 0.5;
  74
  75         /* Convert to unsigned byte */
  76         dit[ i ] = (unsigned char) ( level * 255.0 ) ;
  77     }
  78
  79     for ( i = TRANSITION_BYTES;
  80           i < DIT_SIZE - TRANSITION_BYTES - COUNT_SIZE; ++i ) {
  81         float level = ( sin( (double) i * 2.0 * M_PI / (8000.0 / FREQUENCY) ) )
  82             / 2.0 + 0.5;
  83
  84         /* Convert to unsigned byte */
  85         dit[ i ] = (unsigned char) ( level * 255.0 ) ;
  86     }
  87     j = TRANSITION_BYTES;
  88     for ( i = DIT_SIZE - TRANSITION_BYTES - COUNT_SIZE;
  89           i < DIT_SIZE - COUNT_SIZE;
  90           ++i ) {
  91         float level = ( sin( (double) i * 2.0 * M_PI / (8000.0 / FREQUENCY) ) )
  92             * ((double)j / TRANSITION_BYTES) / 2.0 + 0.5;
  93         --j;
  94
  95         /* Convert to unsigned byte */
  96         dit[ i ] = (unsigned char) ( level * 255.0 ) ;
  97     }
  98     for ( i = DIT_SIZE - COUNT_SIZE; i < DIT_SIZE; ++i ) {
  99         dit[ i ] = (unsigned char) ( 0.5 * 255.0 ) ;
 100     }
 101
 102     // Make DAH
 103     for ( i = 0; i < TRANSITION_BYTES; ++i ) {
 104         float level = ( sin( (double) i * 2.0 * M_PI / (8000.0 / FREQUENCY) ) )
 105             * ((double)i / TRANSITION_BYTES) / 2.0 + 0.5;
 106
 107         /* Convert to unsigned byte */
 108         dah[ i ] = (unsigned char) ( level * 255.0 ) ;
 109     }
 110
 111     for ( i = TRANSITION_BYTES;
 112           i < DAH_SIZE - TRANSITION_BYTES - COUNT_SIZE;
 113           ++i ) {
 114         float level = ( sin( (double) i * 2.0 * M_PI / (8000.0 / FREQUENCY) ) )
 115             / 2.0 + 0.5;
 116
 117         /* Convert to unsigned byte */
 118         dah[ i ] = (unsigned char) ( level * 255.0 ) ;
 119     }
 120     j = TRANSITION_BYTES;
 121     for ( int i = DAH_SIZE - TRANSITION_BYTES - COUNT_SIZE;
 122           i < DAH_SIZE - COUNT_SIZE;
 123           ++i ) {
 124         float level = ( sin( (double) i * 2.0 * M_PI / (8000.0 / FREQUENCY) ) )
 125             * ((double)j / TRANSITION_BYTES) / 2.0 + 0.5;
 126         --j;
 127
 128         /* Convert to unsigned byte */
 129         dah[ i ] = (unsigned char) ( level * 255.0 ) ;
 130     }
 131     for ( int i = DAH_SIZE - COUNT_SIZE; i < DAH_SIZE; ++i ) {
 132         dah[ i ] = (unsigned char) ( 0.5 * 255.0 ) ;
 133     }
 134
 135     // Make SPACE
 136     for ( int i = 0; i < SPACE_SIZE; ++i ) {
 137         space[ i ] = (unsigned char) ( 0.5 * 255 ) ;
 138     }
 139
 140     return true;
 141 }
 142
 143
 144 // make a FGSimpleSound morse code transmission for the specified string
 145 FGSimpleSound *FGMorse::make_ident( const string& id ) {
 146     char *idptr = (char *)id.c_str();
 147
 148     int length = 0;
 149     int i, j;
 150
 151     // 1. Determine byte length of message
 152     for ( i = 0; i < (int)id.length(); ++i ) {
 153         if ( idptr[i] >= 'A' && idptr[i] <= 'Z' ) {
 154             char c = idptr[i] - 'A';
 155             for ( j = 0; j < 4 || alphabet[c][j] == end; ++j ) {
 156                 if ( alphabet[c][j] == DIT ) {
 157                     length += DIT_SIZE;
 158                 } else if ( alphabet[c][j] == DAH ) {
 159                     length += DAH_SIZE;
 160                 }
 161             }
 162             length += SPACE_SIZE;
 163         } else {
 164             // skip unknown character
 165         }
 166     }
 167
 168     // 2. Allocate space for the message
 169     unsigned char *buffer = new unsigned char[length];
 170
 171     // 3. Assemble the message;
 172     unsigned char *bufptr = buffer;
 173
 174     for ( i = 0; i < (int)id.length(); ++i ) {
 175         if ( idptr[i] >= 'A' && idptr[i] <= 'Z' ) {
 176             char c = idptr[i] - 'A';
 177             for ( j = 0; j < 4 || alphabet[c][j] == end; ++j ) {
 178                 if ( alphabet[c][j] == DIT ) {
 179                     memcpy( bufptr, dit, DIT_SIZE );
 180                     bufptr += DIT_SIZE;
 181                 } else if ( alphabet[c][j] == DAH ) {
 182                     memcpy( bufptr, dah, DAH_SIZE );
 183                     bufptr += DAH_SIZE;
 184                 }
 185             }
 186             memcpy( bufptr, space, SPACE_SIZE );
 187             bufptr += SPACE_SIZE;
 188         } else {
 189             // skip unknown character
 190         }
 191     }
 192
 193     // 4. create the simple sound and return
 194     FGSimpleSound *sample = new FGSimpleSound( buffer, length );
 195
 196     return sample;
 197 }