Пример #1
0
static int init(int rate_hz, int channels, int format, int flags)
{
	int err;
	int frag_spec;

	if( (err=arts_init()) ) {
		mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ARTS_CantInit, arts_error_text(err));
		return 0;
	}
	mp_msg(MSGT_AO, MSGL_INFO, MSGTR_AO_ARTS_ServerConnect);

	/*
	 * arts supports 8bit unsigned and 16bit signed sample formats
	 * (16bit apparently in little endian format, even in the case
	 * when artsd runs on a big endian cpu).
	 *
	 * Unsupported formats are translated to one of these two formats
	 * using mplayer's audio filters.
	 */
	switch (format) {
	case AF_FORMAT_U8:
	case AF_FORMAT_S8:
	    format = AF_FORMAT_U8;
	    break;
	default:
	    format = AF_FORMAT_S16_LE;    /* artsd always expects little endian?*/
	    break;
	}

	ao_data.format = format;
	ao_data.channels = channels;
	ao_data.samplerate = rate_hz;
	ao_data.bps = (rate_hz*channels);

	if(format != AF_FORMAT_U8 && format != AF_FORMAT_S8)
		ao_data.bps*=2;

	stream=arts_play_stream(rate_hz, OBTAIN_BITRATE(format), channels, "MPlayer");

	if(stream == NULL) {
		mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ARTS_CantOpenStream);
		arts_free();
		return 0;
	}

	/* Set the stream to blocking: it will not block anyway, but it seems */
	/* to be working better */
	arts_stream_set(stream, ARTS_P_BLOCKING, 1);
	frag_spec = ARTS_PACKET_SIZE_LOG2 | ARTS_PACKETS << 16;
	arts_stream_set(stream, ARTS_P_PACKET_SETTINGS, frag_spec);
	ao_data.buffersize = arts_stream_get(stream, ARTS_P_BUFFER_SIZE);
	mp_msg(MSGT_AO, MSGL_INFO, MSGTR_AO_ARTS_StreamOpen);

	mp_msg(MSGT_AO, MSGL_INFO, MSGTR_AO_ARTS_BufferSize,
	    ao_data.buffersize);
	mp_msg(MSGT_AO, MSGL_INFO, MSGTR_AO_ARTS_BufferSize,
	    arts_stream_get(stream, ARTS_P_PACKET_SIZE));

	return 1;
}
Пример #2
0
static int Audio_Available(void)
{
	if(arts_init())
		return 0;
	else
		return 1;
}
Пример #3
0
     static gboolean gst_artsdsink_open_audio (GstArtsdsink * sink)
{
  const char connname[] = "gstreamer";
  int errcode;

  /* Name used by aRtsd for this connection. */
  if (sink->connect_name != NULL)
    connname = sink->connect_name;

  /* FIXME: this should only ever happen once per process. */
  /* Really, artsc needs to be made thread safe to fix this (and other related */
  /* problems). */
  errcode = arts_init ();
  if (errcode < 0) {
    fprintf (stderr, "arts_init error: %s\n", arts_error_text (errcode));
    return FALSE;
  }

  GST_DEBUG ("artsdsink: attempting to open connection to aRtsd server");
  sink->stream = arts_play_stream (sink->frequency, sink->depth,
      sink->channels, connname);
  /* FIXME: check connection */
  /*   GST_DEBUG ("artsdsink: can't open connection to aRtsd server"); */

  GST_OBJECT_FLAG_SET (sink, GST_ARTSDSINK_OPEN);
  sink->connected = TRUE;

  return TRUE;
}
Пример #4
0
/* initialize the sound card or connect to aRts server */
void audio_init(audio_dev_handle* handle, int rate, int latency, int try_arts)
{
#ifdef HAS_ARTS
    int artserr = 0;

    handle->arts_handle = NULL;
    handle->use_arts    = 0;
#endif
    handle->alsa_handle = NULL;
    handle->channels    = 1;  /* mono */
    handle->format      = SND_PCM_FORMAT_U8;
    handle->rate        = rate;
    handle->latency     = latency; /* in ms */

#ifdef HAS_ARTS    
    if( try_arts )
    {
        artserr = arts_init();
        if( artserr < 0 )
        {
            fprintf(stderr, "Error initializing aRts: %s\n", arts_error_text(artserr));
            exit(-1);
        }
        handle->arts_handle = arts_play_stream( *rate, 8, handle->channels, "arts-whitenoise" );
        arts_stream_set(handle->arts_handle, ARTS_P_BUFFER_TIME, *latency);
        handle->use_arts = 1;
    }
    else
#endif
    {
        alsa_init(handle);
    }
}
Пример #5
0
static int op_arts_init(void)
{
	int rc;

	rc = arts_init();
	if (rc < 0) {
		return -1;
	}
	return 0;
}
Пример #6
0
/* public methods (static but exported through the sysdep_dsp or plugin
   struct) */
