smem.c 17 KB
Newer Older
1 2 3
/*****************************************************************************
 * smem.c: stream output to memory buffer module
 *****************************************************************************
4
 * Copyright (C) 2009 VLC authors and VideoLAN
5 6 7 8
 * $Id$
 *
 * Authors: Christophe Courtaut <christophe.courtaut@gmail.com>
 *
9 10 11
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
12 13 14 15
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
18
 *
19 20 21
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 23 24 25 26 27 28 29 30 31 32 33 34
 *****************************************************************************/

/*****************************************************************************
 * How to use it
 *****************************************************************************
 *
 * You should use this module in combination with the transcode module, to get
 * raw datas from it. This module does not make any conversion at all, so you
 * need to use the transcode module for this purpose.
 *
 * For example, you can use smem as it :
 * --sout="#transcode{vcodec=RV24,acodec=s16l}:smem{smem-options}"
 *
35
 * Into each lock function (audio and video), you will have all the information
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
 * you need to allocate a buffer, so that this module will copy data in it.
 *
 * the video-data and audio-data pointers will be passed to lock/unlock function
 *
 ******************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_sout.h>
#include <vlc_block.h>
#include <vlc_codec.h>
55
#include <vlc_aout.h>
56 57 58 59 60 61

/*****************************************************************************
 * Module descriptor
 *****************************************************************************/

#define T_VIDEO_PRERENDER_CALLBACK N_( "Video prerender callback" )
Kaarlo Raiha's avatar
Kaarlo Raiha committed
62 63
#define LT_VIDEO_PRERENDER_CALLBACK N_( "Address of the video prerender callback function. " \
                                "This function will set the buffer where render will be done." )
64 65

#define T_AUDIO_PRERENDER_CALLBACK N_( "Audio prerender callback" )
Kaarlo Raiha's avatar
Kaarlo Raiha committed
66 67
#define LT_AUDIO_PRERENDER_CALLBACK N_( "Address of the audio prerender callback function. " \
                                        "This function will set the buffer where render will be done." )
68 69

#define T_VIDEO_POSTRENDER_CALLBACK N_( "Video postrender callback" )
Kaarlo Raiha's avatar
Kaarlo Raiha committed
70 71
#define LT_VIDEO_POSTRENDER_CALLBACK N_( "Address of the video postrender callback function. " \
                                        "This function will be called when the render is into the buffer." )
72 73

#define T_AUDIO_POSTRENDER_CALLBACK N_( "Audio postrender callback" )
Kaarlo Raiha's avatar
Kaarlo Raiha committed
74 75
#define LT_AUDIO_POSTRENDER_CALLBACK N_( "Address of the audio postrender callback function. " \
                                        "This function will be called when the render is into the buffer." )
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

#define T_VIDEO_DATA N_( "Video Callback data" )
#define LT_VIDEO_DATA N_( "Data for the video callback function." )

#define T_AUDIO_DATA N_( "Audio callback data" )
#define LT_AUDIO_DATA N_( "Data for the audio callback function." )

#define T_TIME_SYNC N_( "Time Synchronized output" )
#define LT_TIME_SYNC N_( "Time Synchronisation option for output. " \
                        "If true, stream will render as usual, else " \
                        "it will be rendered as fast as possible.")

static int  Open ( vlc_object_t * );
static void Close( vlc_object_t * );

#define SOUT_CFG_PREFIX "sout-smem-"
#define SOUT_PREFIX_VIDEO SOUT_CFG_PREFIX"video-"
#define SOUT_PREFIX_AUDIO SOUT_CFG_PREFIX"audio-"

vlc_module_begin ()
96
    set_shortname( N_("Smem"))
97
    set_description( N_("Stream output to memory buffer") )
98
    set_capability( "sout stream", 0 )
99 100 101
    add_shortcut( "smem" )
    set_category( CAT_SOUT )
    set_subcategory( SUBCAT_SOUT_STREAM )
