Populate media/experimental with future media_kit classes

* Node implementations headers are move into src/kits/media.
This commit is contained in:
Dario Casalinuovo
2017-01-16 23:04:14 +01:00
parent 41acdd1d90
commit 7561d9ac5d
17 changed files with 25 additions and 17 deletions
-145
View File
@@ -1,145 +0,0 @@
/*
* Copyright 2015, Dario Casalinuovo. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#ifndef _MEDIA_CLIENT_NODE_H
#define _MEDIA_CLIENT_NODE_H
#include <BufferConsumer.h>
#include <BufferProducer.h>
#include <Controllable.h>
#include <MediaDefs.h>
#include <MediaEventLooper.h>
namespace BPrivate { namespace media {
class BMediaClient;
class BMediaConnection;
class BMediaClientNode : public BBufferConsumer, public BBufferProducer,
public BMediaEventLooper {
public:
BMediaClientNode(const char* name,
BMediaClient* owner,
media_type type
= B_MEDIA_UNKNOWN_TYPE);
// Various useful stuff
status_t SendBuffer(BBuffer* buffer, BMediaConnection* conn);
protected:
virtual BMediaAddOn* AddOn(int32* id) const;
virtual void NodeRegistered();
virtual void SetRunMode(run_mode mode);
virtual void Start(bigtime_t performanceTime);
virtual void Stop(bigtime_t performanceTime,
bool immediate);
virtual void Seek(bigtime_t mediaTime,
bigtime_t performanceTime);
virtual void TimeWarp(bigtime_t realTime,
bigtime_t performanceTime);
virtual status_t HandleMessage(int32 message,
const void* data,
size_t size);
// BBufferConsumer
virtual status_t AcceptFormat(const media_destination& dest,
media_format* format);
virtual status_t GetNextInput(int32* cookie,
media_input* input);
virtual void DisposeInputCookie(int32 cookie);
virtual void BufferReceived(BBuffer* buffer);
virtual status_t GetLatencyFor(const media_destination& dest,
bigtime_t* latency,
media_node_id* timesource);
virtual status_t Connected(const media_source& source,
const media_destination& dest,
const media_format& format,
media_input* outInput);
virtual void Disconnected(const media_source& source,
const media_destination& dest);
virtual status_t FormatChanged(const media_source& source,
const media_destination& consumer,
int32 tag,
const media_format& format);
// BBufferProducer
virtual status_t FormatSuggestionRequested(media_type type,
int32 quality, media_format* format);
virtual status_t FormatProposal(const media_source& source,
media_format *format);
virtual status_t FormatChangeRequested(const media_source& source,
const media_destination& dest,
media_format *format,
int32* _deprecated_);
virtual void LateNoticeReceived(const media_source& source,
bigtime_t late, bigtime_t when);
virtual status_t GetNextOutput(int32 *cookie, media_output *output);
virtual status_t DisposeOutputCookie(int32 cookie);
virtual status_t SetBufferGroup(const media_source& source,
BBufferGroup *group);
virtual status_t PrepareToConnect(const media_source& source,
const media_destination& dest,
media_format *format,
media_source *out_source,
char *name);
virtual void Connect(status_t status,
const media_source& source,
const media_destination& dest,
const media_format &format,
char* name);
virtual void Disconnect(const media_source& source,
const media_destination& dest);
virtual void EnableOutput(const media_source& source,
bool enabled, int32* _deprecated_);
virtual status_t GetLatency(bigtime_t *outLatency);
virtual void LatencyChanged( const media_source& source,
const media_destination& dest,
bigtime_t latency, uint32 flags);
void ProducerDataStatus(const media_destination& dest,
int32 status, bigtime_t when);
protected:
virtual void HandleEvent(const media_timed_event *event,
bigtime_t late,
bool realTimeEvent=false);
virtual ~BMediaClientNode();
private:
void _ScheduleConnections(bigtime_t eventTime);
void _HandleBuffer(BBuffer* buffer);
void _ProduceNewBuffer(const media_timed_event* event,
bigtime_t late);
BMediaClient* fOwner;
bigtime_t fStartTime;
};
}
}
using namespace BPrivate::media;
#endif
-118
View File
@@ -1,118 +0,0 @@
/*
* Copyright 2014-2016, Dario Casalinuovo
* Copyright 1999, Be Incorporated
* All Rights Reserved.
* This file may be used under the terms of the Be Sample Code License.
*/
#ifndef _MEDIA_RECORDER_NODE_H
#define _MEDIA_RECORDER_NODE_H
#include <BufferConsumer.h>
#include <MediaEventLooper.h>
#include <MediaRecorder.h>
#include <String.h>
namespace BPrivate { namespace media {
class BMediaRecorderNode : public BMediaEventLooper,
public BBufferConsumer {
public:
BMediaRecorderNode(const char* name,
BMediaRecorder* recorder,
media_type type
= B_MEDIA_UNKNOWN_TYPE);
// TODO these are not thread safe; we should fix that...
void SetAcceptedFormat(const media_format& format);
const media_format& AcceptedFormat() const;
void GetInput(media_input* input);
void SetDataEnabled(bool enabled);
void ActivateInternalConnect(bool connectMode);
protected:
virtual BMediaAddOn* AddOn(int32* id) const;
virtual void NodeRegistered();
virtual void SetRunMode(run_mode mode);
virtual void HandleEvent(const media_timed_event* event,
bigtime_t lateness,
bool realTimeEvent);
virtual void Start(bigtime_t performanceTime);
virtual void Stop(bigtime_t performanceTime,
bool immediate);
virtual void Seek(bigtime_t mediaTime,
bigtime_t performanceTime);
virtual void TimeWarp(bigtime_t realTime,
bigtime_t performanceTime);
virtual status_t HandleMessage(int32 message,
const void* data,
size_t size);
// Someone, probably the producer, is asking you about
// this format. Give your honest opinion, possibly
// modifying *format. Do not ask upstream producer about
// the format, since he's synchronously waiting for your
// reply.
virtual status_t AcceptFormat(const media_destination& dest,
media_format* format);
virtual status_t GetNextInput(int32* cookie,
media_input* outInput);
virtual void DisposeInputCookie(int32 cookie);
virtual void BufferReceived(BBuffer* buffer);
virtual void ProducerDataStatus(
const media_destination& destination,
int32 status,
bigtime_t performanceTime);
virtual status_t GetLatencyFor(const media_destination& destination,
bigtime_t* outLatency,
media_node_id* outTimesource);
virtual status_t Connected(const media_source& producer,
const media_destination& where,
const media_format& format,
media_input* outInput);
virtual void Disconnected(const media_source& producer,
const media_destination& where);
virtual status_t FormatChanged(const media_source& producer,
const media_destination& consumer,
int32 tag,
const media_format& format);
protected:
virtual ~BMediaRecorderNode();
BMediaRecorder* fRecorder;
media_format fOKFormat;
media_input fInput;
BString fName;
bool fConnectMode;
};
}
}
using namespace BPrivate::media;
#endif // _MEDIA_RECORDER_NODE_H
@@ -14,12 +14,11 @@
#include <MediaDefs.h>
#include <MediaNode.h>
#include "MediaClientNode.h"
namespace BPrivate { namespace media {
class BMediaClientNode;
class BMediaConnection;
class BMediaInput;
class BMediaOutput;
@@ -12,11 +12,11 @@
#include <MediaClient.h>
#include <MediaClientDefs.h>
#include "MediaClientNode.h"
namespace BPrivate { namespace media {
class BMediaClientNode;
// The BMediaConnection class is the swiss knife of BMediaClient.
// It represents a connection between two nodes and allow to create complex