xref: /haiku/src/apps/soundrecorder/RecorderWindow.cpp (revision f7fceb6920c6de6f515c69d1cf1636486adb9dbc)

/*
 * Copyright 2014, Dario Casalinuovo. All rights reserved.
 * Copyright 2005, Jérôme Duval. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Inspired by SoundCapture from Be newsletter (Media Kit Basics:
 *	Consumers and Producers)
 */

#include <Application.h>
#include <Alert.h>
#include <Debug.h>
#include <Screen.h>
#include <Button.h>
#include <CheckBox.h>
#include <TextControl.h>
#include <MenuField.h>
#include <PopUpMenu.h>
#include <MenuItem.h>
#include <Box.h>
#include <ScrollView.h>
#include <Beep.h>
#include <StringView.h>
#include <String.h>
#include <Slider.h>
#include <Message.h>

#include <Path.h>
#include <FindDirectory.h>
#include <MediaAddOn.h>

#include <SoundPlayer.h>

#include <assert.h>
#include <stdio.h>
#include <strings.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>

#include <MediaRoster.h>
#include <TimeSource.h>
#include <NodeInfo.h>

#include "RecorderWindow.h"
#include "FileUtils.h"

#if ! NDEBUG
#define FPRINTF(args) fprintf args
#else
#define FPRINTF(args)
#endif

#define DEATH FPRINTF
#define CONNECT FPRINTF
#define WINDOW FPRINTF

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "RecorderWindow"


// default window positioning
static const float MIN_WIDTH = 400.0f;
static const float MIN_HEIGHT = 175.0f;
static const float XPOS = 100.0f;
static const float YPOS = 200.0f;

#define FOURCC(a,b,c,d)	((((uint32)(d)) << 24) | (((uint32)(c)) << 16) \
	| (((uint32)(b)) << 8) | ((uint32)(a)))

struct riff_struct
{
	uint32 riff_id; // 'RIFF'
	uint32 len;
	uint32 wave_id;	// 'WAVE'
};

struct chunk_struct
{
	uint32 fourcc;
	uint32 len;
};

struct format_struct
{
	uint16 format_tag;
	uint16 channels;
	uint32 samples_per_sec;
	uint32 avg_bytes_per_sec;
	uint16 block_align;
	uint16 bits_per_sample;
};


struct wave_struct
{
	struct riff_struct riff;
	struct chunk_struct format_chunk;
	struct format_struct format;
	struct chunk_struct data_chunk;
};


RecorderWindow::RecorderWindow()
	:
	BWindow(BRect(XPOS, YPOS, XPOS + MIN_WIDTH, YPOS + MIN_HEIGHT),
		B_TRANSLATE_SYSTEM_NAME("SoundRecorder"), B_TITLED_WINDOW,
		B_ASYNCHRONOUS_CONTROLS | B_NOT_V_RESIZABLE | B_NOT_ZOOMABLE),
	fPlayer(NULL),
	fSoundList(NULL),
	fPlayFile(NULL),
	fPlayTrack(NULL),
	fPlayFrames(0),
	fLooping(false),
	fSavePanel(NULL),
	fInitCheck(B_OK)
{
	fRoster = NULL;
	fRecordButton = NULL;
	fPlayButton = NULL;
	fStopButton = NULL;
	fSaveButton = NULL;
	fLoopButton = NULL;
	fInputField = NULL;
	fRecorder = NULL;
	fRecording = false;
	fExternalConnection = false;
	fTempCount = -1;
	fButtonState = btnPaused;

	CalcSizes(MIN_WIDTH, MIN_HEIGHT);

	fInitCheck = InitWindow();
	if (fInitCheck != B_OK) {
		if (fInitCheck == B_NAME_NOT_FOUND)
			ErrorAlert(B_TRANSLATE("Cannot find default audio hardware"),
				fInitCheck);
		else
			ErrorAlert(B_TRANSLATE("Cannot connect to media server"),
				fInitCheck);
		PostMessage(B_QUIT_REQUESTED);
	} else
		Show();
}


RecorderWindow::~RecorderWindow()
{
	//  The MediaRecorder have to be deleted, the dtor
	//  disconnect it from the media_kit.
	delete fRecorder;

	delete fPlayer;

	if (fPlayTrack && fPlayFile)
		fPlayFile->ReleaseTrack(fPlayTrack);

	if (fPlayFile)
		delete fPlayFile;
	fPlayTrack = NULL;
	fPlayFile = NULL;

	//	Clean up items in list view.
	if (fSoundList) {
		fSoundList->DeselectAll();
		for (int i = 0; i < fSoundList->CountItems(); i++) {
			WINDOW((stderr, "clean up item %d\n", i+1));
			SoundListItem* item = dynamic_cast<SoundListItem *>(fSoundList->ItemAt(i));
			if (item) {
				if (item->IsTemp())
					item->Entry().Remove();	//	delete temp file
				delete item;
			}
		}
		fSoundList->MakeEmpty();
	}
	//	Clean up currently recording file, if any.
	fRecEntry.Remove();
	fRecEntry.Unset();

	delete fSavePanel;
}


status_t
RecorderWindow::InitCheck()
{
	return fInitCheck;
}


void
RecorderWindow::CalcSizes(float min_width, float min_height)
{
	//	Set up size limits based on new screen size
	BScreen screen(this);
	BRect rect = screen.Frame();
	float width = rect.Width() - 12;
	SetSizeLimits(min_width, width, min_height, rect.Height() - 24);

	//	Don't zoom to cover all of screen; user can resize last bit if necessary.
	//	This leaves other windows visible.
	if (width > 640)
		width = 640 + (width - 640) / 2;
	SetZoomLimits(width, rect.Height() - 24);
}


