From d4b430e13bff41e3775a02baf8910c0bf59f0414 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Hugo=20Beauz=C3=A9e-Luyssen?= Date: Fri, 17 Feb 2017 16:20:08 +0100 Subject: [PATCH] chromecast: Prefix intf_sys_t member variables --- modules/stream_out/chromecast/chromecast.h | 44 +-- modules/stream_out/chromecast/chromecast_ctrl.cpp | 368 +++++++++++----------- 2 files changed, 206 insertions(+), 206 deletions(-) diff --git a/modules/stream_out/chromecast/chromecast.h b/modules/stream_out/chromecast/chromecast.h index 9f79ac828a..ca83868011 100644 --- a/modules/stream_out/chromecast/chromecast.h +++ b/modules/stream_out/chromecast/chromecast.h @@ -91,7 +91,7 @@ enum receiver_state { class ChromecastCommunication { public: - ChromecastCommunication( vlc_object_t* m_module, const char* targetIP, unsigned int devicePort ); + ChromecastCommunication( vlc_object_t* module, const char* targetIP, unsigned int devicePort ); ~ChromecastCommunication(); /** * @brief disconnect close the connection with the chromecast @@ -203,46 +203,46 @@ private: private: - vlc_object_t * const p_module; - const int i_port; - std::string mime; + vlc_object_t * const m_module; + const int m_streaming_port; + std::string m_mime; - std::string appTransportId; - std::string mediaSessionId; - receiver_state receiverState; + std::string m_appTransportId; + std::string m_mediaSessionId; + receiver_state m_receiverState; - vlc_mutex_t lock; - vlc_cond_t loadCommandCond; - vlc_thread_t chromecastThread; + vlc_mutex_t m_lock; + vlc_cond_t m_loadCommandCond; + vlc_thread_t m_chromecastThread; ChromecastCommunication m_communication; - enum connection_status conn_status; - enum command_status cmd_status; - std::atomic_bool requested_stop; - std::atomic_bool requested_seek; + connection_status m_conn_status; + command_status m_cmd_status; + std::atomic_bool m_requested_stop; + std::atomic_bool m_requested_seek; - bool has_input; + bool m_has_input; - std::string artwork; - std::string title; + std::string m_artwork; + std::string m_title; - vlc_interrupt_t *p_ctl_thread_interrupt; + vlc_interrupt_t *m_ctl_thread_interrupt; /* local date when playback started/resumed, used by monotone clock */ mtime_t m_time_playback_started; /* local playback time of the input when playback started/resumed */ - mtime_t i_ts_local_start; - mtime_t i_length; + mtime_t m_ts_local_start; + mtime_t m_length; /* playback time reported by the receiver, used to wait for seeking point */ mtime_t m_chromecast_start_time; /* seek time with Chromecast relative timestamp */ mtime_t m_seek_request_time; - vlc_cond_t seekCommandCond; + vlc_cond_t m_seekCommandCond; /* shared structure with the demux-filter */ - chromecast_common common; + chromecast_common m_common; }; #endif /* VLC_CHROMECAST_H */ diff --git a/modules/stream_out/chromecast/chromecast_ctrl.cpp b/modules/stream_out/chromecast/chromecast_ctrl.cpp index d9a17e77b4..cb5480f6ca 100644 --- a/modules/stream_out/chromecast/chromecast_ctrl.cpp +++ b/modules/stream_out/chromecast/chromecast_ctrl.cpp @@ -47,46 +47,46 @@ static const mtime_t SEEK_FORWARD_OFFSET = 1000000; * intf_sys_t: class definition *****************************************************************************/ intf_sys_t::intf_sys_t(vlc_object_t * const p_this, int port, std::string device_addr, int device_port, vlc_interrupt_t *p_interrupt) - : p_module(p_this) - , i_port(port) - , receiverState(RECEIVER_IDLE) + : m_module(p_this) + , m_streaming_port(port) + , m_receiverState(RECEIVER_IDLE) , m_communication( p_this, device_addr.c_str(), device_port ) - , requested_stop(false) - , requested_seek(false) - , conn_status(CHROMECAST_DISCONNECTED) - , cmd_status(NO_CMD_PENDING) - , has_input(false) - , p_ctl_thread_interrupt(p_interrupt) + , m_requested_stop(false) + , m_requested_seek(false) + , m_conn_status(CHROMECAST_DISCONNECTED) + , m_cmd_status(NO_CMD_PENDING) + , m_has_input(false) + , m_ctl_thread_interrupt(p_interrupt) , m_time_playback_started( VLC_TS_INVALID ) - , i_ts_local_start( VLC_TS_INVALID ) - , i_length( VLC_TS_INVALID ) + , m_ts_local_start( VLC_TS_INVALID ) + , m_length( VLC_TS_INVALID ) , m_chromecast_start_time( VLC_TS_INVALID ) , m_seek_request_time( VLC_TS_INVALID ) { - vlc_mutex_init(&lock); - vlc_cond_init(&loadCommandCond); - vlc_cond_init(&seekCommandCond); - - common.p_opaque = this; - common.pf_get_position = get_position; - common.pf_get_time = get_time; - common.pf_set_length = set_length; - common.pf_wait_app_started = wait_app_started; - common.pf_request_seek = request_seek; - common.pf_wait_seek_done = wait_seek_done; - common.pf_set_pause_state = set_pause_state; - common.pf_set_artwork = set_artwork; - common.pf_set_title = set_title; - - assert( var_Type( p_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME) == 0 ); - if (var_Create( p_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME, VLC_VAR_ADDRESS ) == VLC_SUCCESS ) - var_SetAddress( p_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME, &common ); + vlc_mutex_init(&m_lock); + vlc_cond_init(&m_loadCommandCond); + vlc_cond_init(&m_seekCommandCond); + + m_common.p_opaque = this; + m_common.pf_get_position = get_position; + m_common.pf_get_time = get_time; + m_common.pf_set_length = set_length; + m_common.pf_wait_app_started = wait_app_started; + m_common.pf_request_seek = request_seek; + m_common.pf_wait_seek_done = wait_seek_done; + m_common.pf_set_pause_state = set_pause_state; + m_common.pf_set_artwork = set_artwork; + m_common.pf_set_title = set_title; + + assert( var_Type( m_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME) == 0 ); + if (var_Create( m_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME, VLC_VAR_ADDRESS ) == VLC_SUCCESS ) + var_SetAddress( m_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME, &m_common ); // Start the Chromecast event thread. - if (vlc_clone(&chromecastThread, ChromecastThread, this, + if (vlc_clone(&m_chromecastThread, ChromecastThread, this, VLC_THREAD_PRIORITY_LOW)) { - msg_Err( p_module, "Could not start the Chromecast talking thread"); + msg_Err( m_module, "Could not start the Chromecast talking thread"); } } @@ -94,13 +94,13 @@ intf_sys_t::~intf_sys_t() { setHasInput( false ); - var_Destroy( p_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME ); + var_Destroy( m_module->obj.parent->obj.parent, CC_SHARED_VAR_NAME ); - switch ( conn_status ) + switch ( m_conn_status ) { case CHROMECAST_APP_STARTED: // Generate the close messages. - m_communication.msgReceiverClose(appTransportId); + m_communication.msgReceiverClose(m_appTransportId); // ft case CHROMECAST_TLS_CONNECTED: case CHROMECAST_AUTHENTICATED: @@ -112,50 +112,50 @@ intf_sys_t::~intf_sys_t() break; } - vlc_interrupt_kill( p_ctl_thread_interrupt ); + vlc_interrupt_kill( m_ctl_thread_interrupt ); - vlc_join(chromecastThread, NULL); + vlc_join(m_chromecastThread, NULL); - vlc_interrupt_destroy( p_ctl_thread_interrupt ); + vlc_interrupt_destroy( m_ctl_thread_interrupt ); // make sure we unblock the demuxer m_seek_request_time = VLC_TS_INVALID; - vlc_cond_signal(&seekCommandCond); + vlc_cond_signal(&m_seekCommandCond); - vlc_cond_destroy(&seekCommandCond); - vlc_cond_destroy(&loadCommandCond); - vlc_mutex_destroy(&lock); + vlc_cond_destroy(&m_seekCommandCond); + vlc_cond_destroy(&m_loadCommandCond); + vlc_mutex_destroy(&m_lock); } void intf_sys_t::setHasInput( bool b_has_input, const std::string mime_type ) { - vlc_mutex_locker locker(&lock); - msg_Dbg( p_module, "setHasInput %s session:%s",b_has_input ? "true":"false", mediaSessionId.c_str() ); + vlc_mutex_locker locker(&m_lock); + msg_Dbg( m_module, "setHasInput %s session:%s",b_has_input ? "true":"false", m_mediaSessionId.c_str() ); - this->has_input = b_has_input; - this->mime = mime_type; + this->m_has_input = b_has_input; + this->m_mime = mime_type; - if( this->has_input ) + if( this->m_has_input ) { - mutex_cleanup_push(&lock); - while (conn_status != CHROMECAST_APP_STARTED && conn_status != CHROMECAST_CONNECTION_DEAD) + mutex_cleanup_push(&m_lock); + while (m_conn_status != CHROMECAST_APP_STARTED && m_conn_status != CHROMECAST_CONNECTION_DEAD) { - msg_Dbg( p_module, "setHasInput waiting for Chromecast connection, current %d", conn_status); - vlc_cond_wait(&loadCommandCond, &lock); + msg_Dbg( m_module, "setHasInput waiting for Chromecast connection, current %d", m_conn_status); + vlc_cond_wait(&m_loadCommandCond, &m_lock); } vlc_cleanup_pop(); - if (conn_status == CHROMECAST_CONNECTION_DEAD) + if (m_conn_status == CHROMECAST_CONNECTION_DEAD) { - msg_Warn( p_module, "no Chromecast hook possible"); + msg_Warn( m_module, "no Chromecast hook possible"); return; } - if ( receiverState == RECEIVER_IDLE ) + if ( m_receiverState == RECEIVER_IDLE ) { // we cannot start a new load when the last one is still processing - i_ts_local_start = VLC_TS_0; - m_communication.msgPlayerLoad( appTransportId, i_port, title, artwork, mime_type ); + m_ts_local_start = VLC_TS_0; + m_communication.msgPlayerLoad( m_appTransportId, m_streaming_port, m_title, m_artwork, mime_type ); setPlayerStatus(CMD_LOAD_SENT); } } @@ -168,10 +168,10 @@ void intf_sys_t::disconnectChromecast() { m_communication.disconnect(); setConnectionStatus(CHROMECAST_DISCONNECTED); - appTransportId = ""; - mediaSessionId = ""; // this session is not valid anymore + m_appTransportId = ""; + m_mediaSessionId = ""; // this session is not valid anymore setPlayerStatus(NO_CMD_PENDING); - receiverState = RECEIVER_IDLE; + m_receiverState = RECEIVER_IDLE; } /** @@ -184,7 +184,7 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) const std::string & namespace_ = msg.namespace_(); #ifndef NDEBUG - msg_Dbg( p_module, "processMessage: %s->%s %s", namespace_.c_str(), msg.destination_id().c_str(), msg.payload_utf8().c_str()); + msg_Dbg( m_module, "processMessage: %s->%s %s", namespace_.c_str(), msg.destination_id().c_str(), msg.payload_utf8().c_str()); #endif if (namespace_ == NAMESPACE_DEVICEAUTH) @@ -194,15 +194,15 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) if (authMessage.has_error()) { - msg_Err( p_module, "Authentification error: %d", authMessage.error().error_type()); + msg_Err( m_module, "Authentification error: %d", authMessage.error().error_type()); } else if (!authMessage.has_response()) { - msg_Err( p_module, "Authentification message has no response field"); + msg_Err( m_module, "Authentification message has no response field"); } else { - vlc_mutex_locker locker(&lock); + vlc_mutex_locker locker(&m_lock); setConnectionStatus(CHROMECAST_AUTHENTICATED); m_communication.msgConnect(DEFAULT_CHOMECAST_RECEIVER); m_communication.msgReceiverGetStatus(); @@ -215,16 +215,16 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) if (type == "PING") { - msg_Dbg( p_module, "PING received from the Chromecast"); + msg_Dbg( m_module, "PING received from the Chromecast"); m_communication.msgPong(); } else if (type == "PONG") { - msg_Dbg( p_module, "PONG received from the Chromecast"); + msg_Dbg( m_module, "PONG received from the Chromecast"); } else { - msg_Warn( p_module, "Heartbeat command not supported: %s", type.c_str()); + msg_Warn( m_module, "Heartbeat command not supported: %s", type.c_str()); } json_value_free(p_data); @@ -239,7 +239,7 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) json_value applications = (*p_data)["status"]["applications"]; const json_value *p_app = NULL; - vlc_mutex_locker locker(&lock); + vlc_mutex_locker locker(&m_lock); for (unsigned i = 0; i < applications.u.array.length; ++i) { std::string appId(applications[i]["appId"]); @@ -248,7 +248,7 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) const char *pz_transportId = applications[i]["transportId"]; if (pz_transportId != NULL) { - appTransportId = std::string(pz_transportId); + m_appTransportId = std::string(pz_transportId); p_app = &applications[i]; } break; @@ -257,30 +257,30 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) if ( p_app ) { - if (!appTransportId.empty() - && conn_status == CHROMECAST_AUTHENTICATED) + if (!m_appTransportId.empty() + && m_conn_status == CHROMECAST_AUTHENTICATED) { - m_communication.msgConnect( appTransportId ); + m_communication.msgConnect( m_appTransportId ); setPlayerStatus(NO_CMD_PENDING); setConnectionStatus(CHROMECAST_APP_STARTED); } } else { - switch( conn_status ) + switch( m_conn_status ) { /* If the app is no longer present */ case CHROMECAST_APP_STARTED: - msg_Warn( p_module, "app is no longer present. closing"); - m_communication.msgReceiverClose(appTransportId); + msg_Warn( m_module, "app is no longer present. closing"); + m_communication.msgReceiverClose(m_appTransportId); setConnectionStatus(CHROMECAST_CONNECTION_DEAD); break; case CHROMECAST_AUTHENTICATED: - msg_Dbg( p_module, "Chromecast was running no app, launch media_app"); - appTransportId = ""; - mediaSessionId = ""; // this session is not valid anymore - receiverState = RECEIVER_IDLE; + msg_Dbg( m_module, "Chromecast was running no app, launch media_app"); + m_appTransportId = ""; + m_mediaSessionId = ""; // this session is not valid anymore + m_receiverState = RECEIVER_IDLE; m_communication.msgReceiverLaunchApp(); break; @@ -293,12 +293,12 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) else if (type == "LAUNCH_ERROR") { json_value reason = (*p_data)["reason"]; - msg_Err( p_module, "Failed to start the MediaPlayer: %s", + msg_Err( m_module, "Failed to start the MediaPlayer: %s", (const char *)reason); } else { - msg_Warn( p_module, "Receiver command not supported: %s", + msg_Warn( m_module, "Receiver command not supported: %s", msg.payload_utf8().c_str()); } @@ -312,62 +312,62 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) if (type == "MEDIA_STATUS") { json_value status = (*p_data)["status"]; - msg_Dbg( p_module, "Player state: %s sessionId:%d", + msg_Dbg( m_module, "Player state: %s sessionId:%d", status[0]["playerState"].operator const char *(), (int)(json_int_t) status[0]["mediaSessionId"]); - vlc_mutex_locker locker(&lock); - receiver_state oldPlayerState = receiverState; + vlc_mutex_locker locker(&m_lock); + receiver_state oldPlayerState = m_receiverState; std::string newPlayerState = status[0]["playerState"].operator const char *(); std::string idleReason = status[0]["idleReason"].operator const char *(); if (newPlayerState == "IDLE") - receiverState = RECEIVER_IDLE; + m_receiverState = RECEIVER_IDLE; else if (newPlayerState == "PLAYING") - receiverState = RECEIVER_PLAYING; + m_receiverState = RECEIVER_PLAYING; else if (newPlayerState == "BUFFERING") - receiverState = RECEIVER_BUFFERING; + m_receiverState = RECEIVER_BUFFERING; else if (newPlayerState == "PAUSED") - receiverState = RECEIVER_PAUSED; + m_receiverState = RECEIVER_PAUSED; else if (!newPlayerState.empty()) - msg_Warn( p_module, "Unknown Chromecast state %s", newPlayerState.c_str()); + msg_Warn( m_module, "Unknown Chromecast state %s", newPlayerState.c_str()); - if (receiverState == RECEIVER_IDLE) + if (m_receiverState == RECEIVER_IDLE) { - mediaSessionId = ""; // this session is not valid anymore + m_mediaSessionId = ""; // this session is not valid anymore } else { char session_id[32]; if( snprintf( session_id, sizeof(session_id), "%" PRId64, (json_int_t) status[0]["mediaSessionId"] ) >= (int)sizeof(session_id) ) { - msg_Err( p_module, "snprintf() truncated string for mediaSessionId" ); + msg_Err( m_module, "snprintf() truncated string for mediaSessionId" ); session_id[sizeof(session_id) - 1] = '\0'; } - if (session_id[0] && mediaSessionId != session_id) { - if (!mediaSessionId.empty()) - msg_Warn( p_module, "different mediaSessionId detected %s was %s", session_id, this->mediaSessionId.c_str()); - mediaSessionId = session_id; + if (session_id[0] && m_mediaSessionId != session_id) { + if (!m_mediaSessionId.empty()) + msg_Warn( m_module, "different mediaSessionId detected %s was %s", session_id, this->m_mediaSessionId.c_str()); + m_mediaSessionId = session_id; } } - if (receiverState != oldPlayerState) + if (m_receiverState != oldPlayerState) { #ifndef NDEBUG - msg_Dbg( p_module, "change Chromecast player state from %d to %d", oldPlayerState, receiverState); + msg_Dbg( m_module, "change Chromecast player state from %d to %d", oldPlayerState, m_receiverState ); #endif - switch( receiverState ) + switch( m_receiverState ) { case RECEIVER_BUFFERING: if ( double(status[0]["currentTime"]) == 0.0 ) { - receiverState = oldPlayerState; - msg_Dbg( p_module, "Invalid buffering time, keep previous state %d", oldPlayerState); + m_receiverState = oldPlayerState; + msg_Dbg( m_module, "Invalid buffering time, keep previous state %d", oldPlayerState); } else { m_chromecast_start_time = (1 + mtime_t( double( status[0]["currentTime"] ) ) ) * 1000000L; - msg_Dbg( p_module, "Playback pending with an offset of %" PRId64, m_chromecast_start_time); + msg_Dbg( m_module, "Playback pending with an offset of %" PRId64, m_chromecast_start_time); } m_time_playback_started = VLC_TS_INVALID; break; @@ -375,76 +375,76 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) case RECEIVER_PLAYING: /* TODO reset demux PCR ? */ if (unlikely(m_chromecast_start_time == VLC_TS_INVALID)) { - msg_Warn( p_module, "start playing without buffering" ); + msg_Warn( m_module, "start playing without buffering" ); m_chromecast_start_time = (1 + mtime_t( double( status[0]["currentTime"] ) ) ) * 1000000L; } setPlayerStatus(CMD_PLAYBACK_SENT); m_time_playback_started = mdate(); #ifndef NDEBUG - msg_Dbg( p_module, "Playback started with an offset of %" PRId64 " now:%" PRId64 " i_ts_local_start:%" PRId64, m_chromecast_start_time, m_time_playback_started, i_ts_local_start); + msg_Dbg( m_module, "Playback started with an offset of %" PRId64 " now:%" PRId64 " i_ts_local_start:%" PRId64, m_chromecast_start_time, m_time_playback_started, m_ts_local_start); #endif break; case RECEIVER_PAUSED: m_chromecast_start_time = (1 + mtime_t( double( status[0]["currentTime"] ) ) ) * 1000000L; #ifndef NDEBUG - msg_Dbg( p_module, "Playback paused with an offset of %" PRId64 " date_play_start:%" PRId64, m_chromecast_start_time, m_time_playback_started); + msg_Dbg( m_module, "Playback paused with an offset of %" PRId64 " date_play_start:%" PRId64, m_chromecast_start_time, m_time_playback_started); #endif if ( m_time_playback_started != VLC_TS_INVALID && oldPlayerState == RECEIVER_PLAYING ) { /* this is a pause generated remotely, adjust the playback time */ - i_ts_local_start += mdate() - m_time_playback_started; + m_ts_local_start += mdate() - m_time_playback_started; #ifndef NDEBUG - msg_Dbg( p_module, "updated i_ts_local_start:%" PRId64, i_ts_local_start); + msg_Dbg( m_module, "updated i_ts_local_start:%" PRId64, m_ts_local_start); #endif } m_time_playback_started = VLC_TS_INVALID; break; case RECEIVER_IDLE: - if ( has_input ) + if ( m_has_input ) setPlayerStatus(NO_CMD_PENDING); m_time_playback_started = VLC_TS_INVALID; break; } } - if (receiverState == RECEIVER_BUFFERING && m_seek_request_time != VLC_TS_INVALID) + if (m_receiverState == RECEIVER_BUFFERING && m_seek_request_time != VLC_TS_INVALID) { - msg_Dbg( p_module, "Chromecast seeking possibly done"); - vlc_cond_signal( &seekCommandCond ); + msg_Dbg( m_module, "Chromecast seeking possibly done"); + vlc_cond_signal( &m_seekCommandCond ); } - if ( (cmd_status != CMD_LOAD_SENT || idleReason == "CANCELLED") && receiverState == RECEIVER_IDLE && has_input ) + if ( (m_cmd_status != CMD_LOAD_SENT || idleReason == "CANCELLED") && m_receiverState == RECEIVER_IDLE && m_has_input ) { - msg_Dbg( p_module, "the device missed the LOAD command"); - i_ts_local_start = VLC_TS_0; - m_communication.msgPlayerLoad( appTransportId, i_port, title, artwork, mime ); + msg_Dbg( m_module, "the device missed the LOAD command"); + m_ts_local_start = VLC_TS_0; + m_communication.msgPlayerLoad( m_appTransportId, m_streaming_port, m_title, m_artwork, m_mime ); setPlayerStatus(CMD_LOAD_SENT); } } else if (type == "LOAD_FAILED") { - msg_Err( p_module, "Media load failed"); - vlc_mutex_locker locker(&lock); + msg_Err( m_module, "Media load failed"); + vlc_mutex_locker locker(&m_lock); /* close the app to restart it */ - if ( conn_status == CHROMECAST_APP_STARTED ) - m_communication.msgReceiverClose(appTransportId); + if ( m_conn_status == CHROMECAST_APP_STARTED ) + m_communication.msgReceiverClose(m_appTransportId); else m_communication.msgReceiverGetStatus(); } else if (type == "LOAD_CANCELLED") { - msg_Dbg( p_module, "LOAD canceled by another command"); + msg_Dbg( m_module, "LOAD canceled by another command"); } else if (type == "INVALID_REQUEST") { - msg_Dbg( p_module, "We sent an invalid request reason:%s", (*p_data)["reason"].operator const char *()); + msg_Dbg( m_module, "We sent an invalid request reason:%s", (*p_data)["reason"].operator const char *()); } else { - msg_Warn( p_module, "Media command not supported: %s", + msg_Warn( m_module, "Media command not supported: %s", msg.payload_utf8().c_str()); } @@ -458,23 +458,23 @@ void intf_sys_t::processMessage(const castchannel::CastMessage &msg) if (type == "CLOSE") { - msg_Warn( p_module, "received close message"); + msg_Warn( m_module, "received close message"); setHasInput( false ); - vlc_mutex_locker locker(&lock); + vlc_mutex_locker locker(&m_lock); setConnectionStatus(CHROMECAST_CONNECTION_DEAD); // make sure we unblock the demuxer m_seek_request_time = VLC_TS_INVALID; - vlc_cond_signal(&seekCommandCond); + vlc_cond_signal(&m_seekCommandCond); } else { - msg_Warn( p_module, "Connection command not supported: %s", + msg_Warn( m_module, "Connection command not supported: %s", type.c_str()); } } else { - msg_Err( p_module, "Unknown namespace: %s", msg.namespace_().c_str()); + msg_Err( m_module, "Unknown namespace: %s", msg.namespace_().c_str()); } } @@ -492,11 +492,11 @@ void* intf_sys_t::ChromecastThread(void* p_data) void intf_sys_t::mainLoop() { - vlc_interrupt_set( p_ctl_thread_interrupt ); + vlc_interrupt_set( m_ctl_thread_interrupt ); - vlc_mutex_lock(&lock); + vlc_mutex_lock(&m_lock); setConnectionStatus(CHROMECAST_TLS_CONNECTED); - vlc_mutex_unlock(&lock); + vlc_mutex_unlock(&m_lock); m_communication.msgAuth(); @@ -516,24 +516,24 @@ bool intf_sys_t::handleMessages() bool b_msgReceived = false; uint32_t i_payloadSize = 0; - if ( requested_stop.exchange(false) && !mediaSessionId.empty() ) + if ( m_requested_stop.exchange(false) && !m_mediaSessionId.empty() ) { - m_communication.msgPlayerStop( appTransportId, mediaSessionId ); + m_communication.msgPlayerStop( m_appTransportId, m_mediaSessionId ); } - if ( requested_seek.exchange(false) && !mediaSessionId.empty() ) + if ( m_requested_seek.exchange(false) && !m_mediaSessionId.empty() ) { char current_time[32]; m_seek_request_time = mdate() + SEEK_FORWARD_OFFSET; if( snprintf( current_time, sizeof(current_time), "%.3f", double( m_seek_request_time ) / 1000000.0 ) >= (int)sizeof(current_time) ) { - msg_Err( p_module, "snprintf() truncated string for mediaSessionId" ); + msg_Err( m_module, "snprintf() truncated string for mediaSessionId" ); current_time[sizeof(current_time) - 1] = '\0'; } - vlc_mutex_locker locker(&lock); + vlc_mutex_locker locker(&m_lock); setPlayerStatus(CMD_SEEK_SENT); /* send a fake time to seek to, to make sure the device flushes its buffers */ - m_communication.msgPlayerSeek( appTransportId, mediaSessionId, current_time ); + m_communication.msgPlayerSeek( m_appTransportId, m_mediaSessionId, current_time ); } int i_ret = m_communication.recvPacket( &b_msgReceived, i_payloadSize, @@ -547,8 +547,8 @@ bool intf_sys_t::handleMessages() if ((i_ret < 0 && errno != EAGAIN) || i_ret == 0) #endif { - msg_Err( p_module, "The connection to the Chromecast died (receiving)."); - vlc_mutex_locker locker(&lock); + msg_Err( m_module, "The connection to the Chromecast died (receiving)."); + vlc_mutex_locker locker(&m_lock); setConnectionStatus(CHROMECAST_CONNECTION_DEAD); } @@ -565,47 +565,47 @@ bool intf_sys_t::handleMessages() processMessage(msg); } - vlc_mutex_locker locker(&lock); - return conn_status != CHROMECAST_CONNECTION_DEAD; + vlc_mutex_locker locker(&m_lock); + return m_conn_status != CHROMECAST_CONNECTION_DEAD; } void intf_sys_t::notifySendRequest() { - vlc_interrupt_raise( p_ctl_thread_interrupt ); + vlc_interrupt_raise( m_ctl_thread_interrupt ); } void intf_sys_t::requestPlayerStop() { - requested_stop = true; + m_requested_stop = true; setHasInput(false); notifySendRequest(); } void intf_sys_t::requestPlayerSeek(mtime_t pos) { - vlc_mutex_locker locker(&lock); + vlc_mutex_locker locker(&m_lock); if ( pos != VLC_TS_INVALID ) - i_ts_local_start = pos; - requested_seek = true; + m_ts_local_start = pos; + m_requested_seek = true; notifySendRequest(); } void intf_sys_t::setPauseState(bool paused) { - msg_Dbg( p_module, "%s state for %s", paused ? "paused" : "playing", title.c_str() ); + msg_Dbg( m_module, "%s state for %s", paused ? "paused" : "playing", m_title.c_str() ); if ( !paused ) { - if ( !mediaSessionId.empty() && receiverState != RECEIVER_IDLE ) + if ( !m_mediaSessionId.empty() && m_receiverState != RECEIVER_IDLE ) { - m_communication.msgPlayerPlay( appTransportId, mediaSessionId ); + m_communication.msgPlayerPlay( m_appTransportId, m_mediaSessionId ); setPlayerStatus(CMD_PLAYBACK_SENT); } } else { - if ( !mediaSessionId.empty() && receiverState != RECEIVER_IDLE ) + if ( !m_mediaSessionId.empty() && m_receiverState != RECEIVER_IDLE ) { - m_communication.msgPlayerPause( appTransportId, mediaSessionId ); + m_communication.msgPlayerPause( m_appTransportId, m_mediaSessionId ); setPlayerStatus(CMD_PLAYBACK_SENT); } } @@ -613,29 +613,29 @@ void intf_sys_t::setPauseState(bool paused) void intf_sys_t::waitAppStarted() { - vlc_mutex_locker locker(&lock); - mutex_cleanup_push(&lock); - while ( conn_status != CHROMECAST_APP_STARTED && - conn_status != CHROMECAST_CONNECTION_DEAD ) - vlc_cond_wait(&loadCommandCond, &lock); + vlc_mutex_locker locker(&m_lock); + mutex_cleanup_push(&m_lock); + while ( m_conn_status != CHROMECAST_APP_STARTED && + m_conn_status != CHROMECAST_CONNECTION_DEAD ) + vlc_cond_wait(&m_loadCommandCond, &m_lock); vlc_cleanup_pop(); } void intf_sys_t::waitSeekDone() { - vlc_mutex_locker locker(&lock); + vlc_mutex_locker locker(&m_lock); if ( m_seek_request_time != VLC_TS_INVALID ) { - mutex_cleanup_push(&lock); + mutex_cleanup_push(&m_lock); while ( m_chromecast_start_time < m_seek_request_time && - conn_status == CHROMECAST_APP_STARTED ) + m_conn_status == CHROMECAST_APP_STARTED ) { #ifndef NDEBUG - msg_Dbg( p_module, "waiting for Chromecast seek" ); + msg_Dbg( m_module, "waiting for Chromecast seek" ); #endif - vlc_cond_wait(&seekCommandCond, &lock); + vlc_cond_wait(&m_seekCommandCond, &m_lock); #ifndef NDEBUG - msg_Dbg( p_module, "finished waiting for Chromecast seek" ); + msg_Dbg( m_module, "finished waiting for Chromecast seek" ); #endif } vlc_cleanup_pop(); @@ -645,93 +645,93 @@ void intf_sys_t::waitSeekDone() void intf_sys_t::setConnectionStatus(connection_status status) { - if (conn_status != status) + if (m_conn_status != status) { #ifndef NDEBUG - msg_Dbg(p_module, "change Chromecast connection status from %d to %d", conn_status, status); + msg_Dbg(m_module, "change Chromecast connection status from %d to %d", m_conn_status, status); #endif - conn_status = status; - vlc_cond_broadcast(&loadCommandCond); - vlc_cond_signal(&seekCommandCond); + m_conn_status = status; + vlc_cond_broadcast(&m_loadCommandCond); + vlc_cond_signal(&m_seekCommandCond); } } bool intf_sys_t::isFinishedPlaying() { - vlc_mutex_locker locker(&lock); - return conn_status == CHROMECAST_CONNECTION_DEAD || (receiverState == RECEIVER_BUFFERING && cmd_status != CMD_SEEK_SENT); + vlc_mutex_locker locker(&m_lock); + return m_conn_status == CHROMECAST_CONNECTION_DEAD || (m_receiverState == RECEIVER_BUFFERING && m_cmd_status != CMD_SEEK_SENT); } void intf_sys_t::setTitle(const char* psz_title) { if ( psz_title ) - title = psz_title; + m_title = psz_title; else - title = ""; + m_title = ""; } void intf_sys_t::setArtwork(const char* psz_artwork) { if ( psz_artwork ) - artwork = psz_artwork; + m_artwork = psz_artwork; else - artwork = ""; + m_artwork = ""; } void intf_sys_t::setPlayerStatus(command_status status) { - if (cmd_status != status) + if (m_cmd_status != status) { - msg_Dbg(p_module, "change Chromecast command status from %d to %d", cmd_status, status); - cmd_status = status; + msg_Dbg(m_module, "change Chromecast command status from %d to %d", m_cmd_status, status); + m_cmd_status = status; } } mtime_t intf_sys_t::getPlaybackTimestamp() const { - switch( receiverState ) + switch( m_receiverState ) { case RECEIVER_PLAYING: - return ( mdate() - m_time_playback_started ) + i_ts_local_start; + return ( mdate() - m_time_playback_started ) + m_ts_local_start; case RECEIVER_IDLE: - msg_Dbg(p_module, "receiver idle using buffering time %" PRId64, i_ts_local_start); + msg_Dbg(m_module, "receiver idle using buffering time %" PRId64, m_ts_local_start); break; case RECEIVER_BUFFERING: - msg_Dbg(p_module, "receiver buffering using buffering time %" PRId64, i_ts_local_start); + msg_Dbg(m_module, "receiver buffering using buffering time %" PRId64, m_ts_local_start); break; case RECEIVER_PAUSED: - msg_Dbg(p_module, "receiver paused using buffering time %" PRId64, i_ts_local_start); + msg_Dbg(m_module, "receiver paused using buffering time %" PRId64, m_ts_local_start); break; } - return i_ts_local_start; + return m_ts_local_start; } double intf_sys_t::getPlaybackPosition() const { - if( i_length > 0 && m_time_playback_started != VLC_TS_INVALID) - return (double) getPlaybackTimestamp() / (double)( i_length ); + if( m_length > 0 && m_time_playback_started != VLC_TS_INVALID) + return (double) getPlaybackTimestamp() / (double)( m_length ); return 0.0; } mtime_t intf_sys_t::get_time(void *pt) { intf_sys_t *p_this = reinterpret_cast(pt); - vlc_mutex_locker locker( &p_this->lock ); + vlc_mutex_locker locker( &p_this->m_lock ); return p_this->getPlaybackTimestamp(); } double intf_sys_t::get_position(void *pt) { intf_sys_t *p_this = reinterpret_cast(pt); - vlc_mutex_locker locker( &p_this->lock ); + vlc_mutex_locker locker( &p_this->m_lock ); return p_this->getPlaybackPosition(); } void intf_sys_t::set_length(void *pt, mtime_t length) { intf_sys_t *p_this = reinterpret_cast(pt); - p_this->i_length = length; + p_this->m_length = length; } void intf_sys_t::wait_app_started(void *pt) -- 2.11.4.GIT