libsndfile/src/ircam.c

   1 /*
   2 ** Copyright (C) 2001-2003 Erik de Castro Lopo <erikd@zip.com.au>
   3 **
   4 ** This program is free software; you can redistribute it and/or modify
   5 ** it under the terms of the GNU Lesser General Public License as published by
   6 ** the Free Software Foundation; either version 2.1 of the License, or
   7 ** (at your option) any later version.
   8 **
   9 ** This program is distributed in the hope that it will be useful,
  10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 ** GNU Lesser General Public License for more details.
  13 **
  14 ** You should have received a copy of the GNU Lesser General Public License
  15 ** along with this program; if not, write to the Free Software
  16 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17 */
  18
  19 #include        <stdio.h>
  20 #include        <unistd.h>
  21 #include        <fcntl.h>
  22 #include        <string.h>
  23 #include        <ctype.h>
  24
  25 #include        "sndfile.h"
  26 #include        "config.h"
  27 #include        "sfendian.h"
  28 #include        "common.h"
  29
  30 /*------------------------------------------------------------------------------
  31 ** Macros to handle big/little endian issues.
  32 */
  33
  34 /* The IRCAM magic number is weird in that one byte in the number can have
  35 ** values of 0x1, 0x2, 0x03 or 0x04. Hence the need for a marker and a mask.
  36 */
  37
  38 #define IRCAM_BE_MASK           (MAKE_MARKER (0xFF, 0xFF, 0x00, 0xFF))
  39 #define IRCAM_BE_MARKER         (MAKE_MARKER (0x64, 0xA3, 0x00, 0x00))
  40
  41 #define IRCAM_LE_MASK           (MAKE_MARKER (0xFF, 0x00, 0xFF, 0xFF))
  42 #define IRCAM_LE_MARKER         (MAKE_MARKER (0x00, 0x00, 0xA3, 0x64))
  43
  44 #define IRCAM_02B_MARKER        (MAKE_MARKER (0x00, 0x02, 0xA3, 0x64))
  45 #define IRCAM_03L_MARKER        (MAKE_MARKER (0x64, 0xA3, 0x03, 0x00))
  46
  47 #define IRCAM_DATA_OFFSET       (1024)
  48
  49 /*------------------------------------------------------------------------------
  50 ** Typedefs.
  51 */
  52
  53 enum
  54 {       IRCAM_PCM_16    = 0x00002,
  55         IRCAM_FLOAT             = 0x00004,
  56         IRCAM_ALAW              = 0x10001,
  57         IRCAM_ULAW              = 0x20001,
  58         IRCAM_PCM_32    = 0x40004
  59 } ;
  60
  61
  62 /*------------------------------------------------------------------------------
  63 ** Private static functions.
  64 */
  65
  66 static  int             ircam_close                     (SF_PRIVATE *psf) ;
  67 static  int             ircam_write_header      (SF_PRIVATE *psf, int calc_length) ;
  68 static  int             ircam_read_header       (SF_PRIVATE *psf) ;
  69
  70 static  int             get_encoding (int subformat) ;
  71
  72 static  char*   get_encoding_str (int encoding) ;
  73
  74 /*------------------------------------------------------------------------------
  75 ** Public function.
  76 */
  77
  78 int
  79 ircam_open      (SF_PRIVATE *psf)
  80 {       int             subformat ;
  81         int             error = SFE_NO_ERROR ;
  82
  83         if (psf->mode == SFM_READ || (psf->mode == SFM_RDWR && psf->filelength > 0))
  84         {       if ((error = ircam_read_header (psf)))
  85                         return error ;
  86                 } ;
  87
  88         subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
  89
  90         if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
  91         {       if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_IRCAM)
  92                         return  SFE_BAD_OPEN_FORMAT ;
  93
  94                 psf->endian = psf->sf.format & SF_FORMAT_ENDMASK ;
  95                 if (psf->endian == 0 || psf->endian == SF_ENDIAN_CPU)
  96                         psf->endian = (CPU_IS_BIG_ENDIAN) ? SF_ENDIAN_BIG : SF_ENDIAN_LITTLE ;
  97
  98                 psf->dataoffset  = IRCAM_DATA_OFFSET ;
  99
 100                 if ((error = ircam_write_header (psf, SF_FALSE)))
 101                         return error ;
 102
 103                 psf->write_header = ircam_write_header ;
 104                 } ;
 105
 106         psf->close = ircam_close ;
 107
 108         switch (subformat)
 109         {       case  SF_FORMAT_ULAW :          /* 8-bit Ulaw encoding. */
 110                                 error = ulaw_init (psf) ;
 111                                 break ;
 112
 113                 case  SF_FORMAT_ALAW :          /* 8-bit Alaw encoding. */
 114                                 error = alaw_init (psf) ;
 115                                 break ;
 116
 117                 case  SF_FORMAT_PCM_16 :        /* 16-bit linear PCM. */
 118                 case  SF_FORMAT_PCM_32 :        /* 32-bit linear PCM. */
 119                                 error = pcm_init (psf) ;
 120                                 break ;
 121
 122                 case  SF_FORMAT_FLOAT : /* 32-bit linear PCM. */
 123                                 error = float32_init (psf) ;
 124                                 break ;
 125
 126                 default :   break ;
 127                 } ;
 128
 129         return error ;
 130 } /* ircam_open */
 131
 132 /*------------------------------------------------------------------------------
 133 */
 134
 135 static int
 136 ircam_read_header       (SF_PRIVATE *psf)
 137 {       unsigned int    marker, encoding ;
 138         float                   samplerate ;
 139         int                             error = SFE_NO_ERROR ;
 140
 141         psf_binheader_readf (psf, "epmf44", 0, &marker, &samplerate, &(psf->sf.channels), &encoding) ;
 142
 143         if (((marker & IRCAM_LE_MASK) != IRCAM_LE_MARKER) &&
 144                 ((marker & IRCAM_BE_MASK) != IRCAM_BE_MARKER))
 145         {       psf_log_printf (psf, "marker: 0x%X\n", marker) ;
 146                 return SFE_IRCAM_NO_MARKER ;
 147                 } ;
 148
 149         psf->endian = SF_ENDIAN_LITTLE ;
 150
 151         if (psf->sf.channels > 256)
 152         {       psf_binheader_readf (psf, "Epmf44", 0, &marker, &samplerate, &(psf->sf.channels), &encoding) ;
 153
 154                 /* Sanity checking for endian-ness detection. */
 155                 if (psf->sf.channels > 256)
 156                 {       psf_log_printf (psf, "marker: 0x%X\n", marker) ;
 157                         return SFE_IRCAM_BAD_CHANNELS ;
 158                         } ;
 159
 160                 psf->endian = SF_ENDIAN_BIG ;
 161                 } ;
 162
 163         psf_log_printf (psf, "marker: 0x%X\n", marker) ;
 164
 165         psf->sf.samplerate = (int) samplerate ;
 166
 167         psf_log_printf (psf, "  Sample Rate : %d\n"
 168                                                  "  Channels    : %d\n"
 169                                                  "  Encoding    : %X => %s\n", psf->sf.samplerate, psf->sf.channels, encoding, get_encoding_str (encoding)) ;
 170
 171         switch (encoding)
 172         {       case  IRCAM_PCM_16 :
 173                                 psf->bytewidth  = 2 ;
 174                                 psf->blockwidth = psf->sf.channels * psf->bytewidth ;
 175
 176                                 psf->sf.format = SF_FORMAT_IRCAM | SF_FORMAT_PCM_16 ;
 177                                 break ;
 178
 179                 case IRCAM_PCM_32 :
 180                                 psf->bytewidth  = 4 ;
 181                                 psf->blockwidth = psf->sf.channels * psf->bytewidth ;
 182
 183                                 psf->sf.format = SF_FORMAT_IRCAM | SF_FORMAT_PCM_32 ;
 184                                 break ;
 185
 186                 case  IRCAM_FLOAT :
 187                                 psf->bytewidth  = 4 ;
 188                                 psf->blockwidth = psf->sf.channels * psf->bytewidth ;
 189
 190                                 psf->sf.format = SF_FORMAT_IRCAM | SF_FORMAT_FLOAT ;
 191                                 break ;
 192
 193                 case IRCAM_ALAW :
 194                                 psf->bytewidth  = 1 ;
 195                                 psf->blockwidth = psf->sf.channels * psf->bytewidth ;
 196
 197                                 psf->sf.format = SF_FORMAT_IRCAM | SF_FORMAT_ALAW ;
 198                                 break ;
 199
 200                 case IRCAM_ULAW :
 201                                 psf->bytewidth  = 1 ;
 202                                 psf->blockwidth = psf->sf.channels * psf->bytewidth ;
 203
 204                                 psf->sf.format = SF_FORMAT_IRCAM | SF_FORMAT_ULAW ;
 205                                 break ;
 206
 207                 default :
 208                                 error = SFE_IRCAM_UNKNOWN_FORMAT ;
 209                                 break ;
 210                 } ;
 211
 212         if (psf->endian == SF_ENDIAN_BIG)
 213                 psf->sf.format |= SF_ENDIAN_BIG ;
 214         else
 215                 psf->sf.format |= SF_ENDIAN_LITTLE ;
 216
 217         if (error)
 218                 return error ;
 219
 220         psf->dataoffset = IRCAM_DATA_OFFSET ;
 221         psf->datalength = psf->filelength - psf->dataoffset ;
 222
 223         if (! psf->sf.frames && psf->blockwidth)
 224                 psf->sf.frames = psf->datalength / psf->blockwidth ;
 225
 226         psf_log_printf (psf, "  Samples     : %d\n", psf->sf.frames) ;
 227
 228         psf_binheader_readf (psf, "p", IRCAM_DATA_OFFSET) ;
 229
 230         return 0 ;
 231 } /* ircam_read_header */
 232
 233 static int
 234 ircam_close     (SF_PRIVATE  *psf)
 235 {
 236         psf_log_printf (psf, "close\n") ;
 237
 238         return 0 ;
 239 } /* ircam_close */
 240
 241 static int
 242 ircam_write_header (SF_PRIVATE *psf, int calc_length)
 243 {       int                     encoding ;
 244         float           samplerate ;
 245         sf_count_t      current ;
 246
 247         current = psf_ftell (psf) ;
 248
 249         calc_length = calc_length ;
 250
 251         /* This also sets psf->endian. */
 252         encoding = get_encoding (psf->sf.format & SF_FORMAT_SUBMASK) ;
 253
 254         if (! encoding)
 255                 return SFE_BAD_OPEN_FORMAT ;
 256
 257         /* Reset the current header length to zero. */
 258         psf->header [0] = 0 ;
 259         psf->headindex = 0 ;
 260         psf_fseek (psf, 0, SEEK_SET) ;
 261
 262         samplerate = psf->sf.samplerate ;
 263
 264         if (psf->endian == SF_ENDIAN_BIG)
 265         {       psf_binheader_writef (psf, "Emf", IRCAM_02B_MARKER, samplerate) ;
 266                 psf_binheader_writef (psf, "E44", psf->sf.channels, encoding) ;
 267                 }
 268         else if  (psf->endian == SF_ENDIAN_LITTLE)
 269         {       psf_binheader_writef (psf, "emf", IRCAM_03L_MARKER, samplerate) ;
 270                 psf_binheader_writef (psf, "e44", psf->sf.channels, encoding) ;
 271                 }
 272         else
 273                 return SFE_BAD_OPEN_FORMAT ;
 274
 275         psf_binheader_writef (psf, "z", IRCAM_DATA_OFFSET - psf->headindex) ;
 276
 277         /* Header construction complete so write it out. */
 278         psf_fwrite (psf->header, psf->headindex, 1, psf) ;
 279
 280         if (psf->error)
 281                 return psf->error ;
 282
 283         if (current > 0)
 284                 psf_fseek (psf, current, SEEK_SET) ;
 285
 286         return psf->error ;
 287 } /* ircam_write_header */
 288
 289 static int
 290 get_encoding (int subformat)
 291 {       switch (subformat)
 292         {       case SF_FORMAT_PCM_16 : return IRCAM_PCM_16 ;
 293                 case SF_FORMAT_PCM_32 : return IRCAM_PCM_32 ;
 294
 295                 case SF_FORMAT_FLOAT :  return IRCAM_FLOAT ;
 296
 297                 case SF_FORMAT_ULAW :   return IRCAM_ULAW ;
 298                 case SF_FORMAT_ALAW :   return IRCAM_ALAW ;
 299
 300                 default : break ;
 301                 } ;
 302
 303         return 0 ;
 304 } /* get_encoding */
 305
 306 static  char*
 307 get_encoding_str (int encoding)
 308 {       switch (encoding)
 309         {       case IRCAM_PCM_16       : return "16 bit PCM" ;
 310                 case IRCAM_FLOAT        : return "32 bit float" ;
 311                 case IRCAM_ALAW         : return "A law" ;
 312                 case IRCAM_ULAW         : return "u law" ;
 313                 case IRCAM_PCM_32       : return "32 bit PCM" ;
 314                 } ;
 315         return "Unknown encoding" ;
 316 } /* get_encoding_str */
 317