static void *arts_dsp_create(const void *flags)
{
   struct sysdep_dsp_struct *dsp = NULL;
   struct arts_dsp_priv_data *priv = NULL;
   const struct sysdep_dsp_create_params *params = flags;
   
   
   /* allocate the dsp struct */
   if (!(dsp = calloc(1, sizeof(struct sysdep_dsp_struct))))
   {
      fprintf(stderr,
         "error malloc failed for struct sysdep_dsp_struct\n");
      return NULL;
   }

   if(!(priv = calloc(1, sizeof(struct arts_dsp_priv_data))))
   {
      fprintf(stderr,
         "error malloc failed for struct arts_dsp_priv_data\n");
      return NULL;
   }

   
   /* fill in the functions and some data */
   priv->stream=0; 
   dsp->_priv = priv;
   dsp->write = arts_dsp_write;
   dsp->destroy = arts_dsp_destroy;
   dsp->hw_info.type = params->type;
   dsp->hw_info.samplerate = params->samplerate;
   dsp->hw_info.bufsize = 1024;
   
   /* open the sound device */
   arts_init();
   priv->stream=arts_play_stream(dsp->hw_info.samplerate,
				 (dsp->hw_info.type&SYSDEP_DSP_16BIT)?16:8,
				 (dsp->hw_info.type&SYSDEP_DSP_STEREO)?2:1,
				 "xmame arts");
   
   /* Set the buffering time */
   arts_stream_set(priv->stream,ARTS_P_BUFFER_TIME,btime);

   /* set non-blocking mode if selected */
   if(params->flags & SYSDEP_DSP_O_NONBLOCK)
   {
	   arts_stream_set(priv->stream,ARTS_P_BLOCKING,0);
   }
   
   return dsp;
}
Пример #7
0
static int open_output(void)
{
    int i, include_enc, exclude_enc;
    int sample_width, channels;

    include_enc = 0;
    exclude_enc = PE_ULAW|PE_ALAW|PE_BYTESWAP; /* They can't mean these */
    if(dpm.encoding & PE_16BIT)
	include_enc |= PE_SIGNED;
    else
	exclude_enc |= PE_SIGNED;
    dpm.encoding = validate_encoding(dpm.encoding, include_enc, exclude_enc);
    sample_width = (dpm.encoding & PE_16BIT) ? 16 : 8;
    channels = (dpm.encoding & PE_MONO) ? 1 : 2;

    /* Open the audio device */
    switch (arts_init_state) {
    case 0:
	if((i = arts_init()) != 0)
	{
	    ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
		      dpm.name, arts_error_text(i));
	    return -1;
	}
	arts_init_state = 1;
	break;
    case 2:
	ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
	    "TiMidity aRts bug: open_output() after close_output() not supported");
	return -1;
    }
    stream = arts_play_stream(dpm.rate,
			      LE_LONG(sample_width),
			      channels,
			      "timidity");
    if(stream == NULL)
    {
	ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
		  dpm.name, strerror(errno));
	return -1;
    }
    arts_stream_set(stream, ARTS_P_BLOCKING, 1);

    server_buffer = arts_stream_get(stream, ARTS_P_SERVER_LATENCY) * dpm.rate * (sample_width/8) * channels / 1000;
    output_count = 0;
    return 0;
    /* "this aRts function isnot yet implemented"
     *
    if (dpm.extra_param[0]) {
        i = arts_stream_set(stream,
            ARTS_P_PACKET_COUNT,
            dpm.extra_param[0]);
	if (i < 0) {
            ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
              dpm.name, arts_error_text(i));
	    return 1;
        }
    }
    return 0;
     *
     */
}
Пример #8
0
/* public methods (static but exported through the sysdep_dsp or plugin
   struct) */
