[haiku-commits] haiku: hrev50703 - src/kits/media headers/private/media src/tests/kits/media/media_client

  • From: b.vitruvio@xxxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Thu, 24 Nov 2016 00:36:47 +0100 (CET)

hrev50703 adds 3 changesets to branch 'master'
old head: a9d53d9e7e24ac82e150d792f05ea45bf8e497a1
new head: 8e980a4066387aad8f09a330ee7c8c8fd976dc9c
overview: 
http://cgit.haiku-os.org/haiku/log/?qt=range&q=8e980a406638+%5Ea9d53d9e7e24

----------------------------------------------------------------------------

23d5326e2b40: MediaClient: Introduce media_client and media_connection
  
  * Those structs are provided as replacement for the classic
  media_kit ones. They provide better encapsulation of the data
  and the resulting code is heavily simplified. It's planned to
  introduce BMediaRoster functions to provide conversion from
  media_node and media_input/media_output to media_client
  and media_connection.

f506f3056fce: MediaClient: Improve internals and API
  
  * Capabilities() become Kind()
  * Use media_client and media_connection to better model
  the different situations of the API. Reduce code duplication
  and move media_kit structs/methods into private.
  * Various API and beauty improvements.
  * Introduce id management for media_connections.
  * Fix different issues preventing to correctly begin a connection.

8e980a406638: media_client test: Set an actual format for connections

                                [ Dario Casalinuovo <b.vitruvio@xxxxxxxxx> ]

----------------------------------------------------------------------------

9 files changed, 382 insertions(+), 259 deletions(-)
headers/private/media/MediaClient.h              |  70 ++++-----
headers/private/media/MediaClientDefs.h          | 103 +++++++++++++
headers/private/media/MediaConnection.h          |  53 +++----
src/kits/media/Jamfile                           |   1 +
src/kits/media/MediaClient.cpp                   | 129 ++++++----------
src/kits/media/MediaClientDefs.cpp               |  89 +++++++++++
src/kits/media/MediaClientNode.cpp               |  25 +--
src/kits/media/MediaConnection.cpp               | 153 ++++++++-----------
.../kits/media/media_client/media_client.cpp     |  18 ++-

############################################################################

Commit:      23d5326e2b400a4ffb0818b9875227d3f5a17a8d
URL:         http://cgit.haiku-os.org/haiku/commit/?id=23d5326e2b40
Author:      Dario Casalinuovo <b.vitruvio@xxxxxxxxx>
Date:        Wed Nov 23 23:14:00 2016 UTC

MediaClient: Introduce media_client and media_connection

* Those structs are provided as replacement for the classic
media_kit ones. They provide better encapsulation of the data
and the resulting code is heavily simplified. It's planned to
introduce BMediaRoster functions to provide conversion from
media_node and media_input/media_output to media_client
and media_connection.

----------------------------------------------------------------------------