102
    add_string( SOUT_PREFIX_VIDEO "prerender-callback", "0", T_VIDEO_PRERENDER_CALLBACK, LT_VIDEO_PRERENDER_CALLBACK, true )
103
        change_volatile()
104
    add_string( SOUT_PREFIX_AUDIO "prerender-callback", "0", T_AUDIO_PRERENDER_CALLBACK, LT_AUDIO_PRERENDER_CALLBACK, true )
105
        change_volatile()
106
    add_string( SOUT_PREFIX_VIDEO "postrender-callback", "0", T_VIDEO_POSTRENDER_CALLBACK, LT_VIDEO_POSTRENDER_CALLBACK, true )
107
        change_volatile()
108
    add_string( SOUT_PREFIX_AUDIO "postrender-callback", "0", T_AUDIO_POSTRENDER_CALLBACK, LT_AUDIO_POSTRENDER_CALLBACK, true )
109
        change_volatile()
110
    add_string( SOUT_PREFIX_VIDEO "data", "0", T_VIDEO_DATA, LT_VIDEO_DATA, true )
111
        change_volatile()
112
    add_string( SOUT_PREFIX_AUDIO "data", "0", T_AUDIO_DATA, LT_VIDEO_DATA, true )
113
        change_volatile()
114
    add_bool( SOUT_CFG_PREFIX "time-sync", true, T_TIME_SYNC, LT_TIME_SYNC, true )
115
        change_private()
116 117 118 119 120 121 122 123 124 125 126 127
    set_callbacks( Open, Close )
vlc_module_end ()


/*****************************************************************************
 * Exported prototypes
 *****************************************************************************/
static const char *const ppsz_sout_options[] = {
    "video-prerender-callback", "audio-prerender-callback",
    "video-postrender-callback", "audio-postrender-callback", "video-data", "audio-data", "time-sync", NULL
};

128
static sout_stream_id_sys_t *Add( sout_stream_t *, const es_format_t * );
129
static void              Del ( sout_stream_t *, sout_stream_id_sys_t * );
130
static int               Send( sout_stream_t *, sout_stream_id_sys_t *, block_t* );
131

132 133 134 135
static sout_stream_id_sys_t *AddVideo( sout_stream_t *p_stream,
                                       const es_format_t *p_fmt );
static sout_stream_id_sys_t *AddAudio( sout_stream_t *p_stream,
                                       const es_format_t *p_fmt );
136

137
static int SendVideo( sout_stream_t *p_stream, sout_stream_id_sys_t *id,
138
                      block_t *p_buffer );
139
static int SendAudio( sout_stream_t *p_stream, sout_stream_id_sys_t *id,
140 141
                      block_t *p_buffer );

142
struct sout_stream_id_sys_t
143
{
144
    es_format_t format;
145
    void *p_data;
146 147 148 149 150
};

struct sout_stream_sys_t
{
    vlc_mutex_t *p_lock;
151 152 153 154
    void ( *pf_video_prerender_callback ) ( void* p_video_data, uint8_t** pp_pixel_buffer, size_t size );
    void ( *pf_audio_prerender_callback ) ( void* p_audio_data, uint8_t** pp_pcm_buffer, size_t size );
    void ( *pf_video_postrender_callback ) ( void* p_video_data, uint8_t* p_pixel_buffer, int width, int height, int pixel_pitch, size_t size, mtime_t pts );
    void ( *pf_audio_postrender_callback ) ( 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, mtime_t pts );
155 156 157
    bool time_sync;
};

Adrien Maglo's avatar
Adrien Maglo committed
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
void VideoPrerenderDefaultCallback( void* p_video_data, uint8_t** pp_pixel_buffer, size_t size );
void AudioPrerenderDefaultCallback( void* p_audio_data, uint8_t** pp_pcm_buffer, size_t size );
void VideoPostrenderDefaultCallback( void* p_video_data, uint8_t* p_pixel_buffer, int width, int height,
                                     int pixel_pitch, size_t size, mtime_t pts );
void AudioPostrenderDefaultCallback( 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, mtime_t pts );

