Tizen

Tizen.Multimedia.AudioPlayback class enables your application to play uncompressed audio. You can <a href=https://samsungtizenos.com/"#simple_playback\">play audio synchronously<\/a>, or <a href=https://samsungtizenos.com/"#async_playback\">do it asynchronously<\/a>.<\/p>\nYour application must define the following PCM data settings:<\/p>\n<ul>\n<li>Audio channels:\n<ul>\n<li><code>Mono<\/code> : Mono (1 channel)<\/li>\n<li><code>Stereo<\/code> : Stereo (2 channels)<\/li>\n<li><code>MultiChannel3<\/code> : Multi channel (3 channels)<\/li>\n<li><code>MultiChannel4<\/code> : Multi channel (4 channels)<\/li>\n<li><code>MultiChannel5<\/code> : Multi channel (5 channels)<\/li>\n<li><code>MultiChannel6<\/code> : Multi channel (6 channels)<\/li>\n<li><code>MultiChannel7<\/code> : Multi channel (7 channels)<\/li>\n<li><code>MultiChannel8<\/code> : Multi channel (8 channels)<\/li>\n<\/ul>\n<\/li>\n<li>Audio sample type:\n<ul>\n<li><code>U8<\/code> : Unsigned 8-bit PCM<\/li>\n<li><code>S16LE<\/code> : Signed 16-bit PCM, little endian<\/li>\n<li><code>S24LE<\/code> : Signed 24-bit PCM, little endian<\/li>\n<li><code>S24Packed<\/code> : Signed 24 bit PCM in LSB of 32 bit words, little endian<\/li>\n<li><code>S32LE<\/code> : Signed 32 bit PCM, little endian<\/li>\n<\/ul>\n<\/li>\n<li>Audio sample rate:\n<ul>\n<li>8000 ~ 192000 Hz<\/li>\n<\/ul>\n<\/li>\n<\/ul>\nTo support various low-end Tizen devices, the application must follow certain guidelines which are described below:<\/p>\n<ul>\n<li>\nDo not use excessive instances of the <code>Tizen.Multimedia.AudioPlayback<\/code> class.<\/p>\nUsing many <code>Tizen.Multimedia.AudioPlayback<\/code> class instances decrease application performance because processing audio data for re-sampling and mixing imposes a heavy burden on the system.<\/p>\n<\/li>\n<li>\nUse the device-preferred PCM format.<\/p>\nTo reduce the processing overhead, select the PCM format based on the target device preference (for example, signed 16-bit little endian, stereo, 44100 Hz).<\/p>\nUsing the preferred format reduces internal operations, such as converting audio samples from mono to stereo or re-sampling audio frequency to fit the target device's input sample rate.<\/p>\n<\/li>\n<li>\nReduce event delay and remove glitches.<\/p>\nThe <code>Tizen.Multimedia.AudioPlayback<\/code> class instance works recursively, using events. The smaller the buffer size, the more often events are generated. If you use a small buffer in addition to other resources (for example, a timer or sensor), application performance decreases because the events cause delays. To prevent problems, set an appropriate write buffer size.<\/p>\nTo guarantee that the events of the <code>Tizen.Multimedia.AudioPlayback<\/code> class work independently, create a <code>Tizen.Multimedia.AudioPlayback<\/code> class instance in the event thread.<\/p>\n<\/li>\n<li>\nUse double buffering.<\/p>\nUse the double-buffering mechanism to reduce latency. It works by first writing the data twice before starting playback. After starting, whenever the event handler is called, you can write additional data.<\/p>\n<\/li>\n<li>\nSave power.<\/p>\nIf audio playback has stopped for a long time, such as because the screen has switched off or there is no audio data, call the <code>Unprepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class to pause the stream and save power. The device cannot go into sleep mode while the <code>Tizen.Multimedia.AudioPlayback<\/code> instance is in the <code>Running<\/code> state.<\/p>\n<\/li>\n<\/ul>\n<a name=\"record_pcm\"><\/a><\/p>\n<h2 id=\"content-audio-input\"><a href=https://samsungtizenos.com/"#content-audio-input\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Audio input<\/h2>\nYou can enable your application to record uncompressed audio from a microphone-type input device. You can <a href=https://samsungtizenos.com/"#simple_recording\">record audio synchronously<\/a> with the <a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Multimedia.AudioCapture.md/">Tizen.Multimedia.AudioCapture class, or <a href=https://samsungtizenos.com/"#async_recording\">do it asynchronously<\/a> with the <a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Multimedia.AsyncAudioCapture.md/">Tizen.Multimedia.AsyncAudioCapture class.<\/p>\nAudio data is captured periodically. To receive the audio PCM data from the input device, you must implement the audio capture interface to notify the application of audio data events, such as when the audio data buffer is full.<\/p>\nBefore recording audio, you must define the PCM data settings. For more information, see <a href=https://samsungtizenos.com/"#play_pcm\">audio output<\/a>.<\/p>\n<h2 id=\"content-prerequisites\"><a href=https://samsungtizenos.com/"#content-prerequisites\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Prerequisites<\/h2>\nTo make your application visible in the official site for Tizen applications only for devices that support a microphone, the application must specify the following feature in the <code>tizen-manifest.xml<\/code> file:<\/p>\n<code class=\"language-XML\"><feature name="http:\/\/tizen.org\/feature\/microphone"\/>\n<\/code>\n<a name=\"simple_playback\"><\/a><\/p>\n<h2 id=\"content-manage-synchronous-playback\"><a href=https://samsungtizenos.com/"#content-manage-synchronous-playback\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage synchronous playback<\/h2>\nBecause the synchronous playback process blocks other processes running in the same thread, launching a playback process from the application main thread can make the application unresponsive. To prevent this, launch the playback process from its own thread.<\/p>\nTo play audio, follow these steps:<\/p>\n<ol>\n<li>\nPrepare the audio output device and start the playback process using the <code>Prepare()<\/code> method of the <a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Multimedia.AudioPlayback.md/">Tizen.Multimedia.AudioPlayback class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>var<\/span> <\/span>audioPlayback<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>AudioPlayback<\/span>(<\/span>44100<\/span>, AudioChannel.Mono, AudioSampleType.S16Le);<\/span><\/span>\n<\/span>\n\/\/\/ Prepare the audio output device (start the hardware playback process)<\/span><\/span>\naudioPlayback<\/span>.<\/span>Prepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\nThe hardware device prepares its internal output buffer for playback. Playback begins when the internal output buffer starts receiving audio data.<\/p>\n<\/li>\n<li>\nTo start playing the recorded audio, copy the audio data from the local buffer to the internal output buffer using the <code>Write()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>int<\/span> <\/span>bytesWritten<\/span> <\/span>=<\/span> audioPlayback.<\/span>Write<\/span>(buffer);<\/span><\/span>\n<\/span><\/code><\/pre>\nThe returned value represents the number of bytes written to the internal output buffer.<\/p>\n<\/li>\n<li>\nStop the playback process using the <code>Unprepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>audioPlayback.<\/span>Unprepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<\/ol>\n<a name=\"async_playback\"><\/a><\/p>\n<h2 id=\"content-manage-asynchronous-playback\"><a href=https://samsungtizenos.com/"#content-manage-asynchronous-playback\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage asynchronous playback<\/h2>\nThe asynchronous playback process uses the <code>BufferAvailable<\/code> event of the <a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Multimedia.AudioPlayback.md/">Tizen.Multimedia.AudioPlayback class to play the recorded audio. The event is raised for each recorded audio chunk. In the following example, the audio data is read from a stream.<\/p>\nTo start playing the recorded audio, follow these steps:<\/p>\n<ol>\n<li>\nAdd an event handler for the <code>BufferAvailable<\/code> event:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>audioPlayback.BufferAvailable <\/span>+=<\/span> OnBufferAvailable;<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<li>\nPrepare the audio output device and start the playback process using the <code>Prepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>audioPlayback.<\/span>Prepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\nThe hardware device prepares its internal output buffer for playback.<\/p>\n<\/li>\n<li>\nPlay audio from a stream.<\/p>\nRead audio data from the stream and write it to the internal output buffer using the <code>Write()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class. Playback begins when the internal output buffer starts receiving the audio data:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>Stream<\/span> <\/span>stream<\/span>;<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>OnBufferAvailable<\/span>(<\/span>object<\/span> <\/span>sender<\/span>, <\/span>AudioPlaybackBufferAvailableEventArgs<\/span> <\/span>args<\/span>)<\/span><\/span>\n{<\/span><\/span>\n <\/span>if<\/span> (args.Length <\/span>><\/span> <\/span>0<\/span>)<\/span><\/span>\n {<\/span><\/span>\n <\/span>try<\/span><\/span>\n {<\/span><\/span>\n \/\/\/ Allocate a local buffer for reading the audio data from the stream<\/span><\/span>\n <\/span>byte<\/span>[] <\/span>buffer<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>byte<\/span>[args.Length];<\/span><\/span>\n<\/span>\n \/\/\/ Read audio data from the stream and store it in the local buffer<\/span><\/span>\n stream.<\/span>Read<\/span>(buffer, <\/span>0<\/span>, args.Length);<\/span><\/span>\n<\/span>\n \/\/\/ Copy the audio data from the local buffer<\/span><\/span>\n \/\/\/ to the internal output buffer (starts playback)<\/span><\/span>\n audioPlayback.<\/span>Write<\/span>(buffer);<\/span><\/span>\n }<\/span><\/span>\n <\/span>catch<\/span>(<\/span>Exception<\/span> <\/span>e<\/span>)<\/span><\/span>\n {<\/span><\/span>\n Tizen.Log.<\/span>Error<\/span>(LOG_TAG, <\/span>"Failed to write. "<\/span> <\/span>+<\/span> e);<\/span><\/span>\n }<\/span><\/span>\n }<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<li>\nStop the playback process using the <code>Unprepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>\/\/\/ Stop the hardware playback process<\/span><\/span>\naudioPlayback.<\/span>Unprepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\nThe device no longer raises the event.<\/p>\n<\/li>\n<\/ol>\n<a name=\"simple_recording\"><\/a><\/p>\n<h2 id=\"content-manage-synchronous-recording\"><a href=https://samsungtizenos.com/"#content-manage-synchronous-recording\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage synchronous recording<\/h2>\nBefore starting the synchronous recording process, you need to know the size of the buffer where the recorded audio data is to be saved, based on the expected recording duration. The recording process ends once it has read the specified number of bytes.<\/p>\nTo calculate and set the required buffer size, use one of the following options:<\/p>\n<ol>\n<li>\nCalculate the buffer size based on the recommendation of the sound server, such as PulseAudio:<\/p>\n<ul>\n<li>\nRetrieve the recommended buffer size using the <code>GetBufferSize()<\/code> method of the <a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Multimedia.AudioCapture.md/">Tizen.Multimedia.AudioCapture class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>var<\/span> <\/span>audioCapture<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>AudioCapture<\/span>(<\/span>44100<\/span>, AudioChannel.Mono, AudioSampleType.S16Le);<\/span><\/span>\n<\/span>\nint<\/span> <\/span>bufferSize<\/span> <\/span>=<\/span> audioCapture.<\/span>GetBufferSize<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\nIf no exception is thrown, the method returns the preferred size in bytes, based on the specified audio parameters.<\/p>\nThe recommended buffer size depends on the device. The size can be different for mobile, wearable, and TV devices.<\/p>\n<\/li>\n<li>\nSet the buffer size to correspond to the desired recording duration.<\/p>\nFor the device in this example, the <code>GetBufferSize()<\/code> method returns the recommended buffer size for 100 milliseconds of recording time. To determine the total recommended buffer size, multiply the recommended buffer size by 10 (to get the buffer size per second) and by the length of the recording in seconds:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>const<\/span> <\/span>int<\/span> <\/span>RecordingSec<\/span> <\/span>=<\/span> <\/span>5<\/span>;<\/span><\/span>\n<\/span>\nbufferSize <\/span>*=<\/span> <\/span>10<\/span> <\/span>*<\/span> RecordingSec;<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<\/ul>\n<\/li>\n<li>\nCalculate the required buffer size explicitly:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>int<\/span> <\/span>bufferSize<\/span> <\/span>=<\/span> AudioCapture.SampleRate <\/span>*<\/span> (audioCapture.Channel <\/span>==<\/span> AudioChannel.Stereo <\/span>?<\/span> <\/span>2<\/span> <\/span>:<\/span> <\/span>1<\/span>) <\/span>*<\/span><\/span>\n (<\/span>audioCapture<\/span>.<\/span>SampleType<\/span> <\/span>==<\/span> <\/span>AudioSampleType<\/span>.<\/span>S16Le<\/span> <\/span>?<\/span> <\/span>2<\/span> <\/span>:<\/span> <\/span>1<\/span>);<\/span><\/span>\n<\/span>\nbufferSize <\/span>*=<\/span> RecordingSec;<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<\/ol>\nThe synchronous recording process blocks other processes running in the same thread. Launching a recording process from the application main thread can make the application unresponsive. To prevent this, launch the recording process from its own thread.<\/p>\nTo record audio, follow these steps:<\/p>\n<ol>\n<li>\nPrepare the audio input device and start the recording process using the <code>Prepare()<\/code> method of the <code>Tizen.Multimedia.AudioCapture<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>audioCapture.<\/span>Prepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\nThe hardware device starts buffering the audio recorded by the audio input device. The audio data is buffered to the internal input buffer.<\/p>\n<\/li>\n<li>\nRead the audio data from the internal input buffer using the <code>Read()<\/code> method:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>byte<\/span>[] <\/span>buffer<\/span> <\/span>=<\/span> audioCapture.<\/span>Read<\/span>(bufferSize);<\/span><\/span>\n<\/span><\/code><\/pre>\nThe <code>Read()<\/code> method can behave in the following ways:<\/p>\n<ul>\n<li>If the method is called immediately after preparing the audio input device, it blocks the thread that it was launched from until it reads bytes specified.<\/li>\n<li>If the method is called with a delay long enough to allow the internal input buffer to store more audio data than the specified size, the method returns immediately without blocking its thread.<\/li>\n<\/ul>\n<\/li>\n<li>\nStop the recording process using the <code>Unprepare()<\/code> method:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>audioCapture.<\/span>Unprepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<\/ol>\n<a name=\"async_recording\"><\/a><\/p>\n<h2 id=\"content-manage-asynchronous-recording\"><a href=https://samsungtizenos.com/"#content-manage-asynchronous-recording\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage asynchronous recording<\/h2>\nThe asynchronous recording process uses an event to store the audio recorded by the audio input device. The event is raised for each recorded audio chunk. In this use case, the audio data is stored in a stream.<\/p>\nTo start recording audio, follow these steps:<\/p>\n<ol>\n<li>\nAdd an event handler for the <code>DataAvailable<\/code> event of the <a href=https://samsungtizenos.com/"//application//dotnet//api//TizenFX//latest//api//Tizen.Multimedia.AsyncAudioCapture.md/">Tizen.Multimedia.AsyncAudioCapture class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>var<\/span> <\/span>asyncAudioCapture<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>AsyncAudioCapture<\/span>(<\/span>44100<\/span>, AudioChannel.Mono, AudioSampleType.S16Le);<\/span><\/span>\n<\/span>\n\/\/\/ Add an event handler invoked asynchronously for each recorded audio chunk<\/span><\/span>\nasyncAudioCapture<\/span>.<\/span>DataAvailable<\/span> <\/span>+<\/span>=<\/span> OnDataAvailable;<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<li>\nPrepare the audio input device and start the recording process using the <code>Prepare()<\/code> method of the <code>Tizen.Multimedia.AsyncAudioCapture<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>asyncAudioCapture.<\/span>Prepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\nThe hardware device starts buffering the audio recorded by the audio input device. The audio data is buffered to the internal input buffer. The event is raised for each audio data chunk.<\/p>\n<\/li>\n<li>\nTo store the recorded audio data:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>Stream<\/span> <\/span>stream<\/span>;<\/span><\/span>\n<\/span>\n\/\/\/ Event handler invoked for each recorded audio chunk<\/span><\/span>\nvoid<\/span> <\/span>OnDataAvailable<\/span>(<\/span>object<\/span> <\/span>sender<\/span>, <\/span>AudioDataAvailableEventArgs<\/span> <\/span>args<\/span>)<\/span><\/span>\n{<\/span><\/span>\n \/\/\/ Write the recorded audio data to the stream<\/span><\/span>\n stream.<\/span>Write<\/span>(args.Data, <\/span>0<\/span>, args.Data.Length);<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre>\n<\/li>\n<li>\nStop the recording process using the <code>Unprepare()<\/code> method:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code>asyncAudioCapture.<\/span>Unprepare<\/span>();<\/span><\/span>\n<\/span><\/code><\/pre>\nThe device no longer raises the event.<\/p>\n<\/li>\n<\/ol>\n<h2 id=\"content-related-information\"><a href=https://samsungtizenos.com/"#content-related-information\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Related information<\/h2>\n<ul>\n<li>Dependencies\n<ul>\n<li>Tizen 4.0 and Higher<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n","table_of_content":"<ul class=\"table-of-contents\">\n<li><a href=https://samsungtizenos.com/"#content-audio-output\">Audio output<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-audio-input\">Audio input<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-prerequisites\">Prerequisites<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-manage-synchronous-playback\">Manage synchronous playback<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-manage-asynchronous-playback\">Manage asynchronous playback<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-manage-synchronous-recording\">Manage synchronous recording<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-manage-asynchronous-recording\">Manage asynchronous recording<\/a><\/li>\n<li><a href=https://samsungtizenos.com/"#content-related-information\">Related information<\/a><\/li>\n<\/ul>\n","title":"Raw Audio Playback and Recording","raw":null},{"class":"App\\Services\\Documentation\\Data\\RenderedMarkdown","s":"wrbl"}]},"memo":{"id":"Snxcmvz2oGrS1UllciF7","name":"documentation::article","path":"docs\/application\/dotnet\/guides\/multimedia\/raw-audio","method":"GET","release":"a-a-a","children":[],"scripts":[],"assets":[],"lazyLoaded":false,"lazyIsolated":true,"errors":[],"locale":"en","islands":[]},"checksum":"401f1eb048e65d8828f79fc72b23b6f8b5e23901f6119e280af79e6b781010d5"}" wire:effects="[]" wire:id="Snxcmvz2oGrS1UllciF7" wire:name="documentation::article" x-init="$wire.__lazyLoad('{"data":{"forMount":[{"markdown":[{"body":"<h1 id=\"content-raw-audio-playback-and-recording\"><a href=\"#content-raw-audio-playback-and-recording\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Raw Audio Playback and Recording<\/h1><div data-knowledge-base-metadata><\/div>\n<p>Pulse Code Modulated (PCM) data contains uncompressed audio. You can play and record uncompressed audio data both synchronously and asynchronously.<\/p>\n<p>The main uncompressed audio management features are described below:<\/p>\n<ul>\n<li>\n<p>Playing uncompressed audio<\/p>\n<p>You can <a href=\"#play_pcm\">play uncompressed audio<\/a> in your application.<\/p>\n<\/li>\n<li>\n<p>Recording uncompressed audio<\/p>\n<p>You can <a href=\"#record_pcm\">record uncompressed audio<\/a> synchronously or asynchronously.<\/p>\n<\/li>\n<\/ul>\n<p><a name=\"play_pcm\"><\/a><\/p>\n<h2 id=\"content-audio-output\"><a href=\"#content-audio-output\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Audio output<\/h2>\n<p>The <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Multimedia.AudioPlayback.md\">Tizen.Multimedia.AudioPlayback<\/a> class enables your application to play uncompressed audio. You can <a href=\"#simple_playback\">play audio synchronously<\/a>, or <a href=\"#async_playback\">do it asynchronously<\/a>.<\/p>\n<p>Your application must define the following PCM data settings:<\/p>\n<ul>\n<li>Audio channels:\n<ul>\n<li><code>Mono<\/code> : Mono (1 channel)<\/li>\n<li><code>Stereo<\/code> : Stereo (2 channels)<\/li>\n<li><code>MultiChannel3<\/code> : Multi channel (3 channels)<\/li>\n<li><code>MultiChannel4<\/code> : Multi channel (4 channels)<\/li>\n<li><code>MultiChannel5<\/code> : Multi channel (5 channels)<\/li>\n<li><code>MultiChannel6<\/code> : Multi channel (6 channels)<\/li>\n<li><code>MultiChannel7<\/code> : Multi channel (7 channels)<\/li>\n<li><code>MultiChannel8<\/code> : Multi channel (8 channels)<\/li>\n<\/ul>\n<\/li>\n<li>Audio sample type:\n<ul>\n<li><code>U8<\/code> : Unsigned 8-bit PCM<\/li>\n<li><code>S16LE<\/code> : Signed 16-bit PCM, little endian<\/li>\n<li><code>S24LE<\/code> : Signed 24-bit PCM, little endian<\/li>\n<li><code>S24Packed<\/code> : Signed 24 bit PCM in LSB of 32 bit words, little endian<\/li>\n<li><code>S32LE<\/code> : Signed 32 bit PCM, little endian<\/li>\n<\/ul>\n<\/li>\n<li>Audio sample rate:\n<ul>\n<li>8000 ~ 192000 Hz<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p>To support various low-end Tizen devices, the application must follow certain guidelines which are described below:<\/p>\n<ul>\n<li>\n<p>Do not use excessive instances of the <code>Tizen.Multimedia.AudioPlayback<\/code> class.<\/p>\n<p>Using many <code>Tizen.Multimedia.AudioPlayback<\/code> class instances decrease application performance because processing audio data for re-sampling and mixing imposes a heavy burden on the system.<\/p>\n<\/li>\n<li>\n<p>Use the device-preferred PCM format.<\/p>\n<p>To reduce the processing overhead, select the PCM format based on the target device preference (for example, signed 16-bit little endian, stereo, 44100 Hz).<\/p>\n<p>Using the preferred format reduces internal operations, such as converting audio samples from mono to stereo or re-sampling audio frequency to fit the target device's input sample rate.<\/p>\n<\/li>\n<li>\n<p>Reduce event delay and remove glitches.<\/p>\n<p>The <code>Tizen.Multimedia.AudioPlayback<\/code> class instance works recursively, using events. The smaller the buffer size, the more often events are generated. If you use a small buffer in addition to other resources (for example, a timer or sensor), application performance decreases because the events cause delays. To prevent problems, set an appropriate write buffer size.<\/p>\n<p>To guarantee that the events of the <code>Tizen.Multimedia.AudioPlayback<\/code> class work independently, create a <code>Tizen.Multimedia.AudioPlayback<\/code> class instance in the event thread.<\/p>\n<\/li>\n<li>\n<p>Use double buffering.<\/p>\n<p>Use the double-buffering mechanism to reduce latency. It works by first writing the data twice before starting playback. After starting, whenever the event handler is called, you can write additional data.<\/p>\n<\/li>\n<li>\n<p>Save power.<\/p>\n<p>If audio playback has stopped for a long time, such as because the screen has switched off or there is no audio data, call the <code>Unprepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class to pause the stream and save power. The device cannot go into sleep mode while the <code>Tizen.Multimedia.AudioPlayback<\/code> instance is in the <code>Running<\/code> state.<\/p>\n<\/li>\n<\/ul>\n<p><a name=\"record_pcm\"><\/a><\/p>\n<h2 id=\"content-audio-input\"><a href=\"#content-audio-input\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Audio input<\/h2>\n<p>You can enable your application to record uncompressed audio from a microphone-type input device. You can <a href=\"#simple_recording\">record audio synchronously<\/a> with the <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Multimedia.AudioCapture.md\">Tizen.Multimedia.AudioCapture<\/a> class, or <a href=\"#async_recording\">do it asynchronously<\/a> with the <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Multimedia.AsyncAudioCapture.md\">Tizen.Multimedia.AsyncAudioCapture<\/a> class.<\/p>\n<p>Audio data is captured periodically. To receive the audio PCM data from the input device, you must implement the audio capture interface to notify the application of audio data events, such as when the audio data buffer is full.<\/p>\n<p>Before recording audio, you must define the PCM data settings. For more information, see <a href=\"#play_pcm\">audio output<\/a>.<\/p>\n<h2 id=\"content-prerequisites\"><a href=\"#content-prerequisites\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Prerequisites<\/h2>\n<p>To make your application visible in the official site for Tizen applications only for devices that support a microphone, the application must specify the following feature in the <code>tizen-manifest.xml<\/code> file:<\/p>\n<code class=\"language-XML\">&lt;feature name=&quot;http:\/\/tizen.org\/feature\/microphone&quot;\/&gt;\n<\/code>\n<p><a name=\"simple_playback\"><\/a><\/p>\n<h2 id=\"content-manage-synchronous-playback\"><a href=\"#content-manage-synchronous-playback\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage synchronous playback<\/h2>\n<p>Because the synchronous playback process blocks other processes running in the same thread, launching a playback process from the application main thread can make the application unresponsive. To prevent this, launch the playback process from its own thread.<\/p>\n<p>To play audio, follow these steps:<\/p>\n<ol>\n<li>\n<p>Prepare the audio output device and start the playback process using the <code>Prepare()<\/code> method of the <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Multimedia.AudioPlayback.md\">Tizen.Multimedia.AudioPlayback<\/a> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">var<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">audioPlayback<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">new<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">AudioPlayback<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#24292E;--shiki-dark:#79B8FF\">44100<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, AudioChannel.Mono, AudioSampleType.S16Le);<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">\/\/\/ Prepare the audio output device (start the hardware playback process)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">audioPlayback<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Prepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The hardware device prepares its internal output buffer for playback. Playback begins when the internal output buffer starts receiving audio data.<\/p>\n<\/li>\n<li>\n<p>To start playing the recorded audio, copy the audio data from the local buffer to the internal output buffer using the <code>Write()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">int<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">bytesWritten<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> audioPlayback.<\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">Write<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(buffer);<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The returned value represents the number of bytes written to the internal output buffer.<\/p>\n<\/li>\n<li>\n<p>Stop the playback process using the <code>Unprepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">audioPlayback.<\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">Unprepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<\/ol>\n<p><a name=\"async_playback\"><\/a><\/p>\n<h2 id=\"content-manage-asynchronous-playback\"><a href=\"#content-manage-asynchronous-playback\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage asynchronous playback<\/h2>\n<p>The asynchronous playback process uses the <code>BufferAvailable<\/code> event of the <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Multimedia.AudioPlayback.md\">Tizen.Multimedia.AudioPlayback<\/a> class to play the recorded audio. The event is raised for each recorded audio chunk. In the following example, the audio data is read from a stream.<\/p>\n<p>To start playing the recorded audio, follow these steps:<\/p>\n<ol>\n<li>\n<p>Add an event handler for the <code>BufferAvailable<\/code> event:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">audioPlayback.BufferAvailable <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">+=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> OnBufferAvailable;<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<li>\n<p>Prepare the audio output device and start the playback process using the <code>Prepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">audioPlayback.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Prepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The hardware device prepares its internal output buffer for playback.<\/p>\n<\/li>\n<li>\n<p>Play audio from a stream.<\/p>\n<p>Read audio data from the stream and write it to the internal output buffer using the <code>Write()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class. Playback begins when the internal output buffer starts receiving the audio data:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Stream<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">stream<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnBufferAvailable<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">object<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">sender<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">AudioPlaybackBufferAvailableEventArgs<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">args<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">if<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> (args.Length <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">&gt;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">0<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    {<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">try<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        {<\/span><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">            \/\/\/ Allocate a local buffer for reading the audio data from the stream<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">            <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">byte<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">[] <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">buffer<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">new<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">byte<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">[args.Length];<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">            \/\/\/ Read audio data from the stream and store it in the local buffer<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">            stream.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Read<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(buffer, <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">0<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, args.Length);<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">            \/\/\/ Copy the audio data from the local buffer<\/span><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">            \/\/\/ to the internal output buffer (starts playback)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">            audioPlayback.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Write<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(buffer);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        }<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">catch<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Exception<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">e<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        {<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">            Tizen.Log.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Error<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(LOG_TAG, <\/span><span style=\"color:#032F62;--shiki-dark:#9ECBFF\">&quot;Failed to write. &quot;<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">+<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> e);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">        }<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    }<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<li>\n<p>Stop the playback process using the <code>Unprepare()<\/code> method of the <code>Tizen.Multimedia.AudioPlayback<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">\/\/\/ Stop the hardware playback process<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">audioPlayback.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Unprepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The device no longer raises the event.<\/p>\n<\/li>\n<\/ol>\n<p><a name=\"simple_recording\"><\/a><\/p>\n<h2 id=\"content-manage-synchronous-recording\"><a href=\"#content-manage-synchronous-recording\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage synchronous recording<\/h2>\n<p>Before starting the synchronous recording process, you need to know the size of the buffer where the recorded audio data is to be saved, based on the expected recording duration. The recording process ends once it has read the specified number of bytes.<\/p>\n<p>To calculate and set the required buffer size, use one of the following options:<\/p>\n<ol>\n<li>\n<p>Calculate the buffer size based on the recommendation of the sound server, such as PulseAudio:<\/p>\n<ul>\n<li>\n<p>Retrieve the recommended buffer size using the <code>GetBufferSize()<\/code> method of the <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Multimedia.AudioCapture.md\">Tizen.Multimedia.AudioCapture<\/a> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">var<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">audioCapture<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">new<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">AudioCapture<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">44100<\/span><span style=\"color:#005CC5;--shiki-dark:#E1E4E8\">, AudioChannel.Mono, AudioSampleType.S16Le);<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">int<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">bufferSize<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> audioCapture.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">GetBufferSize<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>If no exception is thrown, the method returns the preferred size in bytes, based on the specified audio parameters.<\/p>\n<p>The recommended buffer size depends on the device. The size can be different for mobile, wearable, and TV devices.<\/p>\n<\/li>\n<li>\n<p>Set the buffer size to correspond to the desired recording duration.<\/p>\n<p>For the device in this example, the <code>GetBufferSize()<\/code> method returns the recommended buffer size for 100 milliseconds of recording time. To determine the total recommended buffer size, multiply the recommended buffer size by 10 (to get the buffer size per second) and by the length of the recording in seconds:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">const<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">int<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#B392F0\">RecordingSec<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#79B8FF\">5<\/span><span style=\"color:#D73A49;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">bufferSize <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">*=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">10<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">*<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> RecordingSec;<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Calculate the required buffer size explicitly:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">int<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">bufferSize<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> AudioCapture.SampleRate <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">*<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> (audioCapture.Channel <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">==<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> AudioChannel.Stereo <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">?<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#79B8FF\">2<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">:<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#79B8FF\">1<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">) <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">*<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    (<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">audioCapture<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">SampleType<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">==<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">AudioSampleType<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">S16Le<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">?<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#79B8FF\">2<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">:<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#79B8FF\">1<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">);<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">bufferSize <\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">*=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> RecordingSec;<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<\/ol>\n<p>The synchronous recording process blocks other processes running in the same thread. Launching a recording process from the application main thread can make the application unresponsive. To prevent this, launch the recording process from its own thread.<\/p>\n<p>To record audio, follow these steps:<\/p>\n<ol>\n<li>\n<p>Prepare the audio input device and start the recording process using the <code>Prepare()<\/code> method of the <code>Tizen.Multimedia.AudioCapture<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">audioCapture.<\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">Prepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The hardware device starts buffering the audio recorded by the audio input device. The audio data is buffered to the internal input buffer.<\/p>\n<\/li>\n<li>\n<p>Read the audio data from the internal input buffer using the <code>Read()<\/code> method:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">byte<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">[] <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">buffer<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> audioCapture.<\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">Read<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(bufferSize);<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The <code>Read()<\/code> method can behave in the following ways:<\/p>\n<ul>\n<li>If the method is called immediately after preparing the audio input device, it blocks the thread that it was launched from until it reads bytes specified.<\/li>\n<li>If the method is called with a delay long enough to allow the internal input buffer to store more audio data than the specified size, the method returns immediately without blocking its thread.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Stop the recording process using the <code>Unprepare()<\/code> method:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">audioCapture.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Unprepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<\/ol>\n<p><a name=\"async_recording\"><\/a><\/p>\n<h2 id=\"content-manage-asynchronous-recording\"><a href=\"#content-manage-asynchronous-recording\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Manage asynchronous recording<\/h2>\n<p>The asynchronous recording process uses an event to store the audio recorded by the audio input device. The event is raised for each recorded audio chunk. In this use case, the audio data is stored in a stream.<\/p>\n<p>To start recording audio, follow these steps:<\/p>\n<ol>\n<li>\n<p>Add an event handler for the <code>DataAvailable<\/code> event of the <a href=\"\/application\/dotnet\/api\/TizenFX\/latest\/api\/Tizen.Multimedia.AsyncAudioCapture.md\">Tizen.Multimedia.AsyncAudioCapture<\/a> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#D73A49;--shiki-dark:#F97583\">var<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">asyncAudioCapture<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">new<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">AsyncAudioCapture<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#24292E;--shiki-dark:#79B8FF\">44100<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, AudioChannel.Mono, AudioSampleType.S16Le);<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">\/\/\/ Add an event handler invoked asynchronously for each recorded audio chunk<\/span><\/span>\n<span class=\"line\"><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">asyncAudioCapture<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">.<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">DataAvailable<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#24292E;--shiki-dark:#F97583\">+<\/span><span style=\"color:#D73A49;--shiki-dark:#F97583\">=<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> OnDataAvailable;<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<li>\n<p>Prepare the audio input device and start the recording process using the <code>Prepare()<\/code> method of the <code>Tizen.Multimedia.AsyncAudioCapture<\/code> class:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">asyncAudioCapture.<\/span><span style=\"color:#24292E;--shiki-dark:#B392F0\">Prepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The hardware device starts buffering the audio recorded by the audio input device. The audio data is buffered to the internal input buffer. The event is raised for each audio data chunk.<\/p>\n<\/li>\n<li>\n<p>To store the recorded audio data:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Stream<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">stream<\/span><span style=\"color:#6F42C1;--shiki-dark:#E1E4E8\">;<\/span><\/span>\n<span class=\"line\"><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">\/\/\/ Event handler invoked for each recorded audio chunk<\/span><\/span>\n<span class=\"line\"><span style=\"color:#6F42C1;--shiki-dark:#F97583\">void<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">OnDataAvailable<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(<\/span><span style=\"color:#6F42C1;--shiki-dark:#F97583\">object<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">sender<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">AudioDataAvailableEventArgs<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\"> <\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">args<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">)<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">{<\/span><\/span>\n<span class=\"line\"><span style=\"color:#6A737D;--shiki-dark:#6A737D\">    \/\/\/ Write the recorded audio data to the stream<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">    stream.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Write<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">(args.Data, <\/span><span style=\"color:#005CC5;--shiki-dark:#79B8FF\">0<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">, args.Data.Length);<\/span><\/span>\n<span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">}<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<\/li>\n<li>\n<p>Stop the recording process using the <code>Unprepare()<\/code> method:<\/p>\n<pre class=\"shiki shiki-themes github-light github-dark\" style=\"background-color:#fff;--shiki-dark-bg:#24292e;color:#24292e;--shiki-dark:#e1e4e8;\"><code><span class=\"line\"><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">asyncAudioCapture.<\/span><span style=\"color:#6F42C1;--shiki-dark:#B392F0\">Unprepare<\/span><span style=\"color:#24292E;--shiki-dark:#E1E4E8\">();<\/span><\/span>\n<span class=\"line\"><\/span><\/code><\/pre>\n<p>The device no longer raises the event.<\/p>\n<\/li>\n<\/ol>\n<h2 id=\"content-related-information\"><a href=\"#content-related-information\" class=\"heading-permalink\" aria-hidden=\"true\" title=\"Permalink\">\u00b6<\/a>Related information<\/h2>\n<ul>\n<li>Dependencies\n<ul>\n<li>Tizen 4.0 and Higher<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n","table_of_content":"<ul class=\"table-of-contents\">\n<li><a href=\"#content-audio-output\">Audio output<\/a><\/li>\n<li><a href=\"#content-audio-input\">Audio input<\/a><\/li>\n<li><a href=\"#content-prerequisites\">Prerequisites<\/a><\/li>\n<li><a href=\"#content-manage-synchronous-playback\">Manage synchronous playback<\/a><\/li>\n<li><a href=\"#content-manage-asynchronous-playback\">Manage asynchronous playback<\/a><\/li>\n<li><a href=\"#content-manage-synchronous-recording\">Manage synchronous recording<\/a><\/li>\n<li><a href=\"#content-manage-asynchronous-recording\">Manage asynchronous recording<\/a><\/li>\n<li><a href=\"#content-related-information\">Related information<\/a><\/li>\n<\/ul>\n","title":"Raw Audio Playback and Recording","raw":null},{"class":"App\\Services\\Documentation\\Data\\RenderedMarkdown","s":"wrbl"}]},{"s":"arr"}]},"memo":{"id":"dGXHgIQMz0GzBw4hIqZG","name":"__mountParamsContainer","path":"docs\/application\/dotnet\/guides\/multimedia\/raw-audio","method":"GET","release":"a-a-a"},"checksum":"bbd904ecd1f665286f9533d9fcd898fc9d46c8382d12853d9fdb52cd5af7c950"}')" >

Customize your cookie preferences

Necessary

Analytics