diff --git a/headers/private/media/MediaClientDefs.h 
b/headers/private/media/MediaClientDefs.h
new file mode 100644
index 0000000..79325e5
--- /dev/null
+++ b/headers/private/media/MediaClientDefs.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2015, Haiku, Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef _MEDIA_CLIENT_DEFS_H
+#define _MEDIA_CLIENT_DEFS_H
+
+#include <MediaDefs.h>
+#include <MediaNode.h>
+
+
+namespace BPrivate { namespace media {
+
+
+typedef int32 media_client_id;
+typedef int32 media_client_kind;
+typedef int32 media_connection_id;
+
+
+enum media_client_kinds {
+       // The client can receive media data.
+       B_MEDIA_RECORDER                = 0x000000001,
+       // The client can send media data to another client.
+       B_MEDIA_PLAYER                  = 0x000000002,
+       // The client specify a control GUI which can be used to configure it.
+       B_MEDIA_CONTROLLABLE    = 0x000000004
+};
+
+enum media_connection_kind {
+       B_MEDIA_INPUT = 0,
+       B_MEDIA_OUTPUT = 1
+};
+
+
+typedef struct media_client {
+       media_client_id                         Id() const;
+       media_client_kind                       Kind() const;
+
+       BMessage*                                       ToMessage();
+
+private:
+       media_client_kind                       kind;
+
+       media_node                                      node;
+       uint32                                          padding[16];
+
+       friend class BMediaClient;
+       friend class BMediaConnection;
+       friend class media_connection;
+} media_client;
+
+
+typedef struct media_connection {
+       media_connection_id                     Id() const;
+       media_connection_kind           Kind() const;
+
+       media_client                            Client() const;
+
+       const char*                                     Name() const;
+
+       bool                                            IsInput() const;
+       bool                                            IsOutput() const;
+
+       BMessage*                                       ToMessage() const;
+
+private:
+       media_input                                     MediaInput() const;
+       media_output                            MediaOutput() const;
+
+       const media_source&                     Source() const;
+       const media_destination&        Destination() const;
+
+       media_node                                      RemoteNode() const;
+
+private:
+       media_connection_id                     id;
+
+       media_client                            client;
+       // TODO really needed?
+       media_client                            remote_client;
+
+    media_source                               source;
+    media_destination                  destination;
+    media_format                               format;
+    char                                               
name[B_MEDIA_NAME_LENGTH];
+
+       media_connection_kind           kind;
+       uint32                                          padding[16];
+
+       friend class BMediaClient;
+       friend class BMediaConnection;
+       friend class BMediaClientNode;
+} media_connection;
+
+
+}
+
+}
+
+using namespace BPrivate::media;
+
+#endif
diff --git a/src/kits/media/MediaClientDefs.cpp 
b/src/kits/media/MediaClientDefs.cpp
new file mode 100644
index 0000000..dd532b9
--- /dev/null
+++ b/src/kits/media/MediaClientDefs.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2015, Dario Casalinuovo. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <MediaClient.h>
+#include <MediaConnection.h>
+
+#include "debug.h"
+
+
+media_client_id
+media_client::Id() const
+{
+       return node.node;
+}
+
+
+media_connection_id
+media_connection::Id() const
+{
+       return id;
+}
+
+
+media_connection_kind
+media_connection::Kind() const
+{
+       return kind;
+}
+
+
+bool
+media_connection::IsInput() const
+{
+       return Kind() == B_MEDIA_INPUT;
+}
+
+
+bool
+media_connection::IsOutput() const
+{
+       return Kind() == B_MEDIA_OUTPUT;
+}
+
+
+media_input
+media_connection::MediaInput() const
+{
+       media_input input;
+       input.node = client.node;
+       input.source = source;
+       input.destination = destination;
+       input.format = format;
+       return input;
+}
+
+
+media_output
+media_connection::MediaOutput() const
+{
+       media_output output;
+       output.node = client.node;
+       output.source = source;
+       output.destination = destination;
+       output.format = format;
+       return output;
+}
+
+
+const media_source&
+media_connection::Source() const
+{
+       return source;
+}
+
+
+const media_destination&
+media_connection::Destination() const
+{
+       return destination;
+}
+
+
+media_node
+media_connection::RemoteNode() const
+{
+       return remote_client.node;
+}

############################################################################

Commit:      f506f3056fce86ec83341eb39e5d1fbbc469ecf7
URL:         http://cgit.haiku-os.org/haiku/commit/?id=f506f3056fce
Author:      Dario Casalinuovo <b.vitruvio@xxxxxxxxx>
Date:        Wed Nov 23 23:19:06 2016 UTC

MediaClient: Improve internals and API

* Capabilities() become Kind()
* Use media_client and media_connection to better model
the different situations of the API. Reduce code duplication
and move media_kit structs/methods into private.
* Various API and beauty improvements.
* Introduce id management for media_connections.
* Fix different issues preventing to correctly begin a connection.

----------------------------------------------------------------------------

diff --git a/headers/private/media/MediaClient.h 
b/headers/private/media/MediaClient.h
index 44d8fd5..f1e9f0d 100755
--- a/headers/private/media/MediaClient.h
+++ b/headers/private/media/MediaClient.h
@@ -10,6 +10,7 @@
 #include <Buffer.h>
 
 #include <MediaAddOn.h>
+#include <MediaClientDefs.h>
 #include <MediaConnection.h>
 #include <MediaDefs.h>
 #include <MediaNode.h>
@@ -19,19 +20,6 @@
 
 namespace BPrivate { namespace media {
 
-typedef int32 media_client_kind;
-
-enum media_client_kinds {
-       // The node can receive media data.
-       B_MEDIA_RECORDER                = 0x000000001,
-       // The node can send media data to another node.
-       B_MEDIA_PLAYER                  = 0x000000002,
-       // The node specify a control GUI which can be used to configure it.
-       B_MEDIA_CONTROLLABLE    = 0x000000004
-};
-
-// TODO: Add file interface
-// TODO: Offline mode is still missing
 
 // BMediaClient is a general purpose class allowing to create any kind
 // of media_node. It automatically manage the expected behavior under
@@ -56,20 +44,25 @@ public:
                                                                                
        ...);
 
        // TODO: Should allow BControllable capabilities
+       // TODO: Add file interface
+       // TODO: Offline mode is still missing
+
                                                                        
BMediaClient(const char* name,
                                                                                
media_type type
                                                                                
        = B_MEDIA_UNKNOWN_TYPE,
                                                                                
media_client_kind
-                                                                               
        capabilities = B_MEDIA_PLAYER
+                                                                               
        kind = B_MEDIA_PLAYER
                                                                                
                & B_MEDIA_RECORDER);
 
        virtual                                                 ~BMediaClient();
 
-                       status_t                                InitCheck() 
const;
+                       const media_client&             Client() const;
 
        // Return the capabilities of this BMediaClient instance.
-                       media_client_kind               Capabilities() const;
-                       media_type                              Type() const;
+                       media_client_kind               Kind() const;
+                       media_type                              MediaType() 
const;
+
+                       status_t                                InitCheck() 
const;
 
        // To connect pass the BMediaConnection to this class or to another 
BMediaClient,
        // also in another team the connection object will be valid.
@@ -84,11 +77,6 @@ public:
        // will automatically connect to this node.
        virtual BMediaConnection*               
BeginConnection(media_connection_kind kind);
 
-       // Those are used if you want to connect to a precise input/output of
-       // another node, the connection returned represents a remote 
input/output.
-       virtual BMediaConnection*               BeginConnection(const 
media_input& input);
-       virtual BMediaConnection*               BeginConnection(const 
media_output& output);
-
        // Bind internally two connections of the same BMediaClient, so that the
        // input will be automatically forwarded to the output just after the
        // ProcessFunc is called. The buffer is automatically recycled too.
@@ -110,18 +98,20 @@ public:
                                                                                
BMediaConnection* theirConnection);
 
        virtual status_t                                
