Changeset 017455e in mainline

Timestamp:

2012-08-30T19:36:14Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b5d2e57

Parents:

e1534533

Message:

wavplay: Implement playback without without using events.

Needs HZ constant changed to 1000 to work reasonably.

File:

• uspace/app/wavplay/dplay.c (modified) (10 diffs)

uspace/app/wavplay/dplay.c

@@ -41 +41 @@
 #include <audio_pcm_iface.h>
 #include <fibril_synch.h>
-#include <stdio.h>
+#include <pcm/format.h>
 #include <sys/mman.h>
 #include <sys/time.h>
@@ -60 +60 @@
                 void* position;
         } buffer;
+        pcm_format_t f;
         FILE* source;
         volatile bool playing;
@@ -86 +87 @@
         async_answer_0(iid, EOK);
         playback_t *pb = arg;
-        const size_t buffer_part = pb->buffer.size / BUFFER_PARTS;
+        const size_t fragment_size = pb->buffer.size / BUFFER_PARTS;
         while (1) {
                 ipc_call_t call;
@@ -93 +94 @@
                 case PCM_EVENT_PLAYBACK_STARTED:
                 case PCM_EVENT_FRAMES_PLAYED:
-                        printf("%u frames\n", IPC_GET_ARG1(call));
+                        printf("%u frames: ", IPC_GET_ARG1(call));
                         async_answer_0(callid, EOK);
                         break;
@@ -111 +112 @@
                 }
                 const size_t bytes = fread(pb->buffer.position, sizeof(uint8_t),
-                   buffer_part, pb->source);
+                   fragment_size, pb->source);
+                printf("Copied from position %p size %zu/%zu\n",
+                    pb->buffer.position, bytes, fragment_size);
                 if (bytes == 0) {
                         audio_pcm_last_playback_fragment(pb->device);
                 }
-                bzero(pb->buffer.position + bytes, buffer_part - bytes);
-                pb->buffer.position += buffer_part;
+                bzero(pb->buffer.position + bytes, fragment_size - bytes);
+                pb->buffer.position += fragment_size;
 
                 if (pb->buffer.position >= (pb->buffer.base + pb->buffer.size))
-                        pb->buffer.position = pb->buffer.base;
-        }
-}
-
-
-static void play(playback_t *pb, unsigned channels, unsigned sampling_rate,
-    pcm_sample_format_t format)
+                        pb->buffer.position -= pb->buffer.size;
+        }
+}
+
+static void play_fragment(playback_t *pb)
 {
         assert(pb);
         assert(pb->device);
-        const size_t buffer_part = pb->buffer.size / BUFFER_PARTS;
-        pb->buffer.position = pb->buffer.base + buffer_part;
+        const size_t fragment_size = pb->buffer.size / BUFFER_PARTS;
         printf("Registering event callback\n");
         int ret = audio_pcm_register_event_callback(pb->device,
@@ -138 +138 @@
                 return;
         }
-        printf("Playing: %dHz, %s, %d channel(s).\n",
-            sampling_rate, pcm_sample_format_str(format), channels);
+        printf("Playing: %dHz, %s, %d channel(s).\n", pb->f.sampling_rate,
+            pcm_sample_format_str(pb->f.sample_format), pb->f.channels);
         const size_t bytes = fread(pb->buffer.base, sizeof(uint8_t),
-            buffer_part, pb->source);
-        if (bytes != buffer_part)
-                bzero(pb->buffer.base + bytes, buffer_part - bytes);
-        printf("Buffer data ready.\n");
+            fragment_size, pb->source);
+        if (bytes != fragment_size)
+                bzero(pb->buffer.base + bytes, fragment_size - bytes);
+        printf("Initial: Copied from position %p size %zu/%zu\n",
+            pb->buffer.base, bytes, fragment_size);
+        pb->buffer.position = pb->buffer.base + fragment_size;
         fibril_mutex_lock(&pb->mutex);
-        const unsigned frames = pb->buffer.size /
-            (BUFFER_PARTS * channels * pcm_sample_format_size(format));
-        ret = audio_pcm_start_playback_fragment(pb->device, frames, channels,
-            sampling_rate, format);
+        const unsigned frames = pcm_format_size_to_frames(fragment_size, &pb->f);
+        ret = audio_pcm_start_playback_fragment(pb->device, frames,
+            pb->f.channels, pb->f.sampling_rate, pb->f.sample_format);
         if (ret != EOK) {
                 fibril_mutex_unlock(&pb->mutex);
                 printf("Failed to start playback: %s.\n", str_error(ret));
+                audio_pcm_unregister_event_callback(pb->device);
                 return;
         }
@@ -164 +166 @@
 }
 
