i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrote headers.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32753 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stephan Aßmus
2009-08-27 13:49:18 +00:00
parent 8780d2073d
commit d95656d79e
4 changed files with 258 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/media/BufferProducer.h
+3 -1
View File
@@ -178,6 +178,8 @@ protected:
void SetInitialLatency(bigtime_t inInitialLatency, void SetInitialLatency(bigtime_t inInitialLatency,
uint32 flags = 0); uint32 flags = 0);
// TODO: Needs a Perform() virtual method!
private: private:
// FBC padding and forbidden methods // FBC padding and forbidden methods
BBufferProducer(); BBufferProducer();
@@ -223,5 +225,5 @@ private:
uint32 _reserved_buffer_producer_[12]; uint32 _reserved_buffer_producer_[12];
}; };
#endif /* _BUFFER_PRODUCER_H */ #endif // _BUFFER_PRODUCER_H
headers/os/media/Controllable.h
+93 -108
View File
@@ -1,139 +1,124 @@
/******************************************************************************* /*
/ * Copyright 2009, Haiku, Inc. All rights reserved.
/ File: Controllable.h * Distributed under the terms of the MIT License.
/ */
/ Description: A BControllable is a BMediaNode with "tweakable" parameters/settings. #ifndef _CONTROLLABLE_H
/
/ Copyright 1997-98, Be Incorporated, All Rights Reserved
/
*******************************************************************************/
#if !defined(_CONTROLLABLE_H)
#define _CONTROLLABLE_H #define _CONTROLLABLE_H
#include <MediaDefs.h>
#include <MediaNode.h> #include <MediaNode.h>
class BParameterWeb; class BParameterWeb;
class BControllable : class BControllable : public virtual BMediaNode {
public virtual BMediaNode
{
protected: protected:
/* Need this to force vtable */ virtual ~BControllable();
virtual ~BControllable();
public: public:
/* BControllable might seem somewhat spartan. */ // Control change requests and notifications typically come in/go out in
// B_MEDIA_PARAMETERS type buffers (and a BControllable thus also needs
// to be a BBufferConsumer and/or a BBufferProducer).
// The format of these buffers is:
// media_node(node),
// int32(count)
// repeat(count) {
// int64(when),
// int32(control_id),
// int32(value_size),
// <value>
// }
/* That is because control change requests and notifications */ BParameterWeb* Web();
/* typically come in/go out in B_MEDIA_PARAMETERS type buffers */ bool LockParameterWeb();
/* (and a BControllable thus also needs to be a BBufferConsumer */ void UnlockParameterWeb();
/* and/or a BBufferProducer) */
/* The format of these buffers is: */
/* media_node(node), int32(count) */
/* repeat(count) { int64(when), int32(control_id), int32(value_size), <value> } */
BParameterWeb * Web();
bool LockParameterWeb();
void UnlockParameterWeb();
protected: protected:
BControllable(); /* call SetParameterWeb() from your constructor */ BControllable();
status_t SetParameterWeb(
BParameterWeb * web);
virtual status_t HandleMessage( // NOTE: Call SetParameterWeb() from your constructor!
int32 message, status_t SetParameterWeb(BParameterWeb* web);
const void * data,
size_t size);
/* Call when the actual control changes, NOT when the value changes. */ virtual status_t HandleMessage(int32 message, const void* data,
/* A typical case would be a CD with a Selector for Track when a new CD is inserted */ size_t size);
status_t BroadcastChangedParameter(
int32 id);
/* Call this function when a value change takes effect, and */ // Call when the actual control changes, NOT when the value changes.
/* you want people who are interested to stay in sync with you. */ // A typical case would be a CD with a Selector for Track when a new
/* Don't call this too densely, though, or you will flood the system */ // CD is inserted.
/* with messages. */ status_t BroadcastChangedParameter(int32 id);
status_t BroadcastNewParameterValue(
bigtime_t when, // performance time
int32 id, // parameter ID
void * newValue,
size_t valueSize);
/* These are alternate methods of accomplishing the same thing as */ // Call this function when a value change takes effect, and
/* connecting to control information source/destinations would. */ // you want people who are interested to stay in sync with you.
virtual status_t GetParameterValue( // Don't call this too densely, though, or you will flood the system
int32 id, // with messages.
bigtime_t * last_change, status_t BroadcastNewParameterValue(
void * value, bigtime_t performanceTime,
size_t * ioSize) = 0; int32 parameterID, void* newValue,
virtual void SetParameterValue( size_t valueSize);
int32 id,
bigtime_t when,
const void * value,
size_t size) = 0;
/* The default implementation of StartControlPanel launches the add-on */ // These are alternate methods of accomplishing the same thing as
/* as an application (if the Node lives in an add-on). Thus, you can write your */ // connecting to control information source/destinations would.
/* control panel as a "main()" in your add-on, and it'll automagically work! */ virtual status_t GetParameterValue(int32 id,
/* Your add-on needs to have multi-launch app flags for this to work right. */ bigtime_t* lastChange,
/* The first argv argument to main() will be a string of the format "node=%d" */ void* value, size_t* ioSize) = 0;
/* with the node ID in question as "%d". */
virtual status_t StartControlPanel(
BMessenger * out_messenger);
/* Call this from your BufferReceived() for control information buffers */ virtual void SetParameterValue(int32 id, bigtime_t when,
/* if you implement BBufferConsumer for that format (recommended!) */ const void* value, size_t size) = 0;
status_t ApplyParameterData(
const void * value, // The default implementation of StartControlPanel launches the add-on
size_t size); // as an application (if the Node lives in an add-on). Thus, you can
/* If you want to generate control information for a set of controls, you */ // write your control panel as a "main()" in your add-on, and it'll
/* can use this utility function. */ // automagically work! Your add-on needs to have multi-launch app flags
status_t MakeParameterData( // for this to work right. The first argv argument to main() will be a
const int32 * controls, // string of the format "node=%d" with the node ID in question as "%d".
int32 count, virtual status_t StartControlPanel(BMessenger* _messenger);
void * buf,
size_t * ioSize); // Call this from your BufferReceived() for control information buffers
// if you implement BBufferConsumer for that format (recommended!)
status_t ApplyParameterData(const void* value,
size_t size);
// If you want to generate control information for a set of controls, you
// can use this utility function.
status_t MakeParameterData(const int32* controls,
int32 count, void* buffer, size_t* ioSize);
// TODO: Needs a Perform() virtual method!
private: private:
// FBC padding and forbidden methods
BControllable(const BControllable& other);
BControllable& operator=(const BControllable& other);
friend class BMediaNode; virtual status_t _Reserved_Controllable_0(void*);
virtual status_t _Reserved_Controllable_1(void*);
virtual status_t _Reserved_Controllable_2(void*);
virtual status_t _Reserved_Controllable_3(void*);
virtual status_t _Reserved_Controllable_4(void*);
virtual status_t _Reserved_Controllable_5(void*);
virtual status_t _Reserved_Controllable_6(void*);
virtual status_t _Reserved_Controllable_7(void*);
virtual status_t _Reserved_Controllable_8(void*);
virtual status_t _Reserved_Controllable_9(void*);
virtual status_t _Reserved_Controllable_10(void*);
virtual status_t _Reserved_Controllable_11(void*);
virtual status_t _Reserved_Controllable_12(void*);
virtual status_t _Reserved_Controllable_13(void*);
virtual status_t _Reserved_Controllable_14(void*);
virtual status_t _Reserved_Controllable_15(void*);
BControllable( /* private unimplemented */ private:
const BControllable & clone); friend class BMediaNode;
BControllable & operator=(
const BControllable & clone);
/* Mmmh, stuffing! */ BParameterWeb* fWeb;
virtual status_t _Reserved_Controllable_0(void *); sem_id fSem;
virtual status_t _Reserved_Controllable_1(void *); int32 fBen;
virtual status_t _Reserved_Controllable_2(void *);
virtual status_t _Reserved_Controllable_3(void *);
virtual status_t _Reserved_Controllable_4(void *);
virtual status_t _Reserved_Controllable_5(void *);
virtual status_t _Reserved_Controllable_6(void *);
virtual status_t _Reserved_Controllable_7(void *);
virtual status_t _Reserved_Controllable_8(void *);
virtual status_t _Reserved_Controllable_9(void *);
virtual status_t _Reserved_Controllable_10(void *);
virtual status_t _Reserved_Controllable_11(void *);
virtual status_t _Reserved_Controllable_12(void *);
virtual status_t _Reserved_Controllable_13(void *);
virtual status_t _Reserved_Controllable_14(void *);
virtual status_t _Reserved_Controllable_15(void *);
BParameterWeb * fWeb; uint32 _reserved_controllable_[14];
sem_id fSem;
int32 fBen;
uint32 _reserved_controllable_[14];
}; };
#endif /* _CONTROLLABLE_H */ #endif // _CONTROLLABLE_H
headers/os/media/FileInterface.h
+45 -71
View File
@@ -1,93 +1,67 @@
/******************************************************************************* /*
/ * Copyright 2009, Haiku, Inc. All rights reserved.
/ File: FileInterface.h * Distributed under the terms of the MIT License.
/ */
/ Description: A BFileInterface is something which can read and/or write files for the #ifndef _FILE_INTERFACE_H
/ use of other Media Kit participants.
/
/ Copyright 1997-98, Be Incorporated, All Rights Reserved
/
*******************************************************************************/
#if !defined(_FILE_INTERFACE_H)
#define _FILE_INTERFACE_H #define _FILE_INTERFACE_H
#include <MediaDefs.h>
#include <MediaNode.h> #include <MediaNode.h>
struct entry_ref; struct entry_ref;
class BFileInterface : class BFileInterface : public virtual BMediaNode {
public virtual BMediaNode
{
protected: protected:
virtual ~BFileInterface();
virtual ~BFileInterface(); /* force vtable */
public:
/* look, no hands! */
protected: protected:
BFileInterface();
BFileInterface(); virtual status_t HandleMessage(int32 message, const void* data,
virtual status_t HandleMessage( size_t size);
int32 message,
const void * data,
size_t size);
virtual status_t GetNextFileFormat( virtual status_t GetNextFileFormat(int32* cookie,
int32 * cookie, media_file_format* _format) = 0;
media_file_format * out_format) = 0; virtual void DisposeFileFormatCookie(int32 cookie) = 0;
virtual void DisposeFileFormatCookie(
int32 cookie) = 0;
virtual status_t GetDuration( virtual status_t GetDuration(bigtime_t* _time) = 0;
bigtime_t * out_time) = 0; virtual status_t SniffRef(const entry_ref& file,
virtual status_t SniffRef( char* _mimeType, // 256 bytes
const entry_ref & file, float* _quality) = 0;
char * out_mime_type, /* 256 bytes */ virtual status_t SetRef(const entry_ref& file,
float * out_quality) = 0; bool create, bigtime_t* _time) = 0;
virtual status_t SetRef( virtual status_t GetRef(entry_ref* _ref, char* _mimeType) = 0;
const entry_ref & file,
bool create, // TODO: Needs a Perform() virtual method!
bigtime_t * out_time) = 0;
virtual status_t GetRef(
entry_ref * out_ref,
char * out_mime_type) = 0;
private: private:
// FBC padding and forbidden methods
friend class BMediaNode; friend class BMediaNode;
BFileInterface( /* private unimplemented */ BFileInterface(const BFileInterface& other);
const BFileInterface & clone); BFileInterface& operator=(const BFileInterface& other);
BFileInterface & operator=(
const BFileInterface & clone);
/* Mmmh, stuffing! */ virtual status_t _Reserved_FileInterface_0(void*);
virtual status_t _Reserved_FileInterface_0(void *); virtual status_t _Reserved_FileInterface_1(void*);
virtual status_t _Reserved_FileInterface_1(void *); virtual status_t _Reserved_FileInterface_2(void*);
virtual status_t _Reserved_FileInterface_2(void *); virtual status_t _Reserved_FileInterface_3(void*);
virtual status_t _Reserved_FileInterface_3(void *); virtual status_t _Reserved_FileInterface_4(void*);
virtual status_t _Reserved_FileInterface_4(void *); virtual status_t _Reserved_FileInterface_5(void*);
virtual status_t _Reserved_FileInterface_5(void *); virtual status_t _Reserved_FileInterface_6(void*);
virtual status_t _Reserved_FileInterface_6(void *); virtual status_t _Reserved_FileInterface_7(void*);
virtual status_t _Reserved_FileInterface_7(void *); virtual status_t _Reserved_FileInterface_8(void*);
virtual status_t _Reserved_FileInterface_8(void *); virtual status_t _Reserved_FileInterface_9(void*);
virtual status_t _Reserved_FileInterface_9(void *); virtual status_t _Reserved_FileInterface_10(void*);
virtual status_t _Reserved_FileInterface_10(void *); virtual status_t _Reserved_FileInterface_11(void*);
virtual status_t _Reserved_FileInterface_11(void *); virtual status_t _Reserved_FileInterface_12(void*);
virtual status_t _Reserved_FileInterface_12(void *); virtual status_t _Reserved_FileInterface_13(void*);
virtual status_t _Reserved_FileInterface_13(void *); virtual status_t _Reserved_FileInterface_14(void*);
virtual status_t _Reserved_FileInterface_14(void *); virtual status_t _Reserved_FileInterface_15(void*);
virtual status_t _Reserved_FileInterface_15(void *);
uint32 _reserved_file_interface_[16];
uint32 _reserved_file_interface_[16];
}; };
#endif // _FILE_INTERFACE_H
#endif /* _FILE_INTERFACE_H */
headers/os/media/MediaAddOn.h
+117 -124
View File
@@ -1,181 +1,174 @@
/******************************************************************************* /*
/ * Copyright 2009, Haiku, Inc. All rights reserved.
/ File: MediaAddOn.h * Distributed under the terms of the MIT License.
/ */
/ Description: A BMediaAddOn is created by Media Kit add-ons to instantiate and #ifndef _MEDIA_ADD_ON_H
/ handle "latent" Nodes.
/
/ Copyright 1997-98, Be Incorporated, All Rights Reserved
/
*******************************************************************************/
#if !defined(_MEDIA_ADD_ON_H)
#define _MEDIA_ADD_ON_H #define _MEDIA_ADD_ON_H
#include <image.h> #include <image.h>
#include <MediaDefs.h> #include <MediaDefs.h>
#include <Flattenable.h> #include <Flattenable.h>
class BMediaNode; class BMediaNode;
class BMimeType; class BMimeType;
struct entry_ref; struct entry_ref;
struct dormant_node_info { struct dormant_node_info {
dormant_node_info(); dormant_node_info();
~dormant_node_info(); ~dormant_node_info();
media_addon_id addon;
int32 flavor_id;
char name[B_MEDIA_NAME_LENGTH];
media_addon_id addon;
int32 flavor_id;
char name[B_MEDIA_NAME_LENGTH];
private: private:
char reserved[128]; char reserved[128];
}; };
enum // flavor_flags
{ // flavor_flags enum {
B_FLAVOR_IS_GLOBAL = 0x100000L, // force in media_addon_server, only one instance B_FLAVOR_IS_GLOBAL = 0x100000L, // force in media_addon_server,
B_FLAVOR_IS_LOCAL = 0x200000L // force in loading app, many instances // only one instance
// if none is set, could go either way B_FLAVOR_IS_LOCAL = 0x200000L // force in loading app, many
// instances if none is set, could
// go either way
}; };
struct flavor_info { struct flavor_info {
char * name; char* name;
char * info; char* info;
uint64 kinds; /* node_kind */ uint64 kinds; // node kind
uint32 flavor_flags; uint32 flavor_flags;
int32 internal_id; /* For BMediaAddOn internal use */ int32 internal_id; // For BMediaAddOn internal use
int32 possible_count; /* 0 for "any number" */ int32 possible_count; // 0 for "any number"
int32 in_format_count; /* for BufferConsumer kinds */ int32 in_format_count; // for BufferConsumer kinds
uint32 in_format_flags; /* set to 0 */ uint32 in_format_flags; // set to 0
const media_format * in_formats; const media_format* in_formats;
int32 out_format_count; /* for BufferProducer kinds */ int32 out_format_count; // for BufferProducer kinds
uint32 out_format_flags; /* set to 0 */ uint32 out_format_flags; // set to 0
const media_format * out_formats; const media_format* out_formats;
uint32 _reserved_[16]; uint32 _reserved_[16];
private: private:
flavor_info & operator=(const flavor_info & other); flavor_info& operator=(const flavor_info& other);
}; };
struct dormant_flavor_info : public flavor_info, public BFlattenable { struct dormant_flavor_info : public flavor_info, public BFlattenable {
dormant_flavor_info();
virtual ~dormant_flavor_info();
dormant_flavor_info(); dormant_flavor_info(
virtual ~dormant_flavor_info(); const dormant_flavor_info& other);
dormant_flavor_info(const dormant_flavor_info &); dormant_flavor_info& operator=(const dormant_flavor_info& other);
dormant_flavor_info& operator=(const dormant_flavor_info &); dormant_flavor_info& operator=(const flavor_info& other);
dormant_flavor_info& operator=(const flavor_info &);
dormant_node_info node_info; dormant_node_info node_info;
void set_name(const char * in_name); void set_name(const char* name);
void set_info(const char * in_info); void set_info(const char* info);
void add_in_format(const media_format & in_format); void add_in_format(const media_format& format);
void add_out_format(const media_format & out_format); void add_out_format(const media_format& format);
virtual bool IsFixedSize() const; virtual bool IsFixedSize() const;
virtual type_code TypeCode() const; virtual type_code TypeCode() const;
virtual ssize_t FlattenedSize() const; virtual ssize_t FlattenedSize() const;
virtual status_t Flatten(void *buffer, ssize_t size) const; virtual status_t Flatten(void* buffer, ssize_t size) const;
virtual status_t Unflatten(type_code c, const void *buf, ssize_t size); virtual status_t Unflatten(type_code type, const void* buffer,
ssize_t size);
}; };
namespace BPrivate { namespace BPrivate {
namespace media { namespace media {
class DormantNodeManager; class DormantNodeManager;
}; };
}; };
/* a MediaAddOn is something which can manufacture MediaNodes */
class BMediaAddOn //! a MediaAddOn is something which can manufacture MediaNodes
{ class BMediaAddOn {
public: public:
explicit BMediaAddOn( explicit BMediaAddOn(image_id image);
image_id image); virtual ~BMediaAddOn();
virtual ~BMediaAddOn();
virtual status_t InitCheck( virtual status_t InitCheck(const char** _failureText);
const char ** out_failure_text); virtual int32 CountFlavors();
virtual int32 CountFlavors(); virtual status_t GetFlavorAt(int32 index,
virtual status_t GetFlavorAt( const flavor_info** _info);
int32 n, virtual BMediaNode* InstantiateNodeFor(const flavor_info* info,
const flavor_info ** out_info); BMessage* config, status_t* _error);
virtual BMediaNode * InstantiateNodeFor( virtual status_t GetConfigurationFor(BMediaNode* yourNode,
const flavor_info * info, BMessage* intoMessage);
BMessage * config, virtual bool WantsAutoStart();
status_t * out_error); virtual status_t AutoStart(int index, BMediaNode** _node,
virtual status_t GetConfigurationFor( int32* _internalID, bool* _hasMore);
BMediaNode * your_node,
BMessage * into_message);
virtual bool WantsAutoStart();
virtual status_t AutoStart(
int in_index,
BMediaNode ** out_node,
int32 * out_internal_id,
bool * out_has_more);
/* only implement if you have a B_FILE_INTERFACE node */
virtual status_t SniffRef(
const entry_ref & file,
BMimeType * io_mime_type,
float * out_quality,
int32 * out_internal_id);
virtual status_t SniffType( // This is broken if you deal with producers
const BMimeType & type, // and consumers both. Use SniffTypeKind instead.
float * out_quality, // If you implement SniffTypeKind, this doesn't
int32 * out_internal_id); // get called.
virtual status_t GetFileFormatList(
int32 flavor_id, // for this node flavor (if it matters)
media_file_format * out_writable_formats, // don't write here if NULL
int32 in_write_items, // this many slots in out_writable_formats
int32 * out_write_items, // set this to actual # available, even if bigger than in count
media_file_format * out_readable_formats, // don't write here if NULL
int32 in_read_items, // this many slots in out_readable_formats
int32 * out_read_items, // set this to actual # available, even if bigger than in count
void * _reserved); // ignore until further notice
virtual status_t SniffTypeKind( // Like SniffType, but for the specific kind(s)
const BMimeType & type,
uint64 in_kinds,
float * out_quality,
int32 * out_internal_id,
void * _reserved);
image_id ImageID(); // NOTE: Only implement if you have a B_FILE_INTERFACE node
media_addon_id AddonID(); virtual status_t SniffRef(const entry_ref& file,
BMimeType* ioMimeType, float* _quality,
int32* _internalID);
// NOTE: This is broken if you deal with producers and consumers both.
// Implement SniffTypeKind instead. If you implement SniffTypeKind, this
// doesn't get called.
virtual status_t SniffType(const BMimeType& type,
float* _quality, int32* _internalID);
virtual status_t GetFileFormatList(int32 forNodeFlavorID,
media_file_format* _writableFormats,
int32 writableFormatsCount,
int32* _writableFormatsTotalCount,
media_file_format* _readableFormats,
int32 readableFormatsCount,
int32* _readableFormatsTotalCount,
void* _reserved);
// NOTE: Like SniffType, but for the specific kind(s)
virtual status_t SniffTypeKind(const BMimeType& type,
uint64 kinds, float* _quality,
int32* _internalID, void* _reserved);
image_id ImageID();
media_addon_id AddonID();
protected: protected:
// Calling this will cause everyone to get notified, and also
// cause the server to re-scan your flavor info. It is thread safe.
status_t NotifyFlavorChange();
// Calling this will cause everyone to get notified, and also // TODO: Needs a Perform() virtual method!
// cause the server to re-scan your flavor info. It is thread safe.
status_t NotifyFlavorChange();
private: private:
BMediaAddOn(); /* private unimplemented */ // FBC padding and forbidden methods
BMediaAddOn(const BMediaAddOn & clone); BMediaAddOn();
BMediaAddOn & operator=(const BMediaAddOn & clone); BMediaAddOn(const BMediaAddOn& other);
BMediaAddOn& operator=(const BMediaAddOn& other);
friend class BPrivate::media::DormantNodeManager; friend class BPrivate::media::DormantNodeManager;
/* Mmmh, stuffing! */ virtual status_t _Reserved_MediaAddOn_2(void*);
virtual status_t _Reserved_MediaAddOn_2(void *); virtual status_t _Reserved_MediaAddOn_3(void*);
virtual status_t _Reserved_MediaAddOn_3(void *); virtual status_t _Reserved_MediaAddOn_4(void*);
virtual status_t _Reserved_MediaAddOn_4(void *); virtual status_t _Reserved_MediaAddOn_5(void*);
virtual status_t _Reserved_MediaAddOn_5(void *); virtual status_t _Reserved_MediaAddOn_6(void*);
virtual status_t _Reserved_MediaAddOn_6(void *); virtual status_t _Reserved_MediaAddOn_7(void*);
virtual status_t _Reserved_MediaAddOn_7(void *);
image_id fImage; image_id fImage;
media_addon_id fAddon; media_addon_id fAddon;
uint32 _reserved_media_add_on_[7];
uint32 _reserved_media_add_on_[7];
}; };
#if BUILDING_MEDIA_ADDON #if BUILDING_MEDIA_ADDON
extern "C" _EXPORT BMediaAddOn * make_media_addon(image_id you); extern "C" _EXPORT BMediaAddOn* make_media_addon(image_id yourImage);
#endif #endif
#endif /* _MEDIA_ADD_ON_H */ #endif // _MEDIA_ADD_ON_H