Connect(BMediaConnection* ourConnection,
-                                                                               
const dormant_node_info& dormantInfo);
+                                                                               
const media_connection& theirConnection);
 
+       // Find a free input/output and try to connect to the media_client,
+       // return meaningful error otherwise.
        virtual status_t                                
Connect(BMediaConnection* ourConnection,
-                                                                               
const media_node& node);
+                                                                               
const media_client& client);
 
        // Disconnect any connection belonging to this object, to disconnect
        // a single connection use BMediaConnection::Disconnect().
        virtual status_t                                Disconnect();
 
-                       int32                                   
CountConnections() const;
                        int32                                   CountInputs() 
const;
                        int32                                   CountOutputs() 
const;
+
                        BMediaConnection*               InputAt(int32 index) 
const;
                        BMediaConnection*               OutputAt(int32 index) 
const;
 
@@ -164,14 +154,6 @@ public:
        // when run_mode != B_OFFLINE.
                        bigtime_t                               
PerformanceTime() const;
 
-       // When a connection is not binded with another, it's your job to send
-       // the buffer to the connection you want. You might want
-       // to ovverride it so that you can track something, in this case
-       // be sure to call the base version.
-       // Automatically recycle the BBuffer.
-       virtual status_t                                SendBuffer(BBuffer* 
buffer,
-                                                                               
BMediaConnection* connection);
-
        // This is supplied to support using this class in a BMediaAddOn.
        // Default version just return NULL.
        virtual BMediaAddOn*                    AddOn(int32* id) const;
@@ -180,6 +162,13 @@ public:
                                                                                
void* cookie = NULL);
 
 protected:
+       // When a connection is not binded with another, it's your job to send
+       // the buffer to the connection you want. You might want
+       // to ovverride it so that you can track something, in this case
+       // be sure to call the base version.
+       virtual status_t                                SendBuffer(BBuffer* 
buffer,
+                                                                               
BMediaConnection* connection);
+
        virtual void                                    
BufferReceived(BMediaConnection* connection,
                                                                                
BBuffer* buffer);
 
@@ -192,24 +181,20 @@ protected:
                        status_t                                
DisconnectConnection(BMediaConnection* conn);
                        status_t                                
ResetConnection(BMediaConnection* conn);
                        status_t                                
ReleaseConnection(BMediaConnection* conn);
+
 private:
 
                        void                                    _Init();
                        void                                    _Deinit();
 
-                       status_t                                
_TranslateConnection(BMediaConnection* dest,
-                                                                               
BMediaConnection* source);
-
-                       status_t                                
_Connect(BMediaConnection* conn,
-                                                                               
media_node node);
                        status_t                                
_ConnectInput(BMediaConnection* output,
-                                                                               
BMediaConnection* input);
+                                                                               
const media_connection& input);
                        status_t                                
_ConnectOutput(BMediaConnection* input,
-                                                                               
BMediaConnection* output);
+                                                                               
const media_connection& output);
 
                        status_t                                fInitErr;
 
-                       media_client_kind               fCapabilities;
+                       media_client                    fClient;
 
                        bool                                    fRunning;
                        BMediaClientNode*               fNode;
@@ -227,6 +212,9 @@ private:
                        BObjectList<BMediaConnection> fInputs;
                        BObjectList<BMediaConnection> fOutputs;
 
+                       int32                                   fLastInputID;
+                       int32                                   fLastOutputID;
+
        virtual void                                    _ReservedMediaClient0();
        virtual void                                    _ReservedMediaClient1();
        virtual void                                    _ReservedMediaClient2();
