haiku.git

// MediaReader.cpp
//
// Andrew Bachmann, 2002
//
// A MediaReader is a node that
// implements FileInterface and BBufferProducer.
// It reads any file and produces one output,
// which is a multistream.
//
// see also MediaReaderAddOn.cpp
#include "../AbstractFileInterfaceNode.h"
#include "MediaReader.h"
#include "../misc.h"
#include "debug.h"

#include <Buffer.h>
#include <BufferGroup.h>
#include <BufferProducer.h>
#include <Controllable.h>
#include <Entry.h>
#include <Errors.h>
#include <File.h>
#include <FileInterface.h>
#include <MediaAddOn.h>
#include <MediaDefs.h>
#include <MediaEventLooper.h>
#include <MediaNode.h>
#include <MediaRoster.h>
#include <ParameterWeb.h>
#include <TimeSource.h>


#include <limits.h>
#include <stdio.h>
#include <string.h>


MediaReader::~MediaReader(void)
{
	fprintf(stderr,"MediaReader::~MediaReader\n");
	if (fBufferGroup != 0) {
		BBufferGroup * group = fBufferGroup;
		fBufferGroup = 0;
		delete group;
	}	
}


MediaReader::MediaReader(
				size_t defaultChunkSize,
				float defaultBitRate,
				const flavor_info * info,
				BMessage * config,
				BMediaAddOn * addOn)
	: BMediaNode("MediaReader"),
	  BBufferProducer(B_MEDIA_MULTISTREAM),
	  AbstractFileInterfaceNode(defaultChunkSize, defaultBitRate, info, config, addOn)
{
	CALLED();

	// null some fields
	fBufferGroup = 0;	
	// start enabled
	fOutputEnabled = true;
	// don't overwrite available space, and be sure to terminate
	strncpy(output.name,"MediaReader Output",B_MEDIA_NAME_LENGTH-1);
	output.name[B_MEDIA_NAME_LENGTH-1] = '\0';
	// initialize the output
	output.node = media_node::null;     // until registration
	output.source = media_source::null; // until registration
	output.destination = media_destination::null;
	GetFormat(&output.format);
}


// -------------------------------------------------------- //
// implementation of BMediaNode
// -------------------------------------------------------- //
void MediaReader::Preroll(void)
{
	CALLED();
	// XXX:Performance opportunity
	BMediaNode::Preroll();
}


status_t MediaReader::HandleMessage(
				int32 message,
				const void * data,
				size_t size)
{
	CALLED();

	status_t status = B_OK;

	switch (message) {
		// no special messages for now
		default:
			status = BBufferProducer::HandleMessage(message,data,size);
			if (status == B_OK) {
				break;
			}
			status = AbstractFileInterfaceNode::HandleMessage(message,data,size);
			break;
	}

	return status;
}


void MediaReader::NodeRegistered(void)
{
	CALLED();
	
	// now we can do this
	output.node = Node();
	output.source.id = 0;
	output.source.port = output.node.port; // same as ControlPort();

	// creates the parameter web and starts the looper thread
	AbstractFileInterfaceNode::NodeRegistered();
}


// -------------------------------------------------------- //
// implementation of BFileInterface
// -------------------------------------------------------- //
status_t MediaReader::SetRef(
				const entry_ref & file,
				bool create,
				bigtime_t * out_time)
{
	CALLED();

	status_t status = AbstractFileInterfaceNode::SetRef(file,B_READ_ONLY,create,out_time);
	if (status != B_OK) {
		PRINT("AbstractFileInterfaceNode::SetRef returned an error\n");
		return status;
	}

	if (output.destination == media_destination::null) {
		// reset the format, and set the requirements imposed by this file
		GetFormat(&output.format);
		AddRequirements(&output.format);
		return B_OK;
	}

	// if we are connected we may have to re-negotiate the connection
	media_format format;
	GetFormat(&format);
	AddRequirements(&format);
	if (format_is_acceptible(format,output.format)) {
		fprintf(stderr,"  compatible format = no re-negotiation necessary\n");
		return B_OK;
	}
	// first try the easy way : SORRY DEPRECATED into private :-(
	// this code from MediaWriter would be different for MediaReader even if it worked...
	//	int32 change_tag = NewChangeTag();
	//	status = this->BBufferConsumer::RequestFormatChange(output.source,output.destination,&format,&change_tag);
	//	if (status == B_OK) {
	//		fprintf(stderr,"  format change successful\n");
	//		return B_OK;
	//	}

	// okay, the hard way requires we get the MediaRoster
	BMediaRoster * roster = BMediaRoster::Roster(&status);
	if (roster == 0)
		return B_MEDIA_SYSTEM_FAILURE;

	if (status != B_OK)
		return status;

	// before disconnect one should always stop the nodes (bebook says)
	// requires run_state cast since the return type on RunState() is
	// wrong [int32]
	run_state destinationRunState = run_state(RunState());
	if (destinationRunState == BMediaEventLooper::B_STARTED)
		Stop(0,true); // stop us right now

	// should also stop the destination if it is running, but how?
	/*	BMediaNode destinationNode = ??
	run_state destinationRunState = destinationNode->??;
	status = destinationNode->StopNode(??,0,true);
	if (status != B_OK) {
		return status;
	}  */
	// we should disconnect right now
	media_destination outputDestination = output.destination;
	status = roster->Disconnect(output.source.id,output.source,
							    output.destination.id,output.destination);
	if (status != B_OK)
		return status;

	// if that went okay, we'll try reconnecting	
	media_output connectOutput;
	media_input connectInput;
	status = roster->Connect(output.source,outputDestination,
							 &format,&connectOutput,&connectInput);
	if (status != B_OK)
		return status;

	// now restart if necessary
	if (destinationRunState == BMediaEventLooper::B_STARTED) {
		Start(0);
	}							 
	return status;
}


// -------------------------------------------------------- //
// implemention of BBufferProducer
// -------------------------------------------------------- //

// They are asking us to make the first offering.
// So, we get a fresh format and then add requirements based
// on the current file. (if any)
status_t MediaReader::FormatSuggestionRequested(
				media_type type,
				int32 quality,
				media_format * format)
{
	CALLED();

	if ((type != B_MEDIA_MULTISTREAM) && (type != B_MEDIA_UNKNOWN_TYPE)) {
		PRINT("\t<- B_MEDIA_BAD_FORMAT\n");
		return B_MEDIA_BAD_FORMAT;
	}

	GetFormat(format);
	AddRequirements(format);
	return B_OK;
}


// They made an offer to us.  We should make sure that the offer is
// acceptable, and then we can add any requirements we have on top of
// that.  We leave wildcards for anything that we don't care about.
status_t MediaReader::FormatProposal(
				const media_source & output_source,
				media_format * format)
{
	CALLED();

	if (output.source != output_source) {
		PRINT("\t<- B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE; // we only have one output so that better be it
	}
	/*	media_format * myFormat = GetFormat();
	fprintf(stderr,"proposed format: ");
	print_media_format(format);
	fprintf(stderr,"\n");
	fprintf(stderr,"my format: ");
	print_media_format(myFormat);
	fprintf(stderr,"\n"); */
	// Be's format_is_compatible doesn't work.
	//	if (!format_is_compatible(*format,*myFormat)) {
	media_format myFormat;
	GetFormat(&myFormat);
	if (!format_is_acceptible(*format,myFormat)) {
		PRINT("\t<- B_MEDIA_BAD_FORMAT\n");
		return B_MEDIA_BAD_FORMAT;
	}
	AddRequirements(format);
	return B_OK;
}


// Presumably we have already agreed with them that this format is
// okay.  But just in case, we check the offer. (and complain if it
// is invalid)  Then as the last thing we do, we get rid of any
// remaining wilcards.
status_t MediaReader::FormatChangeRequested(
				const media_source & source,
				const media_destination & destination,
				media_format * io_format,
				int32 * _deprecated_)
{
	CALLED();

	if (output.source != source) {
		PRINT("\t<- B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE;
	}	
	status_t status = FormatProposal(source,io_format);
	if (status != B_OK) {
		PRINT("\terror returned by FormatProposal\n");
		GetFormat(io_format);
		return status;
	}

	return ResolveWildcards(io_format);
}


status_t MediaReader::GetNextOutput(	/* cookie starts as 0 */
				int32 * cookie,
				media_output * out_output)
{
	CALLED();

	if (*cookie != 0) {
		PRINT("\t<- B_ERROR (no more outputs)\n");
		return B_ERROR;
	}

	// so next time they won't get the same output again
	*cookie = 1;
	*out_output = output;
	return B_OK;
}


status_t MediaReader::DisposeOutputCookie(
				int32 cookie)
{
	CALLED();
	// nothing to do since our cookies are just integers
	return B_OK;
}


status_t MediaReader::SetBufferGroup(
				const media_source & for_source,
				BBufferGroup * group)
{
	CALLED();

	if (output.source != for_source) {
		PRINT("\t<- B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE; // we only have one output so that better be it
	}
	if (fBufferGroup != 0) {
		if (fBufferGroup == group)
			return B_OK; // time saver
		delete fBufferGroup;
	}
	if (group != 0) {
		fBufferGroup = group;
	} else {
		// let's take advantage of this opportunity to recalculate
		// our downstream latency and ensure that it is up to date
		media_node_id id;
		FindLatencyFor(output.destination, &fDownstreamLatency, &id);
		// buffer period gets initialized in Connect() because
		// that is the first time we get the real values for
		// chunk size and bit rate, which are used to compute buffer period
		// note: you can still make a buffer group before connecting (why?)
		//       but we don't make it, you make it yourself and pass it here.
		//       not sure why anybody would want to do that since they need
		//       a connection anyway...
		if (fBufferPeriod <= 0) {
			fprintf(stderr,"<- B_NO_INIT");
			return B_NO_INIT;
		}
		int32 count = int32(fDownstreamLatency/fBufferPeriod)+2;
		PRINT("\tdownstream latency = %lld, buffer period = %lld, buffer count = %ld\n",
				fDownstreamLatency, fBufferPeriod, count);

		// allocate the buffers
		fBufferGroup = new BBufferGroup(output.format.u.multistream.max_chunk_size,count);
		if (fBufferGroup == 0) {
			PRINT("\t<- B_NO_MEMORY\n");
			return B_NO_MEMORY;
		}
		status_t status = fBufferGroup->InitCheck();
		if (status != B_OK) {
			PRINT("\t<- fBufferGroup initialization failed\n");
			return status;
		}
	}
	return B_OK;
}


/* Format of clipping is (as int16-s): <from line> <npairs> <startclip> <endclip>. */
/* Repeat for each line where the clipping is different from the previous line. */
/* If <npairs> is negative, use the data from line -<npairs> (there are 0 pairs after */
/* a negative <npairs>. Yes, we only support 32k*32k frame buffers for clipping. */
/* Any non-0 field of 'display' means that that field changed, and if you don't support */
/* that change, you should return an error and ignore the request. Note that the buffer */
/* offset values do not have wildcards; 0 (or -1, or whatever) are real values and must */
/* be adhered to. */
status_t MediaReader::VideoClippingChanged(
				const media_source & for_source,
				int16 num_shorts,
				int16 * clip_data,
				const media_video_display_info & display,
				int32 * _deprecated_)
{
	return BBufferProducer::VideoClippingChanged(for_source,num_shorts,clip_data,display,_deprecated_);
}


status_t MediaReader::GetLatency(
				bigtime_t * out_latency)
{
	CALLED();

	*out_latency = EventLatency() + SchedulingLatency();
	return B_OK;
}


status_t MediaReader::PrepareToConnect(
				const media_source & what,
				const media_destination & where,
				media_format * format,
				media_source * out_source,
				char * out_name)
{
	CALLED();

	if (output.source != what) {
		PRINT("\t<- B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE;
	}	
	if (output.destination != media_destination::null) {
		PRINT("\t<- B_MEDIA_ALREADY_CONNECTED\n");
		return B_MEDIA_ALREADY_CONNECTED;
	}

	status_t status = FormatChangeRequested(output.source,where,format,0);
	if (status != B_OK) {
		PRINT("\t<- MediaReader::FormatChangeRequested failed\n");
		return status;
	}

	// last check for wildcards and general validity
	if (format->type != B_MEDIA_MULTISTREAM) {
		PRINT("\t<- B_MEDIA_BAD_FORMAT\n");
		return B_MEDIA_BAD_FORMAT;
	}

	*out_source = output.source;
	output.destination = where;
	strncpy(out_name,output.name,B_MEDIA_NAME_LENGTH-1);
	out_name[B_MEDIA_NAME_LENGTH] = '\0';
	return ResolveWildcards(format);
}


void MediaReader::Connect(
				status_t error, 
				const media_source & source,
				const media_destination & destination,
				const media_format & format,
				char * io_name)
{
	CALLED();

	if (error != B_OK) {
		PRINT("\t<- error already\n");
		output.destination = media_destination::null;
		GetFormat(&output.format);
		return;
	}
	if (output.source != source) {
		PRINT("\t<- B_MEDIA_BAD_SOURCE\n");
		output.destination = media_destination::null;
		GetFormat(&output.format);
		return;
	}	
	
	// record the agreed upon values
	output.destination = destination;
	output.format = format;
	strncpy(io_name,output.name,B_MEDIA_NAME_LENGTH-1);
	io_name[B_MEDIA_NAME_LENGTH-1] = '\0';

	// determine our downstream latency
	media_node_id id;
	FindLatencyFor(output.destination, &fDownstreamLatency, &id);

	// compute the buffer period (must be done before setbuffergroup)
	fBufferPeriod = bigtime_t(1000u * 8000000u / 1024u
	                     * output.format.u.multistream.max_chunk_size
			             / output.format.u.multistream.max_bit_rate);

	PRINT("\tmax chunk size = %ld, max bit rate = %f, buffer period = %lld\n",
			output.format.u.multistream.max_chunk_size,
			output.format.u.multistream.max_bit_rate,fBufferPeriod);

	// setup the buffers if they aren't setup yet
	if (fBufferGroup == 0) {
		status_t status = SetBufferGroup(output.source,0);
		if (status != B_OK) {
			PRINT("\t<- SetBufferGroup failed\n");
			output.destination = media_destination::null;
			GetFormat(&output.format);
			return;
		}
	}

	SetBufferDuration(fBufferPeriod);

	if (GetCurrentFile() != 0) {
		bigtime_t start, end;
		// buffer group buffer size
		uint8 * data = new uint8[output.format.u.multistream.max_chunk_size];
		BBuffer * buffer = 0;
		ssize_t bytesRead = 0;
		{ // timed section
			start = TimeSource()->RealTime();
			// first we try to use a real BBuffer
			buffer = fBufferGroup->RequestBuffer(
					output.format.u.multistream.max_chunk_size,fBufferPeriod);
			if (buffer != 0) {
				FillFileBuffer(buffer);
			} else {
				// didn't get a real BBuffer, try simulation by just a read from the disk
				bytesRead = GetCurrentFile()->Read(
						data, output.format.u.multistream.max_chunk_size);
			}
			end = TimeSource()->RealTime();
		}
		bytesRead = buffer->SizeUsed();
		delete[] data;
		if (buffer != 0) {
			buffer->Recycle();
		}
		GetCurrentFile()->Seek(-bytesRead,SEEK_CUR); // put it back where we found it
	
		fInternalLatency = end - start;
		
		PRINT("\tinternal latency from disk read = %lld\n", fInternalLatency);
	} else {
		fInternalLatency = 100; // just guess
		PRINT("\tinternal latency guessed = %lld\n", fInternalLatency);
	}
	
	SetEventLatency(fDownstreamLatency + fInternalLatency);
	
	// XXX: do anything else?
}


void MediaReader::Disconnect(
				const media_source & what,
				const media_destination & where)
{
	CALLED();

	if (output.destination != where) {
		PRINT("\t<- B_MEDIA_BAD_DESTINATION\n");
		return;
	}
	if (output.source != what) {
		PRINT("\t<- B_MEDIA_BAD_SOURCE\n");
		return;
	}

	output.destination = media_destination::null;
	GetFormat(&output.format);
	if (fBufferGroup != 0) {
		BBufferGroup * group = fBufferGroup;
		fBufferGroup = 0;
		delete group;
	}	
}


void MediaReader::LateNoticeReceived(
				const media_source & what,
				bigtime_t how_much,
				bigtime_t performance_time)
{
	CALLED();

	if (what == output.source) {
		switch (RunMode()) {
			case B_OFFLINE:
			    // nothing to do
				break;
			case B_RECORDING:
			    // nothing to do
				break;
			case B_INCREASE_LATENCY:
				fInternalLatency += how_much;
				SetEventLatency(fDownstreamLatency + fInternalLatency);
				break;
			case B_DECREASE_PRECISION:
				// XXX : shorten our buffer period
				//       We could opt to just not wait but we should
				//       probably gradually shorten the period so we
				//       don't starve others.  Also, we need to make
				//       sure we are catching up!  We may have some sort
				//       of time goal for how long it takes us to
				//       catch up, as well.
				break;
			case B_DROP_DATA:
				// Okay you asked for it, we'll skip ahead in the file!
				// We'll drop 1 buffer's worth
				if (GetCurrentFile() == 0) {
					PRINT("MediaReader::LateNoticeReceived called without"
						  "an GetCurrentFile() (!)\n");
				} else {
					GetCurrentFile()->Seek(output.format.u.multistream.max_chunk_size,SEEK_CUR);
				}
				break;
			default:
				// huh?? there aren't any more run modes.
				PRINT("MediaReader::LateNoticeReceived with unexpected run mode.\n");
				break;
		}
	}
}


void MediaReader::EnableOutput(
				const media_source & what,
				bool enabled,
				int32 * _deprecated_)
{
	CALLED();

	if (output.source != what) {
		PRINT("\t<- B_MEDIA_BAD_SOURCE\n");
		return;
	}

	fOutputEnabled = enabled;
}


status_t MediaReader::SetPlayRate(
				int32 numer,
				int32 denom)
{
	return BBufferProducer::SetPlayRate(numer,denom); // XXX: do something intelligent later
}


void MediaReader::AdditionalBufferRequested(			//	used to be Reserved 0
				const media_source & source,
				media_buffer_id prev_buffer,
				bigtime_t prev_time,
				const media_seek_tag * prev_tag)
{
	CALLED();

	if (output.source == source) {
		BBuffer * buffer;
		status_t status = GetFilledBuffer(&buffer);
		if (status != B_OK) {
			PRINT("MediaReader::AdditionalBufferRequested got an error from GetFilledBuffer.\n");
			return; // don't send the buffer
		}
		SendBuffer(buffer, output.source, output.destination);
	}
}


void MediaReader::LatencyChanged(
				const media_source & source,
				const media_destination & destination,
				bigtime_t new_latency,
				uint32 flags)
{
	CALLED();
	if ((output.source == source) && (output.destination == destination)) {
		fDownstreamLatency = new_latency;
		SetEventLatency(fDownstreamLatency + fInternalLatency);
	}
	// we may have to recompute the number of buffers that we are using
	// see SetBufferGroup
}


// -------------------------------------------------------- //
// implementation for BMediaEventLooper
// -------------------------------------------------------- //
// protected:
status_t MediaReader::HandleBuffer(
				const media_timed_event *event,
				bigtime_t lateness,
				bool realTimeEvent)
{
	CALLED();

	if (output.destination == media_destination::null)
		return B_MEDIA_NOT_CONNECTED;

	status_t status = B_OK;
	BBuffer * buffer = fBufferGroup->RequestBuffer(output.format.u.multistream.max_chunk_size,fBufferPeriod);
	if (buffer != 0) {
	    status = FillFileBuffer(buffer);
	    if (status != B_OK) {
			PRINT("MediaReader::HandleEvent got an error from FillFileBuffer.\n");
			buffer->Recycle();
		} else {
			if (fOutputEnabled) {
				status = SendBuffer(buffer, output.source, output.destination);
				if (status != B_OK) {
					PRINT("MediaReader::HandleEvent got an error from SendBuffer.\n");
					buffer->Recycle();
				}
			} else {
				buffer->Recycle();
			}
		}
	}
	bigtime_t nextEventTime = event->event_time+fBufferPeriod;
	media_timed_event nextBufferEvent(nextEventTime, BTimedEventQueue::B_HANDLE_BUFFER);
	EventQueue()->AddEvent(nextBufferEvent);
	return status;
}


status_t MediaReader::HandleDataStatus(
						const media_timed_event *event,
						bigtime_t lateness,
						bool realTimeEvent)
{
	CALLED();
	return SendDataStatus(event->data,output.destination,event->event_time);
}


// -------------------------------------------------------- //
// MediaReader specific functions
// -------------------------------------------------------- //
// static:
void MediaReader::GetFlavor(flavor_info * outInfo, int32 id)
{
	CALLED();

	if (outInfo == 0)
		return;

	AbstractFileInterfaceNode::GetFlavor(outInfo,id);
	outInfo->name = strdup("Media Reader");
	outInfo->info = strdup(
		"The Haiku Media Reader reads a file and produces a multistream.");
	outInfo->kinds |= B_BUFFER_PRODUCER;
	outInfo->out_format_count = 1; // 1 output
	media_format * formats = new media_format[outInfo->out_format_count];
	GetFormat(&formats[0]);
	outInfo->out_formats = formats;
	return;
}


void MediaReader::GetFormat(media_format * outFormat)
{
	CALLED();

	AbstractFileInterfaceNode::GetFormat(outFormat);
	return;
}


void MediaReader::GetFileFormat(media_file_format * outFileFormat)
{
	CALLED();

	AbstractFileInterfaceNode::GetFileFormat(outFileFormat);
	outFileFormat->capabilities |= media_file_format::B_READABLE;
	return;
}


// protected:
status_t MediaReader::GetFilledBuffer(
				BBuffer ** outBuffer)
{
	CALLED();

	BBuffer * buffer = fBufferGroup->RequestBuffer(output.format.u.multistream.max_chunk_size,-1);
	if (buffer == 0) {
		// XXX: add a new buffer and get it
		PRINT("MediaReader::GetFilledBuffer needs a new buffer.\n");
		return B_ERROR; // don't send the buffer
	}

	status_t status = FillFileBuffer(buffer);
	*outBuffer = buffer;
	return status;
}		


status_t MediaReader::FillFileBuffer(
				BBuffer * buffer)
{
	CALLED();

	if (GetCurrentFile() == 0) {
		PRINT("\t<- B_NO_INIT\n");
		return B_NO_INIT;
	}
	PRINT("\t%ld buffer bytes used, %ld buffer bytes available\n",
			buffer->SizeUsed(), buffer->SizeAvailable());
	off_t position = GetCurrentFile()->Position();
	ssize_t bytesRead = GetCurrentFile()->Read(buffer->Data(),buffer->SizeAvailable());
	if (bytesRead < 0) {
		PRINT("\t<- B_IO_ERROR\n");
		return B_IO_ERROR; // some sort of I/O related error
	}
	PRINT("\t%ld file bytes read at position %ld.\n",
			bytesRead, position);

	buffer->SetSizeUsed(bytesRead);
	media_header * header = buffer->Header();
	header->type = B_MEDIA_MULTISTREAM;
	header->size_used = bytesRead;
	header->file_pos = position;
	header->orig_size = bytesRead;
	header->time_source = TimeSource()->ID();
	header->start_time = TimeSource()->Now();
	// nothing more to say?
	return B_OK;
}


// -------------------------------------------------------- //
// stuffing
// -------------------------------------------------------- //
status_t MediaReader::_Reserved_MediaReader_0(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_1(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_2(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_3(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_4(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_5(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_6(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_7(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_8(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_9(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_10(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_11(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_12(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_13(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_14(void *) { return B_ERROR; }
status_t MediaReader::_Reserved_MediaReader_15(void *) { return B_ERROR; }