Changeset d86c9736 in mainline

Timestamp:

2012-08-19T14:35:32Z (12 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

fa91c0f

Parents:

ad42844

Message:

Rename record → capture.

Location:

uspace

Files:

• app/drec/drec.c (modified) (3 diffs)
• drv/audio/sb16/dsp.c (modified) (6 diffs)
• drv/audio/sb16/dsp.h (modified) (2 diffs)
• drv/audio/sb16/pcm_iface.c (modified) (3 diffs)
• lib/drv/generic/remote_audio_pcm.c (modified) (8 diffs)
• lib/drv/include/audio_pcm_iface.h (modified) (4 diffs)
• srv/audio/hound/audio_device.c (modified) (3 diffs)

uspace/app/drec/drec.c

@@ -89 +89 @@
                 ipc_callid_t callid = async_get_call(&call);
                 switch(IPC_GET_IMETHOD(call)) {
-                case PCM_EVENT_FRAMES_RECORDED:
+                case PCM_EVENT_FRAMES_CAPTURED:
                         printf("%u frames\n", IPC_GET_ARG1(call));
                         async_answer_0(callid, EOK);
                         break;
-                case PCM_EVENT_RECORDING_TERMINATED:
+                case PCM_EVENT_CAPTURE_TERMINATED:
                         printf("Recording terminated\n");
                         return;
@@ -124 +124 @@
         const unsigned frames = rec->buffer.size /
             (BUFFER_PARTS * channels * pcm_sample_format_size(format));
-        int ret = audio_pcm_start_record(rec->device,
+        int ret = audio_pcm_start_capture(rec->device,
             frames, channels, sampling_rate, format);
         if (ret != EOK) {
@@ -133 +133 @@
         getchar();
         printf("\n");
-        audio_pcm_stop_record(rec->device);
+        audio_pcm_stop_capture(rec->device);
 }
 

uspace/drv/audio/sb16/dsp.c

@@ -215 +215 @@
         }
 
-        if (dsp->status == DSP_RECORDING) {
+        if (dsp->status == DSP_CAPTURE) {
                 sb_dsp_start_active(dsp, SINGLE_DMA_16B_AD);
         }
@@ -232 +232 @@
                             PCM_EVENT_FRAMES_PLAYED, dsp->active.frame_count);
                         break;
-                case DSP_RECORDING:
+                case DSP_CAPTURE:
                         async_msg_1(dsp->event_exchange,
-                            PCM_EVENT_FRAMES_RECORDED, dsp->active.frame_count);
+                            PCM_EVENT_FRAMES_CAPTURED, dsp->active.frame_count);
                         break;
                 default:
@@ -251 +251 @@
 {
         switch(cap) {
-        case AUDIO_CAP_RECORD:
+        case AUDIO_CAP_CAPTURE:
         case AUDIO_CAP_PLAYBACK:
         case AUDIO_CAP_INTERRUPT:
@@ -393 +393 @@
 }
 
-int sb_dsp_start_record(sb_dsp_t *dsp, unsigned frames,
+int sb_dsp_start_capture(sb_dsp_t *dsp, unsigned frames,
     unsigned channels, unsigned sampling_rate, pcm_sample_format_t format)
 {
@@ -401 +401 @@
 
         /* Check supported parameters */
-        ddf_log_debug("Requested record: %u frames, %uHz, %s, %u channel(s).",
+        ddf_log_debug("Requested capture: %u frames, %uHz, %s, %u channel(s).",
             frames, sampling_rate, pcm_sample_format_str(format), channels);
         if (sb_dsp_test_format(dsp, &channels, &sampling_rate, &format) != EOK)
@@ -433 +433 @@
             "(~1/%u sec)", dsp->active.samples,
             sampling_rate / (dsp->active.samples * channels));
-        dsp->status = DSP_RECORDING;
-
-        return EOK;
-}
-
-int sb_dsp_stop_record(sb_dsp_t *dsp)
+        dsp->status = DSP_CAPTURE;
+
+        return EOK;
+}
+
+int sb_dsp_stop_capture(sb_dsp_t *dsp)
 {
         assert(dsp);
         sb_dsp_write(dsp, DMA_16B_EXIT);
-        ddf_log_debug("Stopped recording");
-        async_msg_0(dsp->event_exchange, PCM_EVENT_RECORDING_TERMINATED);
+        ddf_log_debug("Stopped capture");
+        async_msg_0(dsp->event_exchange, PCM_EVENT_CAPTURE_TERMINATED);
         async_exchange_end(dsp->event_exchange);
         dsp->event_exchange = NULL;

uspace/drv/audio/sb16/dsp.h

@@ -63 +63 @@
         enum {
                 DSP_PLAYBACK,
-                DSP_RECORDING,
+                DSP_CAPTURE,
                 DSP_STOPPED,
         } status;
@@ -83 +83 @@
     unsigned channels, unsigned sample_rate, pcm_sample_format_t format);
 int sb_dsp_stop_playback(sb_dsp_t *dsp);
-int sb_dsp_start_record(sb_dsp_t *dsp, unsigned frames,
+int sb_dsp_start_capture(sb_dsp_t *dsp, unsigned frames,
     unsigned channels, unsigned sample_rate, pcm_sample_format_t format);
-int sb_dsp_stop_record(sb_dsp_t *dsp);
+int sb_dsp_stop_capture(sb_dsp_t *dsp);
 
 #endif

uspace/drv/audio/sb16/pcm_iface.c

@@ -104 +104 @@
 }
 
-static int sb_start_record(ddf_fun_t *fun, unsigned frames,
+static int sb_start_capture(ddf_fun_t *fun, unsigned frames,
     unsigned channels, unsigned sample_rate, pcm_sample_format_t format)
 {
@@ -110 +110 @@
         assert(fun->driver_data);
         sb_dsp_t *dsp = fun->driver_data;
-        return sb_dsp_start_record(
+        return sb_dsp_start_capture(
             dsp, frames, channels, sample_rate, format);
 }
 
-static int sb_stop_record(ddf_fun_t *fun)
+static int sb_stop_capture(ddf_fun_t *fun)
 {
         assert(fun);
         assert(fun->driver_data);
         sb_dsp_t *dsp = fun->driver_data;
-        return sb_dsp_stop_record(dsp);
+        return sb_dsp_stop_capture(dsp);
 }
 
@@ -134 +134 @@
         .stop_playback = sb_stop_playback,
 
-        .start_record = sb_start_record,
-        .stop_record = sb_stop_record
+        .start_capture = sb_start_capture,
+        .stop_capture = sb_stop_capture,
 };
 /**

uspace/lib/drv/generic/remote_audio_pcm.c

@@ -51 +51 @@
         IPC_M_AUDIO_PCM_START_PLAYBACK,
         IPC_M_AUDIO_PCM_STOP_PLAYBACK,
-        IPC_M_AUDIO_PCM_START_RECORD,
-        IPC_M_AUDIO_PCM_STOP_RECORD,
+        IPC_M_AUDIO_PCM_START_CAPTURE,
+        IPC_M_AUDIO_PCM_STOP_CAPTURE,
 } audio_pcm_iface_funcs_t;
 
@@ -219 +219 @@
 }
 
-int audio_pcm_start_record(audio_pcm_sess_t *sess, unsigned frames,
+int audio_pcm_start_capture(audio_pcm_sess_t *sess, unsigned frames,
     unsigned channels, unsigned sample_rate, pcm_sample_format_t format)
 {
@@ -228 +228 @@
         async_exch_t *exch = async_exchange_begin(sess);
         const int ret = async_req_4_0(exch,
-            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_START_RECORD,
+            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_START_CAPTURE,
             frames, sample_rate, packed);
         async_exchange_end(exch);
@@ -234 +234 @@
 }
 
-int audio_pcm_stop_record(audio_pcm_sess_t *sess)
+int audio_pcm_stop_capture(audio_pcm_sess_t *sess)
 {
         async_exch_t *exch = async_exchange_begin(sess);
         const int ret = async_req_1_0(exch,
-            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_STOP_RECORD);
+            DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_STOP_CAPTURE);
         async_exchange_end(exch);
         return ret;
@@ -253 +253 @@
 static void remote_audio_pcm_start_playback(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_audio_pcm_stop_playback(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_audio_pcm_start_record(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_audio_pcm_stop_record(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_audio_pcm_start_capture(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_audio_pcm_stop_capture(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 
 /** Remote audio pcm buffer interface operations. */
@@ -265 +265 @@
         [IPC_M_AUDIO_PCM_START_PLAYBACK] = remote_audio_pcm_start_playback,
         [IPC_M_AUDIO_PCM_STOP_PLAYBACK] = remote_audio_pcm_stop_playback,
-        [IPC_M_AUDIO_PCM_START_RECORD] = remote_audio_pcm_start_record,
-        [IPC_M_AUDIO_PCM_STOP_RECORD] = remote_audio_pcm_stop_record,
+        [IPC_M_AUDIO_PCM_START_CAPTURE] = remote_audio_pcm_start_capture,
+        [IPC_M_AUDIO_PCM_STOP_CAPTURE] = remote_audio_pcm_stop_capture,
 };
 
@@ -436 +436 @@
 }
 
-void remote_audio_pcm_start_record(ddf_fun_t *fun, void *iface,
+void remote_audio_pcm_start_capture(ddf_fun_t *fun, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
 {
@@ -446 +446 @@
         const pcm_sample_format_t format = DEV_IPC_GET_ARG3(*call) & UINT16_MAX;
 
-        const int ret = pcm_iface->start_record
-            ? pcm_iface->start_record(fun, frames, channels, rate, format)
+        const int ret = pcm_iface->start_capture
+            ? pcm_iface->start_capture(fun, frames, channels, rate, format)
             : ENOTSUP;
         async_answer_0(callid, ret);
 }
 
-void remote_audio_pcm_stop_record(ddf_fun_t *fun, void *iface,
+void remote_audio_pcm_stop_capture(ddf_fun_t *fun, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
 {
         const audio_pcm_iface_t *pcm_iface = iface;
 
-        const int ret = pcm_iface->stop_record ?
-            pcm_iface->stop_record(fun) : ENOTSUP;
+        const int ret = pcm_iface->stop_capture ?
+            pcm_iface->stop_capture(fun) : ENOTSUP;
         async_answer_0(callid, ret);
 }

uspace/lib/drv/include/audio_pcm_iface.h

@@ -45 +45 @@
 
 typedef enum {
-        AUDIO_CAP_RECORD,
+        AUDIO_CAP_CAPTURE,
         AUDIO_CAP_PLAYBACK,
         AUDIO_CAP_MAX_BUFFER,
@@ -56 +56 @@
 enum {
         PCM_EVENT_FRAMES_PLAYED = IPC_FIRST_USER_METHOD,
-        PCM_EVENT_FRAMES_RECORDED,
+        PCM_EVENT_FRAMES_CAPTURED,
         PCM_EVENT_PLAYBACK_TERMINATED,
-        PCM_EVENT_RECORDING_TERMINATED
+        PCM_EVENT_CAPTURE_TERMINATED
 };
 
@@ -80 +80 @@
 int audio_pcm_stop_playback(audio_pcm_sess_t *);
 
-int audio_pcm_start_record(audio_pcm_sess_t *, unsigned,
+int audio_pcm_start_capture(audio_pcm_sess_t *, unsigned,
     unsigned, unsigned, pcm_sample_format_t);
-int audio_pcm_stop_record(audio_pcm_sess_t *);
+int audio_pcm_stop_capture(audio_pcm_sess_t *);
 
 /** Audio pcm communication interface. */
@@ -96 +96 @@
             unsigned, unsigned, pcm_sample_format_t);
         int (*stop_playback)(ddf_fun_t *);
-        int (*start_record)(ddf_fun_t *, unsigned,
+        int (*start_capture)(ddf_fun_t *, unsigned,
             unsigned, unsigned, pcm_sample_format_t);
-        int (*stop_record)(ddf_fun_t *);
+        int (*stop_capture)(ddf_fun_t *);
 } audio_pcm_iface_t;
 

uspace/srv/audio/hound/audio_device.c

@@ -153 +153 @@
                 const unsigned frames = dev->buffer.size /
                     (BUFFER_PARTS * pcm_format_frame_size(&dev->sink.format));
-                ret = audio_pcm_start_record(dev->sess, frames,
+                ret = audio_pcm_start_capture(dev->sess, frames,
                     dev->sink.format.channels, dev->sink.format.sampling_rate,
                     dev->sink.format.sample_format);
@@ -163 +163 @@
                 }
         } else { /* Disconnected */
-                int ret = audio_pcm_stop_record(dev->sess);
+                int ret = audio_pcm_stop_capture(dev->sess);
                 if (ret != EOK) {
                         log_error("Failed to start recording: %s",
@@ -208 +208 @@
                         break;
                 }
-                case PCM_EVENT_PLAYBACK_TERMINATED: {
+                case PCM_EVENT_PLAYBACK_TERMINATED:
                         log_verbose("Playback terminated!");
                         return;
-                }
-                case PCM_EVENT_FRAMES_RECORDED: {
+                case PCM_EVENT_FRAMES_CAPTURED:
                         //TODO implement
                         break;
-                }
-                case PCM_EVENT_RECORDING_TERMINATED:
+                case PCM_EVENT_CAPTURE_TERMINATED:
                         log_verbose("Recording terminated!");
                         return;