diff --git a/headers/private/media/MediaConnection.h 
b/headers/private/media/MediaConnection.h
index 0bc2b5b..85a3889 100644
--- a/headers/private/media/MediaConnection.h
+++ b/headers/private/media/MediaConnection.h
@@ -9,20 +9,15 @@
 #include <BufferGroup.h>
 #include <MediaDefs.h>
 
+#include <MediaClient.h>
+#include <MediaClientDefs.h>
+
 #include "MediaClientNode.h"
 
 
 namespace BPrivate { namespace media {
 
 
-enum media_connection_kind {
-       B_MEDIA_INPUT = 0,
-       B_MEDIA_OUTPUT = 1
-};
-
-
-class BMediaClient;
-
 // The BMediaConnection class is the swiss knife of BMediaClient.
 // It represents a connection between two nodes and allow to create complex
 // nodes without dealing with the unneeded complexity. Two local connections,
@@ -51,7 +46,8 @@ public:
                B_ASK_TIMER
        };
 
-       // This function is called when it has come the moment to handle a 
buffer.
+
+       // This function is called when it is the moment to handle a buffer.
        typedef void                                    
(*process_hook)(BMediaConnection* connection,
                                                                                
BBuffer* buffer);
 
@@ -63,15 +59,16 @@ public:
 
        virtual                                                 
~BMediaConnection();
 
+       const media_connection&                 Connection() const;
+       media_connection_id                             Id() const;
+       const char*                                             Name() const;
+
        // TODO: while most of the objects for both kinds are common
        // it would be worthwile to have a private implementation
        // so that we can better model the differences and avoid
        // problems.
-       bool                                                    IsOutput() 
const;
        bool                                                    IsInput() const;
-
-       const media_destination&                Destination() const;
-       const media_source&                             Source() const;
+       bool                                                    IsOutput() 
const;
 
        bool                                                    HasBinding() 
const;
        BMediaConnection*                               Binding() const;
@@ -119,11 +116,8 @@ public:
 
 protected:
                                                                        
BMediaConnection(BMediaClient* owner,
-                                                                               
media_connection_kind kind);
-                                                                       
BMediaConnection(BMediaClient* owner,
-                                                                               
const media_output& output);
-                                                                       
BMediaConnection(BMediaClient* owner,
-                                                                               
const media_input& input);
+                                                                               
media_connection_kind kind,
+                                                                               
media_connection_id id);
 
        // TODO: All notifications should be done into private callbacks like 
this.
        void                                                    
ConnectedCallback(const media_source& source,
@@ -134,18 +128,17 @@ protected:
        void                                                    
DisconnectCallback(const media_destination& source);
 
 private:
-       void                                                    
BuildMediaOutput(media_output* output) const;
-       void                                                    
BuildMediaInput(media_input* output) const;
+       media_input                                             MediaInput() 
const;
+       media_output                                    MediaOutput() const;
+
+       const media_source&                             Source() const;
+       const media_destination&                Destination() const;
 
        void                                                    _Init();
 
-       bool                                                    fConnected;
-       bool                                                    fOutputEnabled;
+       media_connection                                fConnection;
 
-       media_connection_kind                   fKind;
        BMediaClient*                                   fOwner;
-       media_node                                              fOwnerNode;
-       team_id                                                 fOwnerTeam;
 
        // A connection might be binded so that it will automatically
        // forward or receive the data from/to a local BMediaConnection,
@@ -156,18 +149,14 @@ private:
        notify_hook                                             fNotifyHook;
        void*                                                   fBufferCookie;
 
-       media_source                                    fSource;
-       media_destination                               fDestination;
-
-       // This represents the node at other end of connection.
-       media_node                                              fRemoteNode;
-
-       media_format                                    fFormat;
        size_t                                                  fBufferSize;
        bigtime_t                                               fBufferDuration;
 
        BBufferGroup*                                   fBufferGroup;
 
+       bool                                                    fConnected;
+       bool                                                    fOutputEnabled;
+
        virtual void                                    
_ReservedMediaConnection0();
        virtual void                                    
_ReservedMediaConnection1();
        virtual void                                    
_ReservedMediaConnection2();
diff --git a/src/kits/media/Jamfile b/src/kits/media/Jamfile
index 4994e22..a977729 100644
--- a/src/kits/media/Jamfile
+++ b/src/kits/media/Jamfile
@@ -27,6 +27,7 @@ for architectureObject in [ MultiArchSubDirSetup ] {
                        AdapterIO.cpp
                        MediaIO.cpp
                        MediaClient.cpp
+                       MediaClientDefs.cpp
                        MediaConnection.cpp
                        MediaRecorder.cpp
 
diff --git a/src/kits/media/MediaClient.cpp b/src/kits/media/MediaClient.cpp
index 3c5255b..cca4444 100755
--- a/src/kits/media/MediaClient.cpp
+++ b/src/kits/media/MediaClient.cpp
@@ -5,6 +5,8 @@
 
 #include "MediaClient.h"
 
+#include <MediaConnection.h>
+
 #include <MediaRoster.h>
 #include <TimeSource.h>
 
@@ -12,14 +14,18 @@
 
 
 BMediaClient::BMediaClient(const char* name,
-       media_type type, media_client_kind capabilities)
+       media_type type, media_client_kind kind)
        :
-       fCapabilities(capabilities)
+       fLastInputID(0),
+       fLastOutputID(0)
 {
        CALLED();
 
        fNode = new BMediaClientNode(name, this, type);
        _Init();
+
+       fClient.node = fNode->Node();
+       fClient.kind = kind;
 }
 
 
@@ -31,6 +37,13 @@ BMediaClient::~BMediaClient()
 }
 
 
