code.delx.au - pulseaudio/blob - src/pulse/channelmap.c

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