source: roaraudio/plugins/mplayer/ao_roar.c @ 3095:b9abe0b8991f

//ao_roar.c:
/*
 * ao_roar - RoarAudio audio output driver for MPlayer
 *
 *      Juergen Keil <jk@tools.de>
 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008, 2009
 *
 * This driver is distributed under the terms of the GPL v. 2
 *
 */

#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <time.h>
#ifdef  __svr4__
#include <stropts.h>
#endif
#include <roaraudio.h>

#include "config.h"
#include "audio_out.h"
#include "audio_out_internal.h"
#include "libaf/af_format.h"
#include "mp_msg.h"
#include "help_mp.h"


#undef  ESD_DEBUG

#if     ESD_DEBUG
#define dprintf(...)    printf(__VA_ARGS__)
#else
#define dprintf(...)    /**/
#endif


#define ROAR_CLIENT_NAME        "MPlayer"

static struct roar_connection  roar_con;
static struct roar_stream      roar_stream;
static struct roar_stream_info roar_info;
static int                     roar_fh;

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

LIBAO_EXTERN(roar)

/*
 * to set/get/query special features/parameters
 */
static int control(int cmd, void *arg)
{
    switch (cmd) {
    case AOCONTROL_GET_VOLUME:
    case AOCONTROL_SET_VOLUME:
      return CONTROL_OK;
    default:
      return CONTROL_UNKNOWN;
    }
}


/*
 * open & setup audio device
 * return: 1=success 0=fail
 */
static int init(int rate_hz, int channels, int format, int flags) {
 int codec = ROAR_CODEC_DEFAULT;
 int bits  = 16;

 if ( roar_simple_connect(&roar_con, NULL, ROAR_CLIENT_NAME) == -1 )
  return 0;

 switch (format) {
  case AF_FORMAT_S8:
   bits = 8;
   break;
  case AF_FORMAT_U8:
   bits  = 8;
   codec = ROAR_CODEC_PCM_U_LE;
   break;
 }

 if ( (roar_fh = roar_simple_new_stream_obj(&roar_con, &roar_stream, rate_hz, channels, bits, codec, ROAR_DIR_PLAY)) == -1 )
  return 0;

 if ( roar_stream_get_info(&roar_con, &roar_stream, &roar_info) == -1 ) {
  close(roar_fh);
  return 0;
 }

 roar_socket_nonblock(roar_fh, ROAR_SOCKET_NONBLOCK);

 return 1;
}


/*
 * close audio device
 */
static void uninit(int immed) {
 if ( roar_fh != -1 )
  close(roar_fh);

 roar_fh = -1;

 roar_disconnect(&roar_con);
}


/*
 * plays 'len' bytes of 'data'
 * it should round it down to outburst*n
 * return: number of bytes played
 */
static int play(void* data, int len, int flags) {
 int pkg  = 441*2*2;
 int ret  = 0;
 int r;

 while (len > 0) {
  if ( (r = write(roar_fh, data, pkg < len ? pkg : len)) > 0 ) {
   len  -= r;
   data += r;
   ret  += r;
  } else {
   break;
  }
 }

// ROAR_WARN("play(*) = %i", ret);

 return ret;
}


/*
 * stop playing, keep buffers (for pause)
 */
static void audio_pause(void)
{
    /*
     * not possible with esd.  the esd daemom will continue playing
     * buffered data (not more than ESD_MAX_DELAY seconds of samples)
     */
}


/*
 * resume playing, after audio_pause()
 */
static void audio_resume(void)
{
    /*
     * not possible with esd.
     *
     * Let's hope the pause was long enough that the esd ran out of
     * buffered data;  we restart our time based delay computation
     * for an audio resume.
     */
}


/*
 * stop playing and empty buffers (for seeking/pause)
 */
static void reset(void) {
}


/*
 * return: how many bytes can be played without blocking
 */
static int get_space(void) {
 fd_set sl;
 struct timeval tv;
 int r;

 FD_ZERO(&sl);
 FD_SET(roar_fh, &sl);

 tv.tv_sec  = 0;
 tv.tv_usec = 1;

 if ((r = select(roar_fh + 1, NULL, &sl, NULL, &tv)) > 0) {
  return roar_info.block_size;
 }
 return 0;
}


/*
 * return: delay in seconds between first and last sample in buffer
 */
static float get_delay(void) {
 return 0.02;
}