static int OutputNew( sout_stream_t *p_stream,
const char *psz_muxer, const char *psz_prefix, const char *psz_extension )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
char *psz_file = NULL;
char *psz_output = NULL;
int i_count;
if( asprintf( &psz_file, "%s%s%s",
psz_prefix, psz_extension ? "." : "", psz_extension ? psz_extension : "" ) < 0 )
{
psz_file = NULL;
goto error;
}
if( asprintf( &psz_output, "std{access=file,mux='%s',dst='%s'}",
psz_muxer, psz_file ) < 0 )
{
psz_output = NULL;
goto error;
}
/* Create the output */
msg_Dbg( p_stream, "Using record output `%s'", psz_output );
p_sys->p_out = sout_StreamChainNew( p_stream->p_sout, psz_output, NULL, NULL );
if( !p_sys->p_out )
goto error;
/* Add es */
i_count = 0;
for( int i = 0; i < p_sys->i_id; i++ )
{
sout_stream_id_t *id = p_sys->id[i];
id->id = sout_StreamIdAdd( p_sys->p_out, &id->fmt );
if( id->id )
i_count++;
}
if( psz_file && psz_extension )
var_SetString( p_stream->p_libvlc, "record-file", psz_file );
free( psz_file );
free( psz_output );
return i_count;
error:
free( psz_file );
free( psz_output );
return -1;
}
/*****************************************************************************
* sout_NewInstance: creates a new stream output instance
*****************************************************************************/
sout_instance_t *sout_NewInstance( vlc_object_t *p_parent, const char *psz_dest )
{
sout_instance_t *p_sout;
char *psz_chain;
assert( psz_dest != NULL );
if( psz_dest[0] == '#' )
{
psz_chain = strdup( &psz_dest[1] );
}
else
{
psz_chain = sout_stream_url_to_chain(
var_InheritBool(p_parent, "sout-display"), psz_dest );
}
if(!psz_chain)
return NULL;
/* *** Allocate descriptor *** */
p_sout = vlc_custom_create( p_parent, sizeof( *p_sout ), "stream output" );
if( p_sout == NULL )
{
free( psz_chain );
return NULL;
}
msg_Dbg( p_sout, "using sout chain=`%s'", psz_chain );
/* *** init descriptor *** */
p_sout->psz_sout = strdup( psz_dest );
p_sout->i_out_pace_nocontrol = 0;
vlc_mutex_init( &p_sout->lock );
p_sout->p_stream = NULL;
var_Create( p_sout, "sout-mux-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
p_sout->p_stream = sout_StreamChainNew( p_sout, psz_chain, NULL, NULL );
if( p_sout->p_stream )
{
free( psz_chain );
return p_sout;
}
msg_Err( p_sout, "stream chain failed for `%s'", psz_chain );
free( psz_chain );
FREENULL( p_sout->psz_sout );
vlc_mutex_destroy( &p_sout->lock );
vlc_object_release( p_sout );
return NULL;
}
static int AddStream(sout_stream_t *stream, char *chain)
{
sout_stream_sys_t *sys = stream->p_sys;
msg_Dbg(stream, "starting new phase \"%s\"", chain);
/* TODO format */
sys->stream = sout_StreamChainNew(stream->p_sout, chain,
stream->p_next, NULL);
if (sys->stream == NULL)
return -1;
for (sout_stream_id_sys_t *id = sys->first; id != NULL; id = id->next)
id->id = sout_StreamIdAdd(sys->stream, &id->fmt);
return 0;
}
/*****************************************************************************
* 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;
config_chain_t *p_cfg;
msg_Dbg( p_stream, "creating 'duplicate'" );
p_sys = malloc( sizeof( sout_stream_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
TAB_INIT( p_sys->i_nb_streams, p_sys->pp_streams );
TAB_INIT( p_sys->i_nb_last_streams, p_sys->pp_last_streams );
TAB_INIT( p_sys->i_nb_select, p_sys->ppsz_select );
for( p_cfg = p_stream->p_cfg; p_cfg != NULL; p_cfg = p_cfg->p_next )
{
if( !strncmp( p_cfg->psz_name, "dst", strlen( "dst" ) ) )
{
sout_stream_t *s, *p_last;
msg_Dbg( p_stream, " * adding `%s'", p_cfg->psz_value );
s = sout_StreamChainNew( p_stream->p_sout, p_cfg->psz_value,
p_stream->p_next, &p_last );
if( s )
{
TAB_APPEND( p_sys->i_nb_streams, p_sys->pp_streams, s );
TAB_APPEND( p_sys->i_nb_last_streams, p_sys->pp_last_streams,
p_last );
TAB_APPEND( p_sys->i_nb_select, p_sys->ppsz_select, NULL );
}
}
else if( !strncmp( p_cfg->psz_name, "select", strlen( "select" ) ) )
{
char *psz = p_cfg->psz_value;
if( p_sys->i_nb_select > 0 && psz && *psz )
{
char **ppsz_select = &p_sys->ppsz_select[p_sys->i_nb_select - 1];
if( *ppsz_select )
{
msg_Err( p_stream, " * ignore selection `%s' (it already has `%s')",
psz, *ppsz_select );
}
else
{
msg_Dbg( p_stream, " * apply selection `%s'", psz );
*ppsz_select = strdup( psz );
}
}
}
else
{
msg_Err( p_stream, " * ignore unknown option `%s'", p_cfg->psz_name );
}
}
if( p_sys->i_nb_streams == 0 )
{
msg_Err( p_stream, "no destination given" );
free( p_sys );
return VLC_EGENERIC;
}
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->p_sys = p_sys;
return VLC_SUCCESS;
}
int sout_stream_sys_t::UpdateOutput( sout_stream_t *p_stream )
{
assert( p_stream->p_sys == this );
if ( es_changed )
{
es_changed = false;
bool canRemux = true;
vlc_fourcc_t i_codec_video = 0, i_codec_audio = 0;
for (std::vector<sout_stream_id_sys_t*>::iterator it = streams.begin(); it != streams.end(); ++it)
{
const es_format_t *p_es = &(*it)->fmt;
if (p_es->i_cat == AUDIO_ES)
{
if (!canDecodeAudio( p_es ))
{
msg_Dbg( p_stream, "can't remux audio track %d codec %4.4s", p_es->i_id, (const char*)&p_es->i_codec );
canRemux = false;
}
else if (i_codec_audio == 0)
i_codec_audio = p_es->i_codec;
}
else if (b_has_video && p_es->i_cat == VIDEO_ES)
{
if (!canDecodeVideo( p_es ))
{
msg_Dbg( p_stream, "can't remux video track %d codec %4.4s", p_es->i_id, (const char*)&p_es->i_codec );
canRemux = false;
}
else if (i_codec_video == 0)
i_codec_video = p_es->i_codec;
}
}
std::stringstream ssout;
if ( !canRemux )
{
if ( i_codec_audio == 0 )
i_codec_audio = DEFAULT_TRANSCODE_AUDIO;
/* avcodec AAC encoder is experimental */
if ( i_codec_audio == VLC_CODEC_MP4A ||
i_codec_audio == VLC_FOURCC('h', 'a', 'a', 'c') ||
i_codec_audio == VLC_FOURCC('l', 'a', 'a', 'c') ||
i_codec_audio == VLC_FOURCC('s', 'a', 'a', 'c'))
i_codec_audio = DEFAULT_TRANSCODE_AUDIO;
if ( i_codec_video == 0 )
i_codec_video = DEFAULT_TRANSCODE_VIDEO;
/* TODO: provide audio samplerate and channels */
ssout << "transcode{acodec=";
char s_fourcc[5];
vlc_fourcc_to_char( i_codec_audio, s_fourcc );
s_fourcc[4] = '\0';
ssout << s_fourcc;
if ( b_has_video )
{
/* TODO: provide maxwidth,maxheight */
ssout << ",vcodec=";
vlc_fourcc_to_char( i_codec_video, s_fourcc );
s_fourcc[4] = '\0';
ssout << s_fourcc;
}
ssout << "}:";
}
std::string mime;
if ( !b_has_video && default_muxer == DEFAULT_MUXER )
mime = "audio/x-matroska";
else if ( i_codec_audio == VLC_CODEC_VORBIS &&
i_codec_video == VLC_CODEC_VP8 &&
default_muxer == DEFAULT_MUXER )
mime = "video/webm";
else
mime = default_mime;
ssout << "http{dst=:" << i_port << "/stream"
<< ",mux=" << default_muxer
<< ",access=http{mime=" << mime << "}}";
if ( sout != ssout.str() )
{
if ( unlikely( p_out != NULL ) )
{
sout_StreamChainDelete( p_out, p_out );
sout = "";
}
p_out = sout_StreamChainNew( p_stream->p_sout, ssout.str().c_str(), NULL, NULL);
if (p_out == NULL) {
msg_Dbg(p_stream, "could not create sout chain:%s", ssout.str().c_str());
return VLC_EGENERIC;
}
sout = ssout.str();
}
/* check the streams we can actually add */
for (std::vector<sout_stream_id_sys_t*>::iterator it = streams.begin(); it != streams.end(); ++it)
{
sout_stream_id_sys_t *p_sys_id = *it;
p_sys_id->p_sub_id = sout_StreamIdAdd( p_out, &p_sys_id->fmt );
if ( p_sys_id->p_sub_id == NULL )
{
msg_Err( p_stream, "can't handle a stream" );
streams.erase( it, it );
}
}
/* tell the chromecast to load the content */
p_intf->setHasInput( true, mime );
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: connect to the Chromecast and initialize the sout
*****************************************************************************/
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_sys = new(std::nothrow) sout_stream_sys_t;
if (p_sys == NULL)
return VLC_ENOMEM;
p_stream->p_sys = p_sys;
config_ChainParse(p_stream, SOUT_CFG_PREFIX, ppsz_sout_options, p_stream->p_cfg);
char *psz_ipChromecast = var_GetNonEmptyString(p_stream, SOUT_CFG_PREFIX "ip");
if (psz_ipChromecast == NULL)
{
msg_Err(p_stream, "No Chromecast receiver IP provided");
Clean(p_stream);
return VLC_EGENERIC;
}
p_sys->i_sock_fd = connectChromecast(p_stream, psz_ipChromecast);
free(psz_ipChromecast);
if (p_sys->i_sock_fd < 0)
{
msg_Err(p_stream, "Could not connect the Chromecast");
Clean(p_stream);
return VLC_EGENERIC;
}
p_sys->i_status = CHROMECAST_TLS_CONNECTED;
char psz_localIP[NI_MAXNUMERICHOST];
if (net_GetSockAddress(p_sys->i_sock_fd, psz_localIP, NULL))
{
msg_Err(p_this, "Cannot get local IP address");
Clean(p_stream);
return VLC_EGENERIC;
}
p_sys->serverIP = psz_localIP;
char *psz_mux = var_GetNonEmptyString(p_stream, SOUT_CFG_PREFIX "mux");
if (psz_mux == NULL)
{
Clean(p_stream);
return VLC_EGENERIC;
}
char *psz_chain = NULL;
int i_bytes = asprintf(&psz_chain, "http{dst=:%u/stream,mux=%s}",
(unsigned)var_InheritInteger(p_stream, SOUT_CFG_PREFIX"http-port"),
psz_mux);
free(psz_mux);
if (i_bytes < 0)
{
Clean(p_stream);
return VLC_EGENERIC;
}
p_sys->p_out = sout_StreamChainNew(p_stream->p_sout, psz_chain, NULL, NULL);
free(psz_chain);
if (p_sys->p_out == NULL)
{
Clean(p_stream);
return VLC_EGENERIC;
}
vlc_mutex_init(&p_sys->lock);
vlc_cond_init(&p_sys->loadCommandCond);
// Start the Chromecast event thread.
if (vlc_clone(&p_sys->chromecastThread, chromecastThread, p_stream,
VLC_THREAD_PRIORITY_LOW))
{
msg_Err(p_stream, "Could not start the Chromecast talking thread");
Clean(p_stream);
return VLC_EGENERIC;
}
/* Ugly part:
* We want to be sure that the Chromecast receives the first data packet sent by
* the HTTP server. */
// Lock the sout thread until we have sent the media loading command to the Chromecast.
int i_ret = 0;
const mtime_t deadline = mdate() + 6 * CLOCK_FREQ;
vlc_mutex_lock(&p_sys->lock);
while (p_sys->i_status != CHROMECAST_MEDIA_LOAD_SENT)
{
i_ret = vlc_cond_timedwait(&p_sys->loadCommandCond, &p_sys->lock, deadline);
if (i_ret == ETIMEDOUT)
{
msg_Err(p_stream, "Timeout reached before sending the media loading command");
vlc_mutex_unlock(&p_sys->lock);
vlc_cancel(p_sys->chromecastThread);
Clean(p_stream);
return VLC_EGENERIC;
}
}
vlc_mutex_unlock(&p_sys->lock);
/* Even uglier: sleep more to let to the Chromecast initiate the connection
* to the http server. */
msleep(2 * CLOCK_FREQ);
// Set the sout callbacks.
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
return VLC_SUCCESS;
}
