libs/ardour/sndfile_helpers.cc

   1 #include <map>
   2
   3 #include <sndfile.h>
   4
   5 #include <ardour/sndfile_helpers.h>
   6
   7 #include "i18n.h"
   8
   9 using std::map;
  10
  11 const char * const sndfile_header_formats_strings[SNDFILE_HEADER_FORMATS+1] = {
  12         N_("WAV"),
  13         N_("AIFF"),
  14         N_("raw (no header)"),
  15         N_("PAF (Ensoniq Paris)"),
  16         N_("AU (Sun/NeXT)"),
  17         N_("IRCAM"),
  18         N_("W64 (64 bit WAV)"),
  19         0
  20 };
  21
  22 int sndfile_header_formats[SNDFILE_HEADER_FORMATS] = {
  23         SF_FORMAT_WAV,
  24         SF_FORMAT_AIFF,
  25         SF_FORMAT_RAW,
  26         SF_FORMAT_PAF,
  27         SF_FORMAT_AU,
  28         SF_FORMAT_IRCAM,
  29         SF_FORMAT_W64
  30 };
  31
  32 const char * const sndfile_bitdepth_formats_strings[SNDFILE_BITDEPTH_FORMATS+1] = {
  33         N_("16 bit"),
  34         N_("24 bit"),
  35         N_("32 bit"),
  36         N_("8 bit"),
  37         N_("float"),
  38         0
  39 };
  40
  41 int sndfile_bitdepth_formats[SNDFILE_BITDEPTH_FORMATS] = {
  42         SF_FORMAT_PCM_16,
  43         SF_FORMAT_PCM_24,
  44         SF_FORMAT_PCM_32,
  45         SF_FORMAT_PCM_S8,
  46         SF_FORMAT_FLOAT
  47 };
  48
  49 const char * const sndfile_endian_formats_strings[SNDFILE_ENDIAN_FORMATS+1] = {
  50         N_("Little-endian (Intel)"),
  51         N_("Big-endian (Mac)"),
  52         0
  53 };
  54
  55 int sndfile_endian_formats[SNDFILE_ENDIAN_FORMATS] = {
  56         SF_ENDIAN_LITTLE,
  57         SF_ENDIAN_BIG
  58 };
  59
  60 int
  61 sndfile_header_format_from_string (string str)
  62 {
  63         for (int n = 0; sndfile_header_formats_strings[n]; ++n) {
  64                 if (str == sndfile_header_formats_strings[n]) {
  65                         return sndfile_header_formats[n];
  66                 }
  67         }
  68         return -1;
  69 }
  70
  71 int
  72 sndfile_bitdepth_format_from_string (string str)
  73 {
  74         for (int n = 0; sndfile_bitdepth_formats_strings[n]; ++n) {
  75                 if (str == sndfile_bitdepth_formats_strings[n]) {
  76                         return sndfile_bitdepth_formats[n];
  77                 }
  78         }
  79         return -1;
  80 }
  81
  82 int
  83 sndfile_endian_format_from_string (string str)
  84 {
  85         for (int n = 0; sndfile_endian_formats_strings[n]; ++n) {
  86                 if (str == sndfile_endian_formats_strings[n]) {
  87                         return sndfile_endian_formats[n];
  88                 }
  89         }
  90         return -1;
  91 }
  92
  93 int
  94 sndfile_data_width (int format)
  95 {
  96         int tval = format & 0xf;
  97
  98         switch (tval) {
  99           case SF_FORMAT_PCM_S8:
 100           case SF_FORMAT_PCM_U8:
 101                 return 8;
 102           case SF_FORMAT_PCM_16:
 103                 return 16;
 104           case SF_FORMAT_PCM_24:
 105                 return 24;
 106           case SF_FORMAT_PCM_32:
 107                 return 32;
 108           case SF_FORMAT_FLOAT:
 109                 return 1; // heh, heh
 110           default:
 111             // we don't handle anything else within ardour
 112                 return 0;
 113         }
 114 }
 115
 116 string
 117 sndfile_major_format(int format)
 118 {
 119         static map<int, string> m;
 120
 121         if(m.empty()){
 122                 SF_FORMAT_INFO format_info;
 123                 int count;
 124                 sf_command(0, SFC_GET_FORMAT_MAJOR_COUNT, &count, sizeof (int));
 125                 for (int i = 0; i < count; ++i){
 126                         format_info.format = i;
 127                         sf_command (0, SFC_GET_FORMAT_MAJOR,
 128                                         &format_info, sizeof (format_info));
 129                         m[format_info.format & SF_FORMAT_TYPEMASK] = format_info.name;
 130                 }
 131         }
 132
 133         map<int, string>::iterator p = m.find(format & SF_FORMAT_TYPEMASK);
 134         if(p != m.end()){
 135                 return m[format & SF_FORMAT_TYPEMASK];
 136         } else {
 137                 return "-Unknown-";
 138         }
 139 }
 140
 141 string
 142 sndfile_minor_format(int format)
 143 {
 144         static map<int, string> m;
 145
 146         if(m.empty()){
 147                 SF_FORMAT_INFO format_info;
 148                 int count;
 149                 sf_command(0, SFC_GET_FORMAT_SUBTYPE_COUNT, &count, sizeof (int));
 150                 for (int i = 0; i < count; ++i){
 151                         format_info.format = i;
 152                         sf_command (0, SFC_GET_FORMAT_SUBTYPE,
 153                                         &format_info, sizeof (format_info));
 154                         m[format_info.format & SF_FORMAT_SUBMASK] = format_info.name;
 155                 }
 156         }
 157
 158         map<int, string>::iterator p = m.find(format & SF_FORMAT_SUBMASK);
 159         if(p != m.end()){
 160                 return m[format & SF_FORMAT_SUBMASK];
 161         } else {
 162                 return "-Unknown-";
 163         }
 164 }