ADTF  3.18.2
filtergraphport.h
Go to the documentation of this file.
1 
7 #pragma once
8 
9 #include "triggerpipe.h"
10 #include "runner_intf.h"
11 #include "pin_intf.h"
12 #include "inpin_intf.h"
13 #include "outpin_intf.h"
14 #include "filtergraphport_intf.h"
16 
17 #include <adtfbase/runnable_intf.h>
18 
19 #include <memory>
20 
21 namespace adtf
22 {
23 namespace streaming
24 {
25 namespace ant
26 {
27  namespace detail
28  {
32  template<typename T, typename U = T>
33  struct port_router
34  {
38  std::vector<adtf::ucom::object_ptr<U>> m_oTos;
39 
41  port_router() = default;
44  {
45  RemoveTos();
46  }
53  {
54  if (m_pFrom.Get() == pFrom.Get())
55  {
56  //we do nothing ... already routing
57  //or nullptr == nullptr
58  }
59  else
60  {
61  if (m_pFrom)
62  {
63  if (pFrom.Get())
64  {
65  RETURN_ERROR_DESC(ERR_DEVICE_IN_USE,
66  "This port is already connected to a sample stream / binding proxy.");
67  }
68 
69  for (const auto& pTo: m_oTos)
70  {
72  }
73  }
74  m_pFrom = pFrom;
75  if (m_pFrom)
76  {
77  for (const auto& pTo: m_oTos)
78  {
80  }
81  }
82  }
84  }
85 
92  {
93  if (std::find(m_oTos.begin(), m_oTos.end(), pTo) != m_oTos.end())
94  {
95  //we do nothing ... already forwarding
96  //or nullptr == nullptr
97  }
98  else
99  {
100  if (pTo.Get())
101  {
102  if (m_pFrom)
103  {
105  }
106 
107  m_oTos.push_back(pTo);
108  }
109  }
111  }
112 
113  void RemoveTos()
114  {
115  for (const auto& pTo: m_oTos)
116  {
118  }
119 
120  m_oTos.clear();
121  }
122 
131  {
132  if (pFrom.Get() != nullptr && pTo.Get() != nullptr)
133  {
134  LOG_DETAIL("Attach routing '%s' -> '%s'",
135  get_named_graph_object_full_name(*pFrom.Get()).GetPtr(),
136  get_named_graph_object_full_name(*pTo.Get()).GetPtr());
137  return pFrom->AttachRouting(pTo);
138  }
139  else
140  {
142  }
143  }
152  {
153  if (pFrom.Get() != nullptr && pTo.Get() != nullptr)
154  {
155  return pFrom->DetachRouting(pTo);
156  }
157  else
158  {
160  }
161  }
162  };
163  }
164 
170  public ucom::catwo::object<IPin,
171  IInPin,
172  IFilterGraphPort,
173  IFilterGraphDataPort,
174  named_graph_object<trigger_pipe_item<IFilterGraphDataInPort>>>
175  {
176 
177  private:
178  detail::port_router<ISampleStream> m_oStreamRouter;
179  std::atomic_bool m_bActive;
180 
181  public:
186  cFilterGraphDataInPort(const char* strName);
188  virtual ~cFilterGraphDataInPort() = default;
189 
190  public:
191  tResult InnerConnect(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) override;
192  tResult InnerDisconnect() override;
193 
194  public:
195  tResult GetType(adtf::ucom::ant::iobject_ptr<const IStreamType>& pStreamType) const override;
196 
197  bool IsConnected() const override;
198  tResult SetActive() override;
199  tResult SetInactive() override;
200 
201  tResult Disconnect() override;
202  tResult GetSampleStream(adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) const override;
203 
204  public:
205  tResult Connect(const adtf::ucom::ant::iobject_ptr<ISampleStream>& pSampleStream) override;
206  };
207 
213  public ucom::catwo::object<IPin,
214  IOutPin,
215  IFilterGraphPort,
216  IFilterGraphDataPort,
217  named_graph_object<trigger_pipe_item<IFilterGraphDataOutPort>>>
218  {
219  public:
220  template <typename T>
222 
223  private:
224  detail::port_router<ISampleStream> m_oStreamRouter;
225  std::atomic_bool m_bActive;
226 
227  public:
232  cFilterGraphDataOutPort(const char* strName);
234  virtual ~cFilterGraphDataOutPort() = default;
235 
236  public:
237  tResult InnerConnect(const iobject_ptr<ISampleStream>& pSampleStream);
238  tResult InnerDisconnect();
239 
240  public:
241  tResult Connect(const iobject_ptr<ISampleStream>& pSampleStream) override;
242 
243  public:
244  tResult GetType(iobject_ptr<const IStreamType>& pStreamType) const override;
245 
246  bool IsConnected() const override;
247  tResult SetActive() override;
248  tResult SetInactive() override;
249 
250  tResult Disconnect() override;
251  tResult GetSampleStream(iobject_ptr<ISampleStream>& pSampleStream) const override;
252 
253  };
254 
260  public ucom::catwo::object<IBindingObject,
261  IBindingServer,
262  IFilterGraphPort,
263  IFilterGraphInterfacePort,
264  named_graph_object<IFilterGraphInterfaceServerPort>>
265  {
266 
267  public:
269  template <typename T>
271 
272  private:
273  detail::port_router<IBindingProxy> m_oProxyRouter;
274 
275  public:
280  cFilterGraphServerPort(const char* strName);
282  virtual ~cFilterGraphServerPort() = default;
283 
284  public:
285  tResult InnerBind(const iobject_ptr<IBindingProxy>& pSampleStream);
286  tResult InnerUnbind();
287 
288  public:
289  tResult Bind(const iobject_ptr<IBindingProxy>& pBindingProxy);
290 
291  public:
292  tResult GetBindingType(iobject_ptr<const IBindingType>& pBindingType) const;
293  tResult GetServerObject(iobject_ptr<IObject>& pServerObject) const;
294  tResult GetBindingProxy(iobject_ptr<IBindingProxy>& pBindingProxy) const;
295  tResult Unbind();
296  };
297 
303  public ucom::catwo::object<IBindingObject,
304  IBindingClient,
305  IFilterGraphPort,
306  IFilterGraphInterfacePort,
307  named_graph_object<IFilterGraphInterfaceClientPort>>
308  {
309 
310  public:
312  template <typename T>
314 
315  private:
318 
319  public:
324  cFilterGraphClientPort(const char* strName);
326  virtual ~cFilterGraphClientPort() = default;
327 
328  public:
329  tResult InnerBind(const iobject_ptr<IBindingClient>& pClientForward) override;
330  tResult InnerUnbind() override;
331 
332  public:
333  tResult Bind(const iobject_ptr<IBindingProxy>& pBindingProxy) override;
334 
335  public:
336  tResult GetBindingType(iobject_ptr<const IBindingType>& pBindingType) const override;
337  tResult GetServerObject(iobject_ptr<IObject>& pServerObject) const override;
338  tResult GetBindingProxy(iobject_ptr<IBindingProxy>& pBindingProxy) const override;
339  tResult Unbind() override;
340  };
341 
347  public ucom::catwo::object<IRunner,
348  IFilterGraphPort,
349  trigger_pipe_item<named_graph_object<IFilterGraphRunnerPort>>>
350  {
351 
352  public:
354  template <typename T>
356 
357  public:
362  cFilterGraphRunnerPort(const char* strName);
364  virtual ~cFilterGraphRunnerPort() = default;
365 
366  public:
367  tResult InnerRegisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
368  tResult InnerUnregisterSubItem(const iobject_ptr<IRunner>& pRunner) override;
369  };
370 
371 } // namespace ant
372 
373 namespace flash
374 {
375 
376 class cFilterGraphRunnerPort: public ucom::catwo::object<base::ant::IRunnable,
377  ant::ITriggerPipeSource,
378  ant::ITriggerPipeItem,
379  ant::INamedGraphObject,
380  ant::IRunner,
381  ant::IFilterGraphPort,
382  ant::IFilterGraphRunnerPort,
383  base::flash::IRunnable>
384 {
385  public:
389  cFilterGraphRunnerPort(const char* strName);
390  ~cFilterGraphRunnerPort() override;
391 
392  tResult InnerRegisterSubItem(const ucom::ant::iobject_ptr<ant::IRunner>& pRunner) override;
393  tResult InnerUnregisterSubItem(const ucom::ant::iobject_ptr<ant::IRunner>& pRunner) override;
394 
395  ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
396 
397  protected:
398  class cImplementation;
399  std::unique_ptr<cImplementation> m_pImplementation;
400 };
401 
402 
403 class cFilterGraphDataInPort: public ucom::catwo::object<base::ant::IRunnable,
404  ant::ITriggerPipeSource,
405  ant::ITriggerPipeItem,
406  ant::INamedGraphObject,
407  IPin,
408  IInPin,
409  IFilterGraphPort,
410  IFilterGraphDataPort,
411  IFilterGraphDataInPort,
412  base::flash::IRunnable>
413 {
414  public:
416  cFilterGraphDataInPort(const char* strName);
417  ~cFilterGraphDataInPort() override;
418 
419  public:
420  tResult InnerConnect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
421  tResult InnerDisconnect() override;
422 
423  public:
424  tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
425 
426  bool IsConnected() const override;
427  tResult SetActive() override;
428  tResult SetInactive() override;
429 
430  tResult Disconnect() override;
431  tResult GetSampleStream(ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) const override;
432 
433  public:
434  tResult Connect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
435 
436  public:
437  ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
438 
439  protected:
440  class cImplementation;
441  std::unique_ptr<cImplementation> m_pImplementation;
442 };
443 
444 class cFilterGraphDataOutPort: public ucom::catwo::object<base::ant::IRunnable,
445  ant::ITriggerPipeSource,
446  ant::ITriggerPipeItem,
447  ant::INamedGraphObject,
448  IPin,
449  IOutPin,
450  IFilterGraphPort,
451  IFilterGraphDataPort,
452  IFilterGraphDataOutPort,
453  base::flash::IRunnable>
454 {
455  public:
457  cFilterGraphDataOutPort(const char* strName);
458  ~cFilterGraphDataOutPort() override;
459 
460  public:
461  tResult InnerConnect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
462  tResult InnerDisconnect() override;
463 
464  public:
465  tResult GetType(ucom::ant::iobject_ptr<const ant::IStreamType>& pStreamType) const override;
466 
467  bool IsConnected() const override;
468  tResult SetActive() override;
469  tResult SetInactive() override;
470 
471  tResult Disconnect() override;
472  tResult GetSampleStream(ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) const override;
473 
474  public:
475  tResult Connect(const ucom::ant::iobject_ptr<ant::ISampleStream>& pSampleStream) override;
476 
477  public:
478  ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
479 
480  protected:
481  class cImplementation;
482  std::unique_ptr<cImplementation> m_pImplementation;
483 };
484 
485 }
486 
487 namespace hollow
488 {
489 
496  public ucom::catwo::object<IBindingObject,
497  IBindingClient,
498  IFilterGraphPort,
499  IFilterGraphInterfacePort,
500  named_graph_object<IFilterGraphInterfaceClientPort>>
501 {
502 public:
507  cFilterGraphClientPort(const char* strName);
509  virtual ~cFilterGraphClientPort() = default;
510 
511 public:
512  tResult InnerBind(const ucom::ant::iobject_ptr<IBindingClient>& pClientForward) override;
513  tResult InnerUnbind() override;
514 
515 public:
516  tResult Bind(const ucom::ant::iobject_ptr<IBindingProxy>& pBindingProxy) override;
517 
518 public:
519  tResult GetBindingType(ucom::ant::iobject_ptr<const IBindingType>& pBindingType) const override;
520  tResult GetServerObject(ucom::ant::iobject_ptr<IObject>& pServerObject) const override;
521  tResult GetBindingProxy(ucom::ant::iobject_ptr<IBindingProxy>& pBindingProxy) const override;
522  tResult Unbind() override;
523 
524 protected:
525  class cImplementation;
526  std::unique_ptr<cImplementation> m_pImplementation;
527 };
528 
529 }
530 
531 namespace quiet
532 {
533 
537 class cFilterGraphRunnerPort: public ucom::catwo::object<flash::cFilterGraphRunnerPort,
538  ITriggerPipeHierachy>
539 {
540  public:
542  cFilterGraphRunnerPort(const char* strName);
543  ~cFilterGraphRunnerPort() override;
544 
545  ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
546 };
547 
551 class cFilterGraphDataInPort: public ucom::catwo::object<flash::cFilterGraphDataInPort,
552  ITriggerPipeHierachy>
553 {
554  public:
556  cFilterGraphDataInPort(const char* strName);
557  ~cFilterGraphDataInPort() override;
558 
559  ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
560 };
561 
565 class cFilterGraphDataOutPort: public ucom::catwo::object<flash::cFilterGraphDataOutPort,
566  ITriggerPipeHierachy>
567 {
568  public:
570  cFilterGraphDataOutPort(const char* strName);
571  ~cFilterGraphDataOutPort() override;
572 
573  ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS
574 };
575 
576 }
577 
588 } // namespace streaming
589 } // namespace adtf
#define RETURN_ERROR_DESC(_code,...)
Same as RETURN_ERROR(_error) using a printf like parameter list for detailed error description.
#define RETURN_IF_FAILED(s)
Return if expression is failed, which requires the calling function's return type to be tResult.
#define RETURN_NOERROR
Return status ERR_NOERROR, which requires the calling function's return type to be tResult.
Default implementation of a ClientPort.
virtual ~cFilterGraphClientPort()=default
DTOR.
cFilterGraphClientPort(const char *strName)
CTOR with name.
The Default implementation of the DataInPort.
cFilterGraphDataInPort(const char *strName)
CTOR with name.
virtual ~cFilterGraphDataInPort()=default
DTOR.
The Default implementation of the IFilterGraphDataOutPort.
cFilterGraphDataOutPort(const char *strName)
CTOR with name.
Default implementation of a RunnerPort.
virtual ~cFilterGraphRunnerPort()=default
DTOR.
cFilterGraphRunnerPort(const char *strName)
CTOR with name.
Default implementation of a ServerPort .
virtual ~cFilterGraphServerPort()=default
DTOR.
cFilterGraphServerPort(const char *strName)
CTOR with name.
cFilterGraphRunnerPort(const char *strName)
CTOR with name.
Default implementation of a ClientPort.
cFilterGraphClientPort(const char *strName)
CTOR with name.
virtual T * Get() const =0
Get raw pointer to shared object.
Base object pointer to realize binary compatible reference counting in interface methods.
Object pointer implementation used for reference counting on objects of type IObject.
Definition: object_ptr.h:163
Use this template if you want to implement an ucom::ant::IObject based Interface and/or subclass an e...
Definition: object.h:379
Copyright © Audi Electronics Venture GmbH.
Copyright © Audi Electronics Venture GmbH.
Copyright © Audi Electronics Venture GmbH.
adtf_util::cString get_named_graph_object_full_name(const INamedGraphObject &oGraphObject)
Helper function to retrieve a full qualified unique name of an object registered in IFilterGraph.
Namespace for entire ADTF SDK.
Copyright © Audi Electronics Venture GmbH.
Copyright © Audi Electronics Venture GmbH.
Copyright © Audi Electronics Venture GmbH.
Copyright © Audi Electronics Venture GmbH.
Helper template class to route a ISampleStream or a IBindingProxy.
std::vector< adtf::ucom::object_ptr< U > > m_oTos
the to reference.
tResult DisconnectRouting(const adtf::ucom::ant::iobject_ptr< T > &pFrom, const adtf::ucom::ant::iobject_ptr< U > &pTo)
Disonnects the Routing.
tResult ResetFrom(const adtf::ucom::ant::iobject_ptr< T > &pFrom)
Resets the From Router.
tResult AddTo(const adtf::ucom::ant::iobject_ptr< U > &pTo)
Resets the To Routing.
adtf::ucom::object_ptr< T > m_pFrom
the from reference.
tResult ConnectRouting(const adtf::ucom::ant::iobject_ptr< T > &pFrom, const adtf::ucom::ant::iobject_ptr< U > &pTo)
Connects the Routing.
Copyright © Audi Electronics Venture GmbH.