libao2/audio_out.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <assert.h>
  23
  24 #include "talloc.h"
  25
  26 #include "config.h"
  27 #include "audio_out.h"
  28
  29 #include "mp_msg.h"
  30
  31 // there are some globals:
  32 struct ao *global_ao;
  33 char *ao_subdevice = NULL;
  34
  35 extern const struct ao_driver audio_out_oss;
  36 extern const struct ao_driver audio_out_coreaudio;
  37 extern const struct ao_driver audio_out_arts;
  38 extern const struct ao_driver audio_out_esd;
  39 extern const struct ao_driver audio_out_pulse;
  40 extern const struct ao_driver audio_out_jack;
  41 extern const struct ao_driver audio_out_openal;
  42 extern const struct ao_driver audio_out_null;
  43 extern const struct ao_driver audio_out_alsa5;
  44 extern const struct ao_driver audio_out_alsa;
  45 extern const struct ao_driver audio_out_nas;
  46 extern const struct ao_driver audio_out_sdl;
  47 extern const struct ao_driver audio_out_sun;
  48 extern const struct ao_driver audio_out_sgi;
  49 extern const struct ao_driver audio_out_win32;
  50 extern const struct ao_driver audio_out_dsound;
  51 extern const struct ao_driver audio_out_kai;
  52 extern const struct ao_driver audio_out_dart;
  53 extern const struct ao_driver audio_out_ivtv;
  54 extern const struct ao_driver audio_out_v4l2;
  55 extern const struct ao_driver audio_out_mpegpes;
  56 extern const struct ao_driver audio_out_pcm;
  57 extern const struct ao_driver audio_out_pss;
  58
  59 static const struct ao_driver * const audio_out_drivers[] = {
  60 // native:
  61 #ifdef CONFIG_DIRECTX
  62     &audio_out_dsound,
  63 #endif
  64 #ifdef CONFIG_WIN32WAVEOUT
  65     &audio_out_win32,
  66 #endif
  67 #ifdef CONFIG_KAI
  68     &audio_out_kai,
  69 #endif
  70 #ifdef CONFIG_DART
  71     &audio_out_dart,
  72 #endif
  73 #ifdef CONFIG_COREAUDIO
  74     &audio_out_coreaudio,
  75 #endif
  76 #ifdef CONFIG_OSS_AUDIO
  77     &audio_out_oss,
  78 #endif
  79 #ifdef CONFIG_ALSA
  80     &audio_out_alsa,
  81 #endif
  82 #ifdef CONFIG_ALSA5
  83     &audio_out_alsa5,
  84 #endif
  85 #ifdef CONFIG_SGI_AUDIO
  86     &audio_out_sgi,
  87 #endif
  88 #ifdef CONFIG_SUN_AUDIO
  89     &audio_out_sun,
  90 #endif
  91     // wrappers:
  92 #ifdef CONFIG_ARTS
  93     &audio_out_arts,
  94 #endif
  95 #ifdef CONFIG_ESD
  96     &audio_out_esd,
  97 #endif
  98 #ifdef CONFIG_PULSE
  99     &audio_out_pulse,
 100 #endif
 101 #ifdef CONFIG_JACK
 102     &audio_out_jack,
 103 #endif
 104 #ifdef CONFIG_NAS
 105     &audio_out_nas,
 106 #endif
 107 #ifdef CONFIG_SDL
 108     &audio_out_sdl,
 109 #endif
 110 #ifdef CONFIG_OPENAL
 111     &audio_out_openal,
 112 #endif
 113     &audio_out_mpegpes,
 114 #ifdef CONFIG_IVTV
 115     &audio_out_ivtv,
 116 #endif
 117 #ifdef CONFIG_V4L2_DECODER
 118     &audio_out_v4l2,
 119 #endif
 120     &audio_out_null,
 121     // should not be auto-selected:
 122     &audio_out_pcm,
 123     NULL
 124 };
 125
 126 void list_audio_out(void)
 127 {
 128     int i=0;
 129     mp_tmsg(MSGT_AO, MSGL_INFO, "Available audio output drivers:\n");
 130     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_OUTPUTS\n");
 131     while (audio_out_drivers[i]) {
 132         const ao_info_t *info = audio_out_drivers[i++]->info;
 133         mp_msg(MSGT_GLOBAL, MSGL_INFO, "\t%s\t%s\n", info->short_name,
 134                info->name);
 135     }
 136     mp_msg(MSGT_GLOBAL, MSGL_INFO,"\n");
 137 }
 138
 139 struct ao *ao_create(void)
 140 {
 141     struct ao *r = talloc(NULL, struct ao);
 142     *r = (struct ao){.outburst = OUTBURST, .buffersize = -1};
 143     return r;
 144 }
 145
 146 void ao_init(struct ao *ao, char **ao_list)
 147 {
 148     /* Caller adding child blocks is not supported as we may call
 149      * talloc_free_children() to clean up after failed open attempts.
 150      */
 151     assert(talloc_total_blocks(ao) == 1);
 152     struct ao backup = *ao;
 153
 154     if (!ao_list)
 155         goto try_defaults;
 156
 157     // first try the preferred drivers, with their optional subdevice param:
 158     while (*ao_list) {
 159         char *ao_name = *ao_list;
 160         if (!*ao_name)
 161             goto try_defaults; // empty entry means try defaults
 162         int ao_len;
 163         char *params = strchr(ao_name, ':');
 164         if (params) {
 165             ao_len = params - ao_name;
 166             params++;
 167         } else
 168             ao_len = strlen(ao_name);
 169
 170         mp_tmsg(MSGT_AO, MSGL_V,
 171                 "Trying preferred audio driver '%.*s', options '%s'\n",
 172                 ao_len, ao_name, params ? params : "[none]");
 173
 174         const struct ao_driver *audio_out = NULL;
 175         for (int i = 0; audio_out_drivers[i]; i++) {
 176             audio_out = audio_out_drivers[i];
 177             if (!strncmp(audio_out->info->short_name, ao_name, ao_len))
 178                 break;
 179             audio_out = NULL;
 180         }
 181         if (audio_out) {
 182             // name matches, try it
 183             ao->driver = audio_out;
 184             if (audio_out->init(ao, params) >= 0) {
 185                 ao->driver = audio_out;
 186                 ao->initialized = true;
 187                 return;
 188             }
 189             mp_tmsg(MSGT_AO, MSGL_WARN,
 190                     "Failed to initialize audio driver '%s'\n", ao_name);
 191             talloc_free_children(ao);
 192             *ao = backup;
 193         } else
 194             mp_tmsg(MSGT_AO, MSGL_WARN, "No such audio driver '%.*s'\n",
 195                     ao_len, ao_name);
 196         ++ao_list;
 197     }
 198     return;
 199
 200  try_defaults:
 201     mp_tmsg(MSGT_AO, MSGL_V, "Trying every known audio driver...\n");
 202
 203     // now try the rest...
 204     for (int i = 0; audio_out_drivers[i]; i++) {
 205         const struct ao_driver *audio_out = audio_out_drivers[i];
 206         ao->driver = audio_out;
 207         if (audio_out->init(ao, NULL) >= 0) {
 208             ao->initialized = true;
 209             ao->driver = audio_out;
 210             return;
 211         }
 212         talloc_free_children(ao);
 213         *ao = backup;
 214     }
 215     return;
 216 }
 217
 218 void ao_uninit(struct ao *ao, bool cut_audio)
 219 {
 220     if (ao->initialized)
 221         ao->driver->uninit(ao, cut_audio);
 222     talloc_free(ao);
 223 }
 224
 225 int ao_play(struct ao *ao, void *data, int len, int flags)
 226 {
 227     return ao->driver->play(ao, data, len, flags);
 228 }
 229
 230 int ao_control(struct ao *ao, int cmd, void *arg)
 231 {
 232     if (ao->driver->control)
 233         return ao->driver->control(ao, cmd, arg);
 234     return CONTROL_UNKNOWN;
 235 }
 236
 237 double ao_get_delay(struct ao *ao)
 238 {
 239     if (!ao->driver->get_delay) {
 240         assert(ao->untimed);
 241         return 0;
 242     }
 243     return ao->driver->get_delay(ao);
 244 }
 245
 246 int ao_get_space(struct ao *ao)
 247 {
 248     return ao->driver->get_space(ao);
 249 }
 250
 251 void ao_reset(struct ao *ao)
 252 {
 253     if (ao->driver->reset)
 254         ao->driver->reset(ao);
 255 }
 256
 257 void ao_pause(struct ao *ao)
 258 {
 259     if (ao->driver->pause)
 260         ao->driver->pause(ao);
 261 }
 262
 263 void ao_resume(struct ao *ao)
 264 {
 265     if (ao->driver->resume)
 266         ao->driver->resume(ao);
 267 }
 268
 269
 270
 271 int old_ao_init(struct ao *ao, char *params)
 272 {
 273     assert(!global_ao);
 274     global_ao = ao;
 275     ao_subdevice = params ? talloc_strdup(ao, params) : NULL;
 276     if (ao->driver->old_functions->init(ao->samplerate, ao->channels,
 277                                         ao->format, 0) == 0)
 278         return -1;
 279     return 0;
 280 }
 281
 282 void old_ao_uninit(struct ao *ao, bool cut_audio)
 283 {
 284     ao->driver->old_functions->uninit(cut_audio);
 285     global_ao = NULL;
 286 }
 287
 288 int old_ao_play(struct ao *ao, void *data, int len, int flags)
 289 {
 290     return ao->driver->old_functions->play(data, len, flags);
 291 }
 292
 293 int old_ao_control(struct ao *ao, int cmd, void *arg)
 294 {
 295     return ao->driver->old_functions->control(cmd, arg);
 296 }
 297
 298 float old_ao_get_delay(struct ao *ao)
 299 {
 300     return ao->driver->old_functions->get_delay();
 301 }
 302
 303 int old_ao_get_space(struct ao *ao)
 304 {
 305     return ao->driver->old_functions->get_space();
 306 }
 307
 308 void old_ao_reset(struct ao *ao)
 309 {
 310     ao->driver->old_functions->reset();
 311 }
 312
 313 void old_ao_pause(struct ao *ao)
 314 {
 315     ao->driver->old_functions->pause();
 316 }
 317
 318 void old_ao_resume(struct ao *ao)
 319 {
 320     ao->driver->old_functions->resume();
 321 }