256 lines
8.8 KiB
C++
256 lines
8.8 KiB
C++
/*
|
|
* Copyright 2002-2009, Haiku, Inc. All rights reserved.
|
|
* Distributed under the terms of the MIT license.
|
|
*/
|
|
#ifndef _MEDIA_FILE_H
|
|
#define _MEDIA_FILE_H
|
|
|
|
|
|
#include <image.h>
|
|
#include <List.h>
|
|
#include <MediaDefs.h>
|
|
#include <MediaFormats.h>
|
|
#include <StorageDefs.h>
|
|
|
|
|
|
namespace BPrivate {
|
|
namespace media {
|
|
class MediaExtractor;
|
|
class MediaStreamer;
|
|
class MediaWriter;
|
|
}
|
|
class _AddonManager;
|
|
}
|
|
|
|
|
|
// forward declarations
|
|
class BMediaTrack;
|
|
class BMessage;
|
|
class BParameterWeb;
|
|
class BUrl;
|
|
class BView;
|
|
|
|
|
|
// flags for the BMediaFile constructor
|
|
enum {
|
|
B_MEDIA_FILE_REPLACE_MODE = 0x00000001,
|
|
B_MEDIA_FILE_NO_READ_AHEAD = 0x00000002,
|
|
B_MEDIA_FILE_UNBUFFERED = 0x00000006,
|
|
B_MEDIA_FILE_BIG_BUFFERS = 0x00000008
|
|
};
|
|
|
|
// BMediaFile represents a media file (AVI, Quicktime, MPEG, AIFF, WAV, etc)
|
|
//
|
|
// To read a file you construct a BMediaFile with an entry_ref, get the
|
|
// BMediaTracks out of it and use those to read the data.
|
|
//
|
|
// To write a file you construct a BMediaFile with an entry ref and an id as
|
|
// returned by get_next_file_format(). You then CreateTrack() to create
|
|
// various audio & video tracks. Once you're done creating tracks, call
|
|
// CommitHeader(), then write data to each track and call CloseFile() when
|
|
// you're done.
|
|
//
|
|
|
|
class BMediaFile {
|
|
public:
|
|
// these four constructors are used for read-only access
|
|
BMediaFile(const entry_ref* ref);
|
|
BMediaFile(BDataIO* source);
|
|
// BFile is a BDataIO
|
|
BMediaFile(const entry_ref* ref, int32 flags);
|
|
BMediaFile(BDataIO* source, int32 flags);
|
|
|
|
// these three constructors are for read-write access
|
|
BMediaFile(const entry_ref* ref,
|
|
const media_file_format* mfi,
|
|
int32 flags = 0);
|
|
BMediaFile(BDataIO* destination,
|
|
const media_file_format* mfi,
|
|
int32 flags = 0);
|
|
BMediaFile(const media_file_format* mfi,
|
|
int32 flags = 0);
|
|
// set file later using SetTo()
|
|
|
|
// Additional constructors used to stream data from protocols
|
|
// supported by the Streamer API
|
|
BMediaFile(const BUrl& url);
|
|
BMediaFile(const BUrl& url, int32 flags);
|
|
// Read-Write streaming constructor
|
|
BMediaFile(const BUrl& destination,
|
|
const media_file_format* mfi,
|
|
int32 flags = 0);
|
|
|
|
virtual ~BMediaFile();
|
|
|
|
status_t SetTo(const entry_ref* ref);
|
|
status_t SetTo(BDataIO* destination);
|
|
// The streaming equivalent of SetTo
|
|
status_t SetTo(const BUrl& url);
|
|
|
|
status_t InitCheck() const;
|
|
|
|
// Get info about the underlying file format.
|
|
status_t GetFileFormatInfo(
|
|
media_file_format* mfi) const;
|
|
|
|
// Returns in _data hierarchical meta-data about the stream.
|
|
// The fields in the message shall follow a defined naming-scheme,
|
|
// such that applications can find the same information in different
|
|
// types of files.
|
|
status_t GetMetaData(BMessage* _data) const;
|
|
|
|
//
|
|
// These functions are for read-only access to a media file.
|
|
// The data is read using the BMediaTrack object.
|
|
//
|
|
const char* Copyright() const;
|
|
int32 CountTracks() const;
|
|
|
|
// Can be called multiple times with the same index. You must call
|
|
// ReleaseTrack() when you're done with a track.
|
|
BMediaTrack* TrackAt(int32 index);
|
|
|
|
// Release the resource used by a given BMediaTrack object, to reduce
|
|
// the memory usage of your application. The specific 'track' object
|
|
// can no longer be used, but you can create another one by calling
|
|
// TrackAt() with the same track index.
|
|
status_t ReleaseTrack(BMediaTrack* track);
|
|
|
|
// A convenience. Deleting a BMediaFile will also call this.
|
|
status_t ReleaseAllTracks();
|
|
|
|
|
|
// Create and add a track to the media file
|
|
BMediaTrack* CreateTrack(media_format* mf,
|
|
const media_codec_info* mci,
|
|
uint32 flags = 0);
|
|
// Create and add a raw track to the media file (it has no encoder)
|
|
BMediaTrack* CreateTrack(media_format* mf,
|
|
uint32 flags = 0);
|
|
|
|
// Lets you set the copyright info for the entire file
|
|
status_t AddCopyright(const char* data);
|
|
|
|
// Call this to add user-defined chunks to a file (if they're supported)
|
|
status_t AddChunk(int32 type, const void* data,
|
|
size_t size);
|
|
|
|
// After you have added all the tracks you want, call this
|
|
status_t CommitHeader();
|
|
|
|
// After you have written all the data to the track objects, call this
|
|
status_t CloseFile();
|
|
|
|
// This is for controlling file format parameters
|
|
|
|
// returns a copy of the parameter web
|
|
status_t GetParameterWeb(BParameterWeb** outWeb);
|
|
status_t GetParameterValue(int32 id, void* value,
|
|
size_t* size);
|
|
status_t SetParameterValue(int32 id, const void* value,
|
|
size_t size);
|
|
BView* GetParameterView();
|
|
|
|
// For the future...
|
|
virtual status_t Perform(int32 selector, void* data);
|
|
|
|
private:
|
|
// deprecated, but for R5 compatibility
|
|
BParameterWeb* Web();
|
|
|
|
// Does nothing, returns B_ERROR, for Zeta compatiblity only
|
|
status_t ControlFile(int32 selector, void* ioData,
|
|
size_t size);
|
|
|
|
BPrivate::media::MediaExtractor* fExtractor;
|
|
int32 _reserved_BMediaFile_was_fExtractorID;
|
|
int32 fTrackNum;
|
|
status_t fErr;
|
|
|
|
BPrivate::_AddonManager* fEncoderMgr;
|
|
BPrivate::_AddonManager* fWriterMgr;
|
|
BPrivate::media::MediaWriter* fWriter;
|
|
int32 fWriterID;
|
|
media_file_format fMFI;
|
|
|
|
BPrivate::media::MediaStreamer* fStreamer;
|
|
|
|
bool fFileClosed;
|
|
bool fDeleteSource;
|
|
bool _reserved_was_fUnused[2];
|
|
BMediaTrack** fTrackList;
|
|
|
|
void _Init();
|
|
void _UnInit();
|
|
void _InitReader(BDataIO* source,
|
|
const BUrl* url = NULL,
|
|
int32 flags = 0);
|
|
void _InitWriter(BDataIO* target,
|
|
const BUrl* url,
|
|
const media_file_format* fileFormat,
|
|
int32 flags);
|
|
void _InitStreamer(const BUrl& url,
|
|
BDataIO** adapter);
|
|
|
|
BMediaFile();
|
|
BMediaFile(const BMediaFile&);
|
|
BMediaFile& operator=(const BMediaFile&);
|
|
|
|
BDataIO* fSource;
|
|
|
|
// FBC data and virtuals
|
|
|
|
uint32 _reserved_BMediaFile_[31];
|
|
|
|
virtual status_t _Reserved_BMediaFile_0(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_1(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_2(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_3(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_4(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_5(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_6(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_7(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_8(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_9(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_10(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_11(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_12(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_13(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_14(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_15(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_16(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_17(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_18(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_19(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_20(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_21(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_22(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_23(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_24(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_25(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_26(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_27(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_28(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_29(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_30(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_31(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_32(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_33(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_34(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_35(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_36(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_37(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_38(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_39(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_40(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_41(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_42(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_43(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_44(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_45(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_46(int32 arg, ...);
|
|
virtual status_t _Reserved_BMediaFile_47(int32 arg, ...);
|
|
};
|
|
|
|
#endif
|