Stream to memory (smem) tutorial - Revision history

DoesItReallyMatter: +{{Example code}}, add wikilinks, markup, syntaxhighlight, +{{docmod}}

2019-03-04T09:38:12Z

+{{Example code}}, add wikilinks, markup, syntaxhighlight, +{{docmod}}

← Older revision		Revision as of 09:38, 4 March 2019
Line 1:		Line 1:
			{{Example code}}
	Here is a small tutorial intended to make a quick tour of the ''stream to memory'' module (smem) , included in VLC 1.1.0.		Here is a small tutorial intended to make a quick tour of the ''stream to memory'' module (smem) , included in VLC 1.1.0.
	This module allows you to write a code which handles the video and audio data read by VLC.		This module allows you to write a code which handles the video and audio data read by VLC.
	This page shows a basic code written in C which uses this module.		This page shows a basic code written in C which uses this module.

	/!\ Starting from VLC 2.2, smem uses size_t instead of unsigned int for buffer sizes.		/!\ Starting from VLC 2.2, smem uses <code>size_t</code> instead of <code>unsigned int</code> for buffer sizes.

	== Including VLC library ==		== Including VLC library ==

	<~~pre~~>#include <stdio.h>		<syntaxhighlight lang="c">
			#include <stdio.h>
	#include <stdint.h>		#include <stdint.h>

	#include <vlc/vlc.h></~~pre~~>		#include <vlc/vlc.h>
			</syntaxhighlight>

	== Defining callbacks ==		== Defining callbacks ==

	VLC sends you the data you need via two functions that you define yourself. They will be run before and after the data is rendered. There are two functions for the audio data, and two for the video one. In this example I will just show how to deal with audio data, the process is the same for video handling.		VLC sends you the data you need via two functions that you define yourself. They will be run before and after the data is rendered. There are two functions for the audio data, and two for the video one. In this example I will just show how to deal with audio data, the process is the same for video handling.
	<~~pre~~>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , size_t size); // Audio prerender callback		<syntaxhighlight lang="c">
			void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , size_t size); // Audio prerender callback
	void handleStream(void* p_audio_data, uint8_t* p_pcm_buffer, unsigned int channels, unsigned int rate, unsigned int nb_samples, unsigned int bits_per_sample, size_t size, int64_t pts); // Audio postrender callback		void handleStream(void* p_audio_data, uint8_t* p_pcm_buffer, unsigned int channels, unsigned int rate, unsigned int nb_samples, unsigned int bits_per_sample, size_t size, int64_t pts); // Audio postrender callback
	// Video prerender and postrender callbacks not implemented.</~~pre~~>		// Video prerender and postrender callbacks not implemented.
			</syntaxhighlight>

	== Creating a VLC instance ==		== Creating a VLC instance ==

	As with every application you build with libvlc, you have to initialize the library. But you also have to tell VLC the address of each callback you wrote. This is made by writing the address in the parameters used to launch VLC.		As with every application you build with libvlc, you have to initialize the library. But you also have to tell VLC the address of each callback you wrote. This is made by writing the address in the parameters used to launch VLC.
	<~~pre~~>int main(int argc, char **argv)		<syntaxhighlight lang="c">int main(int argc, char **argv)
	{		{
	// VLC pointers		// VLC pointers
Line 52:		Line 57:

	return 0;		return 0;
	}</~~pre~~>		}
			</syntaxhighlight>

	== Implementing callbacks ==		== Implementing callbacks ==
	{{mmwiki\|label1=PCM format\|PCM}}		{{mmwiki\|label1=PCM format\|PCM}}
	The smem module sends us the data in PCM format.		The {{docmod\|smem}} module sends us the data in [[PCM]] format.

	The first callback, called ''prepareRender'' in this example, locks the mutex and sets the data pointer (i.e. where the data will be written). All you have to do here is to ensure that ''*pp_pcm_buffer'' points now to a valid array where ''size'' bytes can be written.		The first callback, called <code>prepareRender</code> in this example, locks the mutex and sets the data pointer (i.e. where the data will be written). All you have to do here is to ensure that <code>*pp_pcm_buffer</code> points now to a valid array where <var>size</var> bytes can be written.

	The second callback, here ''handleStream'', is the place where you can do everything you want with the data you got !		The second callback, here <code>handleStream</code>, is the place where you can do everything you want with the data you got !

	The'' p_audio_data'' pointer is linked to the object you set in the command line parameters. It can be useful in order to communicate with the rest of the program.		The <code>p_audio_data</code> pointer is linked to the object you set in the command line parameters. It can be useful in order to communicate with the rest of the program.


	<~~pre~~>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , size_t size)		<syntaxhighlight lang="c">
			void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , size_t size)
	{		{
	// TODO: Lock the mutex		// TODO: Lock the mutex
Line 77:		Line 84:
	// TODO: Unlock the mutex		// TODO: Unlock the mutex
	}		}
	</~~pre~~>		</syntaxhighlight>

	== Handling the data ==		== Handling the data ==
	The PCM format is very raw, but you may still have to do some small transformations in order to be able to get the exact waveform of the audio stream.		The PCM format is very raw, but you may still have to do some small transformations in order to be able to get the exact waveform of the audio stream.

	First, the audio data is sent as an array of bytes, but each sample may be coded on more bytes : if you use the unchanged array, the values won't mean anything. The parameter ''bits_per_sample'' helps you to know how to tackle this problem.		First, the audio data is sent as an array of bytes, but each sample may be coded on more bytes : if you use the unchanged array, the values won't mean anything. The parameter <code>bits_per_sample</code> helps you to know how to tackle this problem.

	Then, the data is still in an unsigned format : the negative values have an offset which makes the data look weird.		Then, the data is still in an unsigned format : the negative values have an offset which makes the data look weird.

	~~[[Category:LibVLC]]~~
	[[Category:Coding]]		[[Category:Coding]]
			[[Category:libVLC]]

