VideoLAN Wiki - User contributions [en]

Stream to memory (smem) tutorial

2010-11-02T08:24:31Z

Berthe: mistakes…

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 page shows a basic code written in C which uses this module.

== Including VLC library ==

<pre>#include <stdio.h>
#include <stdint.h>

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

== 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.
<pre>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int 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
// Video prerender and postrender callbacks not implemented.</pre>

== 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.
<pre>int main(int argc, char **argv)
{
// VLC pointers
libvlc_instance_t *vlcInstance;
libvlc_media_player_t *mp;
libvlc_media_t *media;

// VLC options
char smem_options[256];

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

(long long int)(intptr_t)(void*)&handleStream, (long long int)(intptr_t)(void*)&prepareRender);
// We print (as a decimal value) the addresses. Note that you can also define smem-audio-data : this pointer
// will be passed to your callbacks (it may be useful to retrive some extra informations) but isn't required at all.

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
"--sout", smem_options // Stream to memory
};

// We launch VLC
vlcInstance = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args);

mp = libvlc_media_player_new(vlcInstance);

// To be continued.

return 0;
}</pre>

== Implementing callbacks ==
{{mmwiki|PCM format|PCM}}
The 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 second callback, here ''handleStream'', 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.

<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)
{
// TODO: Lock the mutex

*pp_pcm_buffer = // TODO
}

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 )
{
// TODO: explain how data should be handled
// TODO: Unlock the mutex
}
</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.

Stream to memory (smem) tutorial

2010-10-28T22:44:07Z

Berthe: Added some info about callbacks

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 page shows a basic code written in C which uses this module.

== Including VLC library ==

<pre>#include <stdio.h>
#include <stdint.h>

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

== 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.
<pre>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int 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
// Video prerender and postrender callbacks not implemented.</pre>

== 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.
<pre>int main(int argc, char **argv)
{
// VLC pointers
libvlc_instance_t *vlcInstance;
libvlc_media_player_t *mp;
libvlc_media_t *media;

// VLC options
char smem_options[256];

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

(long long int)(intptr_t)(void*)&handleStream, (long long int)(intptr_t)(void*)&prepareRender);
// We print (as a decimal value) the addresses. Note that you can also define smem-audio-data : this pointer
// will be passed to your callbacks (it may be useful to retrive some extra informations) but isn't required at all.

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
"--sout", smem_options // Stream to memory
};

// We launch VLC
vlcInstance = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args);

mp = libvlc_media_player_new(vlcInstance);

// To be continued.

return 0;
}</pre>

== Implementing callbacks ==
{{mmwiki|PCM format|PCM}}
The 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 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)
{
// TODO: Lock the mutex

*pp_pcm_buffer = // TODO
}

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 )
{
// TODO: explain how data should be handled
// TODO: Unlock the mutex
}
</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.

Stream to memory (smem) tutorial

2010-06-19T12:30:43Z

Berthe: /* Implementing callbacks */ Added some info about PCM (TBC)

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 page shows a basic code written in C which uses this module.

== 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>
#include <stdint.h>

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

== 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.
<pre>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int 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
// Video prerender and postrender callbacks not implemented.</pre>

== 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.
<pre>int main(int argc, char **argv)
{
// VLC pointers
libvlc_instance_t *vlcInstance;
libvlc_media_player_t *mp;
libvlc_media_t *media;

// VLC options
char smem_options[256];

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

(long long int)(intptr_t)(void*)&handleStream, (long long int)(intptr_t)(void*)&prepareRender);
// We print (as a decimal value) the addresses. Note that you can also define smem-audio-data : this pointer
// will be passed to your callbacks (it may be useful to retrive some extra informations) but isn't required at all.

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
"--sout", smem_options // Stream to memory
};

// We launch VLC
vlcInstance = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args);

mp = libvlc_media_player_new(vlcInstance);

// To be continued.

return 0;
}</pre>

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

TODO: Here some text describing the behaviour of callbacks

<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)
{
// TODO: Lock the mutex

*pp_pcm_buffer = // TODO
}

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 )
{
// TODO: explain how data should be handled
// TODO: Unlock the mutex
}
</pre>

Talk:Quality