status_t
RecorderWindow::InitWindow()
{
	BPopUpMenu * popup = 0;
	status_t error;

	try {
		//	Find temp directory for recorded sounds.
		BPath path;
		if (!(error = find_directory(B_SYSTEM_TEMP_DIRECTORY, &path)))
			error = fTempDir.SetTo(path.Path());
		if (error < 0)
			goto bad_mojo;

		//	Make sure the media roster is there (which means the server is there).
		fRoster = BMediaRoster::Roster(&error);
		if (!fRoster)
			goto bad_mojo;

		error = fRoster->GetAudioInput(&fAudioInputNode);
		if (error < B_OK) //	there's no input?
			goto bad_mojo;

		error = fRoster->GetAudioMixer(&fAudioMixerNode);
		if (error < B_OK) //	there's no mixer?
			goto bad_mojo;

		fRecorder = new BMediaRecorder("Sound Recorder",
			B_MEDIA_RAW_AUDIO);

		if (fRecorder->InitCheck() < B_OK)
			goto bad_mojo;

		// Set the node to accept only audio data
		media_format output_format;
		output_format.type = B_MEDIA_RAW_AUDIO;
		output_format.u.raw_audio = media_raw_audio_format::wildcard;
		fRecorder->SetAcceptedFormat(output_format);

		//	Create the window header with controls
		BRect r(Bounds());
		r.bottom = r.top + 175;
		BBox *background = new BBox(r, "_background",
			B_FOLLOW_LEFT_RIGHT	| B_FOLLOW_TOP, B_WILL_DRAW
			| B_FRAME_EVENTS | B_NAVIGABLE_JUMP, B_NO_BORDER);

		AddChild(background);

		r = background->Bounds();
		r.left = 0;
		r.right = r.left + 38;
		r.bottom = r.top + 104;
		fVUView = new VUView(r, B_FOLLOW_LEFT|B_FOLLOW_TOP);
		background->AddChild(fVUView);

		r = background->Bounds();
		r.left = r.left + 40;
		r.bottom = r.top + 104;
		fScopeView = new ScopeView(r, B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP);
		background->AddChild(fScopeView);

		r = background->Bounds();
		r.left = 2;
		r.right -= 26;
		r.top = 115;
		r.bottom = r.top + 30;
		fTrackSlider = new TrackSlider(r, "trackSlider", new BMessage(POSITION_CHANGED),
			B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
		background->AddChild(fTrackSlider);

		BRect buttonRect;

		//	Button for rewinding
		buttonRect = BRect(BPoint(0,0), kSkipButtonSize);
		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-7, 25));
		fRewindButton = new TransportButton(buttonRect, B_TRANSLATE("Rewind"),
			kSkipBackBitmapBits, kPressedSkipBackBitmapBits,
			kDisabledSkipBackBitmapBits, new BMessage(REWIND));
		background->AddChild(fRewindButton);

		//	Button for stopping recording or playback
		buttonRect = BRect(BPoint(0,0), kStopButtonSize);
		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-48, 25));
		fStopButton = new TransportButton(buttonRect, B_TRANSLATE("Stop"),
			kStopButtonBitmapBits, kPressedStopButtonBitmapBits,
			kDisabledStopButtonBitmapBits, new BMessage(STOP));
		background->AddChild(fStopButton);

		//	Button for starting playback of selected sound
		BRect playRect(BPoint(0,0), kPlayButtonSize);
		playRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-82, 25));
		fPlayButton = new PlayPauseButton(playRect, B_TRANSLATE("Play"),
			new BMessage(PLAY), new BMessage(PLAY_PERIOD), ' ', 0);
		background->AddChild(fPlayButton);

		//	Button for forwarding
		buttonRect = BRect(BPoint(0,0), kSkipButtonSize);
		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-133, 25));
		fForwardButton = new TransportButton(buttonRect, B_TRANSLATE("Forward"),
			kSkipForwardBitmapBits, kPressedSkipForwardBitmapBits,
			kDisabledSkipForwardBitmapBits, new BMessage(FORWARD));
		background->AddChild(fForwardButton);

		//	Button to start recording (or waiting for sound)
		buttonRect = BRect(BPoint(0,0), kRecordButtonSize);
		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-174, 25));
		fRecordButton = new RecordButton(buttonRect, B_TRANSLATE("Record"),
			new BMessage(RECORD), new BMessage(RECORD_PERIOD));
		background->AddChild(fRecordButton);

		//	Button for saving selected sound
		buttonRect = BRect(BPoint(0,0), kDiskButtonSize);
		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-250, 21));
		fSaveButton = new TransportButton(buttonRect, B_TRANSLATE("Save"),
			kDiskButtonBitmapsBits, kPressedDiskButtonBitmapsBits,
			kDisabledDiskButtonBitmapsBits, new BMessage(SAVE));
		fSaveButton->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
		background->AddChild(fSaveButton);

		//	Button Loop
		buttonRect = BRect(BPoint(0,0), kArrowSize);
		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(23, 48));
		fLoopButton = new DrawButton(buttonRect, B_TRANSLATE("Loop"),
			kLoopArrowBits, kArrowBits, new BMessage(LOOP));
		fLoopButton->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
		fLoopButton->SetTarget(this);
		background->AddChild(fLoopButton);

		buttonRect = BRect(BPoint(0,0), kSpeakerIconBitmapSize);
		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(121, 17));
		SpeakerView *speakerView = new SpeakerView(buttonRect,
			B_FOLLOW_LEFT | B_FOLLOW_TOP);
		speakerView->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
		background->AddChild(speakerView);

		buttonRect = BRect(BPoint(0,0), BPoint(84, 19));
		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(107, 20));
		fVolumeSlider = new VolumeSlider(buttonRect, "volumeSlider",
			B_FOLLOW_LEFT | B_FOLLOW_TOP);
		fVolumeSlider->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
		background->AddChild(fVolumeSlider);

		// Button to mask/see sounds list
		buttonRect = BRect(BPoint(0,0), kUpDownButtonSize);
		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(21, 25));
		fUpDownButton = new UpDownButton(buttonRect, new BMessage(VIEW_LIST));
		fUpDownButton->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
		background->AddChild(fUpDownButton);

		r = Bounds();
		r.top = background->Bounds().bottom + 1;
		fBottomBox = new BBox(r, "bottomBox", B_FOLLOW_ALL);
		fBottomBox->SetBorder(B_NO_BORDER);
		AddChild(fBottomBox);

		//	The actual list of recorded sounds (initially empty) sits
		//	below the header with the controls.
		r = fBottomBox->Bounds();
		r.left += 190;
		r.InsetBy(10, 10);
		r.left -= 10;
		r.top += 4;
		r.right -= B_V_SCROLL_BAR_WIDTH;
		r.bottom -= 25;
		fSoundList = new SoundListView(r, B_TRANSLATE("Sound List"),
			B_FOLLOW_ALL);
		fSoundList->SetSelectionMessage(new BMessage(SOUND_SELECTED));
		fSoundList->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
		BScrollView *scroller = new BScrollView("scroller", fSoundList,
			B_FOLLOW_ALL, 0, false, true, B_FANCY_BORDER);
		fBottomBox->AddChild(scroller);

		r = fBottomBox->Bounds();
		r.right = r.left + 190;
		r.bottom -= 25;
		r.InsetBy(10, 8);
		r.top -= 1;
		fFileInfoBox = new BBox(r, "fileinfo", B_FOLLOW_LEFT);
		fFileInfoBox->SetLabel(B_TRANSLATE("File info"));

		fFileInfoBox->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		BFont font = be_plain_font;
		font.SetSize(font.Size() * 0.92f);
		font_height height;
		font.GetHeight(&height);
		float fontHeight = height.ascent + height.leading + height.descent;

		r = fFileInfoBox->Bounds();
		r.left = 8;
		r.top = fontHeight + 6;
		r.bottom = r.top + fontHeight + 3;
		r.right -= 10;
		fFilename = new BStringView(r, "filename", B_TRANSLATE("File name:"));
		fFileInfoBox->AddChild(fFilename);
		fFilename->SetFont(&font, B_FONT_SIZE);
		fFilename->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		r.top += fontHeight;
		r.bottom = r.top + fontHeight + 3;
		fFormat = new BStringView(r, "format", B_TRANSLATE("Format:"));
		fFileInfoBox->AddChild(fFormat);
		fFormat->SetFont(&font, B_FONT_SIZE);
		fFormat->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		r.top += fontHeight;
		r.bottom = r.top + fontHeight + 3;
		fCompression = new BStringView(r, "compression",
			B_TRANSLATE("Compression:"));
		fFileInfoBox->AddChild(fCompression);
		fCompression->SetFont(&font, B_FONT_SIZE);
		fCompression->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		r.top += fontHeight;
		r.bottom = r.top + fontHeight + 3;
		fChannels = new BStringView(r, "channels", B_TRANSLATE("Channels:"));
		fFileInfoBox->AddChild(fChannels);
		fChannels->SetFont(&font, B_FONT_SIZE);
		fChannels->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		r.top += fontHeight;
		r.bottom = r.top + fontHeight + 3;
		fSampleSize = new BStringView(r, "samplesize",
			B_TRANSLATE("Sample size:"));
		fFileInfoBox->AddChild(fSampleSize);
		fSampleSize->SetFont(&font, B_FONT_SIZE);
		fSampleSize->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		r.top += fontHeight;
		r.bottom = r.top + fontHeight + 3;
		fSampleRate = new BStringView(r, "samplerate",
			B_TRANSLATE("Sample rate:"));
		fFileInfoBox->AddChild(fSampleRate);
		fSampleRate->SetFont(&font, B_FONT_SIZE);
		fSampleRate->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		r.top += fontHeight;
		r.bottom = r.top + fontHeight + 3;
		fDuration = new BStringView(r, "duration", B_TRANSLATE("Duration:"));
		fFileInfoBox->AddChild(fDuration);
		fDuration->SetFont(&font, B_FONT_SIZE);
		fDuration->SetHighColor(ui_color(B_PANEL_TEXT_COLOR));

		fFileInfoBox->ResizeTo(fFileInfoBox->Frame().Width(),
			r.bottom + fontHeight / 2.0f);
		fDeployedHeight = MIN_HEIGHT + fFileInfoBox->Bounds().Height() + 40.0f;

		//	Input selection lists all available physical inputs that produce
		//	buffers with B_MEDIA_RAW_AUDIO format data.
		popup = new BPopUpMenu(B_TRANSLATE("Input"));
		const int maxInputCount = 64;
		dormant_node_info dni[maxInputCount];

		int32 real_count = maxInputCount;

		error = fRoster->GetDormantNodes(dni, &real_count, 0, &output_format,
			0, B_BUFFER_PRODUCER | B_PHYSICAL_INPUT);
		if (real_count > maxInputCount) {
			WINDOW((stderr, "dropped %" B_PRId32 " inputs\n", real_count - maxInputCount));
			real_count = maxInputCount;
		}
		char selected_name[B_MEDIA_NAME_LENGTH] = "Default input";
		BMessage * msg;
		BMenuItem * item;
		for (int i = 0; i < real_count; i++) {
			msg = new BMessage(INPUT_SELECTED);
			msg->AddData("node", B_RAW_TYPE, &dni[i], sizeof(dni[i]));
			item = new BMenuItem(dni[i].name, msg);
			popup->AddItem(item);
			media_node_id ni[12];
			int32 ni_count = 12;
			error = fRoster->GetInstancesFor(dni[i].addon, dni[i].flavor_id,
				ni, &ni_count);
			if (error == B_OK) {
				for (int j = 0; j < ni_count; j++) {
					if (ni[j] == fAudioInputNode.node) {
						strcpy(selected_name, dni[i].name);
						break;
					}
				}
			}
		}

		//	Create the actual widget
		r = fFileInfoBox->Bounds();
		r.top = r.bottom + 2;
		r.bottom = r.top + 18;
		r.InsetBy(10, 10);
		fInputField = new BMenuField(r, "Input", B_TRANSLATE("Input:"), popup);
		fInputField->SetDivider(fInputField->StringWidth(B_TRANSLATE("Input:"))
			+ 4.0f);
		fBottomBox->AddChild(fInputField);

		fBottomBox->AddChild(fFileInfoBox);

		fBottomBox->Hide();
		CalcSizes(MIN_WIDTH, MIN_HEIGHT);
		ResizeTo(Frame().Width(), MIN_HEIGHT);

		popup->Superitem()->SetLabel(selected_name);

		// Make sure the save panel is happy.
		fSavePanel = new BFilePanel(B_SAVE_PANEL);
		fSavePanel->SetTarget(this);
	}
	catch (...) {
		goto bad_mojo;
	}
	UpdateButtons();
	return B_OK;

	//	Error handling.
