src/pulsecore/core-scache.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2008 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <sys/types.h>
  30 #include <dirent.h>
  31 #include <sys/stat.h>
  32 #include <errno.h>
  33 #include <limits.h>
  34 #include <time.h>
  35
  36 #ifdef HAVE_GLOB_H
  37 #include <glob.h>
  38 #endif
  39
  40 #ifdef HAVE_WINDOWS_H
  41 #include <windows.h>
  42 #endif
  43
  44 #include <pulse/mainloop.h>
  45 #include <pulse/channelmap.h>
  46 #include <pulse/timeval.h>
  47 #include <pulse/util.h>
  48 #include <pulse/volume.h>
  49 #include <pulse/xmalloc.h>
  50 #include <pulse/rtclock.h>
  51
  52 #include <pulsecore/sink-input.h>
  53 #include <pulsecore/play-memchunk.h>
  54 #include <pulsecore/core-subscribe.h>
  55 #include <pulsecore/namereg.h>
  56 #include <pulsecore/sound-file.h>
  57 #include <pulsecore/core-rtclock.h>
  58 #include <pulsecore/core-util.h>
  59 #include <pulsecore/log.h>
  60 #include <pulsecore/core-error.h>
  61 #include <pulsecore/macro.h>
  62
  63 #include "core-scache.h"
  64
  65 #define UNLOAD_POLL_TIME (60 * PA_USEC_PER_SEC)
  66
  67 static void timeout_callback(pa_mainloop_api *m, pa_time_event *e, const struct timeval *t, void *userdata) {
  68     pa_core *c = userdata;
  69
  70     pa_assert(c);
  71     pa_assert(c->mainloop == m);
  72     pa_assert(c->scache_auto_unload_event == e);
  73
  74     pa_scache_unload_unused(c);
  75
  76     pa_core_rttime_restart(c, e, pa_rtclock_now() + UNLOAD_POLL_TIME);
  77 }
  78
  79 static void free_entry(pa_scache_entry *e) {
  80     pa_assert(e);
  81
  82     pa_namereg_unregister(e->core, e->name);
  83     pa_subscription_post(e->core, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_REMOVE, e->index);
  84     pa_xfree(e->name);
  85     pa_xfree(e->filename);
  86     if (e->memchunk.memblock)
  87         pa_memblock_unref(e->memchunk.memblock);
  88     if (e->proplist)
  89         pa_proplist_free(e->proplist);
  90     pa_xfree(e);
  91 }
  92
  93 static pa_scache_entry* scache_add_item(pa_core *c, const char *name) {
  94     pa_scache_entry *e;
  95
  96     pa_assert(c);
  97     pa_assert(name);
  98
  99     if ((e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE))) {
 100         if (e->memchunk.memblock)
 101             pa_memblock_unref(e->memchunk.memblock);
 102
 103         pa_xfree(e->filename);
 104         pa_proplist_clear(e->proplist);
 105
 106         pa_assert(e->core == c);
 107
 108         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
 109     } else {
 110         e = pa_xnew(pa_scache_entry, 1);
 111
 112         if (!pa_namereg_register(c, name, PA_NAMEREG_SAMPLE, e, TRUE)) {
 113             pa_xfree(e);
 114             return NULL;
 115         }
 116
 117         e->name = pa_xstrdup(name);
 118         e->core = c;
 119         e->proplist = pa_proplist_new();
 120
 121         pa_idxset_put(c->scache, e, &e->index);
 122
 123         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_NEW, e->index);
 124     }
 125
 126     e->last_used_time = 0;
 127     pa_memchunk_reset(&e->memchunk);
 128     e->filename = NULL;
 129     e->lazy = FALSE;
 130     e->last_used_time = 0;
 131
 132     pa_sample_spec_init(&e->sample_spec);
 133     pa_channel_map_init(&e->channel_map);
 134     pa_cvolume_init(&e->volume);
 135     e->volume_is_set = FALSE;
 136
 137     pa_proplist_sets(e->proplist, PA_PROP_MEDIA_ROLE, "event");
 138
 139     return e;
 140 }
 141
 142 int pa_scache_add_item(
 143         pa_core *c,
 144         const char *name,
 145         const pa_sample_spec *ss,
 146         const pa_channel_map *map,
 147         const pa_memchunk *chunk,
 148         pa_proplist *p,
 149         uint32_t *idx) {
 150
 151     pa_scache_entry *e;
 152     char st[PA_SAMPLE_SPEC_SNPRINT_MAX];
 153     pa_channel_map tmap;
 154
 155     pa_assert(c);
 156     pa_assert(name);
 157     pa_assert(!ss || pa_sample_spec_valid(ss));
 158     pa_assert(!map || (pa_channel_map_valid(map) && ss && pa_channel_map_compatible(map, ss)));
 159
 160     if (ss && !map) {
 161         pa_channel_map_init_extend(&tmap, ss->channels, PA_CHANNEL_MAP_DEFAULT);
 162         map = &tmap;
 163     }
 164
 165     if (chunk && chunk->length > PA_SCACHE_ENTRY_SIZE_MAX)
 166         return -1;
 167
 168     if (!(e = scache_add_item(c, name)))
 169         return -1;
 170
 171     pa_sample_spec_init(&e->sample_spec);
 172     pa_channel_map_init(&e->channel_map);
 173     pa_cvolume_init(&e->volume);
 174     e->volume_is_set = FALSE;
 175
 176     if (ss) {
 177         e->sample_spec = *ss;
 178         pa_cvolume_reset(&e->volume, ss->channels);
 179     }
 180
 181     if (map)
 182         e->channel_map = *map;
 183
 184     if (chunk) {
 185         e->memchunk = *chunk;
 186         pa_memblock_ref(e->memchunk.memblock);
 187     }
 188
 189     if (p)
 190         pa_proplist_update(e->proplist, PA_UPDATE_REPLACE, p);
 191
 192     if (idx)
 193         *idx = e->index;
 194
 195     pa_log_debug("Created sample \"%s\" (#%d), %lu bytes with sample spec %s",
 196                  name, e->index, (unsigned long) e->memchunk.length,
 197                  pa_sample_spec_snprint(st, sizeof(st), &e->sample_spec));
 198
 199     return 0;
 200 }
 201
 202 int pa_scache_add_file(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
 203     pa_sample_spec ss;
 204     pa_channel_map map;
 205     pa_memchunk chunk;
 206     int r;
 207     pa_proplist *p;
 208
 209 #ifdef OS_IS_WIN32
 210     char buf[MAX_PATH];
 211
 212     if (ExpandEnvironmentStrings(filename, buf, MAX_PATH))
 213         filename = buf;
 214 #endif
 215
 216     pa_assert(c);
 217     pa_assert(name);
 218     pa_assert(filename);
 219
 220     p = pa_proplist_new();
 221     pa_proplist_sets(p, PA_PROP_MEDIA_FILENAME, filename);
 222
 223     if (pa_sound_file_load(c->mempool, filename, &ss, &map, &chunk, p) < 0) {
 224         pa_proplist_free(p);
 225         return -1;
 226     }
 227
 228     r = pa_scache_add_item(c, name, &ss, &map, &chunk, p, idx);
 229     pa_memblock_unref(chunk.memblock);
 230     pa_proplist_free(p);
 231
 232     return r;
 233 }
 234
 235 int pa_scache_add_file_lazy(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
 236     pa_scache_entry *e;
 237
 238 #ifdef OS_IS_WIN32
 239     char buf[MAX_PATH];
 240
 241     if (ExpandEnvironmentStrings(filename, buf, MAX_PATH))
 242         filename = buf;
 243 #endif
 244
 245     pa_assert(c);
 246     pa_assert(name);
 247     pa_assert(filename);
 248
 249     if (!(e = scache_add_item(c, name)))
 250         return -1;
 251
 252     e->lazy = TRUE;
 253     e->filename = pa_xstrdup(filename);
 254
 255     pa_proplist_sets(e->proplist, PA_PROP_MEDIA_FILENAME, filename);
 256
 257     if (!c->scache_auto_unload_event)
 258         c->scache_auto_unload_event = pa_core_rttime_new(c, pa_rtclock_now() + UNLOAD_POLL_TIME, timeout_callback, c);
 259
 260     if (idx)
 261         *idx = e->index;
 262
 263     return 0;
 264 }
 265
 266 int pa_scache_remove_item(pa_core *c, const char *name) {
 267     pa_scache_entry *e;
 268
 269     pa_assert(c);
 270     pa_assert(name);
 271
 272     if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE)))
 273         return -1;
 274
 275     pa_assert_se(pa_idxset_remove_by_data(c->scache, e, NULL) == e);
 276
 277     pa_log_debug("Removed sample \"%s\"", name);
 278
 279     free_entry(e);
 280
 281     return 0;
 282 }
 283
 284 void pa_scache_free_all(pa_core *c) {
 285     pa_scache_entry *e;
 286
 287     pa_assert(c);
 288
 289     while ((e = pa_idxset_steal_first(c->scache, NULL)))
 290         free_entry(e);
 291
 292     if (c->scache_auto_unload_event) {
 293         c->mainloop->time_free(c->scache_auto_unload_event);
 294         c->scache_auto_unload_event = NULL;
 295     }
 296 }
 297
 298 int pa_scache_play_item(pa_core *c, const char *name, pa_sink *sink, pa_volume_t volume, pa_proplist *p, uint32_t *sink_input_idx) {
 299     pa_scache_entry *e;
 300     pa_cvolume r;
 301     pa_proplist *merged;
 302     pa_bool_t pass_volume;
 303
 304     pa_assert(c);
 305     pa_assert(name);
 306     pa_assert(sink);
 307
 308     if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE)))
 309         return -1;
 310
 311     merged = pa_proplist_new();
 312     pa_proplist_sets(merged, PA_PROP_MEDIA_NAME, name);
 313     pa_proplist_sets(merged, PA_PROP_EVENT_ID, name);
 314
 315     if (e->lazy && !e->memchunk.memblock) {
 316         pa_channel_map old_channel_map = e->channel_map;
 317
 318         if (pa_sound_file_load(c->mempool, e->filename, &e->sample_spec, &e->channel_map, &e->memchunk, merged) < 0)
 319             goto fail;
 320
 321         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
 322
 323         if (e->volume_is_set) {
 324             if (pa_cvolume_valid(&e->volume))
 325                 pa_cvolume_remap(&e->volume, &old_channel_map, &e->channel_map);
 326             else
 327                 pa_cvolume_reset(&e->volume, e->sample_spec.channels);
 328         }
 329     }
 330
 331     if (!e->memchunk.memblock)
 332         goto fail;
 333
 334     pa_log_debug("Playing sample \"%s\" on \"%s\"", name, sink->name);
 335
 336     pass_volume = TRUE;
 337
 338     if (e->volume_is_set && PA_VOLUME_IS_VALID(volume)) {
 339         pa_cvolume_set(&r, e->sample_spec.channels, volume);
 340         pa_sw_cvolume_multiply(&r, &r, &e->volume);
 341     } else if (e->volume_is_set)
 342         r = e->volume;
 343     else if (PA_VOLUME_IS_VALID(volume))
 344         pa_cvolume_set(&r, e->sample_spec.channels, volume);
 345     else
 346         pass_volume = FALSE;
 347
 348     pa_proplist_update(merged, PA_UPDATE_REPLACE, e->proplist);
 349
 350     if (p)
 351         pa_proplist_update(merged, PA_UPDATE_REPLACE, p);
 352
 353     if (pa_play_memchunk(sink,
 354                          &e->sample_spec, &e->channel_map,
 355                          &e->memchunk,
 356                          pass_volume ? &r : NULL,
 357                          merged,
 358                          PA_SINK_INPUT_NO_CREATE_ON_SUSPEND|PA_SINK_INPUT_KILL_ON_SUSPEND, sink_input_idx) < 0)
 359         goto fail;
 360
 361     pa_proplist_free(merged);
 362
 363     if (e->lazy)
 364         time(&e->last_used_time);
 365
 366     return 0;
 367
 368 fail:
 369     pa_proplist_free(merged);
 370     return -1;
 371 }
 372
 373 int pa_scache_play_item_by_name(pa_core *c, const char *name, const char*sink_name, pa_volume_t volume, pa_proplist *p, uint32_t *sink_input_idx) {
 374     pa_sink *sink;
 375
 376     pa_assert(c);
 377     pa_assert(name);
 378
 379     if (!(sink = pa_namereg_get(c, sink_name, PA_NAMEREG_SINK)))
 380         return -1;
 381
 382     return pa_scache_play_item(c, name, sink, volume, p, sink_input_idx);
 383 }
 384
 385 const char *pa_scache_get_name_by_id(pa_core *c, uint32_t id) {
 386     pa_scache_entry *e;
 387
 388     pa_assert(c);
 389     pa_assert(id != PA_IDXSET_INVALID);
 390
 391     if (!c->scache || !(e = pa_idxset_get_by_index(c->scache, id)))
 392         return NULL;
 393
 394     return e->name;
 395 }
 396
 397 uint32_t pa_scache_get_id_by_name(pa_core *c, const char *name) {
 398     pa_scache_entry *e;
 399
 400     pa_assert(c);
 401     pa_assert(name);
 402
 403     if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE)))
 404         return PA_IDXSET_INVALID;
 405
 406     return e->index;
 407 }
 408
 409 size_t pa_scache_total_size(pa_core *c) {
 410     pa_scache_entry *e;
 411     uint32_t idx;
 412     size_t sum = 0;
 413
 414     pa_assert(c);
 415
 416     if (!c->scache || !pa_idxset_size(c->scache))
 417         return 0;
 418
 419     for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx))
 420         if (e->memchunk.memblock)
 421             sum += e->memchunk.length;
 422
 423     return sum;
 424 }
 425
 426 void pa_scache_unload_unused(pa_core *c) {
 427     pa_scache_entry *e;
 428     time_t now;
 429     uint32_t idx;
 430
 431     pa_assert(c);
 432
 433     if (!c->scache || !pa_idxset_size(c->scache))
 434         return;
 435
 436     time(&now);
 437
 438     for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx)) {
 439
 440         if (!e->lazy || !e->memchunk.memblock)
 441             continue;
 442
 443         if (e->last_used_time + c->scache_idle_time > now)
 444             continue;
 445
 446         pa_memblock_unref(e->memchunk.memblock);
 447         pa_memchunk_reset(&e->memchunk);
 448
 449         pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
 450     }
 451 }
 452
 453 static void add_file(pa_core *c, const char *pathname) {
 454     struct stat st;
 455     const char *e;
 456
 457     pa_core_assert_ref(c);
 458     pa_assert(pathname);
 459
 460     e = pa_path_get_filename(pathname);
 461
 462     if (stat(pathname, &st) < 0) {
 463         pa_log("stat('%s'): %s", pathname, pa_cstrerror(errno));
 464         return;
 465     }
 466
 467 #if defined(S_ISREG) && defined(S_ISLNK)
 468     if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
 469 #endif
 470         pa_scache_add_file_lazy(c, e, pathname, NULL);
 471 }
 472
 473 int pa_scache_add_directory_lazy(pa_core *c, const char *pathname) {
 474     DIR *dir;
 475
 476     pa_core_assert_ref(c);
 477     pa_assert(pathname);
 478
 479     /* First try to open this as directory */
 480     if (!(dir = opendir(pathname))) {
 481 #ifdef HAVE_GLOB_H
 482         glob_t p;
 483         unsigned int i;
 484         /* If that fails, try to open it as shell glob */
 485
 486         if (glob(pathname, GLOB_ERR|GLOB_NOSORT, NULL, &p) < 0) {
 487             pa_log("failed to open directory '%s': %s", pathname, pa_cstrerror(errno));
 488             return -1;
 489         }
 490
 491         for (i = 0; i < p.gl_pathc; i++)
 492             add_file(c, p.gl_pathv[i]);
 493
 494         globfree(&p);
 495 #else
 496         return -1;
 497 #endif
 498     } else {
 499         struct dirent *e;
 500
 501         while ((e = readdir(dir))) {
 502             char *p;
 503
 504             if (e->d_name[0] == '.')
 505                 continue;
 506
 507             p = pa_sprintf_malloc("%s" PA_PATH_SEP "%s", pathname, e->d_name);
 508             add_file(c, p);
 509             pa_xfree(p);
 510         }
 511
 512         closedir(dir);
 513     }
 514
 515     return 0;
 516 }