Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* When setting the global format, MultiAudioDevice::_InitDriver() will no

Browse Source 
longer return on failure.
* Also, it will now retrieve the global format from the audio device
  afterwards always and uses that.
* Cleanup of MultiAudioNode, part II.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24626 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler 2008-03-28 15:18:33 +00:00
parent 5d2044f643
commit d5420ddccc
4 changed files with 939 additions and 964 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/add-ons/media/media-add-ons/multi_audio/MultiAudioDevice.cpp
View File

@ -144,14 +144,12 @@ MultiAudioDevice::_InitDriver()
if (status != B_OK) { if (status != B_OK) {
fprintf(stderr, "Failed on B_MULTI_SET_GLOBAL_FORMAT: %s\n", fprintf(stderr, "Failed on B_MULTI_SET_GLOBAL_FORMAT: %s\n",
strerror(status)); strerror(status));
#if 0
} }
status = get_global_format(fDevice, &fFormatInfo); status = get_global_format(fDevice, &fFormatInfo);
if (status != B_OK) { if (status != B_OK) {
fprintf(stderr, "Failed on B_MULTI_GET_GLOBAL_FORMAT: %s\n", fprintf(stderr, "Failed on B_MULTI_GET_GLOBAL_FORMAT: %s\n",
strerror(status)); strerror(status));
#endif
return status; return status;
} }
@ -214,21 +212,21 @@ MultiAudioDevice::_InitDriver()
status_t status_t
MultiAudioDevice::DoBufferExchange(multi_buffer_info *info) MultiAudioDevice::BufferExchange(multi_buffer_info *info)
{ {
return buffer_exchange(fDevice, info); return buffer_exchange(fDevice, info);
} }
status_t status_t
MultiAudioDevice::DoSetMix(multi_mix_value_info *info) MultiAudioDevice::SetMix(multi_mix_value_info *info)
{ {
return set_mix(fDevice, info); return set_mix(fDevice, info);
} }
status_t status_t
MultiAudioDevice::DoGetMix(multi_mix_value_info *info) MultiAudioDevice::GetMix(multi_mix_value_info *info)
{ {
return get_mix(fDevice, info); return get_mix(fDevice, info);
} }

6
src/add-ons/media/media-add-ons/multi_audio/MultiAudioDevice.h
View File

@ -27,9 +27,9 @@ public:
const multi_mix_control_info& MixControlInfo() const const multi_mix_control_info& MixControlInfo() const
{ return fMixControlInfo; } { return fMixControlInfo; }
status_t DoBufferExchange(multi_buffer_info* bufferInfo); status_t BufferExchange(multi_buffer_info* bufferInfo);
status_t DoSetMix(multi_mix_value_info* mixValueInfo); status_t SetMix(multi_mix_value_info* mixValueInfo);
status_t DoGetMix(multi_mix_value_info* mixValueInfo); status_t GetMix(multi_mix_value_info* mixValueInfo);
private: private:
status_t _InitDriver(); status_t _InitDriver();

1289
src/add-ons/media/media-add-ons/multi_audio/MultiAudioNode.cpp
View File

File diff suppressed because it is too large Load Diff

298
src/add-ons/media/media-add-ons/multi_audio/MultiAudioNode.h
View File

