src/pulse/channelmap.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include <pulse/xmalloc.h>
  32 #include <pulsecore/core-util.h>
  33
  34 #include "channelmap.h"
  35
  36 const char *const table[] = {
  37     [PA_CHANNEL_POSITION_MONO] = "mono",
  38
  39     [PA_CHANNEL_POSITION_FRONT_CENTER] = "front-center",
  40     [PA_CHANNEL_POSITION_FRONT_LEFT] = "front-left",
  41     [PA_CHANNEL_POSITION_FRONT_RIGHT] = "front-right",
  42
  43     [PA_CHANNEL_POSITION_REAR_CENTER] = "rear-center",
  44     [PA_CHANNEL_POSITION_REAR_LEFT] = "rear-left",
  45     [PA_CHANNEL_POSITION_REAR_RIGHT] = "rear-right",
  46
  47     [PA_CHANNEL_POSITION_LFE] = "lfe",
  48
  49     [PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER] = "front-left-of-center",
  50     [PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER] = "front-right-of-center",
  51
  52     [PA_CHANNEL_POSITION_SIDE_LEFT] = "side-left",
  53     [PA_CHANNEL_POSITION_SIDE_RIGHT] = "side-right",
  54
  55     [PA_CHANNEL_POSITION_AUX0] = "aux0",
  56     [PA_CHANNEL_POSITION_AUX1] = "aux1",
  57     [PA_CHANNEL_POSITION_AUX2] = "aux2",
  58     [PA_CHANNEL_POSITION_AUX3] = "aux3",
  59     [PA_CHANNEL_POSITION_AUX4] = "aux4",
  60     [PA_CHANNEL_POSITION_AUX5] = "aux5",
  61     [PA_CHANNEL_POSITION_AUX6] = "aux6",
  62     [PA_CHANNEL_POSITION_AUX7] = "aux7",
  63     [PA_CHANNEL_POSITION_AUX8] = "aux8",
  64     [PA_CHANNEL_POSITION_AUX9] = "aux9",
  65     [PA_CHANNEL_POSITION_AUX10] = "aux10",
  66     [PA_CHANNEL_POSITION_AUX11] = "aux11",
  67     [PA_CHANNEL_POSITION_AUX12] = "aux12",
  68     [PA_CHANNEL_POSITION_AUX13] = "aux13",
  69     [PA_CHANNEL_POSITION_AUX14] = "aux14",
  70     [PA_CHANNEL_POSITION_AUX15] = "aux15",
  71     [PA_CHANNEL_POSITION_AUX16] = "aux16",
  72     [PA_CHANNEL_POSITION_AUX17] = "aux17",
  73     [PA_CHANNEL_POSITION_AUX18] = "aux18",
  74     [PA_CHANNEL_POSITION_AUX19] = "aux19",
  75     [PA_CHANNEL_POSITION_AUX20] = "aux20",
  76     [PA_CHANNEL_POSITION_AUX21] = "aux21",
  77     [PA_CHANNEL_POSITION_AUX22] = "aux22",
  78     [PA_CHANNEL_POSITION_AUX23] = "aux23",
  79     [PA_CHANNEL_POSITION_AUX24] = "aux24",
  80     [PA_CHANNEL_POSITION_AUX25] = "aux25",
  81     [PA_CHANNEL_POSITION_AUX26] = "aux26",
  82     [PA_CHANNEL_POSITION_AUX27] = "aux27",
  83     [PA_CHANNEL_POSITION_AUX28] = "aux28",
  84     [PA_CHANNEL_POSITION_AUX29] = "aux29",
  85     [PA_CHANNEL_POSITION_AUX30] = "aux30",
  86     [PA_CHANNEL_POSITION_AUX31] = "aux31",
  87
  88     [PA_CHANNEL_POSITION_TOP_CENTER] = "top-center",
  89
  90     [PA_CHANNEL_POSITION_TOP_FRONT_LEFT] = "top-front-left",
  91     [PA_CHANNEL_POSITION_TOP_FRONT_RIGHT] = "top-front-right",
  92     [PA_CHANNEL_POSITION_TOP_FRONT_CENTER] = "top-front-center",
  93
  94     [PA_CHANNEL_POSITION_TOP_REAR_LEFT] = "top-rear-left",
  95     [PA_CHANNEL_POSITION_TOP_REAR_RIGHT] = "top-rear-right",
  96     [PA_CHANNEL_POSITION_TOP_REAR_CENTER] = "top-rear-center"
  97 };
  98
  99 pa_channel_map* pa_channel_map_init(pa_channel_map *m) {
 100     unsigned c;
 101     assert(m);
 102
 103     m->channels = 0;
 104
 105     for (c = 0; c < PA_CHANNELS_MAX; c++)
 106         m->map[c] = PA_CHANNEL_POSITION_INVALID;
 107
 108     return m;
 109 }
 110
 111 pa_channel_map* pa_channel_map_init_mono(pa_channel_map *m) {
 112     assert(m);
 113
 114     pa_channel_map_init(m);
 115
 116     m->channels = 1;
 117     m->map[0] = PA_CHANNEL_POSITION_MONO;
 118     return m;
 119 }
 120
 121 pa_channel_map* pa_channel_map_init_stereo(pa_channel_map *m) {
 122     assert(m);
 123
 124     pa_channel_map_init(m);
 125
 126     m->channels = 2;
 127     m->map[0] = PA_CHANNEL_POSITION_LEFT;
 128     m->map[1] = PA_CHANNEL_POSITION_RIGHT;
 129     return m;
 130 }
 131
 132 pa_channel_map* pa_channel_map_init_auto(pa_channel_map *m, unsigned channels, pa_channel_map_def_t def) {
 133     assert(m);
 134     assert(channels > 0);
 135     assert(channels <= PA_CHANNELS_MAX);
 136
 137     pa_channel_map_init(m);
 138
 139     m->channels = channels;
 140
 141     switch (def) {
 142         case PA_CHANNEL_MAP_AIFF:
 143
 144             /* This is somewhat compatible with RFC3551 */
 145
 146             switch (channels) {
 147                 case 1:
 148                     m->map[0] = PA_CHANNEL_POSITION_MONO;
 149                     return m;
 150
 151                 case 6:
 152                     m->map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
 153                     m->map[1] = PA_CHANNEL_POSITION_SIDE_LEFT;
 154                     m->map[2] = PA_CHANNEL_POSITION_FRONT_CENTER;
 155                     m->map[3] = PA_CHANNEL_POSITION_FRONT_RIGHT;
 156                     m->map[4] = PA_CHANNEL_POSITION_SIDE_RIGHT;
 157                     m->map[5] = PA_CHANNEL_POSITION_LFE;
 158                     return m;
 159
 160                 case 5:
 161                     m->map[2] = PA_CHANNEL_POSITION_FRONT_CENTER;
 162                     m->map[3] = PA_CHANNEL_POSITION_REAR_LEFT;
 163                     m->map[4] = PA_CHANNEL_POSITION_REAR_RIGHT;
 164                     /* Fall through */
 165
 166                 case 2:
 167                     m->map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
 168                     m->map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
 169                     return m;
 170
 171                 case 3:
 172                     m->map[0] = PA_CHANNEL_POSITION_LEFT;
 173                     m->map[1] = PA_CHANNEL_POSITION_RIGHT;
 174                     m->map[2] = PA_CHANNEL_POSITION_CENTER;
 175                     return m;
 176
 177                 case 4:
 178                     m->map[0] = PA_CHANNEL_POSITION_LEFT;
 179                     m->map[1] = PA_CHANNEL_POSITION_CENTER;
 180                     m->map[2] = PA_CHANNEL_POSITION_RIGHT;
 181                     m->map[3] = PA_CHANNEL_POSITION_LFE;
 182                     return m;
 183
 184                 default:
 185                     return NULL;
 186             }
 187
 188         case PA_CHANNEL_MAP_ALSA:
 189
 190             switch (channels) {
 191                 case 1:
 192                     m->map[0] = PA_CHANNEL_POSITION_MONO;
 193                     return m;
 194
 195                 case 8:
 196                     m->map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
 197                     m->map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
 198                     /* Fall through */
 199
 200                 case 6:
 201                     m->map[5] = PA_CHANNEL_POSITION_LFE;
 202                     /* Fall through */
 203
 204                 case 5:
 205                     m->map[4] = PA_CHANNEL_POSITION_FRONT_CENTER;
 206                     /* Fall through */
 207
 208                 case 4:
 209                     m->map[2] = PA_CHANNEL_POSITION_REAR_LEFT;
 210                     m->map[3] = PA_CHANNEL_POSITION_REAR_RIGHT;
 211                     /* Fall through */
 212
 213                 case 2:
 214                     m->map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
 215                     m->map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
 216                     return m;
 217
 218                 default:
 219                     return NULL;
 220             }
 221
 222         case PA_CHANNEL_MAP_AUX: {
 223             unsigned i;
 224
 225             if (channels >= PA_CHANNELS_MAX)
 226                 return NULL;
 227
 228             for (i = 0; i < channels; i++)
 229                 m->map[i] = PA_CHANNEL_POSITION_AUX0 + i;
 230
 231             return m;
 232         }
 233
 234         case PA_CHANNEL_MAP_WAVEEX:
 235
 236             switch (channels) {
 237                 case 1:
 238                     m->map[0] = PA_CHANNEL_POSITION_MONO;
 239                     return m;
 240
 241                 case 18:
 242                     m->map[15] = PA_CHANNEL_POSITION_TOP_REAR_LEFT;
 243                     m->map[16] = PA_CHANNEL_POSITION_TOP_REAR_CENTER;
 244                     m->map[17] = PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
 245                     /* Fall through */
 246
 247                 case 15:
 248                     m->map[12] = PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
 249                     m->map[13] = PA_CHANNEL_POSITION_TOP_FRONT_CENTER;
 250                     m->map[14] = PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
 251                     /* Fall through */
 252
 253                 case 12:
 254                     m->map[11] = PA_CHANNEL_POSITION_TOP_CENTER;
 255                     /* Fall through */
 256
 257                 case 11:
 258                     m->map[9] = PA_CHANNEL_POSITION_SIDE_LEFT;
 259                     m->map[10] = PA_CHANNEL_POSITION_SIDE_RIGHT;
 260                     /* Fall through */
 261
 262                 case 9:
 263                     m->map[8] = PA_CHANNEL_POSITION_REAR_CENTER;
 264                     /* Fall through */
 265
 266                 case 8:
 267                     m->map[6] = PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
 268                     m->map[7] = PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
 269                     /* Fall through */
 270
 271                 case 6:
 272                     m->map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
 273                     m->map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
 274                     /* Fall through */
 275
 276                 case 4:
 277                     m->map[3] = PA_CHANNEL_POSITION_LFE;
 278                     /* Fall through */
 279
 280                 case 3:
 281                     m->map[2] = PA_CHANNEL_POSITION_FRONT_CENTER;
 282                     /* Fall through */
 283
 284                 case 2:
 285                     m->map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
 286                     m->map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
 287                     return m;
 288
 289                 default:
 290                     return NULL;
 291             }
 292
 293         case PA_CHANNEL_MAP_OSS:
 294
 295             switch (channels) {
 296                 case 1:
 297                     m->map[0] = PA_CHANNEL_POSITION_MONO;
 298                     return m;
 299
 300                 case 8:
 301                     m->map[6] = PA_CHANNEL_POSITION_REAR_LEFT;
 302                     m->map[7] = PA_CHANNEL_POSITION_REAR_RIGHT;
 303                     /* Fall through */
 304
 305                 case 6:
 306                     m->map[4] = PA_CHANNEL_POSITION_SIDE_LEFT;
 307                     m->map[5] = PA_CHANNEL_POSITION_SIDE_RIGHT;
 308                     /* Fall through */
 309
 310                 case 4:
 311                     m->map[3] = PA_CHANNEL_POSITION_LFE;
 312                     /* Fall through */
 313
 314                 case 3:
 315                     m->map[2] = PA_CHANNEL_POSITION_FRONT_CENTER;
 316                     /* Fall through */
 317
 318                 case 2:
 319                     m->map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
 320                     m->map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
 321                     return m;
 322
 323                 default:
 324                     return NULL;
 325             }
 326
 327
 328         default:
 329             return NULL;
 330     }
 331 }
 332
 333
 334 const char* pa_channel_position_to_string(pa_channel_position_t pos) {
 335
 336     if (pos < 0 || pos >= PA_CHANNEL_POSITION_MAX)
 337         return NULL;
 338
 339     return table[pos];
 340 }
 341
 342 int pa_channel_map_equal(const pa_channel_map *a, const pa_channel_map *b) {
 343     unsigned c;
 344
 345     assert(a);
 346     assert(b);
 347
 348     if (a->channels != b->channels)
 349         return 0;
 350
 351     for (c = 0; c < a->channels; c++)
 352         if (a->map[c] != b->map[c])
 353             return 0;
 354
 355     return 1;
 356 }
 357
 358 char* pa_channel_map_snprint(char *s, size_t l, const pa_channel_map *map) {
 359     unsigned channel;
 360     int first = 1;
 361     char *e;
 362
 363     assert(s);
 364     assert(l > 0);
 365     assert(map);
 366
 367     *(e = s) = 0;
 368
 369     for (channel = 0; channel < map->channels && l > 1; channel++) {
 370         l -= snprintf(e, l, "%s%s",
 371                       first ? "" : ",",
 372                       pa_channel_position_to_string(map->map[channel]));
 373
 374         e = strchr(e, 0);
 375         first = 0;
 376     }
 377
 378     return s;
 379 }
 380
 381 pa_channel_map *pa_channel_map_parse(pa_channel_map *rmap, const char *s) {
 382     const char *state;
 383     pa_channel_map map;
 384     char *p;
 385
 386     assert(rmap);
 387     assert(s);
 388
 389     memset(&map, 0, sizeof(map));
 390
 391     if (strcmp(s, "stereo") == 0) {
 392         map.channels = 2;
 393         map.map[0] = PA_CHANNEL_POSITION_LEFT;
 394         map.map[1] = PA_CHANNEL_POSITION_RIGHT;
 395         goto finish;
 396     }
 397
 398     state = NULL;
 399     map.channels = 0;
 400
 401     while ((p = pa_split(s, ",", &state))) {
 402
 403         if (map.channels >= PA_CHANNELS_MAX) {
 404             pa_xfree(p);
 405             return NULL;
 406         }
 407
 408         /* Some special aliases */
 409         if (strcmp(p, "left") == 0)
 410             map.map[map.channels++] = PA_CHANNEL_POSITION_LEFT;
 411         else if (strcmp(p, "right") == 0)
 412             map.map[map.channels++] = PA_CHANNEL_POSITION_RIGHT;
 413         else if (strcmp(p, "center") == 0)
 414             map.map[map.channels++] = PA_CHANNEL_POSITION_CENTER;
 415         else if (strcmp(p, "subwoofer") == 0)
 416             map.map[map.channels++] = PA_CHANNEL_POSITION_SUBWOOFER;
 417         else {
 418             pa_channel_position_t i;
 419
 420             for (i = 0; i < PA_CHANNEL_POSITION_MAX; i++)
 421                 if (strcmp(p, table[i]) == 0) {
 422                     map.map[map.channels++] = i;
 423                     break;
 424                 }
 425
 426             if (i >= PA_CHANNEL_POSITION_MAX) {
 427                 pa_xfree(p);
 428                 return NULL;
 429             }
 430         }
 431
 432         pa_xfree(p);
 433     }
 434
 435 finish:
 436
 437     if (!pa_channel_map_valid(&map))
 438         return NULL;
 439
 440     *rmap = map;
 441     return rmap;
 442 }
 443
 444 int pa_channel_map_valid(const pa_channel_map *map) {
 445     unsigned c;
 446
 447     assert(map);
 448
 449     if (map->channels <= 0 || map->channels > PA_CHANNELS_MAX)
 450         return 0;
 451
 452     for (c = 0; c < map->channels; c++) {
 453
 454         if (map->map[c] < 0 ||map->map[c] >= PA_CHANNEL_POSITION_MAX)
 455             return 0;
 456
 457     }
 458
 459     return 1;
 460 }
 461