2010-06-18T11:29:20Z

Berthe: outdated ?

I would suggest listing the testfiles up on the Wiki-page and numbering them. Maybe include advance features like videofilters, special outputs, the used acess-module and/or even the whole vlcrc configuration file.
When someone encounters a problem in QA he/she could refer to 'Test 1' or 'Test A' or something that describes the setup and settings.

== Outdated ? ==
I think this page is outdated, it should be removed or updated, but I don't really know what to put here... [[User:Berthe|berthe]] 11:29, 18 June 2010 (UTC)

Talk:LibVLC

2010-06-16T16:44:40Z

Berthe: /* Add article */

== Add article ==

I created аrticle-translation in Russian "How use libvlc"(http://unick-soft.ru/Articles.cgi?id=15) Can you add link to it in topic? you are interesting articles in English only.

[[User:Unick|Unick]] 23:25, 10 November 2009 (UTC)

== Smem tutorial ==
I started to write a tutorial for smem. Can I add it here ? [http://wiki.videolan.org/Stream_to_memory_%28smem%29_tutorial|link to the tutorial].
[[User:Berthe|berthe]] 16:44, 16 June 2010 (UTC)

Stream to memory (smem) tutorial

2010-06-16T16:31:32Z

Berthe: first sentence was not correct, I hope that's better now

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 page shows a basic code written in C which uses this module.

== 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>
#include <stdint.h>

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

== 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.
<pre>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int 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
// Video prerender and postrender callbacks not implemented.</pre>

== 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.
<pre>int main(int argc, char **argv)
{
// VLC pointers
libvlc_instance_t *vlcInstance;
libvlc_media_player_t *mp;
libvlc_media_t *media;

// VLC options
char smem_options[256];

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

(long long int)(intptr_t)(void*)&handleStream, (long long int)(intptr_t)(void*)&prepareRender);
// We print (as a decimal value) the addresses. Note that you can also define smem-audio-data : this pointer
// will be passed to your callbacks (it may be useful to retrive some extra informations) but isn't required at all.

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
"--sout", smem_options // Stream to memory
};

// We launch VLC
vlcInstance = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args);

mp = libvlc_media_player_new(vlcInstance);

// To be continued.

return 0;
}</pre>

== Implementing callbacks ==

TODO: Here some text describing the behaviour of callbacks

<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)
{
// TODO: Lock the mutex

*pp_pcm_buffer = // TODO
}

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 )
{
// TODO: explain how data should be handled
// TODO: Unlock the mutex
}
</pre>

Stream to memory (smem) tutorial

2010-06-16T16:28:02Z

Berthe: Created page with 'Here is a small tutorial intended to purpose a quick tour of the ''stream to memory (smem)'' module, included in VLC 1.1.0. This module allows you to write a code which handles t…'

Here is a small tutorial intended to purpose a quick tour of the ''stream to memory (smem)'' module, 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 page shows a basic code written in C which uses this module.

== 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>
#include <stdint.h>

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

== 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.
<pre>void prepareRender(void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int 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
// Video prerender and postrender callbacks not implemented.</pre>

== 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.
<pre>int main(int argc, char **argv)
{
// VLC pointers
libvlc_instance_t *vlcInstance;
libvlc_media_player_t *mp;
libvlc_media_t *media;

// VLC options
char smem_options[256];

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

(long long int)(intptr_t)(void*)&handleStream, (long long int)(intptr_t)(void*)&prepareRender);
// We print (as a decimal value) the addresses. Note that you can also define smem-audio-data : this pointer
// will be passed to your callbacks (it may be useful to retrive some extra informations) but isn't required at all.

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
"--sout", smem_options // Stream to memory
};

// We launch VLC
vlcInstance = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args);

mp = libvlc_media_player_new(vlcInstance);

// To be continued.

return 0;
}</pre>

== Implementing callbacks ==

TODO: Here some text describing the behaviour of callbacks

<pre>void prepareRender (void* p_audio_data, uint8_t** pp_pcm_buffer , unsigned int size)
{
// TODO: Lock the mutex

*pp_pcm_buffer = // TODO
}

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 )
{
// TODO: explain how data should be handled
// TODO: Unlock the mutex
}
</pre>