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