haiku.git

/******************************************************************************
/
/	File:			RadeonAddOn.cpp
/
/	Description:	ATI Radeon Video Capture Media AddOn for BeOS.
/
/	Copyright 2001, Carlos Hasan
/
*******************************************************************************/

#include <support/Autolock.h>
#include <media/MediaFormats.h>
#include <Directory.h>
#include <Entry.h>
#include <Debug.h>
#include <File.h>

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

#include <storage/FindDirectory.h>
#include <String.h>

#include "RadeonAddOn.h"
#include "RadeonProducer.h"

#define DPRINT(args) { PRINT(("\x1b[0;30;35m")); PRINT(args); PRINT(("\x1b[0;30;47m")); }

CRadeonPlug::CRadeonPlug( CRadeonAddOn *aaddon, const BPath &adev_path, int aid )
  : addon( aaddon ), dev_path( adev_path ), id( aid ), node( NULL )
{
	fFlavorInfo.name = const_cast<char *>("Radeon In");
	fFlavorInfo.info = const_cast<char *>("Radeon Video In Media Node");
	fFlavorInfo.kinds = B_BUFFER_PRODUCER | B_CONTROLLABLE | B_PHYSICAL_INPUT;
	fFlavorInfo.flavor_flags = 0;
	fFlavorInfo.internal_id = aid;
	fFlavorInfo.possible_count = 1;
	
	fFlavorInfo.in_format_count = 0;
	fFlavorInfo.in_format_flags = 0;
	fFlavorInfo.in_formats = NULL;
	
	fFlavorInfo.out_format_count = 4;
	//fFlavorInfo.out_format_count = 1;
	fFlavorInfo.out_format_flags = 0;
	
	fMediaFormat[0].type = B_MEDIA_RAW_VIDEO;
	fMediaFormat[0].u.raw_video = media_raw_video_format::wildcard;
	fMediaFormat[0].u.raw_video.interlace = 1;
	fMediaFormat[0].u.raw_video.display.format = B_RGB32;
	
	fMediaFormat[1].type = B_MEDIA_RAW_VIDEO;
	fMediaFormat[1].u.raw_video = media_raw_video_format::wildcard;
	fMediaFormat[1].u.raw_video.interlace = 1;
	fMediaFormat[1].u.raw_video.display.format = B_RGB16;
	
	fMediaFormat[2].type = B_MEDIA_RAW_VIDEO;
	fMediaFormat[2].u.raw_video = media_raw_video_format::wildcard;
	fMediaFormat[2].u.raw_video.interlace = 1;
	fMediaFormat[2].u.raw_video.display.format = B_RGB15;

	fMediaFormat[3].type = B_MEDIA_RAW_VIDEO;
	fMediaFormat[3].u.raw_video = media_raw_video_format::wildcard;
	fMediaFormat[3].u.raw_video.interlace = 1;
	fMediaFormat[3].u.raw_video.display.format = B_YCbCr422;
	
	/*fMediaFormat[0].type = B_MEDIA_RAW_VIDEO;
	fMediaFormat[0].u.raw_video = media_raw_video_format::wildcard;
	fMediaFormat[0].u.raw_video.interlace = 1;
	fMediaFormat[0].u.raw_video.display.format = B_YCbCr422;*/
	
	fFlavorInfo.out_formats = fMediaFormat;
	
	readSettings();
}

BPath 
CRadeonPlug::getSettingsPath()
{
	BPath path;
	
	if( find_directory( B_USER_CONFIG_DIRECTORY, &path ) != B_OK )
		return BPath();
		
	path.Append( "settings/Media/RadeonIn" );
	
	create_directory( path.Path(), 755 );
		
	BString id_string;
	
	id_string << "settings" << id;
	
	path.Append( id_string.String() );
	
	return path;
}

void 
CRadeonPlug::writeSettings( BMessage *new_settings )
{
	BMessage cur_settings;

	// if new_settings are provided, use them; else, ask node for settings
	// (needed during shutdown where node cannot reply anymore)
	if( new_settings != NULL ) {
		cur_settings = *new_settings;
		
	} else {
		if( node == NULL )
			return;
				
		if( addon->GetConfigurationFor( node, &cur_settings ) != B_OK )
			return;
	}
			
	BMallocIO old_settings_flat, new_settings_flat;
	
	settings.Flatten( &old_settings_flat );
	cur_settings.Flatten( &new_settings_flat );
	
	if( old_settings_flat.BufferLength() == new_settings_flat.BufferLength() &&
		memcmp( old_settings_flat.Buffer(), new_settings_flat.Buffer(), old_settings_flat.BufferLength() ) == 0 )
		return;
	
	settings = cur_settings;

	BPath settings_path = getSettingsPath();
	
	BFile file( settings_path.Path(), B_WRITE_ONLY | B_CREATE_FILE );
	
	settings.Flatten( &file );
}

void
CRadeonPlug::readSettings()
{
	BPath settings_path = getSettingsPath();
	
	BFile file( settings_path.Path(), B_READ_ONLY );
		
	settings.Unflatten( &file );
}


CRadeonAddOn::CRadeonAddOn(image_id imid)
	: BMediaAddOn(imid),
	settings_thread( -1 ), settings_thread_sem( -1 )
{
	DPRINT(("CRadeonAddOn::CRadeonAddOn()\n"));
			
	fInitStatus = B_NO_INIT;

	if( RecursiveScan( "/dev/video/radeon" ) != B_OK )
		return;
		
	if( (settings_thread_sem = create_sem( 0, "Radeon In settings" )) < 0 )
		return;
		
	if( INIT_BEN( plug_lock, "Radeon device list" ) < 0 )
		return;
		
	if( (settings_thread = spawn_thread( 
		settings_writer, "Radeon In settings", B_LOW_PRIORITY, this )) < 0 )
		return;
		
	resume_thread( settings_thread );

	fInitStatus = B_OK;
}

CRadeonAddOn::~CRadeonAddOn()
{
	status_t dummy;
	
	DPRINT(("CRadeonAddOn::~CRadeonAddOn()\n"));
	
	release_sem( settings_thread_sem );
	wait_for_thread( settings_thread, &dummy );
	
	delete_sem( settings_thread_sem );
	
	for( int32 i = 0; i < fDevices.CountItems(); ++i ) {
		CRadeonPlug *plug = (CRadeonPlug *)fDevices.ItemAt(i);
		
		delete plug;
	}
	
	DELETE_BEN( plug_lock );
}


status_t 
CRadeonAddOn::InitCheck(const char **out_failure_text)
{
	DPRINT(("CRadeonAddOn::InitCheck()\n"));
	
	if (fInitStatus < B_OK) {
		*out_failure_text = "Unknown error";
		return fInitStatus;
	}

	return B_OK;
}

int32 
CRadeonAddOn::settings_writer( void *param )
{
	((CRadeonAddOn *)param)->settingsWriter();
	return B_OK;
}

void 
CRadeonAddOn::writeSettings()
{
	ACQUIRE_BEN( plug_lock );
	
	for( int32 i = 0; i < fDevices.CountItems(); ++i ) {
		CRadeonPlug *plug = (CRadeonPlug *)fDevices.ItemAt(i);

		plug->writeSettings( NULL );
	}
	
	RELEASE_BEN( plug_lock );
}

void
CRadeonAddOn::settingsWriter()
{
	while( acquire_sem_etc( settings_thread_sem, 1, B_RELATIVE_TIMEOUT, 10000000 ) == B_TIMED_OUT ) {
		writeSettings();
	}
}

void
CRadeonAddOn::UnregisterNode( BMediaNode *node, BMessage *settings )
{
	ACQUIRE_BEN( plug_lock );
	
	for( int32 i = 0; i < fDevices.CountItems(); ++i ) {
		CRadeonPlug *plug = (CRadeonPlug *)fDevices.ItemAt(i);
		
		if( plug->getNode() == node ) {
			// write last settings, so they don't get lost
			plug->writeSettings( settings );
			plug->setNode( NULL );
			break;
		}
	}
	
	RELEASE_BEN( plug_lock );
}

int32 
CRadeonAddOn::CountFlavors()
{
	DPRINT(("CRadeonAddOn::CountFlavors()\n"));
	
	if (fInitStatus < B_OK)
		return fInitStatus;

	return fDevices.CountItems();
}

/*
 * The pointer to the flavor received only needs to be valid between 
 * successive calls to BCRadeonAddOn::GetFlavorAt().
 */
status_t 
CRadeonAddOn::GetFlavorAt(int32 n, const flavor_info **out_info)
{
	DPRINT(("CRadeonAddOn::GetFlavorAt()\n"));
	
	if (fInitStatus < B_OK)
		return fInitStatus;

	if (n < 0 || n >= fDevices.CountItems() )
		return B_BAD_INDEX;

	/* Return the flavor defined in the constructor */
	*out_info = ((CRadeonPlug *)fDevices.ItemAt(n))->getFlavorInfo();
	return B_OK;
}

BMediaNode *
CRadeonAddOn::InstantiateNodeFor(
		const flavor_info *info, BMessage *config, status_t *out_error)
{
	DPRINT(("CRadeonAddOn::InstantiateNodeFor()\n"));
	
	CRadeonProducer *node;

	if (fInitStatus < B_OK)
		return NULL;

	if (info->internal_id < 0 || info->internal_id >= fDevices.CountItems())
		return NULL;

	CRadeonPlug *plug = (CRadeonPlug *)fDevices.ItemAt( info->internal_id );
	
	ACQUIRE_BEN( plug_lock );
	
	if( plug->getNode() != NULL ) {
		*out_error = B_BUSY;
		node = NULL;
		
	} else {
		BMessage single_settings;
		
		// under R5, configuration is always an empty message, so we need to
		// get our own configuration
		if( config == NULL || 1 )
			config = plug->getSettings();
		
		node = new CRadeonProducer( this, plug->getName(), 
			plug->getDeviceName(), info->internal_id, config );
			
		if (node && (node->InitCheck() < B_OK)) {
			*out_error = node->InitCheck();
			delete node;
			node = NULL;
		}
	}
	
	plug->setNode( node );
		
	RELEASE_BEN( plug_lock );

	return node;
}

status_t CRadeonAddOn::GetConfigurationFor(
	BMediaNode *your_node,
	BMessage *into_message )
{
	port_id reply_port;
	CRadeonProducer::configuration_msg msg;
	status_t res;
	
	reply_port = create_port( 1, "GetConfiguration Reply" );
	if( reply_port < 0 )
		return reply_port;
		
	msg.reply_port = reply_port;
	
	res = write_port_etc( your_node->ControlPort(), CRadeonProducer::C_GET_CONFIGURATION, 
		&msg, sizeof( msg ), B_TIMEOUT, 10000000 );
	if( res == B_OK ) {
		ssize_t reply_size;
		CRadeonProducer::configuration_msg_reply *reply;
		int32 code;
		
		reply_size = port_buffer_size_etc( reply_port, B_TIMEOUT, 10000000 );
		if( reply_size < 0 )
			res = reply_size;
		else {
			reply = (CRadeonProducer::configuration_msg_reply *)malloc( reply_size );
		
			res = read_port( reply_port, &code, reply, reply_size );
			if( res == reply_size ) {
				if( code != CRadeonProducer::C_GET_CONFIGURATION_REPLY )
					res = B_ERROR;
				else {
					res = reply->res;
					
					if( res == B_OK )
						res = into_message->Unflatten( &reply->config );
				}
			}
			
			free( reply );
		}
	}
	
	delete_port( reply_port );
	
	return res;
}

status_t
CRadeonAddOn::RecursiveScan(const char* rootPath, BEntry *rootEntry = NULL)
{	
	BDirectory root;
	
	if( rootEntry != NULL )
		root.SetTo( rootEntry );
	else if( rootPath != NULL ) {
		root.SetTo( rootPath );
	} else {
		PRINT(("Error in MultiAudioAddOn::RecursiveScan null params\n"));
		return B_ERROR;
	}
	
	BEntry entry;
	int cur_id = 0;
	
	while( root.GetNextEntry( &entry ) > B_ERROR ) {
		if(entry.IsDirectory()) {
			RecursiveScan( rootPath, &entry );
			
		} else {
			BPath path;
			
			entry.GetPath(&path);
			
			CRadeon device( path.Path() );
			
			if( device.InitCheck() != B_OK)
				continue;
				
			CVIPPort vip_port( device );
		
			// if there is a Rage Theatre, then there should be Video-In	
			if( vip_port.InitCheck() == B_OK &&
				((vip_port.FindVIPDevice( C_THEATER100_VIP_DEVICE_ID ) >= 0) 
					|| (vip_port.FindVIPDevice( C_THEATER200_VIP_DEVICE_ID ) >= 0)))
			{
				fDevices.AddItem( new CRadeonPlug( this, path, cur_id++ ));
			}
		}
	}
	
	return B_OK;
}


BMediaAddOn *
make_media_addon(image_id imid)
{
	return new CRadeonAddOn(imid);
}