/*****************************************************************************
 * Default empty callbacks
 *****************************************************************************/

void VideoPrerenderDefaultCallback( void* p_video_data, uint8_t** pp_pixel_buffer, size_t size )
{
    VLC_UNUSED( p_video_data ); VLC_UNUSED( pp_pixel_buffer ); VLC_UNUSED( size );
}

void AudioPrerenderDefaultCallback( void* p_audio_data, uint8_t** pp_pcm_buffer, size_t size )
{
    VLC_UNUSED( p_audio_data ); VLC_UNUSED( pp_pcm_buffer ); VLC_UNUSED( size );
}

void VideoPostrenderDefaultCallback( void* p_video_data, uint8_t* p_pixel_buffer, int width, int height,
                                     int pixel_pitch, size_t size, mtime_t pts )
{
    VLC_UNUSED( p_video_data ); VLC_UNUSED( p_pixel_buffer );
    VLC_UNUSED( width ); VLC_UNUSED( height );
    VLC_UNUSED( pixel_pitch ); VLC_UNUSED( size ); VLC_UNUSED( pts );
}

void AudioPostrenderDefaultCallback( 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, mtime_t pts )
{
    VLC_UNUSED( p_audio_data ); VLC_UNUSED( p_pcm_buffer );
    VLC_UNUSED( channels ); VLC_UNUSED( rate ); VLC_UNUSED( nb_samples );
    VLC_UNUSED( bits_per_sample ); VLC_UNUSED( size ); VLC_UNUSED( pts );
}

197 198 199 200 201 202 203 204 205 206 207 208 209 210
/*****************************************************************************
 * Open:
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
    char* psz_tmp;
    sout_stream_t *p_stream = (sout_stream_t*)p_this;
    sout_stream_sys_t *p_sys;

    p_sys = calloc( 1, sizeof( sout_stream_sys_t ) );
    if( !p_sys )
        return VLC_ENOMEM;
    p_stream->p_sys = p_sys;

211 212 213
    config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,
                       p_stream->p_cfg );

214
    p_sys->time_sync = var_GetBool( p_stream, SOUT_CFG_PREFIX "time-sync" );
215

216
    psz_tmp = var_GetString( p_stream, SOUT_PREFIX_VIDEO "prerender-callback" );
217
    p_sys->pf_video_prerender_callback = (void (*) (void *, uint8_t**, size_t))(intptr_t)atoll( psz_tmp );
218
    free( psz_tmp );
Adrien Maglo's avatar
Adrien Maglo committed
219 220
    if (p_sys->pf_video_prerender_callback == NULL)
        p_sys->pf_video_prerender_callback = VideoPrerenderDefaultCallback;
221

222
    psz_tmp = var_GetString( p_stream, SOUT_PREFIX_AUDIO "prerender-callback" );
223
    p_sys->pf_audio_prerender_callback = (void (*) (void* , uint8_t**, size_t))(intptr_t)atoll( psz_tmp );
224
    free( psz_tmp );
Adrien Maglo's avatar
Adrien Maglo committed
225 226
    if (p_sys->pf_audio_prerender_callback == NULL)
        p_sys->pf_audio_prerender_callback = AudioPrerenderDefaultCallback;
227

228
    psz_tmp = var_GetString( p_stream, SOUT_PREFIX_VIDEO "postrender-callback" );
229
    p_sys->pf_video_postrender_callback = (void (*) (void*, uint8_t*, int, int, int, size_t, mtime_t))(intptr_t)atoll( psz_tmp );
230
    free( psz_tmp );
Adrien Maglo's avatar
Adrien Maglo committed
231 232
    if (p_sys->pf_video_postrender_callback == NULL)
        p_sys->pf_video_postrender_callback = VideoPostrenderDefaultCallback;
233

234
    psz_tmp = var_GetString( p_stream, SOUT_PREFIX_AUDIO "postrender-callback" );
235
    p_sys->pf_audio_postrender_callback = (void (*) (void*, uint8_t*, unsigned int, unsigned int, unsigned int, unsigned int, size_t, mtime_t))(intptr_t)atoll( psz_tmp );
236
    free( psz_tmp );
Adrien Maglo's avatar
Adrien Maglo committed
237 238
    if (p_sys->pf_audio_postrender_callback == NULL)
        p_sys->pf_audio_postrender_callback = AudioPostrenderDefaultCallback;
239 240 241 242 243

    /* Setting stream out module callbacks */
    p_stream->pf_add    = Add;
    p_stream->pf_del    = Del;
    p_stream->pf_send   = Send;