@ -1,35 +1,31 @@
/* /*
* multiaudio replacement media addon for BeOS
*
* Copyright (c) 2002, Jerome Duval (jerome.duval@free.fr) * Copyright (c) 2002, Jerome Duval (jerome.duval@free.fr)
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
*/ */
#ifndef _MULTIAUDIONODE_H #ifndef MULTI_AUDIO_NODE_H
#define _MULTIAUDIONODE_H #define MULTI_AUDIO_NODE_H
#include <MediaDefs.h>
#include <MediaNode.h>
#include <FileInterface.h>
#include <BufferConsumer.h> #include <BufferConsumer.h>
#include <BufferProducer.h> #include <BufferProducer.h>
#include <Controllable.h> #include <Controllable.h>
#include <MediaAddOn.h>
#include <MediaDefs.h>
#include <MediaEventLooper.h> #include <MediaEventLooper.h>
#include <ParameterWeb.h> #include <MediaNode.h>
#include <Message.h>
#include <TimeSource.h> #include <TimeSource.h>
#include <Controllable.h>
#include <File.h>
#include <Entry.h>
#include "hmulti_audio.h" #include "hmulti_audio.h"
#include "MultiAudioDevice.h" #include "MultiAudioDevice.h"
/*bool format_is_acceptible( class BDiscreteParameter;
const media_format & producer_format, class BParameterGroup;
const media_format & consumer_format);*/
class node_input { class node_input {
public: public:
node_input(media_input &input, media_format format); node_input(media_input& input, media_format format);
~node_input(); ~node_input();
int32 fChannelId; int32 fChannelId;
@ -37,13 +33,13 @@ class node_input {
media_format fPreferredFormat; media_format fPreferredFormat;
media_format fFormat; media_format fFormat;
uint32 fBufferCycle; uint32 fBufferCycle;
multi_buffer_info fOldMBI; multi_buffer_info fOldBufferInfo;
BBuffer *fBuffer; BBuffer* fBuffer;
}; };
class node_output { class node_output {
public: public:
node_output(media_output &output, media_format format); node_output(media_output& output, media_format format);
~node_output(); ~node_output();
int32 fChannelId; int32 fChannelId;
@ -51,51 +47,42 @@ class node_output {
media_format fPreferredFormat; media_format fPreferredFormat;
media_format fFormat; media_format fFormat;
BBufferGroup *fBufferGroup; BBufferGroup* fBufferGroup;
bool fOutputEnabled; bool fOutputEnabled;
uint64 fSamplesSent; uint64 fSamplesSent;
volatile uint32 fBufferCycle; volatile uint32 fBufferCycle;
multi_buffer_info fOldMBI; multi_buffer_info fOldBufferInfo;
}; };
class MultiAudioNode : public BBufferConsumer, public BBufferProducer, class MultiAudioNode : public BBufferConsumer, public BBufferProducer,
public BTimeSource, public BMediaEventLooper, public BControllable { public BTimeSource, public BMediaEventLooper, public BControllable {
protected: protected:
virtual ~MultiAudioNode(void); virtual ~MultiAudioNode();
public: public:
explicit MultiAudioNode(BMediaAddOn* addon, const char* name, MultiAudioNode(BMediaAddOn* addon, const char* name,
MultiAudioDevice* device, int32 internalID, BMessage* config); MultiAudioDevice* device, int32 internalID,
BMessage* config);
virtual status_t InitCheck(void) const; virtual status_t InitCheck() const;
/*************************/ static void GetFlavor(flavor_info* info, int32 id);
/* begin from BMediaNode */ static void GetFormat(media_format* outFormat);
public:
status_t GetConfigurationFor(BMessage* message);
// BMediaNode methods
virtual BMediaAddOn* AddOn(int32* internalID) const; virtual BMediaAddOn* AddOn(int32* internalID) const;
protected:
/* These don't return errors; instead, they use the global error condition reporter. */
/* A node is required to have a queue of at least one pending command (plus TimeWarp) */
/* and is recommended to allow for at least one pending command of each type. */
/* Allowing an arbitrary number of outstanding commands might be nice, but apps */
/* cannot depend on that happening. */
virtual void Preroll(void);
public:
virtual status_t HandleMessage(int32 message, const void* data, virtual status_t HandleMessage(int32 message, const void* data,
size_t size); size_t size);
protected: protected:
virtual void Preroll();
virtual void NodeRegistered(); virtual void NodeRegistered();
virtual status_t RequestCompleted(const media_request_info &info); virtual status_t RequestCompleted(const media_request_info& info);
virtual void SetTimeSource(BTimeSource *timeSource); virtual void SetTimeSource(BTimeSource* timeSource);
/* end from BMediaNode */ // BBufferConsumer methods
/***********************/
/******************************/
/* begin from BBufferConsumer */
virtual status_t AcceptFormat(const media_destination& dest, virtual status_t AcceptFormat(const media_destination& dest,
media_format* format); media_format* format);
@ -108,35 +95,31 @@ protected:
bigtime_t* latency, media_node_id* timeSource); bigtime_t* latency, media_node_id* timeSource);
virtual status_t Connected(const media_source& producer, virtual status_t Connected(const media_source& producer,
const media_destination& where, const media_destination& where,
const media_format& withFormat, media_input* input); const media_format& withFormat,
media_input* input);
virtual void Disconnected(const media_source& producer, virtual void Disconnected(const media_source& producer,
const media_destination& where); const media_destination& where);
virtual status_t FormatChanged(const media_source& producer, virtual status_t FormatChanged(const media_source& producer,
const media_destination& consumer, int32 changeTag, const media_destination& consumer,
const media_format& format); int32 changeTag, const media_format& format);
virtual status_t SeekTagRequested(const media_destination& destination, virtual status_t SeekTagRequested(
const media_destination& destination,
bigtime_t targetTime, uint32 flags, bigtime_t targetTime, uint32 flags,
media_seek_tag* _seekTag, bigtime_t* _taggedTime, media_seek_tag* _seekTag, bigtime_t* _taggedTime,
uint32* _flags); uint32* _flags);
/* end from BBufferConsumer */ // BBufferProducer methods
/****************************/
/******************************/
/* begin from BBufferProducer */
virtual status_t FormatSuggestionRequested(media_type type, virtual status_t FormatSuggestionRequested(media_type type,
int32 quality, int32 quality, media_format* format);
media_format* format);
virtual status_t FormatProposal(const media_source& output, virtual status_t FormatProposal(const media_source& output,
media_format* format); media_format* format);
virtual status_t FormatChangeRequested(const media_source& source, virtual status_t FormatChangeRequested(const media_source& source,
const media_destination& destination, const media_destination& destination,
media_format* io_format, media_format* io_format, int32* _deprecated);
int32* _deprecated_);
virtual status_t GetNextOutput(int32* cookie, virtual status_t GetNextOutput(int32* cookie,
media_output* out_output); media_output* out_output);
virtual status_t DisposeOutputCookie(int32 cookie); virtual status_t DisposeOutputCookie(int32 cookie);
@ -146,151 +129,98 @@ protected:
virtual status_t PrepareToConnect(const media_source& what, virtual status_t PrepareToConnect(const media_source& what,
const media_destination& where, const media_destination& where,
media_format* format, media_format* format, media_source* source,
media_source* out_source, char* name);
char* out_name);
virtual void Connect(status_t error, virtual void Connect(status_t error, const media_source& source,
const media_source& source,
const media_destination& destination, const media_destination& destination,
const media_format& format, const media_format& format, char* name);
char* io_name);
virtual void Disconnect(const media_source& what, virtual void Disconnect(const media_source& what,
const media_destination& where); const media_destination& where);
virtual void LateNoticeReceived(const media_source& what, virtual void LateNoticeReceived(const media_source& what,
bigtime_t how_much, bigtime_t howMuch, bigtime_t performanceTime);
bigtime_t performance_time);
virtual void EnableOutput(const media_source & what, virtual void EnableOutput(const media_source& what, bool enabled,
bool enabled, int32* _deprecated);
int32* _deprecated_);
virtual void AdditionalBufferRequested(const media_source& source, virtual void AdditionalBufferRequested(const media_source& source,
media_buffer_id prev_buffer, media_buffer_id previousBuffer,
bigtime_t prev_time, bigtime_t previousTime,
const media_seek_tag* prev_tag); const media_seek_tag* previousTag);
/* end from BBufferProducer */ // BMediaEventLooper methods
/****************************/ virtual void HandleEvent(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
/*****************/ // BTimeSource methods
/* BControllable */
/*****************/
/********************************/
/* start from BMediaEventLooper */
protected:
/* you must override to handle your events! */
/* you should not call HandleEvent directly */
virtual void HandleEvent(const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false);
/* end from BMediaEventLooper */
/******************************/
/********************************/
/* start from BTimeSource */
protected:
virtual void SetRunMode(run_mode mode); virtual void SetRunMode(run_mode mode);
virtual status_t TimeSourceOp(const time_source_op_info &op, virtual status_t TimeSourceOp(const time_source_op_info& op,
void *_reserved); void *_reserved);
/* end from BTimeSource */ // BControllable methods
/******************************/ virtual status_t GetParameterValue(int32 id, bigtime_t* lastChange,
void* value, size_t* size);
/********************************/ virtual void SetParameterValue(int32 id, bigtime_t when,
/* start from BControllable */ const void* value, size_t size);
protected:
virtual status_t GetParameterValue(int32 id,
bigtime_t* last_change,
void * value,
size_t* ioSize);
virtual void SetParameterValue(int32 id,
bigtime_t when,
const void * value,
size_t size);
virtual BParameterWeb* MakeParameterWeb(); virtual BParameterWeb* MakeParameterWeb();
/* end from BControllable */ private:
/******************************/ // private unimplemented
MultiAudioNode(const MultiAudioNode& clone);
MultiAudioNode& operator=(const MultiAudioNode& clone);
protected: status_t _HandleStart(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
status_t _HandleSeek(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
status_t _HandleWarp(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
status_t _HandleStop(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
status_t _HandleBuffer(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
status_t _HandleDataStatus(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
status_t _HandleParameter(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent = false);
virtual status_t HandleStart( char* _PlaybackBuffer(int32 cycle, int32 channel)
const media_timed_event *event, { return fDevice->BufferList().playback_buffers
bigtime_t lateness, [cycle][channel].base; }
bool realTimeEvent = false); uint32 _PlaybackStride(int32 cycle, int32 channel)
virtual status_t HandleSeek( { return fDevice->BufferList().playback_buffers
const media_timed_event *event, [cycle][channel].stride; }
bigtime_t lateness,
bool realTimeEvent = false);
virtual status_t HandleWarp(
const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false);
virtual status_t HandleStop(
const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false);
virtual status_t HandleBuffer(
const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false);
virtual status_t HandleDataStatus(
const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false);
virtual status_t HandleParameter(
const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false);
public: void _WriteZeros(node_input& input, uint32 bufferCycle);
void _FillWithZeros(node_input& input);
void _FillNextBuffer(node_input& channel,
BBuffer* buffer);
static void GetFlavor(flavor_info * outInfo, int32 id); static int32 _run_thread_(void* data);
static void GetFormat(media_format * outFormat); int32 _RunThread();
status_t _StartThread();
status_t _StopThread();
status_t GetConfigurationFor(BMessage * into_message); void _AllocateBuffers(node_output& channel);
BBuffer* _FillNextBuffer(multi_buffer_info& info,
node_output& channel);
void _UpdateTimeSource(multi_buffer_info& info,
multi_buffer_info& oldInfo, node_input& input);
node_output* _FindOutput(media_source source);
node_input* _FindInput(media_destination destination);
node_input* _FindInput(int32 destinationId);
private: const char* _GetControlName(multi_mix_control& control);
void _ProcessGroup(BParameterGroup* group, int32 index,
int32& numParameters);
void _ProcessMux(BDiscreteParameter* parameter,
int32 index);
MultiAudioNode(/* private unimplemented */ private:
const MultiAudioNode & clone); status_t fInitStatus;
MultiAudioNode & operator=(
const MultiAudioNode & clone);
//void WriteBuffer( BBuffer *buffer, node_input &input ); BMediaAddOn* fAddOn;
void WriteZeros(node_input &input, uint32 bufferCycle);
void FillWithZeros(node_input &input);
void FillNextBuffer(node_input &channel, BBuffer* buffer);
static int32 _run_thread_(void *data);
int32 RunThread();
status_t StartThread();
status_t StopThread();
void AllocateBuffers(node_output &channel);
BBuffer* FillNextBuffer(multi_buffer_info &MBI,
node_output &channel);
void UpdateTimeSource(multi_buffer_info &MBI,
multi_buffer_info &oldMBI,
node_input &input);
node_output* FindOutput(media_source source);
node_input* FindInput(media_destination dest);
node_input* FindInput(int32 destinationId);
void ProcessGroup(BParameterGroup *group, int32 index, int32 &nbParameters);
void ProcessMux(BDiscreteParameter *parameter, int32 index);
status_t fInitCheckStatus;
BMediaAddOn *fAddOn;
int32 fId; int32 fId;
BList fInputs; BList fInputs;
@ -304,12 +234,12 @@ protected:
// not the defaults that are in the parameters // not the defaults that are in the parameters
bigtime_t fBufferPeriod; bigtime_t fBufferPeriod;
sem_id fBuffer_free; sem_id fBufferFreeSem;
thread_id fThread; thread_id fThread;
MultiAudioDevice *fDevice; MultiAudioDevice* fDevice;
bool fTimeSourceStarted; bool fTimeSourceStarted;
BParameterWeb *fWeb; BParameterWeb* fWeb;
BMessage fConfig; BMessage fConfig;
}; };
#endif /* _MULTIAUDIONODE_H */ #endif // MULTI_AUDIO_NODE_H