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

  • From: b.vitruvio@xxxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Tue, 29 Nov 2016 01:26:21 +0100 (CET)

hrev50717 adds 1 changeset to branch 'master'
old head: 8ab68339fbed1235e521ed83301320a8caee39c7
new head: ecb395852e86c5deac1ca0b01ecb317ca831eebc
overview: 
http://cgit.haiku-os.org/haiku/log/?qt=range&q=ecb395852e86+%5E8ab68339fbed

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

ecb395852e86: Introduce BSimpleMediaClient
  
  * The idea is to move the callback based mechanism into a derived
  class. The objects can be composed to create working systems.
  * The BMediaClient class supply RegisterInput/RegisterOutput
  and BeginInput/BeginOutput is moved to BSimpleMediaClient.
  * Various minor fixes.

                                [ Dario Casalinuovo <b.vitruvio@xxxxxxxxx> ]

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

Revision:    hrev50717
Commit:      ecb395852e86c5deac1ca0b01ecb317ca831eebc
URL:         http://cgit.haiku-os.org/haiku/commit/?id=ecb395852e86
Author:      Dario Casalinuovo <b.vitruvio@xxxxxxxxx>
Date:        Tue Nov 29 00:19:45 2016 UTC

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

10 files changed, 548 insertions(+), 277 deletions(-)
headers/private/media/MediaClient.h              |  59 ++---
headers/private/media/MediaClientNode.h          |   8 -
headers/private/media/MediaConnection.h          |  59 +----
headers/private/media/SimpleMediaClient.h        | 178 ++++++++++++++
src/kits/media/Jamfile                           |   2 +-
src/kits/media/MediaClient.cpp                   |  85 ++++---
src/kits/media/MediaClientNode.cpp               |  81 +------
src/kits/media/MediaConnection.cpp               |  97 +++-----
src/kits/media/SimpleMediaClient.cpp             | 242 +++++++++++++++++++
.../kits/media/media_client/media_client.cpp     |  14 +-

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