static void *arts_dsp_create(const void *flags)
{
   int i, j, result, bits, channels, block;
   struct arts_dsp_priv_data *priv = NULL;
   struct sysdep_dsp_struct *dsp = NULL;
   const struct sysdep_dsp_create_params *params = flags;
   
   /* allocate the dsp struct */
   if (!(dsp = calloc(1, sizeof(struct sysdep_dsp_struct))))
   {
      fprintf(stderr,
         "error malloc failed for struct sysdep_dsp_struct\n");
      return NULL;
   }
   
   /* alloc private data */
   if(!(priv = calloc(1, sizeof(struct arts_dsp_priv_data))))
   {
      fprintf(stderr,
         "error malloc failed for struct arts_dsp_priv_data\n");
      arts_dsp_destroy(dsp);
      return NULL;
   }
   
   /* fill in the functions and some data */
   priv->stream = NULL;
   dsp->_priv = priv;
   dsp->write = arts_dsp_write;
   dsp->destroy = arts_dsp_destroy;
   dsp->hw_info.type = params->type;
   dsp->hw_info.samplerate = params->samplerate;

   result = arts_init();
   if (result < 0)
   {
      fprintf(stderr,
         "arts_init error: %s\n", arts_error_text(result));
      arts_dsp_destroy(dsp);
      return NULL;
   }

   bits = (dsp->hw_info.type & SYSDEP_DSP_16BIT) ? 16 : 8;
   channels = (dsp->hw_info.type & SYSDEP_DSP_STEREO) ? 2 : 1;
   priv->stream = arts_play_stream(dsp->hw_info.samplerate, bits, channels,
      "xmame arts");

   block = (params->flags & SYSDEP_DSP_O_NONBLOCK) ? 0 : 1;
   result = arts_stream_set(priv->stream, ARTS_P_BLOCKING, block);
   if (result < 0)
   {
      fprintf(stderr,
         "arts_stream_set error: %s\n", arts_error_text(result));
      arts_dsp_destroy(dsp);
      return NULL;
   }
   else 
   {
      if (result != block)
      {
         fprintf(stderr,
            "arts_stream_set ARTS_P_BLOCKING to %d failed\n", block);
         arts_dsp_destroy(dsp);
         return NULL;
      }
   }

   /* calculate fragsize & number of frags */
   /* fragsize (as power of 2) */
   i = 7;
   if (dsp->hw_info.type & SYSDEP_DSP_16BIT) i++;
   if (dsp->hw_info.type & SYSDEP_DSP_STEREO) i++;
   i += dsp->hw_info.samplerate / 22050;
 
   /* number of frags */
   j = ((dsp->hw_info.samplerate * arts_dsp_bytes_per_sample[dsp->hw_info.type] * params->bufsize) / (0x01 << i)) + 1;

   arts_stream_set(priv->stream, ARTS_P_BUFFER_SIZE, (0x01<<i)*j);

#ifdef ARTS_DEBUG
   /* print some info messages ;) */
   fprintf(stderr, "info: aRts buffer size    : %d\n", 
      arts_stream_get(priv->stream, ARTS_P_BUFFER_SIZE));
   fprintf(stderr, "info: aRts buffer time    : %d\n",
      arts_stream_get(priv->stream, ARTS_P_BUFFER_TIME));
   fprintf(stderr, "info: aRts server latency : %d\n",
      arts_stream_get(priv->stream, ARTS_P_SERVER_LATENCY));
   fprintf(stderr, "info: aRts total latency  : %d\n",
      arts_stream_get(priv->stream, ARTS_P_TOTAL_LATENCY));
   fprintf(stderr, "info: aRts blocking       : %s\n",
      arts_stream_get(priv->stream, ARTS_P_BLOCKING) ? "yes" : "no");
#endif /* ifdef ARTS_DEBUG */

   return dsp;
}