Ticket #80: roar_plugin.c

//roar_plugin.c:
/*
 * Copyright (C) 2003-2010 The Music Player Daemon Project
 * copyright (c) 2010 Philipp 'ph3-der-loewe' Schafft
 * copyright (c) 2010 Hans-Kristian 'maister' Arntzen
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "config.h"
#include "output_api.h"
#include "mixer_list.h"
#include <roaraudio.h>

#include <glib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>


#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "roaraudio"


static const char *default_host = "localhost";
static const char *default_port = "12345";

struct roar {
   struct roar_connection con;
   roar_vs_t * vss;
   int err;
};

static inline GQuark
roar_output_quark(void)
{
   return g_quark_from_static_string("roar_output");
}

static void
roar_configure(struct roar * self, const struct config_param *param)
{
   // XXX: ???
/*
   rsd_set_param(rd, RSD_HOST, config_dup_block_string(param, "host", default_host));
   rsd_set_param(rd, RSD_PORT, config_dup_block_string(param, "port", default_port));
*/
}

static void *
roar_init(G_GNUC_UNUSED const struct audio_format *audio_format,
     const struct config_param *param,
     G_GNUC_UNUSED GError **error)
{
  struct roar * self = roar_mm_malloc(sizeof(struct roar));

  if ( self == NULL ) {
     return NULL;
  }

  memset(self, 0, sizeof(struct roar));

  self->err = ROAR_ERROR_NONE;

/*
   if ( rsd_init(&rd) < 0 )
   {
      g_set_error(error, rsound_output_quark(), 0, "Failed to initialize");
      return NULL;
   }
*/

   roar_configure(self, param);

   return self;
}

static void
roar_finish(void *data)
{
   struct roar * self = data;

   roar_close(data);

   roar_disconnect(&(self->con));

   roar_mm_free(self);
}

static bool
roar_open(void *data, struct audio_format *audio_format, GError **error)
{
   struct roar * self = data;
   struct roar_audio_info info;

   self->vss = roar_vs_new_from_con(&(self->con), &(self->err));

   if ( self->vss ) {
      return false;
   }

   info.rate     = audio_format->sample_rate;
   info.channels = audio_format->channels;

   if ( roar_vs_stream(self->vss, &info, ROAR_DIR_PLAY, &(self->err)) == -1 ) {
      roar_vs_close(self->vss, ROAR_VS_TRUE, NULL);
      self->vss = NULL;
      return false;
   }
/*
   audio_format->format = SAMPLE_FORMAT_S16;
   audio_format->reverse_endian = 0;

   int format = RSD_S16_NE;
   rsd_set_param(rd, RSD_FORMAT, &format);
*/

/*
   if ( rsd_start(rd) < 0)
   {
      g_set_error(error, rsound_output_quark(), 0, "Failed to connect to server");
      return false;
   }
   return true;
*/
}

static void
rsound_cancel(void *data)
{
   // XXX: ???
}

static void
roar_close(void *data)
{
   struct roar * self = data;

   if ( self->vss != NULL )
      roar_vs_close(vss, ROAR_VS_FALSE, &(self->err));
}

static size_t
roar_play(void *data, const void *chunk, size_t size, GError **error)
{
   struct roar * self = data;
   ssize_t rc;
   
   rc = roar_vs_write(self->vss, chunk, size, &(self->err));
   if ( rc <= 0 )
   {
      g_set_error(error, roar_output_quark(), 0, "Failed to play data");
      return 0;
   }

   return rc;
}

const struct audio_output_plugin rsound_output_plugin = {
   .name = "roar",
   .init = roar_init,
   .finish = roar_finish,
   .open = rsound_open,
   .play = roar_play,
   .cancel = rsound_cancel,
   .close = roar_close,
};