static int Open (vlc_object_t *obj)
{
aout_instance_t *aout = (aout_instance_t *)obj;
aout_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
aout->output.p_sys = sys;
sys->opaque = var_InheritAddress (obj, "amem-data");
sys->play = var_InheritAddress (obj, "amem-play");
sys->set_volume = var_InheritAddress (obj, "amem-set-volume");
sys->cleanup = NULL; /* defer */
if (sys->play == NULL)
goto error;
vlc_audio_format_cb setup = var_InheritAddress (obj, "amem-setup");
char format[5] = "S16N";
unsigned rate, channels;
if (setup != NULL)
{
rate = aout->output.output.i_rate;
channels = aout_FormatNbChannels(&aout->output.output);
if (setup (&sys->opaque, format, &rate, &channels))
goto error;
/* Only call this callback if setup succeeded */
sys->cleanup = var_InheritAddress (obj, "amem-cleanup");
}
else
{
rate = var_InheritInteger (obj, "amem-rate");
channels = var_InheritInteger (obj, "amem-channels");
}
if (rate == 0 || rate > 192000
|| channels == 0 || channels > AOUT_CHAN_MAX)
goto error;
/* TODO: amem-format */
/* FIXME/TODO channel mapping */
if (strcmp(format, "S16N") || aout->output.output.i_channels != channels)
{
msg_Err (aout, "format not supported");
goto error;
}
aout->output.output.i_format = VLC_CODEC_S16N;
aout->output.output.i_rate = rate;
aout->output.pf_play = Play;
if (sys->set_volume != NULL)
aout->output.pf_volume_set = VolumeSet;
else
aout_VolumeSoftInit (aout);
return VLC_SUCCESS;
error:
Close (obj);
return VLC_EGENERIC;
}
static int Open (vlc_object_t *obj)
{
audio_output_t *aout = (audio_output_t *)obj;
aout_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
void *opaque = var_InheritAddress (obj, "amem-data");
sys->setup = var_InheritAddress (obj, "amem-setup");
if (sys->setup != NULL)
{
sys->cleanup = var_InheritAddress (obj, "amem-cleanup");
sys->setup_opaque = opaque;
}
else
{
sys->cleanup = NULL;
sys->opaque = opaque;
sys->rate = var_InheritInteger (obj, "amem-rate");
sys->channels = var_InheritInteger (obj, "amem-channels");
}
sys->play = var_InheritAddress (obj, "amem-play");
sys->pause = var_InheritAddress (obj, "amem-pause");
sys->resume = var_InheritAddress (obj, "amem-resume");
sys->flush = var_InheritAddress (obj, "amem-flush");
sys->drain = var_InheritAddress (obj, "amem-drain");
sys->set_volume = var_InheritAddress (obj, "amem-set-volume");
sys->volume = 1.;
sys->mute = false;
sys->ready = false;
if (sys->play == NULL)
{
free (sys);
return VLC_EGENERIC;
}
aout->sys = sys;
aout->start = Start;
aout->stop = Stop;
aout->time_get = NULL;
aout->play = Play;
aout->pause = Pause;
aout->flush = Flush;
if (sys->set_volume != NULL)
{
aout->volume_set = VolumeSet;
aout->mute_set = MuteSet;
}
else
{
aout->volume_set = SoftVolumeSet;
aout->mute_set = SoftMuteSet;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_stream_sys_t *p_sys;
p_stream->p_sys = p_sys = malloc(sizeof(sout_stream_sys_t));
if ( unlikely( ! p_sys ) ) return VLC_ENOMEM;
p_sys->id = NULL;
p_sys->b_finished = false;
p_sys->b_done = false;
p_sys->i_total_samples = 0;
p_sys->i_duration = var_InheritInteger( p_stream, "duration" );
p_sys->p_data = var_InheritAddress( p_stream, "fingerprint-data" );
if ( !p_sys->p_data )
{
msg_Err( p_stream, "Fingerprint data holder not set" );
free( p_sys );
return VLC_ENOVAR;
}
msg_Dbg( p_stream, "chromaprint version %s", chromaprint_get_version() );
p_sys->p_chromaprint_ctx = chromaprint_new( CHROMAPRINT_ALGORITHM_DEFAULT );
if ( ! p_sys->p_chromaprint_ctx )
{
msg_Err( p_stream, "Can't create chromaprint context" );
free( p_sys );
return VLC_EGENERIC;
}
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
return VLC_SUCCESS;
}
static int WindowOpen( vout_window_t *p_wnd, const vout_window_cfg_t *cfg )
{
if( cfg->is_standalone )
return VLC_EGENERIC;
intf_thread_t *p_intf =
(intf_thread_t *)var_InheritAddress( p_wnd, "qt4-iface" );
if( !p_intf )
{ /* If another interface is used, this plugin cannot work */
msg_Dbg( p_wnd, "Qt interface not found" );
return VLC_EGENERIC;
}
if( p_intf->p_sys->voutWindowType != cfg->type )
return VLC_EGENERIC;
switch( cfg->type )
{
case VOUT_WINDOW_TYPE_XID:
if( var_InheritBool( p_wnd, "video-wallpaper" ) )
return VLC_EGENERIC;
break;
}
QMutexLocker locker (&lock);
if (unlikely(!active))
return VLC_EGENERIC;
MainInterface *p_mi = p_intf->p_sys->p_mi;
msg_Dbg( p_wnd, "requesting video window..." );
int i_x = cfg->x;
int i_y = cfg->y;
unsigned i_width = cfg->width;
unsigned i_height = cfg->height;
WId wid = p_mi->getVideo( &i_x, &i_y, &i_width, &i_height );
if( !wid )
return VLC_EGENERIC;
switch( cfg->type )
{
case VOUT_WINDOW_TYPE_XID:
p_wnd->handle.xid = (uintptr_t)wid;
p_wnd->display.x11 = NULL;
break;
case VOUT_WINDOW_TYPE_HWND:
p_wnd->handle.hwnd = (void *)wid;
break;
case VOUT_WINDOW_TYPE_NSOBJECT:
p_wnd->handle.nsobject = (void *)wid;
break;
}
p_wnd->control = WindowControl;
p_wnd->sys = (vout_window_sys_t*)p_mi;
return VLC_SUCCESS;
}
static int Open(vlc_object_t *object)
{
stream_t *access = (stream_t *)object;
access_sys_t *sys = vlc_obj_malloc(object, sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
int (*open_cb)(void *, void **, uint64_t *);
void *opaque;
opaque = var_InheritAddress(access, "imem-data");
open_cb = var_InheritAddress(access, "imem-open");
sys->opaque = NULL;
sys->read_cb = var_InheritAddress(access, "imem-read");
sys->seek_cb = var_InheritAddress(access, "imem-seek");
sys->close_cb = var_InheritAddress(access, "imem-close");
sys->size = UINT64_MAX;
if (open_cb == NULL)
open_cb = open_cb_default;
if (sys->read_cb == NULL)
return VLC_EGENERIC;
if (open_cb(opaque, &sys->opaque, &sys->size)) {
msg_Err(access, "open error");
return VLC_EGENERIC;
}
access->pf_read = Read;
access->pf_block = NULL;
access->pf_seek = (sys->seek_cb != NULL) ? Seek : NULL;
access->pf_control = Control;
access->p_sys = sys;
return VLC_SUCCESS;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t*)p_this;
sout_stream_sys_t *p_sys;
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_sys = p_stream->p_sys = (sout_stream_sys_t *)malloc(sizeof(sout_stream_sys_t)); // sunqueen modify
p_sys->data = (sout_description_data_t *)var_InheritAddress(p_stream, "sout-description-data"); // sunqueen modify
if (p_sys->data == NULL)
{
msg_Err(p_stream, "Missing data: the description stream output is "
"not meant to be used without special setup from the core");
free(p_sys);
return VLC_EGENERIC;
}
p_sys->i_stream_start = 0;
return VLC_SUCCESS;
}
int Control( demux_t *p_demux_filter, int i_query, va_list args )
{
if( !m_enabled && i_query != DEMUX_FILTER_ENABLE )
return demux_vaControl( p_demux_filter->p_next, i_query, args );
switch (i_query)
{
case DEMUX_GET_POSITION:
{
double pos = getPosition();
if( pos >= 0 )
{
*va_arg( args, double * ) = pos;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
}
case DEMUX_GET_TIME:
{
vlc_tick_t time = getTime();
if( time >= 0 )
{
*va_arg(args, vlc_tick_t *) = time;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
}
case DEMUX_GET_LENGTH:
{
int ret;
va_list ap;
va_copy( ap, args );
ret = demux_vaControl( p_demux_filter->p_next, i_query, args );
if( ret == VLC_SUCCESS )
m_length = *va_arg( ap, vlc_tick_t * );
va_end( ap );
return ret;
}
case DEMUX_CAN_SEEK:
{
int ret;
va_list ap;
va_copy( ap, args );
ret = demux_vaControl( p_demux_filter->p_next, i_query, args );
if( ret == VLC_SUCCESS )
m_can_seek = *va_arg( ap, bool* );
va_end( ap );
return ret;
}
case DEMUX_SET_POSITION:
{
double pos = va_arg( args, double );
/* Force unprecise seek */
int ret = demux_Control( p_demux->p_next, DEMUX_SET_POSITION, pos, false );
if( ret != VLC_SUCCESS )
return ret;
resetTimes();
resetDemuxEof();
return VLC_SUCCESS;
}
case DEMUX_SET_TIME:
{
vlc_tick_t time = va_arg( args, vlc_tick_t );
/* Force unprecise seek */
int ret = demux_Control( p_demux->p_next, DEMUX_SET_TIME, time, false );
if( ret != VLC_SUCCESS )
return ret;
resetTimes();
resetDemuxEof();
return VLC_SUCCESS;
}
case DEMUX_SET_PAUSE_STATE:
{
va_list ap;
va_copy( ap, args );
int paused = va_arg( ap, int );
va_end( ap );
setPauseState( paused != 0 );
break;
}
case DEMUX_SET_ES:
/* Seek back to the last known pos when changing tracks. This will
* flush sout streams, make sout del/add called right away and
* clear CC buffers. */
seekBack(m_last_time, m_last_pos);
resetTimes();
resetDemuxEof();
break;
case DEMUX_FILTER_ENABLE:
p_renderer = static_cast<chromecast_common *>(
var_InheritAddress( p_demux, CC_SHARED_VAR_NAME ) );
assert(p_renderer != NULL);
m_enabled = true;
init();
return VLC_SUCCESS;
case DEMUX_FILTER_DISABLE:
deinit();
/* Seek back to last known position. Indeed we don't want to resume
* from the input position that can be more than 1 minutes forward
* (depending on the CC buffering policy). */
seekBack(m_last_time, m_last_pos);
m_enabled = false;
p_renderer = NULL;
return VLC_SUCCESS;
}
return demux_vaControl( p_demux_filter->p_next, i_query, args );
}
/*****************************************************************************
* Open: allocates video thread
*****************************************************************************
* This function allocates and initializes a vout method.
*****************************************************************************/
static int Open(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys = malloc(sizeof(*sys));
if (unlikely(!sys))
return VLC_ENOMEM;
/* Get the callbacks */
vlc_format_cb setup = var_InheritAddress(vd, "vmem-setup");
sys->lock = var_InheritAddress(vd, "vmem-lock");
if (sys->lock == NULL) {
msg_Err(vd, "missing lock callback");
free(sys);
return VLC_EGENERIC;
}
sys->unlock = var_InheritAddress(vd, "vmem-unlock");
sys->display = var_InheritAddress(vd, "vmem-display");
sys->cleanup = var_InheritAddress(vd, "vmem-cleanup");
sys->opaque = var_InheritAddress(vd, "vmem-data");
sys->pool = NULL;
/* Define the video format */
video_format_t fmt = vd->fmt;
if (setup != NULL) {
char chroma[5];
memcpy(chroma, &fmt.i_chroma, 4);
chroma[4] = '\0';
memset(sys->pitches, 0, sizeof(sys->pitches));
memset(sys->lines, 0, sizeof(sys->lines));
sys->count = setup(&sys->opaque, chroma, &fmt.i_width, &fmt.i_height,
sys->pitches, sys->lines);
if (sys->count == 0) {
msg_Err(vd, "video format setup failure (no pictures)");
free(sys);
return VLC_EGENERIC;
}
fmt.i_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, chroma);
} else {
char *chroma = var_InheritString(vd, "vmem-chroma");
fmt.i_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, chroma);
free(chroma);
fmt.i_width = var_InheritInteger(vd, "vmem-width");
fmt.i_height = var_InheritInteger(vd, "vmem-height");
sys->pitches[0] = var_InheritInteger(vd, "vmem-pitch");
sys->lines[0] = fmt.i_height;
for (size_t i = 1; i < PICTURE_PLANE_MAX; i++)
{
sys->pitches[i] = sys->pitches[0];
sys->lines[i] = sys->lines[0];
}
sys->count = 1;
sys->cleanup = NULL;
}
if (!fmt.i_chroma) {
msg_Err(vd, "vmem-chroma should be 4 characters long");
free(sys);
return VLC_EGENERIC;
}
/* Define the bitmasks */
switch (fmt.i_chroma)
{
case VLC_CODEC_RGB15:
fmt.i_rmask = 0x001f;
fmt.i_gmask = 0x03e0;
fmt.i_bmask = 0x7c00;
break;
case VLC_CODEC_RGB16:
fmt.i_rmask = 0x001f;
fmt.i_gmask = 0x07e0;
fmt.i_bmask = 0xf800;
break;
case VLC_CODEC_RGB24:
case VLC_CODEC_RGB32:
fmt.i_rmask = 0xff0000;
fmt.i_gmask = 0x00ff00;
fmt.i_bmask = 0x0000ff;
break;
default:
fmt.i_rmask = 0;
fmt.i_gmask = 0;
fmt.i_bmask = 0;
break;
}
/* */
vout_display_info_t info = vd->info;
info.has_hide_mouse = true;
/* */
vd->sys = sys;
vd->fmt = fmt;
vd->info = info;
vd->pool = Pool;
vd->prepare = NULL;
vd->display = Display;
vd->control = Control;
vd->manage = NULL;
/* */
vout_display_SendEventFullscreen(vd, false);
vout_display_SendEventDisplaySize(vd, fmt.i_width, fmt.i_height, false);
return VLC_SUCCESS;
}
static int
Open( vlc_object_t *p_this )
{
vout_display_t *vd = (vout_display_t*)p_this;
vout_display_sys_t *sys;
Evas_Object *p_evas;
if( vout_display_IsWindowed( vd ) )
return VLC_EGENERIC;
p_evas = var_InheritAddress( p_this, "drawable-evasobject" );
if( !p_evas )
return VLC_EGENERIC;
vd->sys = sys = (struct vout_display_sys_t *) calloc( 1, sizeof(*sys) );
if( !sys )
return VLC_ENOMEM;
vlc_mutex_init( &sys->cb_lock );
vlc_cond_init( &sys->cb_wait );
fifo_init( &sys->buffer_fifo );
fifo_init( &sys->event_fifo );
sys->p_evas = p_evas;
msg_Dbg( vd, "request video format: %4.4s",
(const char *)&vd->fmt.i_chroma );
/* Evas Initialisation must be done from the Mainloop */
if( EcoreMainLoopCallSync( vd, EvasInitMainloopCb ) )
{
msg_Err( vd, "EvasInitMainloopCb failed" );
Close( p_this );
return VLC_EGENERIC;
}
for( unsigned int i = 0; i < PICTURE_PLANE_MAX; ++i )
sys->i_planes_order[i] = i;
switch( vd->fmt.i_chroma )
{
case VLC_CODEC_RGB32:
case VLC_CODEC_RGB16:
video_format_FixRgb(&vd->fmt);
break;
case VLC_CODEC_YV12:
sys->i_planes_order[1] = 2;
sys->i_planes_order[2] = 1;
default:
break;
}
msg_Dbg( vd, "got video format: %4.4s, size: %dx%d",
(const char *)&vd->fmt.i_chroma,
sys->i_width, sys->i_height );
/* Setup vout_display */
vd->pool = Pool;
vd->prepare = NULL;
vd->display = Display;
vd->control = Control;
vd->manage = Manage;
return VLC_SUCCESS;
}