bad_mojo:
	if (error >= 0)
		error = B_ERROR;
	if (fRecorder)
		delete fRecorder;

	delete fPlayer;
	if (!fInputField)
		delete popup;
	return error;
}


bool
RecorderWindow::QuitRequested()	//	this means Close pressed
{
	StopRecording();
	StopPlaying();
	be_app->PostMessage(B_QUIT_REQUESTED);
	return true;
}


void
RecorderWindow::MessageReceived(BMessage * message)
{
	//	Your average generic message dispatching switch() statement.
	switch (message->what) {
	case INPUT_SELECTED:
		Input(message);
		break;
	case SOUND_SELECTED:
		Selected(message);
		break;
	case STOP_PLAYING:
		StopPlaying();
		break;
	case STOP_RECORDING:
		StopRecording();
		break;
	case PLAY_PERIOD:
		if (fPlayer) {
			if (fPlayer->HasData())
				fPlayButton->SetPlaying();
			else
				fPlayButton->SetPaused();
		}
		break;
	case RECORD_PERIOD:
		fRecordButton->SetRecording();
		break;
	case RECORD:
		Record(message);
		break;
	case STOP:
		Stop(message);
		break;
	case PLAY:
		Play(message);
		break;
	case SAVE:
		Save(message);
		break;
	case B_SAVE_REQUESTED:
		DoSave(message);
		break;
	case VIEW_LIST:
		if (fUpDownButton->Value() == B_CONTROL_ON) {
			fBottomBox->Show();
			CalcSizes(MIN_WIDTH, fDeployedHeight);
			ResizeTo(Frame().Width(), fDeployedHeight);
		} else {
			fBottomBox->Hide();
			CalcSizes(MIN_WIDTH, MIN_HEIGHT);
			ResizeTo(Frame().Width(), MIN_HEIGHT);

		}
		break;
	case UPDATE_TRACKSLIDER:
		{
			bigtime_t timestamp = fPlayTrack->CurrentTime();
			fTrackSlider->SetMainTime(timestamp, false);
			fScopeView->SetMainTime(timestamp);
		}
		break;
	case POSITION_CHANGED:
		{
			bigtime_t right, left, main;
			if (message->FindInt64("main", &main) == B_OK) {
				if (fPlayTrack) {
					fPlayTrack->SeekToTime(fTrackSlider->MainTime());
					fPlayFrame = fPlayTrack->CurrentFrame();
				}
				fScopeView->SetMainTime(main);
			}
			if (message->FindInt64("right", &right) == B_OK) {
				if (fPlayTrack) {
					fPlayLimit = MIN(fPlayFrames,
						(off_t)(right * fPlayFormat.u.raw_audio.frame_rate
							/ 1000000LL));
				}
				fScopeView->SetRightTime(right);
			}
			if (message->FindInt64("left", &left) == B_OK)
				fScopeView->SetLeftTime(left);
			break;
		}
	case LOOP:
		fLooping = fLoopButton->ButtonState();
		break;
	case B_SIMPLE_DATA:
	case B_REFS_RECEIVED:
		{
			RefsReceived(message);
			break;
		}
	case B_COPY_TARGET:
		CopyTarget(message);
		break;
	default:
		BWindow::MessageReceived(message);
		break;
	}
}