DoesItReallyMatter: /* Implementing callbacks */ fix {{mmwiki}} instance

2016-11-06T06:21:24Z

Implementing callbacks: fix {{mmwiki}} instance

← Older revision		Revision as of 06:21, 6 November 2016
Line 55:		Line 55:

	== Implementing callbacks ==		== Implementing callbacks ==
	{{mmwiki\|PCM format\|PCM}}		{{mmwiki\|label1=PCM format\|PCM}}
	The smem module sends us the data in PCM format.		The smem module sends us the data in PCM format.

Courmisch: Remove broken and/or useless command line options

2014-10-11T11:50:39Z

Remove broken and/or useless command line options

← Older revision		Revision as of 11:50, 11 October 2014
Line 40:		Line 40:

	const char * const vlc_args[] = {		const char * const vlc_args[] = {
	~~"-I", "dummy", // Don't use any interface~~
	~~"--ignore-config", // Don't use VLC's config~~
	~~"--extraintf=logger", // Log anything~~
	"--verbose=2", // Be much more verbose then normal for debugging purpose		"--verbose=2", // Be much more verbose then normal for debugging purpose
	"--sout", smem_options // Stream to memory		"--sout", smem_options // Stream to memory

Chouquette: unsigned int -> size_t for size parameters

2014-01-31T15:00:58Z

unsigned int -> size_t for size parameters

← Older revision		Revision as of 15:00, 31 January 2014
Line 2:		Line 2:
	This module allows you to write a code which handles the video and audio data read by VLC.		This module allows you to write a code which handles the video and audio data read by VLC.
	This page shows a basic code written in C which uses this module.		This page shows a basic code written in C which uses this module.

			/!\ Starting from VLC 2.2, smem uses size_t instead of unsigned int for buffer sizes.

	== Including VLC library ==		== Including VLC library ==
Line 13:		Line 15:

	VLC sends you the data you need via two functions that you define yourself. They will be run before and after the data is rendered. There are two functions for the audio data, and two for the video one. In this example I will just show how to deal with audio data, the process is the same for video handling.		VLC sends you the data you need via two functions that you define yourself. They will be run before and after the data is rendered. There are two functions for the audio data, and two for the video one. In this example I will just show how to deal with audio data, the process is the same for video handling.
	<pre>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , ~~unsigned int~~ size); // Audio prerender callback		<pre>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , size_t size); // Audio prerender callback
	void handleStream(void* p_audio_data, uint8_t* p_pcm_buffer, unsigned int channels, unsigned int rate, unsigned int nb_samples, unsigned int bits_per_sample, ~~unsigned int~~ size, int64_t pts); // Audio postrender callback		void handleStream(void* p_audio_data, uint8_t* p_pcm_buffer, unsigned int channels, unsigned int rate, unsigned int nb_samples, unsigned int bits_per_sample, size_t size, int64_t pts); // Audio postrender callback
	// Video prerender and postrender callbacks not implemented.</pre>		// Video prerender and postrender callbacks not implemented.</pre>

Line 66:		Line 68:


	<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , ~~unsigned int~~ size)		<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , size_t size)
	{		{
	// TODO: Lock the mutex		// TODO: Lock the mutex
Line 73:		Line 75:
	}		}

	void handleStream(void* p_audio_data, uint8_t* p_pcm_buffer, unsigned int channels, unsigned int rate, unsigned int nb_samples, unsigned int bits_per_sample, ~~unsigned int~~ size, int64_t pts )		void handleStream(void* p_audio_data, uint8_t* p_pcm_buffer, unsigned int channels, unsigned int rate, unsigned int nb_samples, unsigned int bits_per_sample, size_t size, int64_t pts )
	{		{
	// TODO: explain how data should be handled		// TODO: explain how data should be handled
Line 85:		Line 87:
	First, the audio data is sent as an array of bytes, but each sample may be coded on more bytes : if you use the unchanged array, the values won't mean anything. The parameter ''bits_per_sample'' helps you to know how to tackle this problem.		First, the audio data is sent as an array of bytes, but each sample may be coded on more bytes : if you use the unchanged array, the values won't mean anything. The parameter ''bits_per_sample'' helps you to know how to tackle this problem.

	Then, the data is still in an unsigned format : the negative values have an offset which makes the data look ~~wierd~~.		Then, the data is still in an unsigned format : the negative values have an offset which makes the data look weird.

	[[Category:LibVLC]]		[[Category:LibVLC]]
	[[Category:Coding]]		[[Category:Coding]]

Edwardw at 01:40, 3 February 2012

2012-02-03T01:40:55Z

← Older revision		Revision as of 01:40, 3 February 2012
Line 87:		Line 87:
	Then, the data is still in an unsigned format : the negative values have an offset which makes the data look wierd.		Then, the data is still in an unsigned format : the negative values have an offset which makes the data look wierd.

			[[Category:LibVLC]]
	[[Category:Coding]]		[[Category:Coding]]

Trishika: Undo revision 21243 by Trishika (Talk)

2012-01-16T17:36:26Z

Undo revision 21243 by Trishika (Talk)

← Older revision		Revision as of 17:36, 16 January 2012
Line 30:		Line 30:
	char smem_options[256];		char smem_options[256];

	sprintf(smem_options, "#transcode{~~vcodec=RV24,~~acodec=s16l}:smem{audio-postrender-callback=%lld,audio-prerender-callback=%lld}",		sprintf(smem_options, "#transcode{acodec=s16l}:smem{audio-postrender-callback=%lld,audio-prerender-callback=%lld}",
	// We are using transcode because smem only support raw audio and video formats		// We are using transcode because smem only support raw audio and video formats

Trishika: Add vcodec for trancode to raw video

2012-01-16T17:32:28Z

Add vcodec for trancode to raw video

← Older revision		Revision as of 17:32, 16 January 2012
Line 30:		Line 30:
	char smem_options[256];		char smem_options[256];

	sprintf(smem_options, "#transcode{acodec=s16l}:smem{audio-postrender-callback=%lld,audio-prerender-callback=%lld}",		sprintf(smem_options, "#transcode{vcodec=RV24,acodec=s16l}:smem{audio-postrender-callback=%lld,audio-prerender-callback=%lld}",
	// We are using transcode because smem only support raw audio and video formats		// We are using transcode because smem only support raw audio and video formats

J-b at 11:27, 23 November 2010

2010-11-23T11:27:28Z

← Older revision		Revision as of 11:27, 23 November 2010
Line 86:		Line 86:

	Then, the data is still in an unsigned format : the negative values have an offset which makes the data look wierd.		Then, the data is still in an unsigned format : the negative values have an offset which makes the data look wierd.


			[[Category:Coding]]

Berthe: mistakes…

2010-11-02T08:24:31Z

mistakes…

← Older revision		Revision as of 08:24, 2 November 2010
Line 63:		Line 63:
	The second callback, here ''handleStream'', is the place where you can do everything you want with the data you got !		The second callback, here ''handleStream'', is the place where you can do everything you want with the data you got !

	The ~~pointer~~ ''p_audio_data'' ~~points~~ to the object you set in the command line parameters. It can be useful to communicate with the rest of the ~~application~~.		The'' p_audio_data'' pointer is linked to the object you set in the command line parameters. It can be useful in order to communicate with the rest of the program.


	<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)		<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)

Berthe: Added some info about callbacks

2010-10-28T22:44:07Z

Added some info about callbacks

← Older revision		Revision as of 22:44, 28 October 2010
Line 4:		Line 4:

	== Including VLC library ==		== Including VLC library ==

	~~An easy part : we just have to include one header. Don't forget to have the linker add the library.~~

	<pre>#include <stdio.h>		<pre>#include <stdio.h>
Line 61:		Line 59:
	The smem module sends us the data in PCM format.		The smem module sends us the data in PCM format.

	~~TODO: Here some text describing~~ the ~~behaviour~~ of ~~callbacks~~		The first callback, called ''prepareRender'' in this example, locks the mutex and sets the data pointer (i.e. where the data will be written). All you have to do here is to ensure that ''*pp_pcm_buffer'' points now to a valid array where ''size'' bytes can be written.

			The second callback, here ''handleStream'', is the place where you can do everything you want with the data you got !

			The pointer ''p_audio_data'' points to the object you set in the command line parameters. It can be useful to communicate with the rest of the application.

	<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)		<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)
Line 76:		Line 78:
	}		}
	</pre>		</pre>

			== Handling the data ==
			The PCM format is very raw, but you may still have to do some small transformations in order to be able to get the exact waveform of the audio stream.

			First, the audio data is sent as an array of bytes, but each sample may be coded on more bytes : if you use the unchanged array, the values won't mean anything. The parameter ''bits_per_sample'' helps you to know how to tackle this problem.

			Then, the data is still in an unsigned format : the negative values have an offset which makes the data look wierd.