244
    p_stream->pace_nocontrol = p_sys->time_sync;
245 246 247 248 249 250 251 252 253 254 255 256 257

    return VLC_SUCCESS;
}

/*****************************************************************************
 * Close:
 *****************************************************************************/
static void Close( vlc_object_t * p_this )
{
    sout_stream_t *p_stream = (sout_stream_t*)p_this;
    free( p_stream->p_sys );
}

258 259
static sout_stream_id_sys_t *Add( sout_stream_t *p_stream,
                                  const es_format_t *p_fmt )
260
{
261
    sout_stream_id_sys_t *id = NULL;
262 263 264 265 266 267 268 269

    if ( p_fmt->i_cat == VIDEO_ES )
        id = AddVideo( p_stream, p_fmt );
    else if ( p_fmt->i_cat == AUDIO_ES )
        id = AddAudio( p_stream, p_fmt );
    return id;
}

270 271
static sout_stream_id_sys_t *AddVideo( sout_stream_t *p_stream,
                                       const es_format_t *p_fmt )
272
{
273
    char* psz_tmp;
274
    sout_stream_id_sys_t    *id;
275 276 277 278 279
    int i_bits_per_pixel;

    switch( p_fmt->i_codec )
    {
        case VLC_CODEC_RGB32:
280
        case VLC_CODEC_RGBA:
281
        case VLC_CODEC_ARGB:
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
            i_bits_per_pixel = 32;
            break;
        case VLC_CODEC_I444:
        case VLC_CODEC_RGB24:
            i_bits_per_pixel = 24;
            break;
        case VLC_CODEC_RGB16:
        case VLC_CODEC_RGB15:
        case VLC_CODEC_RGB8:
        case VLC_CODEC_I422:
            i_bits_per_pixel = 16;
            break;
        case VLC_CODEC_YV12:
        case VLC_CODEC_I420:
            i_bits_per_pixel = 12;
            break;
        case VLC_CODEC_RGBP:
            i_bits_per_pixel = 8;
            break;
        default:
302 303 304
            i_bits_per_pixel = 0;
            msg_Dbg( p_stream, "non raw video format detected (%4.4s), buffers will contain compressed video", (char *)&p_fmt->i_codec );
            break;
305 306
    }

307
    id = calloc( 1, sizeof( sout_stream_id_sys_t ) );
308 309 310
    if( !id )
        return NULL;

311
    psz_tmp = var_GetString( p_stream, SOUT_PREFIX_VIDEO "data" );
312
    id->p_data = (void *)( intptr_t )atoll( psz_tmp );
313 314
    free( psz_tmp );

315 316
    es_format_Copy( &id->format, p_fmt );
    id->format.video.i_bits_per_pixel = i_bits_per_pixel;
317 318 319
    return id;
}

320 321
static sout_stream_id_sys_t *AddAudio( sout_stream_t *p_stream,
                                       const es_format_t *p_fmt )
322
{
323
    char* psz_tmp;
324
    sout_stream_id_sys_t* id;
325
    int i_bits_per_sample = aout_BitsPerSample( p_fmt->i_codec );
326

327
    if( !i_bits_per_sample )
328 329 330 331 332
    {
        msg_Err( p_stream, "Smem does only support raw audio format" );
        return NULL;
    }

333
    id = calloc( 1, sizeof( sout_stream_id_sys_t ) );
334 335 336
    if( !id )
        return NULL;

337
    psz_tmp = var_GetString( p_stream, SOUT_PREFIX_AUDIO "data" );
338
    id->p_data = (void *)( intptr_t )atoll( psz_tmp );
339 340
    free( psz_tmp );

341 342
    es_format_Copy( &id->format, p_fmt );
    id->format.audio.i_bitspersample = i_bits_per_sample;
343
    return id;
344 345
}