void
RecorderWindow::Record(BMessage * message)
{
	//	User pressed Record button
	fRecording = true;
	if (fButtonState != btnPaused) {
		StopRecording();
		return;			//	user is too fast on the mouse
	}
	SetButtonState(btnRecording);
	fRecordButton->SetRecording();

	char name[256];
	//	Create a file with a temporary name
	status_t err = NewTempName(name);
	if (err < B_OK) {
		ErrorAlert(B_TRANSLATE("Cannot find an unused name to use for the "
			"new recording"), err);
		return;
	}
	//	Find the file so we can refer to it later
	err = fTempDir.FindEntry(name, &fRecEntry);
	if (err < B_OK) {
		ErrorAlert(B_TRANSLATE("Cannot find the temporary file created to "
			"hold the new recording"), err);
		return;
	}
	err = fRecFile.SetTo(&fTempDir, name, O_RDWR);
	if (err < B_OK) {
		ErrorAlert(B_TRANSLATE("Cannot open the temporary file created to "
			"hold the new recording"), err);
		fRecEntry.Unset();
		return;
	}
	//	Reserve space on disk (creates fewer fragments)
	err = fRecFile.SetSize(4 * fRecordFormat.u.raw_audio.channel_count
		* fRecordFormat.u.raw_audio.frame_rate
		* (fRecordFormat.u.raw_audio.format
			& media_raw_audio_format::B_AUDIO_SIZE_MASK));
	if (err < B_OK) {
		ErrorAlert(B_TRANSLATE("Cannot record a sound that long"), err);
		fRecEntry.Remove();
		fRecEntry.Unset();
		return;
	}
	fRecSize = 0;

	fRecFile.Seek(sizeof(struct wave_struct), SEEK_SET);

	// Hook up input
	err = MakeRecordConnection(fAudioInputNode);
	if (err < B_OK) {
		ErrorAlert(B_TRANSLATE("Cannot connect to the selected sound input"),
			err);
		fRecEntry.Remove();
		fRecEntry.Unset();
		return;
	}
	fRecorder->Start();
}