diff --git a/headers/private/media/MediaClient.h 
b/headers/private/media/MediaClient.h
index b99a562..d8a712f 100755
--- a/headers/private/media/MediaClient.h
+++ b/headers/private/media/MediaClient.h
@@ -32,24 +32,6 @@ class BMediaOutput;
 // performance_time.
 class BMediaClient {
 public:
-       enum notification {
-               B_WILL_START = 1,                       // performance_time
-               B_WILL_STOP,                            // performance_time 
immediate
-               B_WILL_SEEK,                            // performance_time 
media_time
-               B_WILL_TIMEWARP,                        // real_time 
performance_time
-
-               B_FORMAT_SUGGESTION,            // media_type type, int32 
quality,
-                                                                       // 
media_format* format
-       };
-
-       typedef void                                    (*notify_hook)(void* 
cookie,
-                                                                               
        notification what,
-                                                                               
        ...);
-
-       // 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,
@@ -67,19 +49,17 @@ public:
 
                        status_t                                InitCheck() 
const;
 
+       // TODO: Should allow BControllable capabilities
+       // TODO: Add file interface
+       // TODO: Offline mode is still missing
+
        // To connect pass the BMediaConnection to this class or to another 
BMediaClient,
        // also in another team the connection object will be valid.
        // When those functions return, the BMediaConnection is added to the
        // list and is visible to other nodes as not connected.
 
-       // This is supplied to support generic connections not related
-       // to a certain destination or source node, however for various 
ambiguity
-       // reasons we want the BMediaConnection to be declared as input or 
output.
-       // You can pass the object returned by this function to another
-       // BMediaClient::BeginConnection() and then Connect(), so that it
-       // will automatically connect to this node.
-       virtual BMediaInput*                    BeginInput();
-       virtual BMediaOutput*                   BeginOutput();
+       virtual status_t                                
RegisterInput(BMediaInput* input);
+       virtual status_t                                
RegisterOutput(BMediaOutput* output);
 
        // Bind internally two connections of the same BMediaClient, so that the
        // input will be automatically forwarded to the output just after the
@@ -126,8 +106,8 @@ public:
 
                        bool                                    IsRunning() 
const;
 
-       virtual status_t                                Start(bool force = 
false);
-       virtual status_t                                Stop(bool force = 
false);
+                       status_t                                Start(bool 
force = false);
+                       status_t                                Stop(bool force 
= false);
                        status_t                                Seek(bigtime_t 
mediaTime,
                                                                                
bigtime_t performanceTime);
                        status_t                                Roll(bigtime_t 
start, bigtime_t stop,
@@ -162,9 +142,6 @@ public:
        // Default version just return NULL.
        virtual BMediaAddOn*                    AddOn(int32* id) const;
 
-       void                                                    
SetNotificationHook(notify_hook notifyHook = NULL,
-                                                                               
void* cookie = NULL);
-
 protected:
        // This is used when the user want to override the BeginConnection
        // mechanism, for example to supply your BMediaConnection derived
@@ -172,9 +149,21 @@ protected:
        virtual void                                    AddInput(BMediaInput* 
input);
        virtual void                                    AddOutput(BMediaOutput* 
output);
 
+       virtual void                                    HandleStart(bigtime_t 
performanceTime);
+       virtual void                                    HandleStop(bigtime_t 
performanceTime);
+
+       virtual void                                    HandleSeek(bigtime_t 
mediaTime,
+                                                                               
bigtime_t performanceTime);
+
+       virtual void                                    
HandleTimeWarp(bigtime_t realTime,
+                                                                               
bigtime_t performanceTime);
+
+       virtual status_t                                
HandleFormatSuggestion(media_type type,
+                                                                               
int32 quality, media_format* format);
+
        // Called from BMediaConnection
-                       status_t                                
DisconnectConnection(BMediaConnection* conn);
-                       status_t                                
ReleaseConnection(BMediaConnection* conn);
+                       status_t                                
ConnectionDisconnected(BMediaConnection* conn);
+                       status_t                                
ConnectionReleased(BMediaConnection* conn);
 
 private:
                        BMediaInput*                    FindInput(
@@ -202,10 +191,6 @@ private:
                        bigtime_t                               fMinLatency;
                        bigtime_t                               fMaxLatency;
 
-                       notify_hook                             fNotifyHook;
-
-                       void*                                   fNotifyCookie;
-
                        BObjectList<BMediaInput>        fInputs;
                        BObjectList<BMediaOutput>       fOutputs;
 
diff --git a/headers/private/media/MediaClientNode.h 
b/headers/private/media/MediaClientNode.h
index 8d3a10f..d151ad9 100755
--- a/headers/private/media/MediaClientNode.h
+++ b/headers/private/media/MediaClientNode.h
@@ -132,14 +132,6 @@ private:
                                void            _ProduceNewBuffer(const 
media_timed_event* event,
                                                                bigtime_t late);
 
-                               void            _HandleStart(bigtime_t 
performanceTime);
-                               void            _HandleStop(bigtime_t 
performanceTime,
-                                                               bool immediate);
-                               void            _HandleSeek(bigtime_t mediaTime,
-                                                               bigtime_t 
performanceTime);
-                               void            _HandleTimeWarp(bigtime_t 
realTime,
-                                                               bigtime_t 
performanceTime);
-
                        BMediaClient*   fOwner;
 };
 
diff --git a/headers/private/media/MediaConnection.h 
b/headers/private/media/MediaConnection.h
index 1a97736..bf6b1bb 100644
--- a/headers/private/media/MediaConnection.h
+++ b/headers/private/media/MediaConnection.h
@@ -30,42 +30,14 @@ namespace BPrivate { namespace media {
 // recycle the buffer when you don't want to do anything further.
 class BMediaConnection {
 public:
-       enum notification {
-               B_CONNECTED = 1,
-               B_DISCONNECTED,
-
-               B_PREPARE_TO_CONNECT,   // media_format* format, media_source* 
source,
-                                                               // char* name
-               B_CONNECT,
-               B_DISCONNECT,
-
-               B_FORMAT_PROPOSAL,              // media_format* format
-
-               B_ASK_FORMAT_CHANGE,
-               B_FORMAT_CHANGED
-       };
-
-
-       // This function is called when it is the moment to handle a buffer.
-       typedef void                                    
(*process_hook)(BMediaConnection* connection,
-                                                                               
BBuffer* buffer);
-
-       // Used to notify or inquire the client about what to do when certain
-       // events happen.
-       typedef status_t                                
(*notify_hook)(notification what,
-                                                                               
BMediaConnection* connection,
-                                                                               
...);
-
        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.
+       BMediaClient*                                   MediaClient() const;
+
        bool                                                    IsInput() const;
        bool                                                    IsOutput() 
const;
 
@@ -88,9 +60,6 @@ public:
 
        bool                                                    IsConnected() 
const;
 
-       void                                                    SetCookie(void* 
cookie);
-       void*                                                   Cookie() const;
-
        // Disconnect this connection. When a connection is disconnected,
        // it can be reused as brand new.
        status_t                                                Disconnect();
@@ -101,26 +70,20 @@ public:
        // want to preserve it for future connections just Disconnect() it.
        status_t                                                Release();
 
-       // Use this to set your callbacks.
-       void                                                    
SetHooks(process_hook processHook = NULL,
-                                                                               
notify_hook notifyHook = NULL,
-                                                                               
void* cookie = NULL);
-
 protected:
-                                                                       
BMediaConnection(BMediaClient* owner,
-                                                                               
media_connection_kind kind,
-                                                                               
media_connection_id id);
+                                                                       
BMediaConnection(media_connection_kind kind);
 
        // Those callbacks are shared between BMediaInput and BMediaOutput
        virtual void                                    Connected(const 
media_format& format);
        virtual void                                    Disconnected();
 
 private:
+                       void                                    
ConnectionRegistered(BMediaClient* owner,
+                                                                               
media_connection_id id);
+
        const media_source&                             Source() const;
        const media_destination&                Destination() const;
 
-       void                                                    _Init();
-
        media_connection                                fConnection;
 
        BMediaClient*                                   fOwner;
@@ -130,10 +93,6 @@ private:
        // see BMediaClient::Bind.
        BMediaConnection*                               fBind;
 
-       process_hook                                    fProcessHook;
-       notify_hook                                             fNotifyHook;
-       void*                                                   fBufferCookie;
-
        size_t                                                  fBufferSize;
        bigtime_t                                               fBufferDuration;
 
@@ -164,8 +123,7 @@ private:
 
 class BMediaInput : public BMediaConnection {
 public:
-                                                                       
BMediaInput(BMediaClient* owner,
-                                                                               
media_connection_id id);
+                                                                       
BMediaInput();
 
 protected:
        // Callbacks
@@ -195,8 +153,7 @@ private:
 
 class BMediaOutput : public BMediaConnection {
 public:
-                                                                       
BMediaOutput(BMediaClient* owner,
-                                                                               
media_connection_id id);
+                                                                       
BMediaOutput();
 
        void                                                    
SetOutputEnabled(bool enabled);
        bool                                                    
IsOutputEnabled() const;
diff --git a/headers/private/media/SimpleMediaClient.h 
b/headers/private/media/SimpleMediaClient.h
new file mode 100755
index 0000000..dd10aa3
--- /dev/null
+++ b/headers/private/media/SimpleMediaClient.h
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2015, Haiku, Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#ifndef _MEDIA_SIMPLE_CLIENT_H
+#define _MEDIA_SIMPLE_CLIENT_H
+
+#include <MediaClient.h>
+#include <MediaConnection.h>
+
+
+namespace BPrivate { namespace media {
+
+
+class BSimpleMediaInput;
+class BSimpleMediaOutput;
+
+class BSimpleMediaClient : public BMediaClient {
+public:
+       enum notification {
+               B_WILL_START = 1,                       // performance_time
+               B_WILL_STOP,                            // performance_time 
immediate
+               B_WILL_SEEK,                            // performance_time 
media_time
+               B_WILL_TIMEWARP,                        // real_time 
performance_time
+
+               B_FORMAT_SUGGESTION,            // media_type type, int32 
quality,
+                                                                       // 
media_format* format
+       };
+
+       typedef void                                    (*notify_hook)(void* 
cookie,
+                                                                               
        notification what,
+                                                                               
        ...);
+
+                                                                       
BSimpleMediaClient(const char* name,
+                                                                               
media_type type
+                                                                               
        = B_MEDIA_UNKNOWN_TYPE,
+                                                                               
media_client_kind
+                                                                               
        kind = B_MEDIA_PLAYER
+                                                                               
                & B_MEDIA_RECORDER);
+
+       virtual                                                 
~BSimpleMediaClient();
+
+       // This is supplied to support generic connections not related
+       // to a certain destination or source node, however for various 
ambiguity
+       // reasons we want the BMediaConnection to be declared as input or 
output.
+       // You can pass the object returned by this function to another
+       // BMediaClient::Connect(), so that it will automatically connect to 
this node.
+       virtual BSimpleMediaInput*              BeginInput();
+       virtual BSimpleMediaOutput*             BeginOutput();
+
+                       void                                    
SetNotificationHook(notify_hook notifyHook = NULL,
+                                                                               
void* cookie = NULL);
+
+protected:
+       virtual void                                    HandleStart(bigtime_t 
performanceTime);
+       virtual void                                    HandleStop(bigtime_t 
performanceTime);
+
+       virtual void                                    HandleSeek(bigtime_t 
mediaTime,
+                                                                               
bigtime_t performanceTime);
+
+       virtual void                                    
HandleTimeWarp(bigtime_t realTime,
+                                                                               
bigtime_t performanceTime);
+
+       virtual status_t                                
HandleFormatSuggestion(media_type type,
+                                                                               
int32 quality, media_format* format);
+
+private:
+                       notify_hook                             fNotifyHook;
+                       void*                                   fNotifyCookie;
+
+       virtual void                                    
_ReservedSimpleMediaClient0();
+       virtual void                                    
_ReservedSimpleMediaClient1();
+       virtual void                                    
_ReservedSimpleMediaClient2();
+       virtual void                                    
_ReservedSimpleMediaClient3();
+       virtual void                                    
_ReservedSimpleMediaClient4();
+       virtual void                                    
_ReservedSimpleMediaClient5();
+                       uint32                                  fPadding[32];
+};
+
+
+class BSimpleMediaInput : public BMediaInput {
+public:
+       enum notification {
+               B_CONNECTED = 1,
+               B_DISCONNECTED,
+
+               B_FORMAT_CHANGED
+       };
+
+       // This function is called when it is the moment to handle a buffer.
+       typedef void                                    (*process_hook)(
+                                                                               
BMediaConnection* connection,
+                                                                               
BBuffer* buffer);
+
+       // Used to notify or inquire the client about what to do when certain
+       // events happen.
+       typedef status_t                                (*notify_hook)(
+                                                                               
notification what,
+                                                                               
BMediaConnection* connection,
+                                                                               
...);
+
+                                                                       
BSimpleMediaInput();
+
+                       // Use this to set your callbacks.
+                       void                                    
SetHooks(process_hook processHook = NULL,
+                                                                               
notify_hook notifyHook = NULL,
+                                                                               
void* cookie = NULL);
+
+                       void*                                   Cookie() const;
+
+protected:
+       virtual void                                    Connected(const 
media_format& format);
+       virtual void                                    Disconnected();
+
+                       void                                    
BufferReceived(BBuffer* buffer);
+
+private:
+                       process_hook                    fProcessHook;
+                       notify_hook                             fNotifyHook;
+                       void*                                   fBufferCookie;
+};
+
+
+class BSimpleMediaOutput : public BMediaOutput {
+public:
+       enum notification {
+               B_CONNECTED = 1,
+               B_DISCONNECTED,
+
+               B_PREPARE_TO_CONNECT,   // media_format* format, media_source* 
source,
+                                                               // char* name
+
+               B_FORMAT_PROPOSAL,              // media_format* format
+               B_ASK_FORMAT_CHANGE,
+       };
+
+       // This function is called when it is the moment to handle a buffer.
+       typedef void                                    (*process_hook)(
+                                                                               
BMediaConnection* connection,
+                                                                               
BBuffer* buffer);
+
+       // Used to notify or inquire the client about what to do when certain
+       // events happen.
+       typedef status_t                                (*notify_hook)(
+                                                                               
notification what,
+                                                                               
BMediaConnection* connection,
+                                                                               
...);
+
+                                                                       
BSimpleMediaOutput();
+
+                       // Use this to set your callbacks.
+                       void                                    
SetHooks(process_hook processHook = NULL,
+                                                                               
notify_hook notifyHook = NULL,
+                                                                               
void* cookie = NULL);
+
+                       void*                                   Cookie() const;
+
+protected:
+       virtual void                                    Connected(const 
media_format& format);
+       virtual void                                    Disconnected();
+
+       virtual status_t                                
FormatProposal(media_format* format);
+
+private:
+                       process_hook                    fProcessHook;
+                       notify_hook                             fNotifyHook;
+                       void*                                   fBufferCookie;
+};
+
+
+}
+
+}
+
+using namespace BPrivate::media;
+
+#endif
diff --git a/src/kits/media/Jamfile b/src/kits/media/Jamfile
index a977729..7d2d0a4 100644
--- a/src/kits/media/Jamfile
+++ b/src/kits/media/Jamfile
@@ -30,7 +30,7 @@ for architectureObject in [ MultiArchSubDirSetup ] {
                        MediaClientDefs.cpp
                        MediaConnection.cpp
                        MediaRecorder.cpp
-
+                       SimpleMediaClient.cpp
 
                        # Public Media Kit
                        Buffer.cpp
diff --git a/src/kits/media/MediaClient.cpp b/src/kits/media/MediaClient.cpp
index 295c5e5..ce5b7f9 100755
--- a/src/kits/media/MediaClient.cpp
+++ b/src/kits/media/MediaClient.cpp
@@ -71,25 +71,21 @@ BMediaClient::MediaType() const
 }
 
 
-BMediaInput*
-BMediaClient::BeginInput()
+status_t
+BMediaClient::RegisterInput(BMediaInput* input)
 {
-       CALLED();
-
-       BMediaInput* input = new BMediaInput(this, fLastID++);
+       input->ConnectionRegistered(this, fLastID++);
        AddInput(input);
-       return input;
+       return B_OK;
 }
 
 
-BMediaOutput*
-BMediaClient::BeginOutput()
+status_t
+BMediaClient::RegisterOutput(BMediaOutput* output)
 {
-       CALLED();
-
-       BMediaOutput* output = new BMediaOutput(this, fLastID++);
+       output->ConnectionRegistered(this, fLastID++);
        AddOutput(output);
-       return output;
+       return B_OK;
 }
 
 
@@ -186,24 +182,6 @@ BMediaClient::Disconnect()
 }
 
 
-status_t
-BMediaClient::DisconnectConnection(BMediaConnection* conn)
-{
-       CALLED();
-
-       return B_OK;
-}
-
-
-status_t
-BMediaClient::ReleaseConnection(BMediaConnection* conn)
-{
-       CALLED();
-
-       return B_OK;
-}
-
-
 int32
 BMediaClient::CountInputs() const
 {
@@ -469,12 +447,48 @@ BMediaClient::AddOn(int32* id) const
 
 
 void
-BMediaClient::SetNotificationHook(notify_hook notifyHook, void* cookie)
+BMediaClient::HandleStart(bigtime_t performanceTime)
 {
-       CALLED();
+}
+
+
+void
+BMediaClient::HandleStop(bigtime_t performanceTime)
+{
+}
+
+
+void
+BMediaClient::HandleSeek(bigtime_t mediaTime, bigtime_t performanceTime)
+{
+}
+
+
+void
+BMediaClient::HandleTimeWarp(bigtime_t realTime, bigtime_t performanceTime)
+{
+}
+
+
+status_t
+BMediaClient::HandleFormatSuggestion(media_type type, int32 quality,
+       media_format* format)
+{
+       return B_ERROR;
+}
 
-       fNotifyHook = notifyHook;
-       fNotifyCookie = cookie;
+
+status_t
+BMediaClient::ConnectionReleased(BMediaConnection* connection)
+{
+       return B_OK;
+}
+
+
+status_t
+BMediaClient::ConnectionDisconnected(BMediaConnection* connection)
+{
+       return B_OK;
 }
 
 
@@ -483,9 +497,6 @@ BMediaClient::_Init()
 {
        CALLED();
 
-       fNotifyHook = NULL;
-       fNotifyCookie = NULL;
-
        BMediaRoster* roster = BMediaRoster::Roster(&fInitErr);
        if (fInitErr == B_OK && roster != NULL)
                fInitErr = roster->RegisterNode(fNode);
diff --git a/src/kits/media/MediaClientNode.cpp 
b/src/kits/media/MediaClientNode.cpp
index 9ea6de4..ad2bdc9 100755
--- a/src/kits/media/MediaClientNode.cpp
+++ b/src/kits/media/MediaClientNode.cpp
@@ -280,19 +280,16 @@ BMediaClientNode::FormatSuggestionRequested(media_type 
type,
                return B_MEDIA_BAD_FORMAT;
        }
 
-       if (fOwner->fNotifyHook != NULL) {
-               status_t result = B_OK;
-               (*fOwner->fNotifyHook)(fOwner->fNotifyCookie,
-                       BMediaClient::B_FORMAT_SUGGESTION,
-                       type, quality, format, &result);
-               return result;
-       } else {
+       status_t ret = fOwner->HandleFormatSuggestion(type, quality, format);
+       if (ret != B_OK) {
                // In that case we return just a very generic format.
                media_format outFormat;
                outFormat.type = fOwner->MediaType();
                *format = outFormat;
                return B_OK;
        }
+
+       return ret;
 }
 
 
@@ -539,20 +536,25 @@ BMediaClientNode::HandleEvent(const media_timed_event* 
event,
                case BTimedEventQueue::B_START:
                {
                        if (RunState() != B_STARTED)
-                               _HandleStart(event->event_time);
+                               fOwner->HandleStart(event->event_time);
                        break;
                }
 
                case BTimedEventQueue::B_STOP:
-                       _HandleStop(event->event_time, true);
+               {
+                       fOwner->HandleStop(event->event_time);
+
+                       EventQueue()->FlushEvents(0, 
BTimedEventQueue::B_ALWAYS, true,
+                               BTimedEventQueue::B_HANDLE_BUFFER);
                        break;
+               }
 
                case BTimedEventQueue::B_SEEK:
-                       _HandleSeek(event->event_time, event->bigdata);
+                       fOwner->HandleSeek(event->event_time, event->bigdata);
                        break;
 
                case BTimedEventQueue::B_WARP:
-                       _HandleTimeWarp(event->event_time, event->bigdata);
+                       fOwner->HandleTimeWarp(event->event_time, 
event->bigdata);
                        break;
        }
 }
@@ -595,60 +597,3 @@ BMediaClientNode::_ProduceNewBuffer(const 
media_timed_event* event,
 
        // event.pointer == connection
 }
-
-
-void
-BMediaClientNode::_HandleStart(bigtime_t performanceTime)
-{
-       CALLED();
-
-       if (fOwner->fNotifyHook != NULL) {
-               (*fOwner->fNotifyHook)(fOwner->fNotifyCookie,
-                       BMediaClient::B_WILL_START,
-                       performanceTime);
-       }
-}
-
-
-void
-BMediaClientNode::_HandleStop(bigtime_t performanceTime,
-       bool immediate)
-{
-       CALLED();
-
-       if (fOwner->fNotifyHook != NULL) {
-               (*fOwner->fNotifyHook)(fOwner->fNotifyCookie,
-                       BMediaClient::B_WILL_STOP,
-                       performanceTime, immediate);
-       }
-       EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true,
-               BTimedEventQueue::B_HANDLE_BUFFER);
-}
-
-
-void
-BMediaClientNode::_HandleSeek(bigtime_t mediaTime,
-       bigtime_t performanceTime)
-{
-       CALLED();
-
-       if (fOwner->fNotifyHook != NULL) {
-               (*fOwner->fNotifyHook)(fOwner->fNotifyCookie,
-                       BMediaClient::B_WILL_SEEK,
-                       performanceTime, mediaTime);
-       }
-}
-
-
-void
-BMediaClientNode::_HandleTimeWarp(bigtime_t realTime,
-       bigtime_t performanceTime)
-{
-       CALLED();
-
-       if (fOwner->fNotifyHook != NULL) {
-               (*fOwner->fNotifyHook)(fOwner->fNotifyCookie,
-                       BMediaClient::B_WILL_TIMEWARP,
-                       realTime, performanceTime);
-       }
-}
diff --git a/src/kits/media/MediaConnection.cpp 
b/src/kits/media/MediaConnection.cpp
index 82bdfc1..8ebb322 100644
--- a/src/kits/media/MediaConnection.cpp
+++ b/src/kits/media/MediaConnection.cpp
@@ -8,33 +8,17 @@
 #include "debug.h"
 
 
-BMediaConnection::BMediaConnection(BMediaClient* owner,
-       media_connection_kind kind,
-       media_connection_id id)
+BMediaConnection::BMediaConnection(media_connection_kind kind)
        :
-       fOwner(owner),
-       fBind(NULL)
+       fOwner(NULL),
+       fBind(NULL),
+       fBufferGroup(NULL)
 {
        CALLED();
 
-       _Init();
-
        fConnection.kind = kind;
-       fConnection.id = id;
-       fConnection.client = fOwner->Client();
-
-       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;
-
-               fConnection.source = media_source::null;
-       }
+       fConnection.id = -1;
+       //fConnection.client = media_client::null;
 }
 
 
@@ -115,15 +99,6 @@ BMediaConnection::IsConnected() const
 }
 
 
-void*
-BMediaConnection::Cookie() const
-{
-       CALLED();
-
-       return fBufferCookie;
-}
-
-
 status_t
 BMediaConnection::Disconnect()
 {
@@ -132,7 +107,7 @@ BMediaConnection::Disconnect()
        delete fBufferGroup;
        fBufferGroup = NULL;
 
-       return fOwner->DisconnectConnection(this);
+       return fOwner->ConnectionDisconnected(this);
 }
 
 
@@ -141,19 +116,7 @@ BMediaConnection::Release()
 {
        CALLED();
 
-       return fOwner->ReleaseConnection(this);
-}
-
-
-void
-BMediaConnection::SetHooks(process_hook processHook,
-       notify_hook notifyHook, void* cookie)
-{
-       CALLED();
-
-       fProcessHook = processHook;
-       fNotifyHook = notifyHook;
-       fBufferCookie = cookie;
+       return fOwner->ConnectionReleased(this);
 }
 
 
@@ -196,9 +159,6 @@ BMediaConnection::BufferDuration() const
 void
 BMediaConnection::Connected(const media_format& format)
 {
-       if (fNotifyHook != NULL)
-               (*fNotifyHook)(B_CONNECTED, this);
-
        fConnected = true;
 }
 
@@ -206,21 +166,29 @@ BMediaConnection::Connected(const media_format& format)
 void
 BMediaConnection::Disconnected()
 {
-       if (fNotifyHook != NULL)
-               (*fNotifyHook)(B_DISCONNECTED, this);
-
        fConnected = false;
 }
 
 
 void
-BMediaConnection::_Init()
+BMediaConnection::ConnectionRegistered(BMediaClient* owner,
+       media_connection_id id)
 {
-       CALLED();
+       fOwner = owner;
+       fConnection.id = id;
+       fConnection.client = fOwner->Client();
 
-       fBufferGroup = NULL;
-       fNotifyHook = NULL;
-       fProcessHook = NULL;
+       if (IsOutput()) {
+               fConnection.source.port = fOwner->fNode->ControlPort();
+               fConnection.source.id = fConnection.id;
+
+               fConnection.destination = media_destination::null;
+       } else {
+               fConnection.destination.port = fOwner->fNode->ControlPort();
+               fConnection.destination.id = fConnection.id;
+
+               fConnection.source = media_source::null;
+       }
 }
 
 
@@ -251,9 +219,9 @@ void BMediaConnection::_ReservedMediaConnection9() {}
 void BMediaConnection::_ReservedMediaConnection10() {}
 
 
-BMediaInput::BMediaInput(BMediaClient* owner, media_connection_id id)
+BMediaInput::BMediaInput()
        :
-       BMediaConnection(owner, B_MEDIA_INPUT, id)
+       BMediaConnection(B_MEDIA_INPUT)
 {
 }
 
@@ -282,8 +250,6 @@ BMediaInput::BufferReceived(BBuffer* buffer)
 {
        CALLED();
 
-       if (fProcessHook != NULL)
-               fProcessHook(this, buffer);
 }
 
 
@@ -300,9 +266,9 @@ void BMediaInput::_ReservedMediaInput9() {}
 void BMediaInput::_ReservedMediaInput10() {}
 
 
-BMediaOutput::BMediaOutput(BMediaClient* owner, media_connection_id id)
+BMediaOutput::BMediaOutput()
        :
-       BMediaConnection(owner, B_MEDIA_OUTPUT, id)
+       BMediaConnection(B_MEDIA_OUTPUT)
 {
 }
 
@@ -328,12 +294,7 @@ BMediaOutput::PrepareToConnect(media_format* format)
 status_t
 BMediaOutput::FormatProposal(media_format* format)
 {
-       if (fOwner->fNotifyHook != NULL) {
-               return (*fNotifyHook)(BMediaConnection::B_FORMAT_PROPOSAL,
-                       this, format);
-       } else
-               *format = AcceptedFormat();
-
+       *format = AcceptedFormat();
        return B_OK;
 }
 
diff --git a/src/kits/media/SimpleMediaClient.cpp 
b/src/kits/media/SimpleMediaClient.cpp
new file mode 100644
index 0000000..a2b3e72
--- /dev/null
+++ b/src/kits/media/SimpleMediaClient.cpp
@@ -0,0 +1,242 @@
+/*
+ * Copyright 2015, Dario Casalinuovo. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <SimpleMediaClient.h>
+
+#include <debug.h>
+
+
+BSimpleMediaClient::BSimpleMediaClient(const char* name,
+       media_type type, media_client_kind kind)
+       :
+       BMediaClient(name, type, kind),
+       fNotifyHook(NULL),
+       fNotifyCookie(NULL)
+{
+       CALLED();
+}
+
+
+BSimpleMediaClient::~BSimpleMediaClient()
+{
+       CALLED();
+}
+
+
+BSimpleMediaInput*
+BSimpleMediaClient::BeginInput()
+{
+       CALLED();
+
+       BSimpleMediaInput* input = new BSimpleMediaInput();
+       RegisterInput(input);
+       return input;
+}
+
+
+BSimpleMediaOutput*
+BSimpleMediaClient::BeginOutput()
+{
+       CALLED();
+
+       BSimpleMediaOutput* output = new BSimpleMediaOutput();
+       RegisterOutput(output);
+       return output;
+}
+
+
+void
+BSimpleMediaClient::SetNotificationHook(notify_hook notifyHook, void* cookie)
+{
+       CALLED();
+
+       fNotifyHook = notifyHook;
+       fNotifyCookie = cookie;
+}
+
+
+void
+BSimpleMediaClient::HandleStart(bigtime_t performanceTime)
+{
+       if (fNotifyHook != NULL) {
+               (*fNotifyHook)(fNotifyCookie,
+                       BSimpleMediaClient::B_WILL_START,
+                       performanceTime);
+       }
+}
+
+
+void
+BSimpleMediaClient::HandleStop(bigtime_t performanceTime)
+{
+       if (fNotifyHook != NULL) {
+               (*fNotifyHook)(fNotifyCookie,
+                       BSimpleMediaClient::B_WILL_STOP,
+                       performanceTime);
+       }
+}
+
+
+void
+BSimpleMediaClient::HandleSeek(bigtime_t mediaTime, bigtime_t performanceTime)
+{
+       if (fNotifyHook != NULL) {
+               (*fNotifyHook)(fNotifyCookie,
+                       BSimpleMediaClient::B_WILL_SEEK,
+                       performanceTime, mediaTime);
+       }
+}
+
+
+void
+BSimpleMediaClient::HandleTimeWarp(bigtime_t realTime, bigtime_t 
performanceTime)
+{
+       if (fNotifyHook != NULL) {
+               (*fNotifyHook)(fNotifyCookie,
+                       BSimpleMediaClient::B_WILL_TIMEWARP,
+                       realTime, performanceTime);
+       }
+}
+
+
+status_t
+BSimpleMediaClient::HandleFormatSuggestion(media_type type, int32 quality,
+       media_format* format)
+{
+       if (fNotifyHook != NULL) {
+               status_t result = B_ERROR;
+               (*fNotifyHook)(fNotifyCookie,
+                       BSimpleMediaClient::B_FORMAT_SUGGESTION,
+                       type, quality, format, &result);
+               return result;
+       }
+       return B_ERROR;
+}
+
+
+void BSimpleMediaClient::_ReservedSimpleMediaClient0() {}
+void BSimpleMediaClient::_ReservedSimpleMediaClient1() {}
+void BSimpleMediaClient::_ReservedSimpleMediaClient2() {}
+void BSimpleMediaClient::_ReservedSimpleMediaClient3() {}
+void BSimpleMediaClient::_ReservedSimpleMediaClient4() {}
+void BSimpleMediaClient::_ReservedSimpleMediaClient5() {}
+
+
+BSimpleMediaInput::BSimpleMediaInput()
+       :
+       BMediaInput()
+{
+}
+
+
+void
+BSimpleMediaInput::Connected(const media_format& format)
+{
+       if (fNotifyHook != NULL)
+               (*fNotifyHook)(B_CONNECTED, this);
+
+       BMediaInput::Connected(format);
+}
+
+
+void
+BSimpleMediaInput::Disconnected()
+{
+       if (fNotifyHook != NULL)
+               (*fNotifyHook)(B_DISCONNECTED, this);
+
+       BMediaConnection::Disconnected();
+}
+
+
+void
+BSimpleMediaInput::SetHooks(process_hook processHook,
+       notify_hook notifyHook, void* cookie)
+{
+       CALLED();
+
+       fProcessHook = processHook;
+       fNotifyHook = notifyHook;
+       fBufferCookie = cookie;
+}
+
+
+void*
+BSimpleMediaInput::Cookie() const
+{
+       CALLED();
+
+       return fBufferCookie;
+}
+
+
+void
+BSimpleMediaInput::BufferReceived(BBuffer* buffer)
+{
+       CALLED();
+
+       if (fProcessHook != NULL)
+               (*fProcessHook)((BMediaConnection*)this, buffer);
+}
+
+
+BSimpleMediaOutput::BSimpleMediaOutput()
+       :
+       BMediaOutput()
+{
+}
+
+
+status_t
+BSimpleMediaOutput::FormatProposal(media_format* format)
+{
+       if (fNotifyHook != NULL) {
+               return (*fNotifyHook)(BSimpleMediaOutput::B_FORMAT_PROPOSAL,
+                       this, format);
+       }
+
+       return BMediaOutput::FormatProposal(format);
+}
+
+
+void
+BSimpleMediaOutput::Connected(const media_format& format)
+{
+       if (fNotifyHook != NULL)
+               (*fNotifyHook)(B_CONNECTED, this);
+
+       BMediaConnection::Connected(format);
+}
+
+
+void
+BSimpleMediaOutput::Disconnected()
+{
+       if (fNotifyHook != NULL)
+               (*fNotifyHook)(B_DISCONNECTED, this);
+
+       BMediaConnection::Disconnected();
+}
+
+
+void
+BSimpleMediaOutput::SetHooks(process_hook processHook,
+       notify_hook notifyHook, void* cookie)
+{
+       CALLED();
+
+       fProcessHook = processHook;
+       fNotifyHook = notifyHook;
+       fBufferCookie = cookie;
+}
+
+
+void*
+BSimpleMediaOutput::Cookie() const
+{
+       CALLED();
+
+       return fBufferCookie;
+}
diff --git a/src/tests/kits/media/media_client/media_client.cpp 
b/src/tests/kits/media/media_client/media_client.cpp
index 8156b36..840e61c 100644
--- a/src/tests/kits/media/media_client/media_client.cpp
+++ b/src/tests/kits/media/media_client/media_client.cpp
@@ -3,7 +3,7 @@
  * Distributed under the terms of the MIT License.
  */
 
-#include <MediaClient.h>
+#include <SimpleMediaClient.h>
 #include <MediaConnection.h>
 #include <SupportDefs.h>
 
@@ -18,18 +18,18 @@
 #endif
 
 
-static BMediaClient* sProducer = NULL;
-static BMediaClient* sConsumer = NULL;
-static BMediaClient* sFilter = NULL;
+static BSimpleMediaClient* sProducer = NULL;
+static BSimpleMediaClient* sConsumer = NULL;
+static BSimpleMediaClient* sFilter = NULL;
 
 
 void _InitClients(bool hasFilter)
 {
-       sProducer = new BMediaClient("MediaClientProducer");
-       sConsumer = new BMediaClient("MediaClientConsumer");
+       sProducer = new BSimpleMediaClient("MediaClientProducer");
+       sConsumer = new BSimpleMediaClient("MediaClientConsumer");
 
        if (hasFilter)
-               sFilter = new BMediaClient("MediaClientFilter");
+               sFilter = new BSimpleMediaClient("MediaClientFilter");
        else
                sFilter = NULL;
 }


Other related posts:

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