Changeset 5174:c24a2089056a in roaraudio for plugins/alsavs/thread.c

Timestamp:

10/22/11 12:11:33 (13 years ago)

Author:

phi

Branch:

default

Phase:

public

Message:

added some experimental fork of the old alsa plugin using VS API

File:

• plugins/alsavs/thread.c (modified) (8 diffs)

plugins/alsavs/thread.c

@@ -42 +42 @@
 
 
+
+/*
+ * The following function should be re-written:
+ * write in a loop untill all date is written,
+ * if vs write returns less than requested call the thread and ask it to iterate.
+ */
+
 // Writes to the FIFO buffer. Waits until there is room to write.
 size_t roar_plugin_write(struct roar_alsa_pcm *self, const char *buf, size_t size) {
+ ssize_t ret;
+
+ ROAR_DBG("roar_plugin_write(self=%p, buf=%p, size=%llu) = ?", self, buf, (long long unsigned int)size);
+
+#if 0
  /* Wait until we have a ready buffer */
  while (1) {
@@ -52 +64 @@
   //fprintf(stderr, "%d + %d : %d\n", (int)self->bufptr, (int)size, (int)self->bufsize);
   pthread_mutex_lock(&(self->lock));
-  if (self->bufptr + size <= self->bufsize) {
+  if (roar_vs_get_avail_write(self->vss, NULL) >= (ssize_t)size) {
    pthread_mutex_unlock(&(self->lock));
    break;
@@ -58 +70 @@
   pthread_mutex_unlock(&(self->lock));
 
+  ROAR_DBG("roar_plugin_write(self=%p, buf=%p, size=%llu): Send signal", self, buf, (long long unsigned int)size);
   pthread_cond_signal(&(self->cond));
   /* Sleeps until we can write to the FIFO. */
+  ROAR_DBG("roar_plugin_write(self=%p, buf=%p, size=%llu): Waiting for answer", self, buf, (long long unsigned int)size);
   pthread_mutex_lock(&(self->cond_lock));
   pthread_cond_wait(&(self->cond), &(self->cond_lock));
   pthread_mutex_unlock(&(self->cond_lock));
  }
-
- pthread_mutex_lock(&(self->lock));
- memcpy(self->buffer + self->bufptr, buf, size);
- self->bufptr += (int)size;
- pthread_mutex_unlock(&(self->lock));
-
- /* Send signal to thread that buffer has been updated */
- pthread_cond_signal(&(self->cond));
+#endif
+
+
+ while (size) {
+  pthread_mutex_lock(&(self->lock));
+  ret = roar_vs_write(self->vss, buf, size, NULL);
+  pthread_mutex_unlock(&(self->lock));
+
+  if ( ret == -1 ) {
+   ROAR_WARN("roar_plugin_write(self=%p, buf=?, size=?): Can not write data: %s", self, roar_error2str(roar_error));
+   return -1;
+  }
+
+  size -= ret;
+  buf  += ret;
+
+  /* Send signal to thread that buffer has been updated */
+  ROAR_DBG("roar_plugin_write(self=%p, buf=%p, size=%llu): Send signal", self, buf, (long long unsigned int)size);
+  pthread_cond_signal(&(self->cond));
+ }
 
  return size;
@@ -83 +109 @@
 // Attemps to drain the buffer at all times and write to libroar.
 // If there is no data, it will wait for roar_plugin_write() to fill up more data.
-void* roar_plugin_thread (void * thread_data) {
+void * roar_plugin_thread (void * thread_data) {
  /* We share data between thread and callable functions */
  struct roar_alsa_pcm *self = thread_data;
  int rc;
+ int err;
+
+ ROAR_DBG("roar_plugin_thread(thread_data=%p) = ?", thread_data);
+ pthread_mutex_unlock(&(self->lock)); // we are now up.
 
  /* Plays back data as long as there is data in the buffer. Else, sleep until it can. */
  /* Two loops! :3 Beware! */
  while(1) {
+  ROAR_DBG("roar_plugin_thread(thread_data=%p): got woken up.", thread_data);
   while(1) {
    _TEST_CANCEL();
@@ -96 +127 @@
    // We only bother to check after 1 sec of audio has been played, as it might be quite inaccurate in the start of the stream.
 
+   // do wee need to lock before this?
+   pthread_mutex_lock(&(self->lock));
+   ROAR_DBG("roar_plugin_thread(thread_data=%p): Start iterate", thread_data);
+   rc = roar_vs_iterate(self->vss, ROAR_VS_WAIT, &err);
+   ROAR_DBG("roar_plugin_thread(thread_data=%p): Ended iterate", thread_data);
+   pthread_mutex_unlock(&(self->lock));
+
+   if ( rc == 0 ) {
+    break;
+   } else if ( rc < 0 ) {
+    _TEST_CANCEL();
+    roar_plugin_reset(self);
+
+    /* Wakes up a potentially sleeping fill_buffer() */
+    pthread_cond_signal(&(self->cond));
+
+    /* This thread will not be joined, so detach. */
+    pthread_detach(pthread_self());
+    pthread_exit(NULL);
+   }
+
+   pthread_cond_signal(&(self->cond));
+
+#if 0
    /* If the buffer is empty or we've stopped the stream. Jump out of this for loop */
    pthread_mutex_lock(&(self->lock));
@@ -139 +194 @@
    /* Buffer has decreased, signal fill_buffer() */
    pthread_cond_signal(&(self->cond));
-
-  }
+#endif
+
+  }
+  ROAR_DBG("roar_plugin_thread(thread_data=%p): going to sleep again.", thread_data);
 
   /* If we're still good to go, sleep. We are waiting for fill_buffer() to fill up some data. */
 test_quit:
   if ( self->thread_active ) {
-   pthread_cond_signal(&(self->cond));
+   //struct timespec abstime = {0, 1000*1000*100};
+   pthread_cond_signal(&(self->cond));
+   ROAR_DBG("roar_plugin_thread(thread_data=%p): Wating for wakeup", thread_data);
    pthread_mutex_lock(&(self->cond_lock));
    pthread_cond_wait(&(self->cond), &(self->cond_lock));
@@ -159 +218 @@
 
 void roar_plugin_drain(struct roar_alsa_pcm *self) {
+#if 0
  struct timespec now_tv;
  int64_t temp, temp2;
@@ -183 +243 @@
   self->bytes_in_buffer = self->bufptr;
  }
+#endif
+ ROAR_DBG("roar_plugin_drain(self=%p) = (void)", self);
 }