/*
 * 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>
#if 0  // HoG_GENODE
#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, ...);
};
#else

class BUrl;
class BMediaTrack;

//namespace hog {
//	class Decoder;
//}
namespace Audio_player {
	class Main;
}


class BMediaFile
{
public:
								BMediaFile(const entry_ref* ref);
								BMediaFile(const BUrl& url);
								~BMediaFile();
			status_t			InitCheck() const;
			
			int32				CountTracks() const;
			BMediaTrack*		TrackAt(int32 index);
			status_t			ReleaseTrack(BMediaTrack* track);
			
			///temp accessors/setters///
			void start();
			void stop();
			bool IsTearingDown() const;
			bigtime_t GenodeaudioProgress() const;
			bigtime_t GenodeaudioDuration() const;
			int64 GeCurrentFrame() const;
			int64 GeCountFrames() const;
			///temp accessors/setters///

private:  // Data

		///support for temp accessors/setters///
	//	hog::Decoder * avDecoder;  // probes the container, looking for tracks
		Audio_player::Main * mainAudio;
		
		BMediaTrack * oneTrack;
};
#endif


#endif