346
static void Del( sout_stream_t *p_stream, sout_stream_id_sys_t *id )
347 348
{
    VLC_UNUSED( p_stream );
349
    es_format_Clean( &id->format );
350
    free( id );
351 352
}

353
static int Send( sout_stream_t *p_stream, sout_stream_id_sys_t *id,
354 355
                 block_t *p_buffer )
{
356
    if ( id->format.i_cat == VIDEO_ES )
357
        return SendVideo( p_stream, id, p_buffer );
358
    else if ( id->format.i_cat == AUDIO_ES )
359 360 361 362
        return SendAudio( p_stream, id, p_buffer );
    return VLC_SUCCESS;
}

363
static int SendVideo( sout_stream_t *p_stream, sout_stream_id_sys_t *id,
364 365 366
                      block_t *p_buffer )
{
    sout_stream_sys_t *p_sys = p_stream->p_sys;
367
    size_t i_size = p_buffer->i_buffer;
368
    uint8_t* p_pixels = NULL;
369 370

    /* Calling the prerender callback to get user buffer */
371
    p_sys->pf_video_prerender_callback( id->p_data, &p_pixels, i_size );
372 373 374 375 376 377 378 379

    if (!p_pixels)
    {
        msg_Err( p_stream, "No buffer given!" );
        block_ChainRelease( p_buffer );
        return VLC_EGENERIC;
    }

380
    /* Copying data into user buffer */
381
    memcpy( p_pixels, p_buffer->p_buffer, i_size );
382
    /* Calling the postrender callback to tell the user his buffer is ready */
383
    p_sys->pf_video_postrender_callback( id->p_data, p_pixels,
384 385
                                         id->format.video.i_width, id->format.video.i_height,
                                         id->format.video.i_bits_per_pixel, i_size, p_buffer->i_pts );
386
    block_ChainRelease( p_buffer );
387 388 389
    return VLC_SUCCESS;
}

390
static int SendAudio( sout_stream_t *p_stream, sout_stream_id_sys_t *id,
391 392
                      block_t *p_buffer )
{
393 394
    sout_stream_sys_t *p_sys = p_stream->p_sys;
    int i_size;
395
    uint8_t* p_pcm_buffer = NULL;
396 397 398
    int i_samples = 0;

    i_size = p_buffer->i_buffer;
399
    if (id->format.audio.i_channels == 0)
400 401 402 403 404 405
    {
        msg_Warn( p_stream, "No buffer given!" );
        block_ChainRelease( p_buffer );
        return VLC_EGENERIC;
    }

406
    i_samples = i_size / ( ( id->format.audio.i_bitspersample / 8 ) * id->format.audio.i_channels );
407
    /* Calling the prerender callback to get user buffer */
408
    p_sys->pf_audio_prerender_callback( id->p_data, &p_pcm_buffer, i_size );
409 410 411 412 413 414 415
    if (!p_pcm_buffer)
    {
        msg_Err( p_stream, "No buffer given!" );
        block_ChainRelease( p_buffer );
        return VLC_EGENERIC;
    }

416
    /* Copying data into user buffer */
Rafaël Carré's avatar
Rafaël Carré committed
417
    memcpy( p_pcm_buffer, p_buffer->p_buffer, i_size );
418
    /* Calling the postrender callback to tell the user his buffer is ready */
419
    p_sys->pf_audio_postrender_callback( id->p_data, p_pcm_buffer,
420 421
                                         id->format.audio.i_channels, id->format.audio.i_rate, i_samples,
                                         id->format.audio.i_bitspersample, i_size, p_buffer->i_pts );
422
    block_ChainRelease( p_buffer );
423 424
    return VLC_SUCCESS;
}
425