📄 avstreams_i.cpp
字号:
// Define ourselves as the related_streamctrl property of the sep.
CORBA::Any streamctrl_any;
streamctrl_any <<= this->streamctrl_.in ();
this->sep_b_->define_property ("Related_StreamCtrl",
streamctrl_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
CORBA::Any vdev_b_any;
vdev_b_any <<= this->vdev_b_.in ();
this->sep_b_->define_property ("Related_VDev",
vdev_b_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
CORBA::Any streamendpoint_b_any;
streamendpoint_b_any <<= this->sep_b_.in ();
this->vdev_b_->define_property ("Related_StreamEndpoint",
streamendpoint_b_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
CORBA::Any mmdevice_b_any;
mmdevice_b_any <<= b_party;
this->vdev_b_->define_property ("Related_MMDevice",
mmdevice_b_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
// add the mmdevice, sep and vdev to the map.
MMDevice_Map_Entry map_entry;
MMDevice_Map_Hash_Key key (b_party);
map_entry.sep_ = AVStreams::StreamEndPoint::_duplicate (this->sep_b_.in ());
map_entry.vdev_ = AVStreams::VDev::_duplicate(this->vdev_b_.in ());
map_entry.flowspec_ = the_flows;
map_entry.qos_ = the_qos;
int result =
this->mmdevice_b_map_.bind (key, map_entry);
if (result < 0)
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "Error binding mmdevice entry in the b_map"));
}
}
// Tell the endpoints about each other.
if ((!CORBA::is_nil (a_party)) && (!CORBA::is_nil (b_party)))
{
CORBA::Any sep_a_peer_any;
CORBA::Any sep_b_peer_any;
sep_a_peer_any <<= this->sep_b_.in();
sep_b_peer_any <<= this->sep_a_.in();
this->sep_a_->define_property ("PeerAdapter",
sep_a_peer_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
this->sep_b_->define_property ("PeerAdapter",
sep_b_peer_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
}
// In the full profile case there's no VDev.
if (CORBA::is_nil (b_party) && (!CORBA::is_nil (this->vdev_a_.in ())))
{
// Now set the source id for this A endpoint.
// If the sep contains flow producers then set the source ids for those
// instead.
ACE_TRY_EX (set_source_id)
{
CORBA::Any_ptr flows_any = this->sep_a_->get_property_value ("Flows"
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK_EX (set_source_id);
AVStreams::flowSpec_var flows;
*flows_any >>= flows.out ();
for (u_int i=0; i< flows->length ();i++)
{
CORBA::Object_var fep_obj =
this->sep_a_->get_fep (flows [i] ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK_EX (set_source_id);
ACE_TRY_EX (producer_check)
{
AVStreams::FlowProducer_var producer =
AVStreams::FlowProducer::_narrow (fep_obj.in ()
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK_EX (producer_check);
producer->set_source_id (this->source_id_++);
}
ACE_CATCHANY
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG, " %s ", flows[i].in ()));
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "producer_check: not a producer");
}
ACE_ENDTRY;
ACE_CHECK_RETURN (0);
}
}
ACE_CATCHANY
{
// Since the full profile failed try setting the source id
// for the sep instead.
// @@Naga: What do we do if in the light profile the sep has
// many producers who do not have flow interfaces. Then
// the streamctrl has to give an array of source ids to
// the sep.
this->sep_a_->set_source_id (this->source_id_++
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
}
ACE_ENDTRY;
ACE_CHECK_RETURN (0);
if (!this->mcastconfigif_)
{
ACE_NEW_RETURN (this->mcastconfigif_,
TAO_MCastConfigIf,
0);
// @@: Deactivating the object thru poa means calling remove_ref after _this.
this->mcastconfigif_ptr_ = this->mcastconfigif_->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
ACE_TRY_CHECK;
}
// Multicast source being added.
CORBA::Boolean result = this->vdev_a_->set_Mcast_peer (this->streamctrl_.in (),
this->mcastconfigif_ptr_.in (),
the_qos,
the_flows
ACE_ENV_ARG_PARAMETER);
if (!result)
ACE_ERROR_RETURN ((LM_ERROR, "set_Mcast_peer failed\n"), 0);
}
if (CORBA::is_nil (a_party))
{
if (!CORBA::is_nil (this->vdev_b_.in ()))
{
// Multicast sink being added.
if (!this->mcastconfigif_)
ACE_ERROR_RETURN ((LM_ERROR, "first add a source and then a sink\n"), 0);
this->mcastconfigif_->set_peer (this->vdev_b_.in (),
the_qos,
the_flows
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
}
int connect_leaf_success = 0;
ACE_TRY_EX (connect_leaf)
{
// @@: define null interfaces for Atm so that they can be implemented once
// ACE adds support for ATM multicast.
connect_leaf_success = this->sep_a_->connect_leaf (this->sep_b_.in (),
the_qos,
the_flows
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK_EX (connect_leaf);
connect_leaf_success = 1;
}
ACE_CATCH (AVStreams::notSupported, ex)
{
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "connect_leaf failed\n"));
connect_leaf_success = 0;
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "TAO_StreamCtrl::bind_devs");
}
ACE_ENDTRY;
ACE_CHECK_RETURN (0);
if (!connect_leaf_success)
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,"TAO_StreamCtrl::bind_devs Multiconnect\n"));
AVStreams::flowSpec connect_flows = the_flows;
this->sep_a_->multiconnect (the_qos, connect_flows ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
this->sep_b_->multiconnect (the_qos, connect_flows ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
}
}
if (!CORBA::is_nil (a_party) && !CORBA::is_nil (b_party))
{
// Check to see if the MMDevice contains FDev objects
// If it contains FDev objects, then we are using the
// Full profile, and we want to call bind() instead
// of connect() on the the streamctrl
if( a_party->is_property_defined("Flows") &&
b_party->is_property_defined("Flows") )
{
if (TAO_debug_level > 0) {
ACE_DEBUG ((LM_DEBUG, "(%N,%l) Full profile, invoking bind()\n"));
}
// It is full profile
// we have feps in the sep then dont call connect
// instead call bind on the streamctrl.
this->bind (this->sep_a_.in (),
this->sep_b_.in (),
the_qos,
the_flows
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
}
// This is the light profile, call connect()
else if (!CORBA::is_nil (this->vdev_a_.in ()) && !CORBA::is_nil (this->vdev_b_.in ()))
{
if (TAO_debug_level > 0) {
ACE_DEBUG ((LM_DEBUG, "(%N,%l) Light profile, invoking connect()\n"));
}
// Tell the 2 VDev's about one another
this->vdev_a_->set_peer (this->streamctrl_.in (),
this->vdev_b_.in (),
the_qos,
the_flows
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
this->vdev_b_->set_peer (this->streamctrl_.in (),
this->vdev_a_.in (),
the_qos,
the_flows
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
// Now connect the streams together. This will
// establish the connection
CORBA::Boolean result =
this->sep_a_->connect (this->sep_b_.in (),
the_qos,
the_flows
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
if (result == 0)
ACE_ERROR_RETURN ((LM_ERROR, "sep_a->connect (sep_b) failed\n"), 0);
}
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "TAO_StreamCtrl::bind_devs");
return 0;
}
ACE_ENDTRY;
ACE_CHECK_RETURN (0);
return 1;
}
// Used to establish a connection between two endpoints
// directly, i.e. without a MMDevice
CORBA::Boolean
TAO_StreamCtrl::bind (AVStreams::StreamEndPoint_A_ptr sep_a,
AVStreams::StreamEndPoint_B_ptr sep_b,
AVStreams::streamQoS &stream_qos,
const AVStreams::flowSpec &flow_spec
ACE_ENV_ARG_DECL)
ACE_THROW_SPEC ((CORBA::SystemException,
AVStreams::streamOpFailed,
AVStreams::noSuchFlow,
AVStreams::QoSRequestFailed))
{
this->sep_a_ = AVStreams::StreamEndPoint_A::_duplicate(sep_a);
this->sep_b_ = AVStreams::StreamEndPoint_B::_duplicate(sep_b);
int result = 0;
ACE_TRY
{
if (CORBA::is_nil (sep_a_.in() ) ||
CORBA::is_nil (sep_b_.in() ))
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_StreamCtrl::bind:"
"a_party or b_party null!"),
0);
// Define each other as their peers.
CORBA::Any sep_any;
sep_any <<= sep_b;
sep_a_->define_property ("PeerAdapter",
sep_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
sep_any <<= sep_a;
sep_b_->define_property ("PeerAdapter",
sep_any
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
// since its full profile we do the viable stream setup algorithm.
// get the flows for the A streamendpoint.
// the flows spec is empty and hence we do a exhaustive match.
AVStreams::flowSpec a_flows, b_flows;
CORBA::Any_var flows_any;
flows_any = sep_a_->get_property_value ("Flows" ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
AVStreams::flowSpec *temp_flows;
flows_any.in () >>= temp_flows;
a_flows = *temp_flows;
flows_any = sep_b_->get_property_value ("Flows" ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
flows_any.in () >>= temp_flows;
b_flows = *temp_flows;
u_int i;
FlowEndPoint_Map *a_fep_map;
FlowEndPoint_Map *b_fep_map;
ACE_NEW_RETURN (a_fep_map,
FlowEndPoint_Map,
0);
ACE_NEW_RETURN (b_fep_map,
FlowEndPoint_Map,
0);
for (i=0;i<a_flows.length ();i++)
{
const char *flowname = a_flows[i];
// get the flowendpoint references.
CORBA::Object_var fep_obj =
sep_a_->get_fep (flowname
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
AVStreams::FlowEndPoint_var fep =
AVStreams::FlowEndPoint::_narrow (fep_obj.in ()
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
ACE_CString fep_key (flowname);
result = a_fep_map->bind (fep_key, fep);
if (result == -1)
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO_StreamCtrl::bind failed for %s\n", flowname));
}
// get the flowendpoints for streamendpoint_b
for (i=0;i<b_flows.length ();i++)
{
const char *flowname = b_flows[i];
// get the flowendpoint references.
CORBA::Object_var fep_obj =
sep_b->get_fep (flowname
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
AVStreams::FlowEndPoint_var fep =
AVStreams::FlowEndPoint::_narrow (fep_obj.in ()
ACE_ENV_ARG_PARAMETER);
ACE_TRY_CHECK;
ACE_CString fep_key (flowname);
result = b_fep_map->bind (fep_key, fep);
if (result == -1)
if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "TAO_StreamCtrl::bind failed for %s\n", flowname));
}
FlowEndPoint_Map *map_a = 0, *map_b = 0;
if (flow_spec.length () == 0)
{
map_a = a_fep_map;
map_b = b_fep_map;
}
else
{
FlowEndPoint_Map *spec_fep_map_a, *spec_fep_map_b;
ACE_NEW_RETURN (spec_fep_map_a,
FlowEndPoint_Map,
0);
ACE_NEW_RETURN (spec_fep_map_b,
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -