Ticket #76: ao_roar.2.c

//ao_roar.c:
/*
 * ao_roar - RoarAudio audio output driver for MPlayer
 *
 * copyright (c) 2002 Juergen Keil <jk@tools.de>
 * copyright (c) 2008-2010 Philipp 'ph3-der-loewe' Schafft
 * copyright (c) 2010 Hans-Kristian 'maister' Arntzen
 *
 * This file is part of MPlayer.
 *
 * MPlayer is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MPlayer is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */


#include "config.h"

#include <stdlib.h>
#include <string.h>

#include "libavutil/common.h"
#include "mpbswap.h"
#include "subopt-helper.h"
#include "libaf/af_format.h"
#include "libaf/reorder_ch.h"
#include "audio_out.h"
#include "audio_out_internal.h"
#include "mp_msg.h"
#include "help_mp.h"
#include <assert.h>

#include <roaraudio.h>


static const ao_info_t info =
{
   "RoarAudio audio output",
   "roar",
   "Philipp 'ph3-der-loewe' Schafft <lion@lion.leolix.org>, Hans-Kristian Arntzen",
   ""
};

LIBAO_EXTERN(roar)

static char *host = NULL;
static char *role = NULL;
static roar_vs_t * vss = NULL;
static int err = ROAR_ERROR_NONE;
static const size_t g_buffer_size = (1 << 15);

static int format2codecbits (int format, int * codec_p, int * bits_p) {
   int codec = -1;
   int bits  = -1;

   if ( (format & AF_FORMAT_POINT_MASK) != AF_FORMAT_I && (format & AF_FORMAT_POINT_MASK) != 0 )
      return -1;

   switch (format & (AF_FORMAT_BITS_MASK|AF_FORMAT_SPECIAL_MASK)) {
    case AF_FORMAT_8BIT:
    case AF_FORMAT_A_LAW:
    case AF_FORMAT_MU_LAW:
      bits = 8;
     break;
    case AF_FORMAT_16BIT: bits = 16; break;
    case AF_FORMAT_24BIT: bits = 24; break;
    case AF_FORMAT_32BIT: bits = 32; break;
    case AF_FORMAT_40BIT: bits = 40; break;
    case AF_FORMAT_48BIT: bits = 48; break;
    default:
      return -1;
   }

   switch (format & AF_FORMAT_SPECIAL_MASK) {
    case 0:
      codec = 0;
     break;
    case AF_FORMAT_A_LAW:
      codec = ROAR_CODEC_ALAW;
     break;
    case AF_FORMAT_MU_LAW:
      codec = ROAR_CODEC_MULAW;
     break;
    default:
      return -1;
   }

   if ( codec == 0 ) {
    codec = ROAR_CODEC_PCM;

    switch (format & AF_FORMAT_END_MASK) {
     case AF_FORMAT_BE: codec |= ROAR_CODEC_BE; break;
     case AF_FORMAT_LE: codec |= ROAR_CODEC_LE; break;
     default:
       return -1;
    }
    switch (format & AF_FORMAT_SIGN_MASK) {
     case AF_FORMAT_SI: codec |= 0 /* no specal const here */; break;
     case AF_FORMAT_US: codec |= ROAR_CODEC_UNSIGNED; break;
     default:
       return -1;
    }
   }

   if ( codec_p != NULL )
      *codec_p = codec;
   if ( bits_p != NULL )
      *bits_p  = bits;

   return 0;
}

static int control(int cmd, void *arg)
{
    ao_control_vol_t * vol;

    switch (cmd) {
    case AOCONTROL_QUERY_FORMAT:
      if ( format2codecbits((int)arg, NULL, NULL) == 0 )
        return CONTROL_TRUE;
      return CONTROL_FALSE;
    case AOCONTROL_GET_VOLUME:
      vol = arg;
      if ( roar_vs_volume_get(vss, &(vol->left), &(vol->right), &err) == -1 )
         return CONTROL_ERROR;

      vol->left  *= 100.;
      vol->right *= 100.;

      return CONTROL_OK;
    case AOCONTROL_SET_VOLUME:
      vol = arg;

      if ( roar_vs_volume_stereo(vss, vol->left / 100., vol->right / 100., &err) == -1 )
         return CONTROL_ERROR;
      return CONTROL_OK;

    default:
      return CONTROL_UNKNOWN;
    }
}