+static void play(playback_t *pb)
+{
+        assert(pb);
+        assert(pb->device);
+        pb->buffer.position = pb->buffer.base;
+        printf("Playing: %dHz, %s, %d channel(s).\n", pb->f.sampling_rate,
+            pcm_sample_format_str(pb->f.sample_format), pb->f.channels);
+        static suseconds_t work_time = 8000; /* 2 ms */
+        size_t bytes = fread(pb->buffer.position, sizeof(uint8_t),
+                    pb->buffer.size, pb->source);
+        if (bytes == 0)
+                return;
+        audio_pcm_start_playback(pb->device,
+            pb->f.channels, pb->f.sampling_rate, pb->f.sample_format);
+        do {
+                size_t pos = 0;
+                audio_pcm_get_buffer_pos(pb->device, &pos);
+                useconds_t usecs = pcm_format_size_to_usec(bytes - pos, &pb->f);
+
+                pb->buffer.position += bytes;
+
+                printf("%u usecs to play %zu bytes from pos %zu.\n",
+                    usecs, bytes, pos);
+                async_usleep(usecs - work_time);
+                audio_pcm_get_buffer_pos(pb->device, &pos);
+                printf("Woke up at position %zu/%zu.\n", pos, pb->buffer.size);
+
+                /* Remove any overflow */
+                while (pb->buffer.position >= pb->buffer.base + pb->buffer.size)
+                        pb->buffer.position -= pb->buffer.size;
+
+                if (bytes < pb->buffer.size) {
+                        const size_t remain = pb->buffer.size -
+                            (pb->buffer.position - pb->buffer.base);
+                        /* This was the last part,
+                         * zero 200 bytes or until the end of buffer. */
+                        bzero(pb->buffer.position, min(200, remain));
+                        if ((pb->buffer.base + pos) > pb->buffer.position) {
+                                printf("Overflow: %zu vs. %zu!\n",
+                                    pos, pb->buffer.position - pb->buffer.base);
+                        } else {
+                                udelay(pcm_format_size_to_usec(
+                                    pb->buffer.position - pb->buffer.base - pos,
+                                    &pb->f));
+                                audio_pcm_get_buffer_pos(pb->device, &pos);
+                        }
+                        printf("Stopped at %zu(%zu)/%zu\n",
+                            pos, pb->buffer.position - pb->buffer.base,
+                            pb->buffer.size);
+                        break;
+                }
+                /* copy first half */
+                bytes = fread(pb->buffer.position, sizeof(uint8_t),
+                    pb->buffer.size / 2, pb->source);
+                if (bytes == 0)
+                        break;
+                audio_pcm_get_buffer_pos(pb->device, &pos);
+                printf("Half buffer copied at pos %zu", pos);
+                /* Wait until the rest of the buffer is ready */
+                udelay(pcm_format_size_to_usec(pb->buffer.size - pos, &pb->f));
+                /* copy the other part of the buffer */
+                audio_pcm_get_buffer_pos(pb->device, &pos);
+                printf(" the other half copied at pos %zu\n", pos);
+                bytes += fread(pb->buffer.position + bytes, sizeof(uint8_t),
+                            pb->buffer.size / 2, pb->source);
+        } while (1);
+        audio_pcm_stop_playback(pb->device);
+}
+
 int dplay(const char *device, const char *file)
 {
+        int ret = EOK;
         if (str_cmp(device, "default") == 0)
                 device = DEFAULT_DEVICE;
@@ -174 +246 @@
         }
         printf("Playing on device: %s.\n", device);
+        if (audio_pcm_query_cap(session, AUDIO_CAP_PLAYBACK) <= 0) {
+                printf("Device %s does not support playback\n", device);
+                ret = ENOTSUP;
+                goto close_session;
+        }
 
         const char* info = NULL;
-        int ret = audio_pcm_get_info_str(session, &info);
+        ret = audio_pcm_get_info_str(session, &info);
         if (ret != EOK) {
                 printf("Failed to get PCM info.\n");
@@ -205 +282 @@
         wave_header_t header;
         fread(&header, sizeof(header), 1, pb.source);
-        unsigned rate, channels;
-        pcm_sample_format_t format;
         const char *error;
-        ret = wav_parse_header(&header, NULL, NULL, &channels, &rate, &format,
-            &error);
+        ret = wav_parse_header(&header, NULL, NULL,
+            &pb.f.channels, &pb.f.sampling_rate, &pb.f.sample_format, &error);
         if (ret != EOK) {
                 printf("Error parsing wav header: %s.\n", error);
@@ -215 +290 @@
                 goto cleanup;
         }
-
-        play(&pb, channels, rate, format);
+        if (audio_pcm_query_cap(pb.device, AUDIO_CAP_BUFFER_POS) > 0) {
+                play(&pb);
+        } else {
+                if (audio_pcm_query_cap(pb.device, AUDIO_CAP_INTERRUPT) > 0)
+                        play_fragment(&pb);
+                else
+                        printf("Neither playing method is supported");
+        }
+
+cleanup:
         fclose(pb.source);
-
-cleanup:
         munmap(pb.buffer.base, pb.buffer.size);
         audio_pcm_release_buffer(pb.device);