void
RecorderWindow::Play(BMessage * message)
{
	if (fPlayer) {
		//	User pressed Play button and playing
		if (fPlayer->HasData())
			fPlayButton->SetPaused();
		else
			fPlayButton->SetPlaying();
		fPlayer->SetHasData(!fPlayer->HasData());
		return;
	}

	SetButtonState(btnPlaying);
	fPlayButton->SetPlaying();

	if (!fPlayTrack) {
		ErrorAlert(B_TRANSLATE("Cannot get the file to play"), B_ERROR);
		return;
	}

	fPlayLimit = MIN(fPlayFrames, (off_t)(fTrackSlider->RightTime()
		* fPlayFormat.u.raw_audio.frame_rate / 1000000LL));
	fPlayTrack->SeekToTime(fTrackSlider->MainTime());
	fPlayFrame = fPlayTrack->CurrentFrame();

	// Create our internal Node which plays sound, and register it.
	fPlayer = new BSoundPlayer(fAudioMixerNode, &fPlayFormat.u.raw_audio,
		"Sound Player");
	status_t err = fPlayer->InitCheck();
	if (err < B_OK)
		return;

	fVolumeSlider->SetSoundPlayer(fPlayer);
	fPlayer->SetCallbacks(PlayFile, NotifyPlayFile, this);

	//	And get it going...
	fPlayer->Start();
	fPlayer->SetHasData(true);
}


void
RecorderWindow::Stop(BMessage * message)
{
	//	User pressed Stop button.
	//	Stop recorder.
	StopRecording();
	//	Stop player.
	StopPlaying();
}


void
RecorderWindow::Save(BMessage * message)
{
	//	User pressed Save button.
	//	Find the item to save.
	int32 index = fSoundList->CurrentSelection();
	SoundListItem* pItem = dynamic_cast<SoundListItem*>(fSoundList->ItemAt(index));
	if ((! pItem) || (pItem->Entry().InitCheck() != B_OK))
		return;

	// Update the save panel and show it.
	char filename[B_FILE_NAME_LENGTH];
	pItem->Entry().GetName(filename);
	BMessage saveMsg(B_SAVE_REQUESTED);
	entry_ref ref;
	pItem->Entry().GetRef(&ref);

	if (saveMsg.AddPointer("sound list item", pItem) != B_OK)
		fprintf(stderr, "failed to add pItem\n");
	fSavePanel->SetSaveText(filename);
	fSavePanel->SetMessage(&saveMsg);
	fSavePanel->Show();
}


void
RecorderWindow::DoSave(BMessage * message)
{
	// User picked a place to put the file.
	// Find the location of the old (e.g.
	// temporary file), and the name of the
	// new file to save.
	entry_ref old_ref, new_dir_ref;
	const char* new_name;
	SoundListItem* pItem;

	if ((message->FindPointer("sound list item", (void**) &pItem) == B_OK)
		&& (message->FindRef("directory", &new_dir_ref) == B_OK)
		&& (message->FindString("name", &new_name) == B_OK)) {
		BEntry& oldEntry = pItem->Entry();
		BFile oldFile(&oldEntry, B_READ_WRITE);
		if (oldFile.InitCheck() != B_OK)
			return;

		BDirectory newDir(&new_dir_ref);
		if (newDir.InitCheck() != B_OK)
			return;

		BFile newFile;
		newDir.CreateFile(new_name, &newFile);

		if (newFile.InitCheck() != B_OK)
			return;

		status_t err = CopyFile(newFile, oldFile);

		if (err == B_OK) {
			// clean up the sound list and item
			if (pItem->IsTemp())
				oldEntry.Remove(); // blows away temp file!
			oldEntry.SetTo(&newDir, new_name);
			pItem->SetTemp(false);	// don't blow the new entry away when we exit!
			fSoundList->Invalidate();
		}
	} else {
		WINDOW((stderr, "Couldn't save file.\n"));
	}
}


void
RecorderWindow::Input(BMessage * message)
{
	//	User selected input from pop-up
	const dormant_node_info * dni = 0;
	ssize_t size = 0;
	if (message->FindData("node", B_RAW_TYPE, (const void **)&dni, &size))
		return;		//	bad input selection message

	media_node_id node_id;
	status_t error = fRoster->GetInstancesFor(dni->addon, dni->flavor_id, &node_id);
	if (error != B_OK)
		fRoster->InstantiateDormantNode(*dni, &fAudioInputNode);
	else
		fRoster->GetNodeFor(node_id, &fAudioInputNode);
}


void
RecorderWindow::Selected(BMessage * message)
{
	//	User selected a sound in list view
	int32 selIdx = fSoundList->CurrentSelection();
	SoundListItem* pItem = dynamic_cast<SoundListItem*>(fSoundList->ItemAt(selIdx));
	if (!pItem)
		return;
	status_t err = UpdatePlayFile(pItem, true);
	if (err != B_OK) {
		ErrorAlert(B_TRANSLATE("Cannot recognize this file as a media file"),
			err == B_MEDIA_NO_HANDLER ? B_OK : err);
		RemoveCurrentSoundItem();
	}
	UpdateButtons();
}