static int init(int rate, int channels, int format, int flags)
{
   int bufsize = g_buffer_size;
   int codec;
   int bits;
   int roleid = ROAR_ROLE_UNKNOWN;
   const opt_t subopts[] = {
      {"host", OPT_ARG_MSTRZ, &host, NULL},
      {"role", OPT_ARG_MSTRZ, &role, NULL},
      {NULL}
   };

   if ( host != NULL )
      free(host);

   if ( role != NULL )
      free(role);

   // Parses commandline
   if (subopt_parse(ao_subdevice, subopts) != 0) {
      return 0;
   }


   if ( role != NULL ) {
      roleid = roar_str2role(role);
      if ( roleid == ROAR_ROLE_UNKNOWN )
         return 0;
   }

   ao_data.format = format;

   if ( format2codecbits(format, &codec, &bits) == -1 ) {
      ao_data.format = AF_FORMAT_S16_LE;
      codec = ROAR_CODEC_PCM_S_LE;
      bits  = 16;
   }

   vss = roar_vs_new_simple(host, "MPlayer", rate, channels, codec, bits, ROAR_DIR_PLAY, &err);

   if ( vss == NULL )
      return 0;

   if ( roleid != ROAR_ROLE_UNKNOWN ) {
      if ( roar_vs_role(vss, roleid, &err) == -1 ) {
         roar_vs_close(vss, ROAR_VS_TRUE, NULL);
         vss = NULL;
         return 0;
      }
   }

   if ( roar_vs_buffer(vss, bufsize, &err) == -1 ) {
      roar_vs_close(vss, ROAR_VS_TRUE, NULL);
      vss = NULL;
      return 0;
   }

   // We need non-blocking operation here due to MPlayers buffering scheme.
   if ( roar_vs_blocking(vss, ROAR_VS_FALSE, &err) == -1 ) {
      roar_vs_close(vss, ROAR_VS_TRUE, NULL);
      vss = NULL;
      return 0;
   }

   ao_data.channels = channels;
   ao_data.samplerate = rate;
   ao_data.bps = (channels*rate*bits)/8;

   ao_data.outburst = bufsize >> 5;
   ao_data.buffersize = bufsize;
   
   return 1;
}

static void uninit(int n)
{
   roar_vs_close(vss, ROAR_VS_FALSE, &err);
   vss = NULL;
}

// Reset our buffer. :)
static void reset(void)
{
   roar_vs_reset_buffer(vss, ROAR_VS_TRUE, ROAR_VS_TRUE, &err);
}

static void audio_pause(void)
{
   roar_vs_pause(vss, ROAR_VS_TRUE, &err);
}

static void audio_resume(void)
{
   roar_vs_pause(vss, ROAR_VS_FALSE, &err);
}

// Returns space we are guaranteed to be able to write in a non-blocking fashion.
static int get_space(void)
{
   // Temporary hack while waiting for a proper non-blocking roar_vs_iterate.
   // roar_vs_iterate will keep returning 1 even if non-blocking write couldn't write anything.
   int size;
   int cnt = 0;
   while (roar_vs_iterate(vss, ROAR_VS_NOWAIT, &err) > 0 && ++cnt < 16);

   size = roar_vs_get_avail_write(vss, &err);

   // Round down to nearest multiple of outburst.
   size &= ~(ao_data.outburst - 1);
   return size;
}

static int play(void* data, int len, int flags)
{
   // MPlayer doesn't seem to care about errors here, so just assume everything works out.
   roar_vs_write(vss, data, len, &err);
   return len;
}

static float roar_latency(void)
{
   float latency = roar_vs_latency(vss, ROAR_VS_BACKEND_FIRST, &err) / 1000000.0;
   return latency;
}

// Return audio latency in seconds.
static float get_delay(void)
{
   // Same hack
   int cnt = 0;
   while (roar_vs_iterate(vss, ROAR_VS_NOWAIT, &err) > 0 && ++cnt < 16);

   return roar_latency();
}