+const media_client&
+BMediaClient::Client() const
+{
+       return fClient;
+}
+
+
 status_t
 BMediaClient::InitCheck() const
 {
@@ -41,16 +54,16 @@ BMediaClient::InitCheck() const
 
 
 media_client_kind
-BMediaClient::Capabilities() const
+BMediaClient::Kind() const
 {
        CALLED();
 
-       return fCapabilities;
+       return fClient.kind;
 }
 
 
 media_type
-BMediaClient::Type() const
+BMediaClient::MediaType() const
 {
        CALLED();
 
@@ -64,29 +77,13 @@ BMediaClient::BeginConnection(media_connection_kind kind)
 {
        CALLED();
 
-       BMediaConnection* conn = new BMediaConnection(this, kind);
-       AddConnection(conn);
-       return conn;
-}
-
-
-BMediaConnection*
-BMediaClient::BeginConnection(const media_input& input)
-{
-       CALLED();
-
-       BMediaConnection* conn = new BMediaConnection(this, input);
-       AddConnection(conn);
-       return conn;
-}
-
-
-BMediaConnection*
-BMediaClient::BeginConnection(const media_output& output)
-{
-       CALLED();
+       media_connection_id id;
+       if (kind == B_MEDIA_INPUT)
+               id = fLastInputID++;
+       else
+               id = fLastOutputID++;
 
-       BMediaConnection* conn = new BMediaConnection(this, output);
+       BMediaConnection* conn = new BMediaConnection(this, kind, id);
        AddConnection(conn);
        return conn;
 }
@@ -143,35 +140,28 @@ BMediaClient::Connect(BMediaConnection* ourConnection,
 {
        CALLED();
 
-       if (ourConnection->IsOutput() && theirConnection->IsInput())
-               return _ConnectInput(ourConnection, theirConnection);
-       else if (ourConnection->IsInput() && theirConnection->IsOutput())
-               return _ConnectOutput(ourConnection, theirConnection);
-
-       return B_ERROR;
+       return Connect(ourConnection, theirConnection->Connection());
 }
 
 
 status_t
-BMediaClient::Connect(BMediaConnection* connection,
-       const dormant_node_info& dormantInfo)
+BMediaClient::Connect(BMediaConnection* ourConnection,
+       const media_connection& theirConnection)
 {
        CALLED();
 
-       media_node node;
-       status_t err = BMediaRoster::CurrentRoster()->InstantiateDormantNode(
-               dormantInfo, &node, B_FLAVOR_IS_GLOBAL);
-
-       if (err != B_OK)
-               return err;
+       if (ourConnection->IsOutput() && theirConnection.IsInput())
+               return _ConnectInput(ourConnection, theirConnection);
+       else if (ourConnection->IsInput() && theirConnection.IsOutput())
+               return _ConnectOutput(ourConnection, theirConnection);
 
-       return Connect(connection, node);
+       return B_ERROR;
 }
 
 
 status_t
 BMediaClient::Connect(BMediaConnection* connection,
-       const media_node& node)
+       const media_client& client)
 {
        CALLED();
 
@@ -224,15 +214,6 @@ BMediaClient::ReleaseConnection(BMediaConnection* conn)
 
 
 int32
-BMediaClient::CountConnections() const
-{
-       CALLED();
-
-       return fOutputs.CountItems()+fInputs.CountItems();
-}
-
-
-int32
 BMediaClient::CountInputs() const
 {
        CALLED();
@@ -310,7 +291,7 @@ BMediaClient::Start(bool force)
 
        status_t err = B_OK;
        for (int32 i = 0; i < CountOutputs(); i++) {
-               media_node remoteNode = OutputAt(i)->fRemoteNode;
+               media_node remoteNode = OutputAt(i)->Connection().RemoteNode();
                if (remoteNode.kind & B_TIME_SOURCE)
                        err = BMediaRoster::CurrentRoster()->StartTimeSource(
                                remoteNode, BTimeSource::RealTime());
@@ -534,51 +515,37 @@ BMediaClient::_Deinit()
 
 
 status_t
-BMediaClient::_TranslateConnection(BMediaConnection* dest,
-       BMediaConnection* source)
-{
-       CALLED();
-
-       return B_ERROR;
-}
-
-
-status_t
-BMediaClient::_Connect(BMediaConnection* connection,
-       media_node node)
+BMediaClient::_ConnectInput(BMediaConnection* output,
+       const media_connection& input)
 {
        CALLED();
 
-       return B_ERROR;
-}
+       if (input.Destination() == media_destination::null)
+               return B_MEDIA_BAD_DESTINATION;
 
+       media_output ourOutput = output->Connection().MediaOutput();
+       media_input theirInput = input.MediaInput();
+       media_format format = output->AcceptedFormat();
 
-status_t
-BMediaClient::_ConnectInput(BMediaConnection* output,
-       BMediaConnection* input)
-{
-       CALLED();
-
-       return B_ERROR;
+       return BMediaRoster::CurrentRoster()->Connect(ourOutput.source,
+               theirInput.destination, &format, &ourOutput, &theirInput,
+               BMediaRoster::B_CONNECT_MUTED);
 }
 
 
 status_t
 BMediaClient::_ConnectOutput(BMediaConnection* input,
-       BMediaConnection* output)
+       const media_connection& output)
 {
        CALLED();
 
-       if (output->Source() == media_source::null)
+       if (output.Source() == media_source::null)
                return B_MEDIA_BAD_SOURCE;
 
-       media_input ourInput;
-       media_output theirOutput;
+       media_input ourInput = input->Connection().MediaInput();
+       media_output theirOutput = output.MediaOutput();
        media_format format = input->AcceptedFormat();
 
-       input->BuildMediaInput(&ourInput);
-       output->BuildMediaOutput(&theirOutput);
-
        // TODO manage the node problems
        //fNode->ActivateInternalConnect(false);
 
diff --git a/src/kits/media/MediaClientNode.cpp 
b/src/kits/media/MediaClientNode.cpp
index 68dc83e..e0dab9c 100755
--- a/src/kits/media/MediaClientNode.cpp
+++ b/src/kits/media/MediaClientNode.cpp
@@ -6,6 +6,7 @@
 #include "MediaClientNode.h"
 
 #include <MediaClient.h>
+#include <MediaConnection.h>
 #include <scheduler.h>
 #include <TimeSource.h>
 
@@ -28,11 +29,11 @@ BMediaClientNode::BMediaClientNode(const char* name,
        CALLED();
 
        // Configure the node to do the requested jobs
-       if (fOwner->Capabilities() & B_MEDIA_PLAYER)
+       if (fOwner->Kind() & B_MEDIA_PLAYER)
                AddNodeKind(B_BUFFER_PRODUCER);
-       if (fOwner->Capabilities() & B_MEDIA_RECORDER)
+       if (fOwner->Kind() & B_MEDIA_RECORDER)
                AddNodeKind(B_BUFFER_CONSUMER);
-       if (fOwner->Capabilities() & B_MEDIA_CONTROLLABLE)
+       if (fOwner->Kind() & B_MEDIA_CONTROLLABLE)
                AddNodeKind(B_CONTROLLABLE);
 }
 
@@ -174,7 +175,7 @@ BMediaClientNode::GetNextInput(int32* cookie,
        } else {
                BMediaConnection* conn = fOwner->InputAt(*cookie);
                if (conn != NULL) {
-                       conn->BuildMediaInput(input);
+                       *input = conn->MediaInput();
                        *cookie += 1;
                        return B_OK;
                }
@@ -230,7 +231,7 @@ BMediaClientNode::Connected(const media_source& source,
                return B_MEDIA_BAD_DESTINATION;
 
        conn->ConnectedCallback(source, format);
-       conn->BuildMediaInput(outInput);
+       *outInput = conn->MediaInput();
        return B_OK;
 }
 
@@ -289,7 +290,7 @@ BMediaClientNode::FormatSuggestionRequested(media_type type,
        } else {
                // In that case we return just a very generic format.
                media_format outFormat;
-               outFormat.type = fOwner->Type();
+               outFormat.type = fOwner->MediaType();
                *format = outFormat;
                return B_OK;
        }
@@ -350,7 +351,7 @@ BMediaClientNode::GetNextOutput(int32* cookie, 
media_output* output)
        } else {
                BMediaConnection* conn = fOwner->OutputAt(*cookie);
                if (conn != NULL) {
-                       conn->BuildMediaOutput(output);
+                       *output = conn->MediaOutput();
                        *cookie += 1;
                        return B_OK;
                }
@@ -413,15 +414,15 @@ BMediaClientNode::PrepareToConnect(const media_source& 
source,
        if (conn == NULL)
                return B_MEDIA_BAD_SOURCE;
 
-       if (conn->fDestination != media_destination::null)
+       if (conn->Destination() != media_destination::null)
                return B_MEDIA_ALREADY_CONNECTED;
 
-       if (format->type != fOwner->Type())
+       if (format->type != fOwner->MediaType())
                return B_MEDIA_BAD_FORMAT;
 
-       conn->fDestination = dest;
+       conn->fConnection.destination = dest;
        conn->SetAcceptedFormat(*format);
-       *out_source = conn->fSource;
+       *out_source = conn->Source();
        strcpy(name, Name());
        return B_OK;
 }
@@ -473,7 +474,7 @@ BMediaClientNode::Disconnect(const media_source& source,
        if (conn == NULL)
                return;
 
-       if (source == conn->fSource && dest == conn->fDestination)
+       if (source == conn->Source() && dest == conn->Destination())
                conn->Reset();
 
        conn->DisconnectCallback(dest);
diff --git a/src/kits/media/MediaConnection.cpp 
b/src/kits/media/MediaConnection.cpp
index 2e0e10d..e820037 100644
--- a/src/kits/media/MediaConnection.cpp
+++ b/src/kits/media/MediaConnection.cpp
@@ -5,68 +5,68 @@
 
 #include <MediaConnection.h>
 
-#include <MediaClient.h>
-
 #include "debug.h"
 
 
-bool
-BMediaConnection::IsOutput() const
+BMediaConnection::BMediaConnection(BMediaClient* owner,
+       media_connection_kind kind,
+       media_connection_id id)
+       :
+       fOwner(owner),
+       fBind(NULL)
 {
        CALLED();
 
-       return fKind == B_MEDIA_OUTPUT;
-}
+       _Init();
 
+       fConnection.kind = kind;
+       fConnection.id = id;
+       fConnection.client = fOwner->Client();
 
-bool
-BMediaConnection::IsInput() const
-{
-       CALLED();
+       if (IsOutput()) {
+               fConnection.source.port = fOwner->fNode->ControlPort();
+               fConnection.source.id = fConnection.id;
+
+               fConnection.destination = media_destination::null;
+       } else {
+               // IsInput()
+               fConnection.destination.port = fOwner->fNode->ControlPort();
+               fConnection.destination.id = fConnection.id;
 
-       return fKind == B_MEDIA_INPUT;
+               fConnection.source = media_source::null;
+       }
 }
 
 
-void
-BMediaConnection::BuildMediaOutput(media_output* output) const
+BMediaConnection::~BMediaConnection()
 {
        CALLED();
 
-       output->format = AcceptedFormat();
-       output->node = fOwner->fNode->Node();
-       output->source = fSource;
-       output->source.port = fOwner->fNode->ControlPort();
 }
 
 
-void
-BMediaConnection::BuildMediaInput(media_input* input) const
+const media_connection&
+BMediaConnection::Connection() const
 {
-       CALLED();
-
-       input->format = AcceptedFormat();
-       input->node = fOwner->fNode->Node();
-       input->destination = fDestination;
-       input->destination.port = fOwner->fNode->ControlPort();
+       return fConnection;
 }
 
 
-const media_destination&
-BMediaConnection::Destination() const
+bool
+BMediaConnection::IsOutput() const
 {
        CALLED();
 
-       return fDestination;
+       return fConnection.IsOutput();
 }
 
 
-const media_source&
-BMediaConnection::Source() const
+bool
+BMediaConnection::IsInput() const
 {
        CALLED();
 
-       return fSource;
+       return fConnection.IsInput();
 }
 
 
@@ -93,7 +93,7 @@ BMediaConnection::SetAcceptedFormat(const media_format& 
format)
 {
        CALLED();
 
-       fFormat = format;
+       fConnection.format = format;
 }
 
 
@@ -102,7 +102,7 @@ BMediaConnection::AcceptedFormat() const
 {
        CALLED();
 
-       return fFormat;
+       return fConnection.format;
 }
 
 
@@ -147,11 +147,6 @@ BMediaConnection::Reset()
 {
        CALLED();
 
-       if (IsOutput())
-               fDestination = media_destination::null;
-       else
-               fSource = media_source::null;
-
        delete fBufferGroup;
        fBufferGroup = NULL;
 
@@ -180,52 +175,6 @@ BMediaConnection::SetHooks(process_hook processHook,
 }
 
 
-BMediaConnection::BMediaConnection(BMediaClient* owner,
-       media_connection_kind kind)
-       :
-       fKind(kind),
-       fOwner(owner),
-       fBind(NULL)
-{
-       CALLED();
-
-       _Init();
-}
-
-
-BMediaConnection::BMediaConnection(BMediaClient* owner,
-       const media_output& output)
-       :
-       fKind(B_MEDIA_OUTPUT),
-       fOwner(owner),
-       fBind(NULL)
-{
-       CALLED();
-
-       _Init();
-}
-
-
-BMediaConnection::BMediaConnection(BMediaClient* owner,
-       const media_input& input)
-       :
-       fKind(B_MEDIA_INPUT),
-       fOwner(owner),
-       fBind(NULL)
-{
-       CALLED();
-
-       _Init();
-}
-
-
-BMediaConnection::~BMediaConnection()
-{
-       CALLED();
-
-}
-
-
 void
 BMediaConnection::SetBufferSize(size_t size)
 {
@@ -266,7 +215,7 @@ void
 BMediaConnection::ConnectedCallback(const media_source& source,
        const media_format& format)
 {
-       fSource = source;
+       fConnection.source = source;
        SetAcceptedFormat(format);
 
        if (fNotifyHook != NULL)
@@ -279,8 +228,6 @@ BMediaConnection::ConnectedCallback(const media_source& 
source,
 void
 BMediaConnection::DisconnectedCallback(const media_source& source)
 {
-       fSource = media_source::null;
-
        if (fNotifyHook != NULL)
                (*fNotifyHook)(B_DISCONNECTED, this);
 
@@ -291,14 +238,13 @@ BMediaConnection::DisconnectedCallback(const 
media_source& source)
 void
 BMediaConnection::ConnectCallback(const media_destination& destination)
 {
-       fDestination = destination;
+       fConnection.destination = destination;
 }
 
 
 void
 BMediaConnection::DisconnectCallback(const media_destination& destination)
 {
-       fDestination = destination;
 }
 
 
@@ -310,9 +256,34 @@ BMediaConnection::_Init()
        fBufferGroup = NULL;
        fNotifyHook = NULL;
        fProcessHook = NULL;
+}
+
+
+media_input
+BMediaConnection::MediaInput() const
+{
+       return fConnection.MediaInput();
+}
+
+
+media_output
+BMediaConnection::MediaOutput() const
+{
+       return fConnection.MediaOutput();
+}
+
 
-       fSource = media_source::null;
-       fDestination = media_destination::null;
+const media_source&
+BMediaConnection::Source() const
+{
+       return fConnection.Source();
+}
+
+
+const media_destination&
+BMediaConnection::Destination() const
+{
+       return fConnection.Destination();
 }
 
 

############################################################################

Revision:    hrev50703
Commit:      8e980a4066387aad8f09a330ee7c8c8fd976dc9c
URL:         http://cgit.haiku-os.org/haiku/commit/?id=8e980a406638
Author:      Dario Casalinuovo <b.vitruvio@xxxxxxxxx>
Date:        Wed Nov 23 23:24:04 2016 UTC

media_client test: Set an actual format for connections

----------------------------------------------------------------------------

diff --git a/src/tests/kits/media/media_client/media_client.cpp 
b/src/tests/kits/media/media_client/media_client.cpp
index 823f17f..fe0a35d 100644
--- a/src/tests/kits/media/media_client/media_client.cpp
+++ b/src/tests/kits/media/media_client/media_client.cpp
@@ -18,8 +18,9 @@ static BMediaClient* sFilter = NULL;
 
 void _InitClients(bool hasFilter)
 {
-       BMediaClient* sProducer = new BMediaClient("MediaClientProducer");
-       BMediaClient* sConsumer = new BMediaClient("MediaClientConsumer");
+       sProducer = new BMediaClient("MediaClientProducer");
+       sConsumer = new BMediaClient("MediaClientConsumer");
+
        if (hasFilter)
                sFilter = new BMediaClient("MediaClientFilter");
        else
@@ -35,6 +36,16 @@ void _DeleteClients()
 }
 
 
+media_format _BuildRawAudioFormat()
+{
+       media_format format;
+       format.type = B_MEDIA_RAW_AUDIO;
+       format.u.raw_audio = media_multi_audio_format::wildcard;
+
+       return format;
+}
+
+
 void _ConsumerProducerTest()
 {
        _InitClients(false);
@@ -42,6 +53,9 @@ void _ConsumerProducerTest()
        BMediaConnection* output = sProducer->BeginConnection(B_MEDIA_OUTPUT);
        BMediaConnection* input = sConsumer->BeginConnection(B_MEDIA_INPUT);
 
+       output->SetAcceptedFormat(_BuildRawAudioFormat());
+       input->SetAcceptedFormat(_BuildRawAudioFormat());
+
        assert(sConsumer->Connect(input, output) == B_OK);
        assert(sConsumer->Disconnect() == B_OK);
 


Other related posts:

  • » [haiku-commits] haiku: hrev50703 - src/kits/media headers/private/media src/tests/kits/media/media_client - b . vitruvio