status_t
RecorderWindow::MakeRecordConnection(const media_node & input)
{
	CONNECT((stderr, "RecorderWindow::MakeRecordConnection()\n"));

	status_t err = B_OK;
	media_output audioOutput;

	if (!fRecorder->IsConnected()) {
		//	Find an available output for the given input node.
		int32 count = 0;
		err = fRoster->GetFreeOutputsFor(input, &audioOutput, 1,
			&count, B_MEDIA_RAW_AUDIO);

		if (err < B_OK) {
			CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
				" couldn't get free outputs from audio input node\n"));
			return err;
		}

		if (count < 1) {
			CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
				" no free outputs from audio input node\n"));
			return B_BUSY;
		}

		// Get a format, any format.
		fRecordFormat.u.raw_audio = audioOutput.format.u.raw_audio;
		fExternalConnection = false;
	} else {
		fRecordFormat.u.raw_audio = fRecorder->AcceptedFormat().u.raw_audio;
		fExternalConnection = true;
	}

	fRecordFormat.type = B_MEDIA_RAW_AUDIO;

	//	Tell the consumer where we want data to go.
	err = fRecorder->SetHooks(RecordFile, NotifyRecordFile, this);

	if (err < B_OK) {
		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
			" couldn't set the sound recorder's hook functions\n"));
		return err;
	}

	if (!fRecorder->IsConnected()) {

		err = fRecorder->Connect(input, &audioOutput, &fRecordFormat);

		if (err < B_OK) {
			CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
				" failed to connect sound recorder to audio input node.\n"));

			fRecorder->SetHooks(NULL, NULL, NULL);
			return err;
		}
	}

	return B_OK;
}


status_t
RecorderWindow::BreakRecordConnection()
{
	return fRecorder->Disconnect();
}


status_t
RecorderWindow::StopRecording()
{
	if (!fRecording)
		return B_OK;
	fRecording = false;

	status_t err = B_OK;
	err = fRecorder->Stop(true);
	if (err < B_OK)
		return err;

	// We maintain the connection active
	// if the user connected us from Cortex.
	if (!fExternalConnection) {
		BreakRecordConnection();
	}

	fRecorder->SetHooks(NULL, NULL, NULL);

	if (fRecSize > 0) {

		wave_struct header;
		header.riff.riff_id = FOURCC('R','I','F','F');
		header.riff.len = fRecSize + sizeof(header) - 8;
		header.riff.wave_id = FOURCC('W','A','V','E');
		header.format_chunk.fourcc = FOURCC('f','m','t',' ');
		header.format_chunk.len = sizeof(header.format);
		header.format.format_tag = 1;
		header.format.channels = fRecordFormat.u.raw_audio.channel_count;
		header.format.samples_per_sec = (uint32)fRecordFormat.u.raw_audio.frame_rate;
		header.format.avg_bytes_per_sec = (uint32)(fRecordFormat.u.raw_audio.frame_rate
			* fRecordFormat.u.raw_audio.channel_count
			* (fRecordFormat.u.raw_audio.format & 0xf));
		header.format.bits_per_sample = (fRecordFormat.u.raw_audio.format & 0xf) * 8;
		header.format.block_align = (fRecordFormat.u.raw_audio.format & 0xf)
			* fRecordFormat.u.raw_audio.channel_count;
		header.data_chunk.fourcc = FOURCC('d','a','t','a');
		header.data_chunk.len = fRecSize;
		fRecFile.Seek(0, SEEK_SET);
		fRecFile.Write(&header, sizeof(header));

		fRecFile.SetSize(fRecSize + sizeof(header));
		//	We reserve space; make sure we cut off any excess at the end.
		AddSoundItem(fRecEntry, true);
	} else
		fRecEntry.Remove();

	//	We're done for this time.
	fRecEntry.Unset();
	//	Close the file.
	fRecFile.Unset();
	//	No more recording going on.
	fRecSize = 0;
	SetButtonState(btnPaused);
	fRecordButton->SetStopped();

	return B_OK;
}


status_t
RecorderWindow::StopPlaying()
{
	if (fPlayer) {
		fPlayer->Stop();
		fPlayer->SetCallbacks(0, 0, 0);
		fVolumeSlider->SetSoundPlayer(NULL);
		delete fPlayer;
		fPlayer = NULL;
	}
	SetButtonState(btnPaused);
	fPlayButton->SetStopped();
	fTrackSlider->ResetMainTime();
	fScopeView->SetMainTime(*fTrackSlider->MainTime());
	return B_OK;
}


void
RecorderWindow::SetButtonState(BtnState state)
{
	fButtonState = state;
	UpdateButtons();
}


void
RecorderWindow::UpdateButtons()
{
	bool hasSelection = (fSoundList->CurrentSelection() >= 0);
	fRecordButton->SetEnabled(fButtonState != btnPlaying);
	fPlayButton->SetEnabled((fButtonState != btnRecording) && hasSelection);
	fRewindButton->SetEnabled((fButtonState != btnRecording) && hasSelection);
	fForwardButton->SetEnabled((fButtonState != btnRecording) && hasSelection);
	fStopButton->SetEnabled(fButtonState != btnPaused);
	fSaveButton->SetEnabled(hasSelection && (fButtonState != btnRecording));
	fInputField->SetEnabled(fButtonState != btnRecording);
}

#ifndef __HAIKU__
extern "C" status_t DecodedFormat__11BMediaTrackP12media_format(
	BMediaTrack *self, media_format *inout_format);
#endif


