src/pulse/format.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2011 Intel Corporation
   5   Copyright 2011 Collabora Multimedia
   6   Copyright 2011 Arun Raghavan <arun.raghavan@collabora.co.uk>
   7
   8   PulseAudio is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU Lesser General Public License as published
  10   by the Free Software Foundation; either version 2.1 of the License,
  11   or (at your option) any later version.
  12
  13   PulseAudio is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with PulseAudio; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21   USA.
  22 ***/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <json.h>
  29
  30 #include <pulse/internal.h>
  31 #include <pulse/xmalloc.h>
  32
  33 #include <pulsecore/core-util.h>
  34 #include <pulsecore/i18n.h>
  35 #include <pulsecore/macro.h>
  36
  37 #include "format.h"
  38
  39 #define PA_JSON_MIN_KEY "min"
  40 #define PA_JSON_MAX_KEY "max"
  41
  42 static int pa_format_info_prop_compatible(const char *one, const char *two);
  43
  44 static const char* const _encoding_str_table[]= {
  45     [PA_ENCODING_PCM] = "pcm",
  46     [PA_ENCODING_AC3_IEC61937] = "ac3-iec61937",
  47     [PA_ENCODING_EAC3_IEC61937] = "eac3-iec61937",
  48     [PA_ENCODING_MPEG_IEC61937] = "mpeg-iec61937",
  49     [PA_ENCODING_DTS_IEC61937] = "dts-iec61937",
  50     [PA_ENCODING_ANY] = "any",
  51 };
  52
  53 const char *pa_encoding_to_string(pa_encoding_t e) {
  54     if (e < 0 || e >= PA_ENCODING_MAX)
  55         return NULL;
  56
  57     return _encoding_str_table[e];
  58 }
  59
  60 pa_encoding_t pa_encoding_from_string(const char *encoding) {
  61     pa_encoding_t e;
  62
  63     for (e = PA_ENCODING_ANY; e < PA_ENCODING_MAX; e++)
  64         if (pa_streq(_encoding_str_table[e], encoding))
  65             return e;
  66
  67     return PA_ENCODING_INVALID;
  68 }
  69
  70 pa_format_info* pa_format_info_new(void) {
  71     pa_format_info *f = pa_xnew(pa_format_info, 1);
  72
  73     f->encoding = PA_ENCODING_INVALID;
  74     f->plist = pa_proplist_new();
  75
  76     return f;
  77 }
  78
  79 pa_format_info* pa_format_info_copy(const pa_format_info *src) {
  80     pa_format_info *dest;
  81
  82     pa_assert(src);
  83
  84     dest = pa_xnew(pa_format_info, 1);
  85
  86     dest->encoding = src->encoding;
  87
  88     if (src->plist)
  89         dest->plist = pa_proplist_copy(src->plist);
  90     else
  91         dest->plist = NULL;
  92
  93     return dest;
  94 }
  95
  96 void pa_format_info_free(pa_format_info *f) {
  97     pa_assert(f);
  98
  99     pa_proplist_free(f->plist);
 100     pa_xfree(f);
 101 }
 102
 103 void pa_format_info_free2(pa_format_info *f, void *userdata) {
 104     pa_format_info_free(f);
 105 }
 106
 107 int pa_format_info_valid(const pa_format_info *f) {
 108     return (f->encoding >= 0 && f->encoding < PA_ENCODING_MAX && f->plist != NULL);
 109 }
 110
 111 int pa_format_info_is_pcm(const pa_format_info *f) {
 112     return f->encoding == PA_ENCODING_PCM;
 113 }
 114
 115 char *pa_format_info_snprint(char *s, size_t l, const pa_format_info *f) {
 116     char *tmp;
 117
 118     pa_assert(s);
 119     pa_assert(l > 0);
 120     pa_assert(f);
 121
 122     pa_init_i18n();
 123
 124     if (!pa_format_info_valid(f))
 125         pa_snprintf(s, l, _("(invalid)"));
 126     else {
 127         tmp = pa_proplist_to_string_sep(f->plist, "  ");
 128         if (tmp[0])
 129             pa_snprintf(s, l, "%s, %s", pa_encoding_to_string(f->encoding), tmp);
 130         else
 131             pa_snprintf(s, l, "%s", pa_encoding_to_string(f->encoding));
 132         pa_xfree(tmp);
 133     }
 134
 135     return s;
 136 }
 137
 138 pa_format_info* pa_format_info_from_string(const char *str) {
 139     pa_format_info *f = pa_format_info_new();
 140     char *encoding = NULL, *properties = NULL;
 141     size_t pos;
 142
 143     pos = strcspn(str, ",");
 144
 145     encoding = pa_xstrndup(str, pos);
 146     f->encoding = pa_encoding_from_string(pa_strip(encoding));
 147     if (f->encoding == PA_ENCODING_INVALID)
 148         goto error;
 149
 150     if (pos != strlen(str)) {
 151         pa_proplist *plist;
 152
 153         properties = pa_xstrdup(&str[pos+1]);
 154         plist = pa_proplist_from_string(properties);
 155
 156         if (!plist)
 157             goto error;
 158
 159         pa_proplist_free(f->plist);
 160         f->plist = plist;
 161     }
 162
 163 out:
 164     if (encoding)
 165         pa_xfree(encoding);
 166     if (properties)
 167         pa_xfree(properties);
 168     return f;
 169
 170 error:
 171     pa_format_info_free(f);
 172     f = NULL;
 173     goto out;
 174 }
 175
 176 int pa_format_info_is_compatible(pa_format_info *first, pa_format_info *second) {
 177     const char *key;
 178     void *state = NULL;
 179
 180     pa_assert(first);
 181     pa_assert(second);
 182
 183     if (first->encoding != second->encoding)
 184         return FALSE;
 185
 186     while ((key = pa_proplist_iterate(first->plist, &state))) {
 187         const char *value_one, *value_two;
 188
 189         value_one = pa_proplist_gets(first->plist, key);
 190         value_two = pa_proplist_gets(second->plist, key);
 191
 192         if (!value_two || !pa_format_info_prop_compatible(value_one, value_two))
 193             return FALSE;
 194     }
 195
 196     return TRUE;
 197 }
 198
 199 pa_format_info* pa_format_info_from_sample_spec(pa_sample_spec *ss, pa_channel_map *map) {
 200     char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 201     pa_format_info *f;
 202
 203     pa_assert(ss && pa_sample_spec_valid(ss));
 204     pa_assert(!map || pa_channel_map_valid(map));
 205
 206     f = pa_format_info_new();
 207     f->encoding = PA_ENCODING_PCM;
 208
 209     pa_format_info_set_sample_format(f, ss->format);
 210     pa_format_info_set_rate(f, ss->rate);
 211     pa_format_info_set_channels(f, ss->channels);
 212
 213     if (map) {
 214         pa_channel_map_snprint(cm, sizeof(cm), map);
 215         pa_format_info_set_prop_string(f, PA_PROP_FORMAT_CHANNEL_MAP, cm);
 216     }
 217
 218     return f;
 219 }
 220
 221 /* For PCM streams */
 222 int pa_format_info_to_sample_spec(pa_format_info *f, pa_sample_spec *ss, pa_channel_map *map) {
 223     char *sf = NULL, *m = NULL;
 224     int rate, channels;
 225     int ret = -PA_ERR_INVALID;
 226
 227     pa_assert(f);
 228     pa_assert(ss);
 229     pa_return_val_if_fail(f->encoding == PA_ENCODING_PCM, FALSE);
 230
 231     if (pa_format_info_get_prop_string(f, PA_PROP_FORMAT_SAMPLE_FORMAT, &sf))
 232         goto out;
 233     if (pa_format_info_get_prop_int(f, PA_PROP_FORMAT_RATE, &rate))
 234         goto out;
 235     if (pa_format_info_get_prop_int(f, PA_PROP_FORMAT_CHANNELS, &channels))
 236         goto out;
 237
 238     if ((ss->format = pa_parse_sample_format(sf)) == PA_SAMPLE_INVALID)
 239         goto out;
 240
 241     ss->rate = (uint32_t) rate;
 242     ss->channels = (uint8_t) channels;
 243
 244     if (map) {
 245         pa_channel_map_init(map);
 246
 247         if (pa_format_info_get_prop_string(f, PA_PROP_FORMAT_CHANNEL_MAP, &m) == 0)
 248             if (pa_channel_map_parse(map, m) == NULL)
 249                 goto out;
 250     }
 251
 252     ret = 0;
 253
 254 out:
 255     if (sf)
 256         pa_xfree(sf);
 257     if (m)
 258         pa_xfree(m);
 259
 260     return ret;
 261 }
 262
 263 /* For compressed streams */
 264 int pa_format_info_to_sample_spec_fake(pa_format_info *f, pa_sample_spec *ss) {
 265     int rate;
 266
 267     pa_assert(f);
 268     pa_assert(ss);
 269     pa_return_val_if_fail(f->encoding != PA_ENCODING_PCM, -PA_ERR_INVALID);
 270
 271     ss->format = PA_SAMPLE_S16LE;
 272     ss->channels = 2;
 273
 274     pa_return_val_if_fail(pa_format_info_get_prop_int(f, PA_PROP_FORMAT_RATE, &rate) == 0, -PA_ERR_INVALID);
 275     ss->rate = (uint32_t) rate;
 276
 277     if (f->encoding == PA_ENCODING_EAC3_IEC61937)
 278         ss->rate *= 4;
 279
 280     return 0;
 281 }
 282
 283 void pa_format_info_set_sample_format(pa_format_info *f, pa_sample_format_t sf) {
 284     pa_format_info_set_prop_string(f, PA_PROP_FORMAT_SAMPLE_FORMAT, pa_sample_format_to_string(sf));
 285 }
 286
 287 void pa_format_info_set_rate(pa_format_info *f, int rate) {
 288     pa_format_info_set_prop_int(f, PA_PROP_FORMAT_RATE, rate);
 289 }
 290
 291 void pa_format_info_set_channels(pa_format_info *f, int channels) {
 292     pa_format_info_set_prop_int(f, PA_PROP_FORMAT_CHANNELS, channels);
 293 }
 294
 295 void pa_format_info_set_channel_map(pa_format_info *f, const pa_channel_map *map) {
 296     char map_str[PA_CHANNEL_MAP_SNPRINT_MAX];
 297
 298     pa_channel_map_snprint(map_str, sizeof(map_str), map);
 299
 300     pa_format_info_set_prop_string(f, PA_PROP_FORMAT_CHANNEL_MAP, map_str);
 301 }
 302
 303 int pa_format_info_get_prop_int(pa_format_info *f, const char *key, int *v) {
 304     const char *str;
 305     json_object *o;
 306
 307     pa_assert(f);
 308     pa_assert(key);
 309     pa_assert(v);
 310
 311     str = pa_proplist_gets(f->plist, key);
 312     if (!str)
 313         return -PA_ERR_NOENTITY;
 314
 315     o = json_tokener_parse(str);
 316     if (is_error(o))
 317         return -PA_ERR_INVALID;
 318
 319     if (json_object_get_type(o) != json_type_int) {
 320         json_object_put(o);
 321         return -PA_ERR_INVALID;
 322     }
 323
 324     *v = json_object_get_int(o);
 325     json_object_put(o);
 326
 327     return 0;
 328 }
 329
 330 int pa_format_info_get_prop_int_range(pa_format_info *f, const char *key, int *min, int *max) {
 331     const char *str;
 332     json_object *o, *o1;
 333     int ret = -PA_ERR_INVALID;
 334
 335     pa_assert(f);
 336     pa_assert(key);
 337     pa_assert(min);
 338     pa_assert(max);
 339
 340     str = pa_proplist_gets(f->plist, key);
 341     if (!str)
 342         return -PA_ERR_NOENTITY;
 343
 344     o = json_tokener_parse(str);
 345     if (is_error(o))
 346         return -PA_ERR_INVALID;
 347
 348     if (json_object_get_type(o) != json_type_object)
 349         goto out;
 350
 351     if (!(o1 = json_object_object_get(o, PA_JSON_MIN_KEY)))
 352         goto out;
 353
 354     *min = json_object_get_int(o1);
 355     json_object_put(o1);
 356
 357     if (!(o1 = json_object_object_get(o, PA_JSON_MAX_KEY)))
 358         goto out;
 359
 360     *max = json_object_get_int(o1);
 361     json_object_put(o1);
 362
 363     ret = 0;
 364
 365 out:
 366     json_object_put(o);
 367     return ret;
 368 }
 369
 370 int pa_format_info_get_prop_int_array(pa_format_info *f, const char *key, int **values, int *n_values)
 371 {
 372     const char *str;
 373     json_object *o, *o1;
 374     int i, ret = -PA_ERR_INVALID;
 375
 376     pa_assert(f);
 377     pa_assert(key);
 378     pa_assert(values);
 379     pa_assert(n_values);
 380
 381     str = pa_proplist_gets(f->plist, key);
 382     if (!str)
 383         return -PA_ERR_NOENTITY;
 384
 385     o = json_tokener_parse(str);
 386     if (is_error(o))
 387         return -PA_ERR_INVALID;
 388
 389     if (json_object_get_type(o) != json_type_array)
 390         goto out;
 391
 392     *n_values = json_object_array_length(o);
 393     *values = pa_xnew(int, *n_values);
 394
 395     for (i = 0; i < *n_values; i++) {
 396         o1 = json_object_array_get_idx(o, i);
 397
 398         if (json_object_get_type(o1) != json_type_int) {
 399             json_object_put(o1);
 400             goto out;
 401         }
 402
 403         (*values)[i] = json_object_get_int(o1);
 404         json_object_put(o1);
 405     }
 406
 407     ret = 0;
 408
 409 out:
 410     json_object_put(o);
 411     return ret;
 412 }
 413
 414 int pa_format_info_get_prop_string(pa_format_info *f, const char *key, char **v) {
 415     const char *str = NULL;
 416     json_object *o;
 417
 418     pa_assert(f);
 419     pa_assert(key);
 420     pa_assert(v);
 421
 422     str = pa_proplist_gets(f->plist, key);
 423     if (!str)
 424         return -PA_ERR_NOENTITY;
 425
 426     o = json_tokener_parse(str);
 427     if (is_error(o))
 428         return -PA_ERR_INVALID;
 429
 430     if (json_object_get_type(o) != json_type_string) {
 431         json_object_put(o);
 432         return -PA_ERR_INVALID;
 433     }
 434
 435     *v = pa_xstrdup(json_object_get_string(o));
 436     json_object_put(o);
 437
 438     return 0;
 439 }
 440
 441 int pa_format_info_get_prop_string_array(pa_format_info *f, const char *key, char ***values, int *n_values)
 442 {
 443     const char *str;
 444     json_object *o, *o1;
 445     int i, ret = -PA_ERR_INVALID;
 446
 447     pa_assert(f);
 448     pa_assert(key);
 449     pa_assert(values);
 450     pa_assert(n_values);
 451
 452     str = pa_proplist_gets(f->plist, key);
 453     if (!str)
 454         return -PA_ERR_NOENTITY;
 455
 456     o = json_tokener_parse(str);
 457     if (is_error(o))
 458         return -PA_ERR_INVALID;
 459
 460     if (json_object_get_type(o) != json_type_array)
 461         goto out;
 462
 463     *n_values = json_object_array_length(o);
 464     *values = pa_xnew(char *, *n_values);
 465
 466     for (i = 0; i < *n_values; i++) {
 467         o1 = json_object_array_get_idx(o, i);
 468
 469         if (json_object_get_type(o1) != json_type_string) {
 470             json_object_put(o1);
 471             goto out;
 472         }
 473
 474         (*values)[i] = pa_xstrdup(json_object_get_string(o1));
 475         json_object_put(o1);
 476     }
 477
 478     ret = 0;
 479
 480 out:
 481     json_object_put(o);
 482     return ret;
 483 }
 484
 485 void pa_format_info_free_string_array(char **values, int n_values) {
 486     int i;
 487
 488     for (i = 0; i < n_values; i++)
 489         pa_xfree(values[i]);
 490
 491     pa_xfree(values);
 492 }
 493
 494 void pa_format_info_set_prop_int(pa_format_info *f, const char *key, int value) {
 495     json_object *o;
 496
 497     pa_assert(f);
 498     pa_assert(key);
 499
 500     o = json_object_new_int(value);
 501
 502     pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
 503
 504     json_object_put(o);
 505 }
 506
 507 void pa_format_info_set_prop_int_array(pa_format_info *f, const char *key, const int *values, int n_values) {
 508     json_object *o;
 509     int i;
 510
 511     pa_assert(f);
 512     pa_assert(key);
 513
 514     o = json_object_new_array();
 515
 516     for (i = 0; i < n_values; i++)
 517         json_object_array_add(o, json_object_new_int(values[i]));
 518
 519     pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
 520
 521     json_object_put(o);
 522 }
 523
 524 void pa_format_info_set_prop_int_range(pa_format_info *f, const char *key, int min, int max) {
 525     json_object *o;
 526
 527     pa_assert(f);
 528     pa_assert(key);
 529
 530     o = json_object_new_object();
 531
 532     json_object_object_add(o, PA_JSON_MIN_KEY, json_object_new_int(min));
 533     json_object_object_add(o, PA_JSON_MAX_KEY, json_object_new_int(max));
 534
 535     pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
 536
 537     json_object_put(o);
 538 }
 539
 540 void pa_format_info_set_prop_string(pa_format_info *f, const char *key, const char *value) {
 541     json_object *o;
 542
 543     pa_assert(f);
 544     pa_assert(key);
 545
 546     o = json_object_new_string(value);
 547
 548     pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
 549
 550     json_object_put(o);
 551 }
 552
 553 void pa_format_info_set_prop_string_array(pa_format_info *f, const char *key, const char **values, int n_values) {
 554     json_object *o;
 555     int i;
 556
 557     pa_assert(f);
 558     pa_assert(key);
 559
 560     o = json_object_new_array();
 561
 562     for (i = 0; i < n_values; i++)
 563         json_object_array_add(o, json_object_new_string(values[i]));
 564
 565     pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
 566
 567     json_object_put(o);
 568 }
 569
 570 static pa_bool_t pa_json_is_fixed_type(json_object *o)
 571 {
 572     switch(json_object_get_type(o)) {
 573         case json_type_object:
 574         case json_type_array:
 575             return FALSE;
 576
 577         default:
 578             return TRUE;
 579     }
 580 }
 581
 582 static int pa_json_value_equal(json_object *o1, json_object *o2) {
 583     return (json_object_get_type(o1) == json_object_get_type(o2)) &&
 584         pa_streq(json_object_to_json_string(o1), json_object_to_json_string(o2));
 585 }
 586
 587 static int pa_format_info_prop_compatible(const char *one, const char *two) {
 588     json_object *o1 = NULL, *o2 = NULL;
 589     int i, ret = 0;
 590
 591     o1 = json_tokener_parse(one);
 592     if (is_error(o1))
 593         goto out;
 594
 595     o2 = json_tokener_parse(two);
 596     if (is_error(o2))
 597         goto out;
 598
 599     /* We don't deal with both values being non-fixed - just because there is no immediate need (FIXME) */
 600     pa_return_val_if_fail(pa_json_is_fixed_type(o1) || pa_json_is_fixed_type(o2), FALSE);
 601
 602     if (pa_json_is_fixed_type(o1) && pa_json_is_fixed_type(o2)) {
 603         ret = pa_json_value_equal(o1, o2);
 604         goto out;
 605     }
 606
 607     if (pa_json_is_fixed_type(o1)) {
 608         json_object *tmp = o2;
 609         o2 = o1;
 610         o1 = tmp;
 611     }
 612
 613     /* o2 is now a fixed type, and o1 is not */
 614
 615     if (json_object_get_type(o1) == json_type_array) {
 616         for (i = 0; i < json_object_array_length(o1); i++) {
 617             if (pa_json_value_equal(json_object_array_get_idx(o1, i), o2)) {
 618                 ret = 1;
 619                 break;
 620             }
 621         }
 622     } else if (json_object_get_type(o1) == json_type_object) {
 623         /* o1 should be a range type */
 624         int min, max, v;
 625         json_object *o_min = NULL, *o_max = NULL;
 626
 627         if (json_object_get_type(o2) != json_type_int) {
 628             /* We don't support non-integer ranges */
 629             goto out;
 630         }
 631
 632         o_min = json_object_object_get(o1, PA_JSON_MIN_KEY);
 633         if (!o_min || json_object_get_type(o_min) != json_type_int)
 634             goto out;
 635
 636         o_max = json_object_object_get(o1, PA_JSON_MAX_KEY);
 637         if (!o_max || json_object_get_type(o_max) != json_type_int)
 638             goto out;
 639
 640         v = json_object_get_int(o2);
 641         min = json_object_get_int(o_min);
 642         max = json_object_get_int(o_max);
 643
 644         ret = v >= min && v <= max;
 645     } else {
 646         pa_log_warn("Got a format type that we don't support");
 647     }
 648
 649 out:
 650     if (o1)
 651         json_object_put(o1);
 652     if (o2)
 653         json_object_put(o2);
 654
 655     return ret;
 656 }