status_t
RecorderWindow::UpdatePlayFile(SoundListItem* item, bool updateDisplay)
{
	fScopeView->CancelRendering();
	StopPlaying();
	StopRecording();

	if (fPlayTrack && fPlayFile) {
		fPlayFile->ReleaseTrack(fPlayTrack);
		fPlayTrack = NULL;
	}
	if (fPlayFile) {
		delete fPlayFile;
		fPlayFile = NULL;
	}

	status_t err;
	BEntry& entry = item->Entry();
	entry_ref ref;
	entry.GetRef(&ref);
	fPlayFile = new BMediaFile(&ref); //, B_MEDIA_FILE_UNBUFFERED);
	if ((err = fPlayFile->InitCheck()) < B_OK) {
		delete fPlayFile;
		fPlayFile = NULL;
		return err;
	}

	for (int ix=0; ix < fPlayFile->CountTracks(); ix++) {
		BMediaTrack * track = fPlayFile->TrackAt(ix);
		fPlayFormat.type = B_MEDIA_RAW_AUDIO;
#ifdef __HAIKU__
		if ((track->DecodedFormat(&fPlayFormat) == B_OK)
#else
		if ((DecodedFormat__11BMediaTrackP12media_format(track, &fPlayFormat) == B_OK)
#endif
			&& (fPlayFormat.type == B_MEDIA_RAW_AUDIO)) {
			fPlayTrack = track;
			break;
		}
		if (track)
			fPlayFile->ReleaseTrack(track);
	}

	if (!fPlayTrack) {
		delete fPlayFile;
		fPlayFile = NULL;
		return B_STREAM_NOT_FOUND;
	}

	if (!updateDisplay)
		return B_OK;

	BString filename = B_TRANSLATE("File name: ");
	filename << ref.name;
	fFilename->SetText(filename.String());

	BString format = B_TRANSLATE("Format: ");
	media_file_format file_format;
	if (fPlayFile->GetFileFormatInfo(&file_format) == B_OK)
		format << file_format.short_name;
	BString compression = B_TRANSLATE("Compression: ");
	media_codec_info codec_info;
	if (fPlayTrack->GetCodecInfo(&codec_info) == B_OK) {
		if (strcmp(codec_info.short_name, "raw")==0)
			compression << B_TRANSLATE("None");
		else
			compression << codec_info.short_name;
	}
	BString channels = B_TRANSLATE("Channels: ");
	channels << fPlayFormat.u.raw_audio.channel_count;
	BString samplesize = B_TRANSLATE("Sample size: ");
	samplesize << 8 * (fPlayFormat.u.raw_audio.format & 0xf)
		<< B_TRANSLATE(" bits");
	BString samplerate = B_TRANSLATE("Sample rate: ");
	samplerate << (int)fPlayFormat.u.raw_audio.frame_rate;
	BString durationString = B_TRANSLATE("Duration: ");
	bigtime_t duration = fPlayTrack->Duration();
	durationString << (float)(duration / 1000000.0) << B_TRANSLATE(" seconds");

	fFormat->SetText(format.String());
	fCompression->SetText(compression.String());
	fChannels->SetText(channels.String());
	fSampleSize->SetText(samplesize.String());
	fSampleRate->SetText(samplerate.String());
	fDuration->SetText(durationString.String());

	fTrackSlider->SetTotalTime(duration, true);
	fScopeView->SetTotalTime(duration, true);
	fScopeView->RenderTrack(fPlayTrack, fPlayFormat);

	fPlayFrames = fPlayTrack->CountFrames();
	return B_OK;
}


void
RecorderWindow::ErrorAlert(const char * action, status_t err)
{
	char msg[300];
	if (err != B_OK)
		sprintf(msg, "%s: %s. [%" B_PRIx32 "]", action, strerror(err), (int32) err);
	else
		sprintf(msg, "%s.", action);
	BAlert* alert = new BAlert("", msg, B_TRANSLATE("Stop"));
	alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
	alert->Go();
}


status_t
RecorderWindow::NewTempName(char * name)
{
	int init_count = fTempCount;
again:
	if (fTempCount-init_count > 25) {
		return B_ERROR;
	}
	else {
		fTempCount++;
		if (fTempCount==0)
			sprintf(name, "Audio Clip");
		else
			sprintf(name, "Audio Clip %d", fTempCount);
		BPath path;
		status_t err;
		BEntry tempEnt;
		if ((err = fTempDir.GetEntry(&tempEnt)) < B_OK) {
			return err;
		}
		if ((err = tempEnt.GetPath(&path)) < B_OK) {
			return err;
		}
		path.Append(name);
		int fd;
		//	Use O_EXCL so we know we created the file (sync with other instances)
		if ((fd = open(path.Path(), O_RDWR | O_CREAT | O_EXCL, 0666)) < 0) {
			goto again;
		}
		close(fd);
	}
	return B_OK;
}


void
RecorderWindow::AddSoundItem(const BEntry& entry, bool temp)
{
	//	Create list item to display.
	SoundListItem * listItem = new SoundListItem(entry, temp);
	fSoundList->AddItem(listItem);
	fSoundList->Invalidate();
	fSoundList->Select(fSoundList->IndexOf(listItem));
}


void
RecorderWindow::RemoveCurrentSoundItem() {
	int32 index = fSoundList->CurrentSelection();
	BListItem *item = fSoundList->RemoveItem(index);
	delete item;
	if (index >= fSoundList->CountItems())
		index = fSoundList->CountItems() - 1;
	fSoundList->Select(index);
}


void
RecorderWindow::RecordFile(void* cookie, bigtime_t timestamp,
	void* data, size_t size, const media_format &format)
{
	//	Callback called from the SoundConsumer when receiving buffers.
	RecorderWindow * window = (RecorderWindow *)cookie;

	if (window->fRecording) {
		//	Write the data to file (we don't buffer or guard file access
		//	or anything)
		window->fRecFile.WriteAt(window->fRecSize, data, size);
		window->fVUView->ComputeLevels(data, size, format.u.raw_audio.format);
		window->fRecSize += size;
	}
}


void
RecorderWindow::NotifyRecordFile(void * cookie,
	BMediaRecorder::notification code, ...)
{
	if (code == BMediaRecorder::B_WILL_STOP) {
		RecorderWindow * window = (RecorderWindow *)cookie;
		// Tell the window we've stopped, if it doesn't
		// already know.
		window->PostMessage(STOP_RECORDING);
	}
}


void
RecorderWindow::PlayFile(void * cookie, void * data, size_t size,
	const media_raw_audio_format & format)
{
	//	Callback called from the SoundProducer when producing buffers.
	RecorderWindow * window = (RecorderWindow *)cookie;
	int32 frame_size = (window->fPlayFormat.u.raw_audio.format & 0xf) *
		window->fPlayFormat.u.raw_audio.channel_count;

	if ((window->fPlayFrame < window->fPlayLimit) || window->fLooping) {
		if (window->fPlayFrame >= window->fPlayLimit) {
			bigtime_t left = window->fTrackSlider->LeftTime();
			window->fPlayTrack->SeekToTime(&left);
			window->fPlayFrame = window->fPlayTrack->CurrentFrame();
		}
		int64 frames = 0;
		window->fPlayTrack->ReadFrames(data, &frames);
		window->fVUView->ComputeLevels(data, size / frame_size, format.format);
		window->fPlayFrame += size/frame_size;
		window->PostMessage(UPDATE_TRACKSLIDER);
	} else {
		//	we're done!
		window->PostMessage(STOP_PLAYING);
	}
}


void
RecorderWindow::NotifyPlayFile(void * cookie,
	BSoundPlayer::sound_player_notification code, ...)
{
	if ((code == BSoundPlayer::B_STOPPED) || (code == BSoundPlayer::B_SOUND_DONE)) {
		RecorderWindow * window = (RecorderWindow *)cookie;
		// tell the window we've stopped, if it doesn't
		// already know.
		window->PostMessage(STOP_PLAYING);
	}
}


void
RecorderWindow::RefsReceived(BMessage *msg)
{
	entry_ref ref;
	int32 i = 0;
	int32 countGood = 0;
	int32 countBad = 0;

	while (msg->FindRef("refs", i++, &ref) == B_OK) {

		BEntry entry(&ref, true);
		BPath path(&entry);
		BNode node(&entry);

		if (node.IsFile()) {
			SoundListItem * listItem = new SoundListItem(entry, false);
			if (UpdatePlayFile(listItem) == B_OK) {
				fSoundList->AddItem(listItem);
				countGood++;
				continue;
			}
			delete listItem;
		} else if(node.IsDirectory()) {

		}
		countBad++;
	}

	if (countBad == 1 && countGood == 0) {
		BAlert* alert = new BAlert(B_TRANSLATE("Nothing to play"),
			B_TRANSLATE("The file doesn't appear to be an audio file."),
			B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
		alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
		alert->Go();
	} else if (countBad > 0 && countGood == 0) {
		BAlert* alert = new BAlert(B_TRANSLATE("Nothing to play"),
			B_TRANSLATE("None of the files appear to be audio files."),
			B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
		alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
		alert->Go();
	} else if (countGood > 0) {
		if (countBad > 0) {
			BAlert* alert = new BAlert(B_TRANSLATE("Invalid audio files"),
			B_TRANSLATE("Some of the files don't appear to be audio files."),
				B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_AS_USUAL,
				B_WARNING_ALERT);
			alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
			alert->Go();
		}
		fSoundList->Select(fSoundList->CountItems() - 1);
	}
}


void
RecorderWindow::CopyTarget(BMessage *msg)
{
	const char *type = NULL;
	if (msg->FindString("be:types", &type) == B_OK) {
		if (!strcasecmp(type, B_FILE_MIME_TYPE)) {
			const char *name;
			entry_ref dir;
			if (msg->FindString("be:filetypes") != NULL
				&& msg->FindString("name", &name) == B_OK
				&& msg->FindRef("directory", &dir) == B_OK) {
				BDirectory directory(&dir);
				BFile file(&directory, name, O_RDWR | O_TRUNC);

				// seek time
				bigtime_t start = fTrackSlider->LeftTime();

				// write data
				bigtime_t diffTime = fTrackSlider->RightTime()
					- fTrackSlider->LeftTime();
				int64 framesToWrite = (int64) (diffTime
					* fPlayFormat.u.raw_audio.frame_rate / 1000000LL);
				int32 frameSize = (fPlayFormat.u.raw_audio.format & 0xf)
					* fPlayFormat.u.raw_audio.channel_count;

				wave_struct header;
				header.riff.riff_id = FOURCC('R','I','F','F');
				header.riff.len
					= (frameSize * framesToWrite) + sizeof(header) - 8;
				header.riff.wave_id = FOURCC('W','A','V','E');
				header.format_chunk.fourcc = FOURCC('f','m','t',' ');
				header.format_chunk.len = sizeof(header.format);
				header.format.format_tag = 1;
				header.format.channels = fPlayFormat.u.raw_audio.channel_count;
				header.format.samples_per_sec
					= (uint32)fPlayFormat.u.raw_audio.frame_rate;
				header.format.avg_bytes_per_sec
					= (uint32)(fPlayFormat.u.raw_audio.frame_rate
					* fPlayFormat.u.raw_audio.channel_count
					* (fPlayFormat.u.raw_audio.format & 0xf));
				header.format.bits_per_sample
					= (fPlayFormat.u.raw_audio.format & 0xf) * 8;
				header.format.block_align = frameSize;
				header.data_chunk.fourcc = FOURCC('d','a','t','a');
				header.data_chunk.len = frameSize * framesToWrite;
				file.Seek(0, SEEK_SET);
				file.Write(&header, sizeof(header));

				char *data = (char *)malloc(fPlayFormat.u.raw_audio.buffer_size);

				fPlayTrack->SeekToTime(&start);
				fPlayFrame = fPlayTrack->CurrentFrame();
				while (framesToWrite > 0) {
					int64 frames = 0;
					status_t err = fPlayTrack->ReadFrames(data, &frames);
					if (frames <= 0 || err != B_OK) {
						if (err != B_OK)
							fprintf(stderr, "CopyTarget: ReadFrames failed\n");
						break;
					}
					file.Write(data, frames * frameSize);
					framesToWrite -= frames;
				}

				file.Sync();
				free(data);
				BNodeInfo nodeInfo(&file);
				// set type
			}
		} else {

		}
	}
}