xref: /haiku/src/apps/soundrecorder/RecorderWindow.cpp (revision 7974d3dcf39ce78e5885b481eee12e561ad6e096)
157e2f323SJérôme Duval /*
257e2f323SJérôme Duval  * Copyright 2005, Jérôme Duval. All rights reserved.
357e2f323SJérôme Duval  * Distributed under the terms of the MIT License.
457e2f323SJérôme Duval  *
5ad0c65eaSJérôme Duval  * Inspired by SoundCapture from Be newsletter (Media Kit Basics:
6ad0c65eaSJérôme Duval  *	Consumers and Producers)
757e2f323SJérôme Duval  */
857e2f323SJérôme Duval 
957e2f323SJérôme Duval #include <Application.h>
1057e2f323SJérôme Duval #include <Alert.h>
1157e2f323SJérôme Duval #include <Debug.h>
1257e2f323SJérôme Duval #include <Screen.h>
1357e2f323SJérôme Duval #include <Button.h>
1457e2f323SJérôme Duval #include <CheckBox.h>
1557e2f323SJérôme Duval #include <TextControl.h>
1657e2f323SJérôme Duval #include <MenuField.h>
1757e2f323SJérôme Duval #include <PopUpMenu.h>
1857e2f323SJérôme Duval #include <MenuItem.h>
1957e2f323SJérôme Duval #include <Box.h>
2057e2f323SJérôme Duval #include <ScrollView.h>
2157e2f323SJérôme Duval #include <Beep.h>
2257e2f323SJérôme Duval #include <StringView.h>
2357e2f323SJérôme Duval #include <String.h>
2457e2f323SJérôme Duval #include <Slider.h>
2557e2f323SJérôme Duval #include <Message.h>
2657e2f323SJérôme Duval 
2757e2f323SJérôme Duval #include <Path.h>
2857e2f323SJérôme Duval #include <FindDirectory.h>
2957e2f323SJérôme Duval #include <MediaAddOn.h>
3057e2f323SJérôme Duval 
3157e2f323SJérôme Duval #include <SoundPlayer.h>
3257e2f323SJérôme Duval 
3357e2f323SJérôme Duval #include <assert.h>
3457e2f323SJérôme Duval #include <stdio.h>
3557e2f323SJérôme Duval #include <string.h>
3657e2f323SJérôme Duval #include <stdlib.h>
3757e2f323SJérôme Duval #include <ctype.h>
3857e2f323SJérôme Duval #include <unistd.h>
39338b8dc3SIngo Weinhold #include <fcntl.h>
4057e2f323SJérôme Duval 
4157e2f323SJérôme Duval #include <MediaRoster.h>
4257e2f323SJérôme Duval #include <TimeSource.h>
43019ed09bSJérôme Duval #include <NodeInfo.h>
4457e2f323SJérôme Duval 
4557e2f323SJérôme Duval #include "RecorderWindow.h"
4657e2f323SJérôme Duval #include "SoundConsumer.h"
4757e2f323SJérôme Duval #include "FileUtils.h"
4857e2f323SJérôme Duval 
4957e2f323SJérôme Duval #if ! NDEBUG
5057e2f323SJérôme Duval #define FPRINTF(args) fprintf args
5157e2f323SJérôme Duval #else
5257e2f323SJérôme Duval #define FPRINTF(args)
5357e2f323SJérôme Duval #endif
5457e2f323SJérôme Duval 
5557e2f323SJérôme Duval #define DEATH FPRINTF
5657e2f323SJérôme Duval #define CONNECT FPRINTF
5757e2f323SJérôme Duval #define WINDOW FPRINTF
5857e2f323SJérôme Duval 
5957e2f323SJérôme Duval // default window positioning
6057e2f323SJérôme Duval static const float MIN_WIDTH = 400.0f;
6157e2f323SJérôme Duval static const float MIN_HEIGHT = 336.0f;
6257e2f323SJérôme Duval static const float XPOS = 100.0f;
6357e2f323SJérôme Duval static const float YPOS = 200.0f;
6457e2f323SJérôme Duval 
65ad0c65eaSJérôme Duval #define FOURCC(a,b,c,d)	((((uint32)(d)) << 24) | (((uint32)(c)) << 16) \
66ad0c65eaSJérôme Duval 	| (((uint32)(b)) << 8) | ((uint32)(a)))
6757e2f323SJérôme Duval 
6857e2f323SJérôme Duval struct riff_struct
6957e2f323SJérôme Duval {
7057e2f323SJérôme Duval 	uint32 riff_id; // 'RIFF'
7157e2f323SJérôme Duval 	uint32 len;
7257e2f323SJérôme Duval 	uint32 wave_id;	// 'WAVE'
7357e2f323SJérôme Duval };
7457e2f323SJérôme Duval 
7557e2f323SJérôme Duval struct chunk_struct
7657e2f323SJérôme Duval {
7757e2f323SJérôme Duval 	uint32 fourcc;
7857e2f323SJérôme Duval 	uint32 len;
7957e2f323SJérôme Duval };
8057e2f323SJérôme Duval 
8157e2f323SJérôme Duval struct format_struct
8257e2f323SJérôme Duval {
8357e2f323SJérôme Duval 	uint16 format_tag;
8457e2f323SJérôme Duval 	uint16 channels;
8557e2f323SJérôme Duval 	uint32 samples_per_sec;
8657e2f323SJérôme Duval 	uint32 avg_bytes_per_sec;
8757e2f323SJérôme Duval 	uint16 block_align;
8857e2f323SJérôme Duval 	uint16 bits_per_sample;
8957e2f323SJérôme Duval };
9057e2f323SJérôme Duval 
9157e2f323SJérôme Duval 
9257e2f323SJérôme Duval struct wave_struct
9357e2f323SJérôme Duval {
9457e2f323SJérôme Duval 	struct riff_struct riff;
9557e2f323SJérôme Duval 	struct chunk_struct format_chunk;
9657e2f323SJérôme Duval 	struct format_struct format;
9757e2f323SJérôme Duval 	struct chunk_struct data_chunk;
9857e2f323SJérôme Duval };
9957e2f323SJérôme Duval 
10057e2f323SJérôme Duval 
10157e2f323SJérôme Duval RecorderWindow::RecorderWindow() :
102ad0c65eaSJérôme Duval 	BWindow(BRect(XPOS,YPOS,XPOS+MIN_WIDTH,YPOS+MIN_HEIGHT), "SoundRecorder",
103ad0c65eaSJérôme Duval 		B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS | B_NOT_V_RESIZABLE | B_NOT_ZOOMABLE),
10457e2f323SJérôme Duval 		fPlayer(NULL),
1055fa77532SJérôme Duval 		fSoundList(NULL),
10657e2f323SJérôme Duval 		fPlayFile(NULL),
10757e2f323SJérôme Duval 		fPlayTrack(NULL),
1087942339dSJérôme Duval 		fPlayFrames(0),
109948356deSJérôme Duval 		fLooping(false),
1105fa77532SJérôme Duval 		fSavePanel(NULL),
1115fa77532SJérôme Duval 		fInitCheck(B_OK)
11257e2f323SJérôme Duval {
11357e2f323SJérôme Duval 	fRoster = NULL;
11457e2f323SJérôme Duval 	fRecordButton = NULL;
11557e2f323SJérôme Duval 	fPlayButton = NULL;
11657e2f323SJérôme Duval 	fStopButton = NULL;
11757e2f323SJérôme Duval 	fSaveButton = NULL;
118948356deSJérôme Duval 	fLoopButton = NULL;
11957e2f323SJérôme Duval 	fInputField = NULL;
12057e2f323SJérôme Duval 	fRecordNode = 0;
12157e2f323SJérôme Duval 	fRecording = false;
12257e2f323SJérôme Duval 	fTempCount = -1;
12357e2f323SJérôme Duval 	fButtonState = btnPaused;
12457e2f323SJérôme Duval 
12557e2f323SJérôme Duval 	CalcSizes(MIN_WIDTH, MIN_HEIGHT);
12657e2f323SJérôme Duval 
1275fa77532SJérôme Duval 	fInitCheck = InitWindow();
1285fa77532SJérôme Duval 	if (fInitCheck != B_OK) {
129bdb1d3acSJérôme Duval 		if (fInitCheck == B_NAME_NOT_FOUND)
130bdb1d3acSJérôme Duval 			ErrorAlert("find default audio hardware", fInitCheck);
131bdb1d3acSJérôme Duval 		else
1325fa77532SJérôme Duval 			ErrorAlert("connect to media server", fInitCheck);
1335fa77532SJérôme Duval 		PostMessage(B_QUIT_REQUESTED);
1345fa77532SJérôme Duval 	} else
1355fa77532SJérôme Duval 		Show();
13657e2f323SJérôme Duval }
13757e2f323SJérôme Duval 
1388e32a27eSPhilippe Saint-Pierre 
13957e2f323SJérôme Duval RecorderWindow::~RecorderWindow()
14057e2f323SJérôme Duval {
141ad0c65eaSJérôme Duval 	//	The sound consumer and producer are Nodes; it has to be released and the Roster
14257e2f323SJérôme Duval 	//	will reap it when it's done.
14357e2f323SJérôme Duval 	if (fRecordNode) {
14457e2f323SJérôme Duval 		fRecordNode->Release();
14557e2f323SJérôme Duval 	}
14657e2f323SJérôme Duval 	if (fPlayer) {
14757e2f323SJérôme Duval 		delete fPlayer;
14857e2f323SJérôme Duval 	}
1497942339dSJérôme Duval 
1507942339dSJérôme Duval 	if (fPlayTrack && fPlayFile)
1517942339dSJérôme Duval 		fPlayFile->ReleaseTrack(fPlayTrack);
1527942339dSJérôme Duval 	if (fPlayFile)
1537942339dSJérôme Duval 		delete fPlayFile;
1547942339dSJérôme Duval 	fPlayTrack = NULL;
1557942339dSJérôme Duval 	fPlayFile = NULL;
1567942339dSJérôme Duval 
15757e2f323SJérôme Duval 	//	Clean up items in list view.
15857e2f323SJérôme Duval 	if (fSoundList) {
15957e2f323SJérôme Duval 		fSoundList->DeselectAll();
160ad0c65eaSJérôme Duval 		for (int i = 0; i < fSoundList->CountItems(); i++) {
161ad0c65eaSJérôme Duval 			WINDOW((stderr, "clean up item %d\n", i+1));
162ad0c65eaSJérôme Duval 			SoundListItem* item = dynamic_cast<SoundListItem *>(fSoundList->ItemAt(i));
16357e2f323SJérôme Duval 			if (item) {
16457e2f323SJérôme Duval 				if (item->IsTemp()) {
16557e2f323SJérôme Duval 					item->Entry().Remove();	//	delete temp file
16657e2f323SJérôme Duval 				}
16757e2f323SJérôme Duval 				delete item;
16857e2f323SJérôme Duval 			}
16957e2f323SJérôme Duval 		}
17057e2f323SJérôme Duval 		fSoundList->MakeEmpty();
17157e2f323SJérôme Duval 	}
17257e2f323SJérôme Duval 	//	Clean up currently recording file, if any.
17357e2f323SJérôme Duval 	fRecEntry.Remove();
17457e2f323SJérôme Duval 	fRecEntry.Unset();
17505ea8535SKarsten Heimrich 
17605ea8535SKarsten Heimrich 	delete fSavePanel;
17757e2f323SJérôme Duval }
17857e2f323SJérôme Duval 
17957e2f323SJérôme Duval 
1805fa77532SJérôme Duval status_t
1815fa77532SJérôme Duval RecorderWindow::InitCheck()
1825fa77532SJérôme Duval {
1835fa77532SJérôme Duval 	return fInitCheck;
1845fa77532SJérôme Duval }
1855fa77532SJérôme Duval 
1865fa77532SJérôme Duval 
18757e2f323SJérôme Duval void
18857e2f323SJérôme Duval RecorderWindow::CalcSizes(float min_wid, float min_hei)
18957e2f323SJérôme Duval {
19057e2f323SJérôme Duval 	//	Set up size limits based on new screen size
1915e99b7dfSJérôme Duval 	BScreen screen(this);
19257e2f323SJérôme Duval 	BRect r = screen.Frame();
19357e2f323SJérôme Duval 	float wid = r.Width()-12;
19457e2f323SJérôme Duval 	SetSizeLimits(min_wid, wid, min_hei, r.Height()-24);
19557e2f323SJérôme Duval 
19657e2f323SJérôme Duval 	//	Don't zoom to cover all of screen; user can resize last bit if necessary.
19757e2f323SJérôme Duval 	//	This leaves other windows visible.
19857e2f323SJérôme Duval 	if (wid > 640) {
19957e2f323SJérôme Duval 		wid = 640 + (wid-640)/2;
20057e2f323SJérôme Duval 	}
20157e2f323SJérôme Duval 	SetZoomLimits(wid, r.Height()-24);
20257e2f323SJérôme Duval }
20357e2f323SJérôme Duval 
20457e2f323SJérôme Duval 
20557e2f323SJérôme Duval status_t
20657e2f323SJérôme Duval RecorderWindow::InitWindow()
20757e2f323SJérôme Duval {
20857e2f323SJérôme Duval 	BPopUpMenu * popup = 0;
20957e2f323SJérôme Duval 	status_t error;
21057e2f323SJérôme Duval 
21157e2f323SJérôme Duval 	try {
21257e2f323SJérôme Duval 		//	Find temp directory for recorded sounds.
21357e2f323SJérôme Duval 		BPath path;
21457e2f323SJérôme Duval 		if (!(error = find_directory(B_COMMON_TEMP_DIRECTORY, &path))) {
21557e2f323SJérôme Duval 			error = fTempDir.SetTo(path.Path());
21657e2f323SJérôme Duval 		}
21757e2f323SJérôme Duval 		if (error < 0) {
21857e2f323SJérôme Duval 			goto bad_mojo;
21957e2f323SJérôme Duval 		}
22057e2f323SJérôme Duval 
22157e2f323SJérôme Duval 		//	Make sure the media roster is there (which means the server is there).
22257e2f323SJérôme Duval 		fRoster = BMediaRoster::Roster(&error);
22357e2f323SJérôme Duval 		if (!fRoster) {
22457e2f323SJérôme Duval 			goto bad_mojo;
22557e2f323SJérôme Duval 		}
22657e2f323SJérôme Duval 
22757e2f323SJérôme Duval 		error = fRoster->GetAudioInput(&fAudioInputNode);
22857e2f323SJérôme Duval 		if (error < B_OK) {	//	there's no input?
22957e2f323SJérôme Duval 			goto bad_mojo;
23057e2f323SJérôme Duval 		}
23157e2f323SJérôme Duval 
23257e2f323SJérôme Duval 		error = fRoster->GetAudioMixer(&fAudioMixerNode);
23357e2f323SJérôme Duval 		if (error < B_OK) {	//	there's no mixer?
23457e2f323SJérôme Duval 			goto bad_mojo;
23557e2f323SJérôme Duval 		}
23657e2f323SJérôme Duval 
23757e2f323SJérôme Duval 		//	Create our internal Node which records sound, and register it.
23857e2f323SJérôme Duval 		fRecordNode = new SoundConsumer("Sound Recorder");
23957e2f323SJérôme Duval 		error = fRoster->RegisterNode(fRecordNode);
24057e2f323SJérôme Duval 		if (error < B_OK) {
24157e2f323SJérôme Duval 			goto bad_mojo;
24257e2f323SJérôme Duval 		}
24357e2f323SJérôme Duval 
24457e2f323SJérôme Duval 		//	Create the window header with controls
24557e2f323SJérôme Duval 		BRect r(Bounds());
24657e2f323SJérôme Duval 		r.bottom = r.top + 175;
247ad0c65eaSJérôme Duval 		BBox *background = new BBox(r, "_background", B_FOLLOW_LEFT_RIGHT
248ad0c65eaSJérôme Duval 			| B_FOLLOW_TOP, B_WILL_DRAW | B_FRAME_EVENTS | B_NAVIGABLE_JUMP, B_NO_BORDER);
24957e2f323SJérôme Duval 		AddChild(background);
25057e2f323SJérôme Duval 
25157e2f323SJérôme Duval 
25257e2f323SJérôme Duval 
25357e2f323SJérôme Duval 		r = background->Bounds();
254a4797804SJérôme Duval 		r.left = 0;
2558881ad65SJérôme Duval 		r.right = r.left + 38;
25657e2f323SJérôme Duval 		r.bottom = r.top + 104;
25757e2f323SJérôme Duval 		fVUView = new VUView(r, B_FOLLOW_LEFT|B_FOLLOW_TOP);
25857e2f323SJérôme Duval 		background->AddChild(fVUView);
25957e2f323SJérôme Duval 
26057e2f323SJérôme Duval 		r = background->Bounds();
2618881ad65SJérôme Duval 		r.left = r.left + 40;
26257e2f323SJérôme Duval 		r.bottom = r.top + 104;
26357e2f323SJérôme Duval 		fScopeView = new ScopeView(r, B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP);
26457e2f323SJérôme Duval 		background->AddChild(fScopeView);
26557e2f323SJérôme Duval 
26657e2f323SJérôme Duval 		r = background->Bounds();
26757e2f323SJérôme Duval 		r.left = 2;
26857e2f323SJérôme Duval 		r.right -= 26;
26957e2f323SJérôme Duval 		r.top = 115;
27057e2f323SJérôme Duval 		r.bottom = r.top + 30;
271ad0c65eaSJérôme Duval 		fTrackSlider = new TrackSlider(r, "trackSlider", new BMessage(POSITION_CHANGED),
272ad0c65eaSJérôme Duval 			B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
27357e2f323SJérôme Duval 		background->AddChild(fTrackSlider);
27457e2f323SJérôme Duval 
27557e2f323SJérôme Duval 		BRect buttonRect;
27657e2f323SJérôme Duval 
27757e2f323SJérôme Duval 		//	Button for rewinding
27857e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), kSkipButtonSize);
27957e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-7, 25));
28057e2f323SJérôme Duval 		fRewindButton = new TransportButton(buttonRect, "Rewind",
281ad0c65eaSJérôme Duval 			kSkipBackBitmapBits, kPressedSkipBackBitmapBits,
282ad0c65eaSJérôme Duval 			kDisabledSkipBackBitmapBits, new BMessage(REWIND));
28357e2f323SJérôme Duval 		background->AddChild(fRewindButton);
28457e2f323SJérôme Duval 
28557e2f323SJérôme Duval 		//	Button for stopping recording or playback
28657e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), kStopButtonSize);
28757e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-48, 25));
28857e2f323SJérôme Duval 		fStopButton = new TransportButton(buttonRect, "Stop",
289ad0c65eaSJérôme Duval 			kStopButtonBitmapBits, kPressedStopButtonBitmapBits,
290ad0c65eaSJérôme Duval 			kDisabledStopButtonBitmapBits, new BMessage(STOP));
29157e2f323SJérôme Duval 		background->AddChild(fStopButton);
29257e2f323SJérôme Duval 
29357e2f323SJérôme Duval 		//	Button for starting playback of selected sound
29457e2f323SJérôme Duval 		BRect playRect(BPoint(0,0), kPlayButtonSize);
29557e2f323SJérôme Duval 		playRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-82, 25));
29657e2f323SJérôme Duval 		fPlayButton = new PlayPauseButton(playRect, "Play",
29757e2f323SJérôme Duval 			new BMessage(PLAY), new BMessage(PLAY_PERIOD), ' ', 0);
29857e2f323SJérôme Duval 		background->AddChild(fPlayButton);
29957e2f323SJérôme Duval 
30057e2f323SJérôme Duval 		//	Button for forwarding
30157e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), kSkipButtonSize);
30257e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-133, 25));
30357e2f323SJérôme Duval 		fForwardButton = new TransportButton(buttonRect, "Forward",
304ad0c65eaSJérôme Duval 			kSkipForwardBitmapBits, kPressedSkipForwardBitmapBits,
305ad0c65eaSJérôme Duval 			kDisabledSkipForwardBitmapBits, new BMessage(FORWARD));
30657e2f323SJérôme Duval 		background->AddChild(fForwardButton);
30757e2f323SJérôme Duval 
30857e2f323SJérôme Duval 		//	Button to start recording (or waiting for sound)
30957e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), kRecordButtonSize);
31057e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-174, 25));
31157e2f323SJérôme Duval 		fRecordButton = new RecordButton(buttonRect, "Record",
31257e2f323SJérôme Duval 			new BMessage(RECORD), new BMessage(RECORD_PERIOD));
31357e2f323SJérôme Duval 		background->AddChild(fRecordButton);
31457e2f323SJérôme Duval 
31557e2f323SJérôme Duval 		//	Button for saving selected sound
31657e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), kDiskButtonSize);
31757e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().LeftBottom() - BPoint(-250, 21));
31857e2f323SJérôme Duval 		fSaveButton = new TransportButton(buttonRect, "Save",
319ad0c65eaSJérôme Duval 			kDiskButtonBitmapsBits, kPressedDiskButtonBitmapsBits,
320ad0c65eaSJérôme Duval 			kDisabledDiskButtonBitmapsBits, new BMessage(SAVE));
32157e2f323SJérôme Duval 		fSaveButton->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
32257e2f323SJérôme Duval 		background->AddChild(fSaveButton);
32357e2f323SJérôme Duval 
324948356deSJérôme Duval 		//	Button Loop
325948356deSJérôme Duval 		buttonRect = BRect(BPoint(0,0), kArrowSize);
326948356deSJérôme Duval 		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(23, 48));
327948356deSJérôme Duval 		fLoopButton = new DrawButton(buttonRect, "Loop",
328948356deSJérôme Duval 			kLoopArrowBits, kArrowBits, new BMessage(LOOP));
329948356deSJérôme Duval 		fLoopButton->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
330948356deSJérôme Duval 		fLoopButton->SetTarget(this);
331948356deSJérôme Duval 		background->AddChild(fLoopButton);
332948356deSJérôme Duval 
33357e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), kSpeakerIconBitmapSize);
33457e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(121, 17));
335ad0c65eaSJérôme Duval 		SpeakerView *speakerView = new SpeakerView(buttonRect,
336ad0c65eaSJérôme Duval 			B_FOLLOW_LEFT | B_FOLLOW_TOP);
33757e2f323SJérôme Duval 		speakerView->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
33857e2f323SJérôme Duval 		background->AddChild(speakerView);
33957e2f323SJérôme Duval 
34057e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), BPoint(84, 19));
34157e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(107, 20));
342ad0c65eaSJérôme Duval 		fVolumeSlider = new VolumeSlider(buttonRect, "volumeSlider",
343ad0c65eaSJérôme Duval 			B_FOLLOW_LEFT | B_FOLLOW_TOP);
34457e2f323SJérôme Duval 		fVolumeSlider->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
34557e2f323SJérôme Duval 		background->AddChild(fVolumeSlider);
34657e2f323SJérôme Duval 
34757e2f323SJérôme Duval 		// Button to mask/see sounds list
34857e2f323SJérôme Duval 		buttonRect = BRect(BPoint(0,0), kUpDownButtonSize);
34957e2f323SJérôme Duval 		buttonRect.OffsetTo(background->Bounds().RightBottom() - BPoint(21, 25));
35057e2f323SJérôme Duval 		fUpDownButton = new UpDownButton(buttonRect, new BMessage(VIEW_LIST));
35157e2f323SJérôme Duval 		fUpDownButton->SetResizingMode(B_FOLLOW_RIGHT | B_FOLLOW_TOP);
35257e2f323SJérôme Duval 		background->AddChild(fUpDownButton);
35357e2f323SJérôme Duval 
35457e2f323SJérôme Duval 		r = Bounds();
35557e2f323SJérôme Duval 		r.top = background->Bounds().bottom + 1;
35657e2f323SJérôme Duval 		fBottomBox = new BBox(r, "bottomBox", B_FOLLOW_ALL);
35757e2f323SJérôme Duval 		fBottomBox->SetBorder(B_NO_BORDER);
35857e2f323SJérôme Duval 		AddChild(fBottomBox);
35957e2f323SJérôme Duval 
36057e2f323SJérôme Duval 		//	The actual list of recorded sounds (initially empty) sits
36157e2f323SJérôme Duval 		//	below the header with the controls.
36257e2f323SJérôme Duval 		r = fBottomBox->Bounds();
36357e2f323SJérôme Duval 		r.left += 190;
36457e2f323SJérôme Duval 		r.InsetBy(10, 10);
36557e2f323SJérôme Duval 		r.left -= 10;
36657e2f323SJérôme Duval 		r.top += 4;
36757e2f323SJérôme Duval 		r.right -= B_V_SCROLL_BAR_WIDTH;
36857e2f323SJérôme Duval 		r.bottom -= 25;
36957e2f323SJérôme Duval 		fSoundList = new SoundListView(r, "Sound List", B_FOLLOW_ALL);
37057e2f323SJérôme Duval 		fSoundList->SetSelectionMessage(new BMessage(SOUND_SELECTED));
37157e2f323SJérôme Duval 		fSoundList->SetViewColor(216, 216, 216);
372ad0c65eaSJérôme Duval 		BScrollView *scroller = new BScrollView("scroller", fSoundList,
373ad0c65eaSJérôme Duval 			B_FOLLOW_ALL, 0, false, true, B_FANCY_BORDER);
37457e2f323SJérôme Duval 		fBottomBox->AddChild(scroller);
37557e2f323SJérôme Duval 
37657e2f323SJérôme Duval 		r = fBottomBox->Bounds();
37757e2f323SJérôme Duval 		r.right = r.left + 190;
37857e2f323SJérôme Duval 		r.bottom -= 25;
37957e2f323SJérôme Duval 		r.InsetBy(10, 8);
38057e2f323SJérôme Duval 		r.top -= 1;
38157e2f323SJérôme Duval 		fFileInfoBox = new BBox(r, "fileinfo", B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
382*7974d3dcSStephan Aßmus 		fFileInfoBox->SetLabel("File info");
38357e2f323SJérôme Duval 
38457e2f323SJérôme Duval 		r = fFileInfoBox->Bounds();
38557e2f323SJérôme Duval 		r.left = 8;
38657e2f323SJérôme Duval 		r.top = 13;
38757e2f323SJérôme Duval 		r.bottom = r.top + 15;
38857e2f323SJérôme Duval 		r.right -= 10;
389*7974d3dcSStephan Aßmus 		fFilename = new BStringView(r, "filename", "File name:");
39057e2f323SJérôme Duval 		fFileInfoBox->AddChild(fFilename);
39157e2f323SJérôme Duval 		r.top += 13;
39257e2f323SJérôme Duval 		r.bottom = r.top + 15;
39357e2f323SJérôme Duval 		fFormat = new BStringView(r, "format", "Format:");
39457e2f323SJérôme Duval 		fFileInfoBox->AddChild(fFormat);
39557e2f323SJérôme Duval 		r.top += 13;
39657e2f323SJérôme Duval 		r.bottom = r.top + 15;
39757e2f323SJérôme Duval 		fCompression = new BStringView(r, "compression", "Compression:");
39857e2f323SJérôme Duval 		fFileInfoBox->AddChild(fCompression);
39957e2f323SJérôme Duval 		r.top += 13;
40057e2f323SJérôme Duval 		r.bottom = r.top + 15;
40157e2f323SJérôme Duval 		fChannels = new BStringView(r, "channels", "Channels:");
40257e2f323SJérôme Duval 		fFileInfoBox->AddChild(fChannels);
40357e2f323SJérôme Duval 		r.top += 13;
40457e2f323SJérôme Duval 		r.bottom = r.top + 15;
405*7974d3dcSStephan Aßmus 		fSampleSize = new BStringView(r, "samplesize", "Sample size:");
40657e2f323SJérôme Duval 		fFileInfoBox->AddChild(fSampleSize);
40757e2f323SJérôme Duval 		r.top += 13;
40857e2f323SJérôme Duval 		r.bottom = r.top + 15;
409*7974d3dcSStephan Aßmus 		fSampleRate = new BStringView(r, "samplerate", "Sample rate:");
41057e2f323SJérôme Duval 		fFileInfoBox->AddChild(fSampleRate);
41157e2f323SJérôme Duval 		r.top += 13;
41257e2f323SJérôme Duval 		r.bottom = r.top + 15;
41357e2f323SJérôme Duval 		fDuration = new BStringView(r, "duration", "Duration:");
41457e2f323SJérôme Duval 		fFileInfoBox->AddChild(fDuration);
41557e2f323SJérôme Duval 
41657e2f323SJérôme Duval 		//	Input selection lists all available physical inputs that produce
41757e2f323SJérôme Duval 		//	buffers with B_MEDIA_RAW_AUDIO format data.
41857e2f323SJérôme Duval 		popup = new BPopUpMenu("Input");
41957e2f323SJérôme Duval 		int max_input_count = 64;
42057e2f323SJérôme Duval 		dormant_node_info dni[max_input_count];
42157e2f323SJérôme Duval 
42257e2f323SJérôme Duval 		int32 real_count = max_input_count;
42357e2f323SJérôme Duval 		media_format output_format;
42457e2f323SJérôme Duval 		output_format.type = B_MEDIA_RAW_AUDIO;
42557e2f323SJérôme Duval 		output_format.u.raw_audio = media_raw_audio_format::wildcard;
42657e2f323SJérôme Duval 		error = fRoster->GetDormantNodes(dni, &real_count, 0, &output_format,
42757e2f323SJérôme Duval 			0, B_BUFFER_PRODUCER | B_PHYSICAL_INPUT);
42857e2f323SJérôme Duval 		if (real_count > max_input_count) {
42957e2f323SJérôme Duval 			WINDOW((stderr, "dropped %ld inputs\n", real_count - max_input_count));
43057e2f323SJérôme Duval 			real_count = max_input_count;
43157e2f323SJérôme Duval 		}
432*7974d3dcSStephan Aßmus 		char selected_name[B_MEDIA_NAME_LENGTH] = "Default input";
43357e2f323SJérôme Duval 		BMessage * msg;
43457e2f323SJérôme Duval 		BMenuItem * item;
435ad0c65eaSJérôme Duval 		for (int i = 0; i < real_count; i++) {
43657e2f323SJérôme Duval 			msg = new BMessage(INPUT_SELECTED);
437ad0c65eaSJérôme Duval 			msg->AddData("node", B_RAW_TYPE, &dni[i], sizeof(dni[i]));
438ad0c65eaSJérôme Duval 			item = new BMenuItem(dni[i].name, msg);
43957e2f323SJérôme Duval 			popup->AddItem(item);
44057e2f323SJérôme Duval 			media_node_id ni[12];
44157e2f323SJérôme Duval 			int32 ni_count = 12;
442ad0c65eaSJérôme Duval 			error = fRoster->GetInstancesFor(dni[i].addon, dni[i].flavor_id,
443ad0c65eaSJérôme Duval 				ni, &ni_count);
44457e2f323SJérôme Duval 			if (error == B_OK)
445ad0c65eaSJérôme Duval 				for (int j = 0; j < ni_count; j++)
446ad0c65eaSJérôme Duval 					if (ni[j] == fAudioInputNode.node) {
447ad0c65eaSJérôme Duval 						strcpy(selected_name, dni[i].name);
44857e2f323SJérôme Duval 						break;
44957e2f323SJérôme Duval 					}
45057e2f323SJérôme Duval 		}
45157e2f323SJérôme Duval 
45257e2f323SJérôme Duval 		//	Create the actual widget
45357e2f323SJérôme Duval 		BRect frame(fBottomBox->Bounds());
45457e2f323SJérôme Duval 		r = frame;
45557e2f323SJérôme Duval 		r.left = 42;
45657e2f323SJérôme Duval 		r.right = (r.left + r.right) / 2;
45757e2f323SJérôme Duval 		r.InsetBy(10,10);
45857e2f323SJérôme Duval 		r.top = r.bottom - 18;
45957e2f323SJérôme Duval 		fInputField = new BMenuField(r, "Input", "Input:", popup);
46080cfc30cSJérôme Duval 		fInputField->SetDivider(fInputField->StringWidth("Input:") + 4.0f);
46157e2f323SJérôme Duval 		fBottomBox->AddChild(fInputField);
46257e2f323SJérôme Duval 
46357e2f323SJérôme Duval 		fBottomBox->AddChild(fFileInfoBox);
46457e2f323SJérôme Duval 
46557e2f323SJérôme Duval 		fBottomBox->Hide();
46657e2f323SJérôme Duval 		CalcSizes(Frame().Width(), MIN_HEIGHT-161);
46757e2f323SJérôme Duval 		ResizeTo(Frame().Width(), MIN_HEIGHT-161);
46857e2f323SJérôme Duval 
46957e2f323SJérôme Duval 
47057e2f323SJérôme Duval 		popup->Superitem()->SetLabel(selected_name);
47157e2f323SJérôme Duval 
47257e2f323SJérôme Duval 		// Make sure the save panel is happy.
4735fa77532SJérôme Duval 		fSavePanel = new BFilePanel(B_SAVE_PANEL);
4745fa77532SJérôme Duval 		fSavePanel->SetTarget(this);
47557e2f323SJérôme Duval 	}
47657e2f323SJérôme Duval 	catch (...) {
47757e2f323SJérôme Duval 		goto bad_mojo;
47857e2f323SJérôme Duval 	}
47957e2f323SJérôme Duval 	UpdateButtons();
48057e2f323SJérôme Duval 	return B_OK;
48157e2f323SJérôme Duval 
48257e2f323SJérôme Duval 	//	Error handling.
48357e2f323SJérôme Duval bad_mojo:
48457e2f323SJérôme Duval 	if (error >= 0) {
48557e2f323SJérôme Duval 		error = B_ERROR;
48657e2f323SJérôme Duval 	}
48757e2f323SJérôme Duval 	if (fRecordNode) {
48857e2f323SJérôme Duval 		fRecordNode->Release();
48957e2f323SJérôme Duval 	}
49057e2f323SJérôme Duval 
49157e2f323SJérôme Duval 	delete fPlayer;
49257e2f323SJérôme Duval 	if (!fInputField) {
49357e2f323SJérôme Duval 		delete popup;
49457e2f323SJérôme Duval 	}
49557e2f323SJérôme Duval 	return error;
49657e2f323SJérôme Duval }
49757e2f323SJérôme Duval 
49857e2f323SJérôme Duval 
49957e2f323SJérôme Duval bool
50057e2f323SJérôme Duval RecorderWindow::QuitRequested()	//	this means Close pressed
50157e2f323SJérôme Duval {
50257e2f323SJérôme Duval 	StopRecording();
50357e2f323SJérôme Duval 	StopPlaying();
50457e2f323SJérôme Duval 	be_app->PostMessage(B_QUIT_REQUESTED);
50557e2f323SJérôme Duval 	return true;
50657e2f323SJérôme Duval }
50757e2f323SJérôme Duval 
50857e2f323SJérôme Duval 
50957e2f323SJérôme Duval void
51057e2f323SJérôme Duval RecorderWindow::MessageReceived(BMessage * message)
51157e2f323SJérôme Duval {
51257e2f323SJérôme Duval 	//	Your average generic message dispatching switch() statement.
51357e2f323SJérôme Duval 	switch (message->what) {
51457e2f323SJérôme Duval 	case INPUT_SELECTED:
51557e2f323SJérôme Duval 		Input(message);
51657e2f323SJérôme Duval 		break;
51757e2f323SJérôme Duval 	case SOUND_SELECTED:
51857e2f323SJérôme Duval 		Selected(message);
51957e2f323SJérôme Duval 		break;
52057e2f323SJérôme Duval 	case STOP_PLAYING:
52157e2f323SJérôme Duval 		StopPlaying();
52257e2f323SJérôme Duval 		break;
52357e2f323SJérôme Duval 	case STOP_RECORDING:
52457e2f323SJérôme Duval 		StopRecording();
52557e2f323SJérôme Duval 		break;
52657e2f323SJérôme Duval 	case PLAY_PERIOD:
52757e2f323SJérôme Duval 		if (fPlayer) {
52857e2f323SJérôme Duval 			if (fPlayer->HasData())
52957e2f323SJérôme Duval 				fPlayButton->SetPlaying();
53057e2f323SJérôme Duval 			else
53157e2f323SJérôme Duval 				fPlayButton->SetPaused();
53257e2f323SJérôme Duval 		}
53357e2f323SJérôme Duval 		break;
53457e2f323SJérôme Duval 	case RECORD_PERIOD:
53557e2f323SJérôme Duval 		fRecordButton->SetRecording();
53657e2f323SJérôme Duval 		break;
53757e2f323SJérôme Duval 	case RECORD:
53857e2f323SJérôme Duval 		Record(message);
53957e2f323SJérôme Duval 		break;
54057e2f323SJérôme Duval 	case STOP:
54157e2f323SJérôme Duval 		Stop(message);
54257e2f323SJérôme Duval 		break;
54357e2f323SJérôme Duval 	case PLAY:
54457e2f323SJérôme Duval 		Play(message);
54557e2f323SJérôme Duval 		break;
54657e2f323SJérôme Duval 	case SAVE:
54757e2f323SJérôme Duval 		Save(message);
54857e2f323SJérôme Duval 		break;
54957e2f323SJérôme Duval 	case B_SAVE_REQUESTED:
55057e2f323SJérôme Duval 		DoSave(message);
55157e2f323SJérôme Duval 		break;
55257e2f323SJérôme Duval 	case VIEW_LIST:
55357e2f323SJérôme Duval 		if (fUpDownButton->Value() == B_CONTROL_ON) {
55457e2f323SJérôme Duval 			fBottomBox->Show();
55557e2f323SJérôme Duval 			CalcSizes(Frame().Width(), MIN_HEIGHT);
55657e2f323SJérôme Duval 			ResizeTo(Frame().Width(), MIN_HEIGHT);
55757e2f323SJérôme Duval 		} else {
55857e2f323SJérôme Duval 			fBottomBox->Hide();
55957e2f323SJérôme Duval 			CalcSizes(Frame().Width(), MIN_HEIGHT-161);
56057e2f323SJérôme Duval 			ResizeTo(Frame().Width(), MIN_HEIGHT-161);
56157e2f323SJérôme Duval 
56257e2f323SJérôme Duval 		}
56357e2f323SJérôme Duval 		break;
56457e2f323SJérôme Duval 	case UPDATE_TRACKSLIDER:
56557e2f323SJérôme Duval 		{
56657e2f323SJérôme Duval 			bigtime_t timestamp = fPlayTrack->CurrentTime();
56757e2f323SJérôme Duval 			fTrackSlider->SetMainTime(timestamp, false);
56857e2f323SJérôme Duval 			fScopeView->SetMainTime(timestamp);
56957e2f323SJérôme Duval 		}
57057e2f323SJérôme Duval 		break;
57157e2f323SJérôme Duval 	case POSITION_CHANGED:
57257e2f323SJérôme Duval 		{
57357e2f323SJérôme Duval 		bigtime_t right, left, main;
57457e2f323SJérôme Duval 		if (message->FindInt64("main", &main) == B_OK) {
57557e2f323SJérôme Duval 			if (fPlayTrack) {
57657e2f323SJérôme Duval 				fPlayTrack->SeekToTime(fTrackSlider->MainTime());
57757e2f323SJérôme Duval 				fPlayFrame = fPlayTrack->CurrentFrame();
57857e2f323SJérôme Duval 			}
57957e2f323SJérôme Duval 			fScopeView->SetMainTime(main);
58057e2f323SJérôme Duval 		}
58157e2f323SJérôme Duval 		if (message->FindInt64("right", &right) == B_OK) {
58257e2f323SJérôme Duval 			if (fPlayTrack)
583ad0c65eaSJérôme Duval 				fPlayLimit = MIN(fPlayFrames,
584ad0c65eaSJérôme Duval 					(off_t)(right * fPlayFormat.u.raw_audio.frame_rate/1000000LL));
58557e2f323SJérôme Duval 			fScopeView->SetRightTime(right);
58657e2f323SJérôme Duval 		}
58757e2f323SJérôme Duval 		if (message->FindInt64("left", &left) == B_OK) {
58857e2f323SJérôme Duval 			fScopeView->SetLeftTime(left);
58957e2f323SJérôme Duval 		}
59057e2f323SJérôme Duval 		}
59157e2f323SJérôme Duval 		break;
592948356deSJérôme Duval 	case LOOP:
593948356deSJérôme Duval 		fLooping = fLoopButton->ButtonState();
594948356deSJérôme Duval 		break;
59557e2f323SJérôme Duval 	case B_SIMPLE_DATA:
59657e2f323SJérôme Duval 	case B_REFS_RECEIVED:
59757e2f323SJérôme Duval 		{
59857e2f323SJérôme Duval 			RefsReceived(message);
59957e2f323SJérôme Duval 			break;
60057e2f323SJérôme Duval 		}
601019ed09bSJérôme Duval 	case B_COPY_TARGET:
602019ed09bSJérôme Duval 		CopyTarget(message);
603019ed09bSJérôme Duval 		break;
60457e2f323SJérôme Duval 	default:
60557e2f323SJérôme Duval 		BWindow::MessageReceived(message);
60657e2f323SJérôme Duval 		break;
60757e2f323SJérôme Duval 	}
60857e2f323SJérôme Duval }
60957e2f323SJérôme Duval 
61057e2f323SJérôme Duval 
61157e2f323SJérôme Duval void
61257e2f323SJérôme Duval RecorderWindow::Record(BMessage * message)
61357e2f323SJérôme Duval {
61457e2f323SJérôme Duval 	//	User pressed Record button
61557e2f323SJérôme Duval 	fRecording = true;
61657e2f323SJérôme Duval 	if (fButtonState != btnPaused) {
61757e2f323SJérôme Duval 		StopRecording();
61857e2f323SJérôme Duval 		return;			//	user is too fast on the mouse
61957e2f323SJérôme Duval 	}
62057e2f323SJérôme Duval 	SetButtonState(btnRecording);
62157e2f323SJérôme Duval 	fRecordButton->SetRecording();
62257e2f323SJérôme Duval 
62357e2f323SJérôme Duval 	char name[256];
62457e2f323SJérôme Duval 	//	Create a file with a temporary name
62557e2f323SJérôme Duval 	status_t err = NewTempName(name);
62657e2f323SJérôme Duval 	if (err < B_OK) {
62757e2f323SJérôme Duval 		ErrorAlert("find an unused name to use for the new recording", err);
62857e2f323SJérôme Duval 		return;
62957e2f323SJérôme Duval 	}
63057e2f323SJérôme Duval 	//	Find the file so we can refer to it later
63157e2f323SJérôme Duval 	err = fTempDir.FindEntry(name, &fRecEntry);
63257e2f323SJérôme Duval 	if (err < B_OK) {
63357e2f323SJérôme Duval 		ErrorAlert("find the temporary file created to hold the new recording", err);
63457e2f323SJérôme Duval 		return;
63557e2f323SJérôme Duval 	}
63657e2f323SJérôme Duval 	err = fRecFile.SetTo(&fTempDir, name, O_RDWR);
63757e2f323SJérôme Duval 	if (err < B_OK) {
63857e2f323SJérôme Duval 		ErrorAlert("open the temporary file created to hold the new recording", err);
63957e2f323SJérôme Duval 		fRecEntry.Unset();
64057e2f323SJérôme Duval 		return;
64157e2f323SJérôme Duval 	}
64257e2f323SJérôme Duval 	//	Reserve space on disk (creates fewer fragments)
64307db0c6fSJérôme Duval 	err = fRecFile.SetSize(4 * fRecordFormat.u.raw_audio.channel_count
644ad0c65eaSJérôme Duval 		* fRecordFormat.u.raw_audio.frame_rate * (fRecordFormat.u.raw_audio.format
645ad0c65eaSJérôme Duval 				& media_raw_audio_format::B_AUDIO_SIZE_MASK));
64657e2f323SJérôme Duval 	if (err < B_OK) {
64757e2f323SJérôme Duval 		ErrorAlert("record a sound that long", err);
64857e2f323SJérôme Duval 		fRecEntry.Remove();
64957e2f323SJérôme Duval 		fRecEntry.Unset();
65057e2f323SJérôme Duval 		return;
65157e2f323SJérôme Duval 	}
65257e2f323SJérôme Duval 	fRecSize = 0;
65357e2f323SJérôme Duval 
65457e2f323SJérôme Duval 	fRecFile.Seek(sizeof(struct wave_struct), SEEK_SET);
65557e2f323SJérôme Duval 
65657e2f323SJérôme Duval 	//	Hook up input
65757e2f323SJérôme Duval 	err = MakeRecordConnection(fAudioInputNode);
65857e2f323SJérôme Duval 	if (err < B_OK) {
65957e2f323SJérôme Duval 		ErrorAlert("connect to the selected sound input", err);
66057e2f323SJérôme Duval 		fRecEntry.Remove();
66157e2f323SJérôme Duval 		fRecEntry.Unset();
66257e2f323SJérôme Duval 		return;
66357e2f323SJérôme Duval 	}
66457e2f323SJérôme Duval 
66557e2f323SJérôme Duval 	//	And get it going...
66657e2f323SJérôme Duval 	bigtime_t then = fRecordNode->TimeSource()->Now() + 50000LL;
66757e2f323SJérôme Duval 	fRoster->StartNode(fRecordNode->Node(), then);
66857e2f323SJérôme Duval 	if (fAudioInputNode.kind & B_TIME_SOURCE) {
669ad0c65eaSJérôme Duval 		fRoster->StartNode(fAudioInputNode,
670ad0c65eaSJérôme Duval 			fRecordNode->TimeSource()->RealTimeFor(then, 0));
67157e2f323SJérôme Duval 	}
67257e2f323SJérôme Duval 	else {
67357e2f323SJérôme Duval 		fRoster->StartNode(fAudioInputNode, then);
67457e2f323SJérôme Duval 	}
67557e2f323SJérôme Duval }
67657e2f323SJérôme Duval 
6778e32a27eSPhilippe Saint-Pierre 
67857e2f323SJérôme Duval void
67957e2f323SJérôme Duval RecorderWindow::Play(BMessage * message)
68057e2f323SJérôme Duval {
68157e2f323SJérôme Duval 	if (fPlayer) {
68257e2f323SJérôme Duval 		//	User pressed Play button and playing
68357e2f323SJérôme Duval 		if (fPlayer->HasData())
68457e2f323SJérôme Duval 			fPlayButton->SetPaused();
68557e2f323SJérôme Duval 		else
68657e2f323SJérôme Duval 			fPlayButton->SetPlaying();
68757e2f323SJérôme Duval 		fPlayer->SetHasData(!fPlayer->HasData());
68857e2f323SJérôme Duval 		return;
68957e2f323SJérôme Duval 	}
69057e2f323SJérôme Duval 
69157e2f323SJérôme Duval 	SetButtonState(btnPlaying);
69257e2f323SJérôme Duval 	fPlayButton->SetPlaying();
69357e2f323SJérôme Duval 
69457e2f323SJérôme Duval 	if (!fPlayTrack) {
69557e2f323SJérôme Duval 		ErrorAlert("get the file to play", B_ERROR);
69657e2f323SJérôme Duval 		return;
69757e2f323SJérôme Duval 	}
69857e2f323SJérôme Duval 
699ad0c65eaSJérôme Duval 	fPlayLimit = MIN(fPlayFrames, (off_t)(fTrackSlider->RightTime()
700ad0c65eaSJérôme Duval 		* fPlayFormat.u.raw_audio.frame_rate / 1000000LL));
70157e2f323SJérôme Duval 	fPlayTrack->SeekToTime(fTrackSlider->MainTime());
70257e2f323SJérôme Duval 	fPlayFrame = fPlayTrack->CurrentFrame();
70357e2f323SJérôme Duval 
70457e2f323SJérôme Duval 	// Create our internal Node which plays sound, and register it.
70557e2f323SJérôme Duval 	fPlayer = new BSoundPlayer(fAudioMixerNode, &fPlayFormat.u.raw_audio, "Sound Player");
70657e2f323SJérôme Duval 	status_t err = fPlayer->InitCheck();
70757e2f323SJérôme Duval 	if (err < B_OK) {
70857e2f323SJérôme Duval 		return;
70957e2f323SJérôme Duval 	}
71057e2f323SJérôme Duval 
71157e2f323SJérôme Duval 	fVolumeSlider->SetSoundPlayer(fPlayer);
71257e2f323SJérôme Duval 	fPlayer->SetCallbacks(PlayFile, NotifyPlayFile, this);
71357e2f323SJérôme Duval 
71457e2f323SJérôme Duval 	//	And get it going...
71557e2f323SJérôme Duval 	fPlayer->Start();
71657e2f323SJérôme Duval 	fPlayer->SetHasData(true);
71757e2f323SJérôme Duval }
71857e2f323SJérôme Duval 
7198e32a27eSPhilippe Saint-Pierre 
72057e2f323SJérôme Duval void
72157e2f323SJérôme Duval RecorderWindow::Stop(BMessage * message)
72257e2f323SJérôme Duval {
72357e2f323SJérôme Duval 	//	User pressed Stop button.
72457e2f323SJérôme Duval 	//	Stop recorder.
72557e2f323SJérôme Duval 	StopRecording();
72657e2f323SJérôme Duval 	//	Stop player.
72757e2f323SJérôme Duval 	StopPlaying();
72857e2f323SJérôme Duval }
72957e2f323SJérôme Duval 
7308e32a27eSPhilippe Saint-Pierre 
73157e2f323SJérôme Duval void
73257e2f323SJérôme Duval RecorderWindow::Save(BMessage * message)
73357e2f323SJérôme Duval {
73457e2f323SJérôme Duval 	//	User pressed Save button.
73557e2f323SJérôme Duval 	//	Find the item to save.
73657e2f323SJérôme Duval 	int32 index = fSoundList->CurrentSelection();
73757e2f323SJérôme Duval 	SoundListItem* pItem = dynamic_cast<SoundListItem*>(fSoundList->ItemAt(index));
73857e2f323SJérôme Duval 	if ((! pItem) || (pItem->Entry().InitCheck() != B_OK)) {
73957e2f323SJérôme Duval 		return;
74057e2f323SJérôme Duval 	}
74157e2f323SJérôme Duval 
74257e2f323SJérôme Duval 	// Update the save panel and show it.
74357e2f323SJérôme Duval 	char filename[B_FILE_NAME_LENGTH];
74457e2f323SJérôme Duval 	pItem->Entry().GetName(filename);
74557e2f323SJérôme Duval 	BMessage saveMsg(B_SAVE_REQUESTED);
74657e2f323SJérôme Duval 	entry_ref ref;
74757e2f323SJérôme Duval 	pItem->Entry().GetRef(&ref);
74857e2f323SJérôme Duval 
749a4797804SJérôme Duval 	if (saveMsg.AddPointer("sound list item", pItem) != B_OK)
750a4797804SJérôme Duval 		fprintf(stderr, "failed to add pItem\n");
7515fa77532SJérôme Duval 	fSavePanel->SetSaveText(filename);
7525fa77532SJérôme Duval 	fSavePanel->SetMessage(&saveMsg);
7535fa77532SJérôme Duval 	fSavePanel->Show();
75457e2f323SJérôme Duval }
75557e2f323SJérôme Duval 
7568e32a27eSPhilippe Saint-Pierre 
75757e2f323SJérôme Duval void
75857e2f323SJérôme Duval RecorderWindow::DoSave(BMessage * message)
75957e2f323SJérôme Duval {
76057e2f323SJérôme Duval 	// User picked a place to put the file.
76157e2f323SJérôme Duval 	// Find the location of the old (e.g.
76257e2f323SJérôme Duval 	// temporary file), and the name of the
76357e2f323SJérôme Duval 	// new file to save.
76457e2f323SJérôme Duval 	entry_ref old_ref, new_dir_ref;
76557e2f323SJérôme Duval 	const char* new_name;
76657e2f323SJérôme Duval 	SoundListItem* pItem;
76757e2f323SJérôme Duval 
76857e2f323SJérôme Duval 	if ((message->FindPointer("sound list item", (void**) &pItem) == B_OK)
76957e2f323SJérôme Duval 		&& (message->FindRef("directory", &new_dir_ref) == B_OK)
77057e2f323SJérôme Duval 		&& (message->FindString("name", &new_name) == B_OK))
77157e2f323SJérôme Duval 	{
77257e2f323SJérôme Duval 		BEntry& oldEntry = pItem->Entry();
77357e2f323SJérôme Duval 		BFile oldFile(&oldEntry, B_READ_WRITE);
77457e2f323SJérôme Duval 		if (oldFile.InitCheck() != B_OK)
77557e2f323SJérôme Duval 			return;
77657e2f323SJérôme Duval 
77757e2f323SJérôme Duval 		BDirectory newDir(&new_dir_ref);
77857e2f323SJérôme Duval 		if (newDir.InitCheck() != B_OK)
77957e2f323SJérôme Duval 			return;
78057e2f323SJérôme Duval 
78157e2f323SJérôme Duval 		BFile newFile;
78257e2f323SJérôme Duval 		newDir.CreateFile(new_name, &newFile);
78357e2f323SJérôme Duval 
78457e2f323SJérôme Duval 		if (newFile.InitCheck() != B_OK)
78557e2f323SJérôme Duval 			return;
78657e2f323SJérôme Duval 
78757e2f323SJérôme Duval 		status_t err = CopyFile(newFile, oldFile);
78857e2f323SJérôme Duval 
78957e2f323SJérôme Duval 		if (err == B_OK) {
79057e2f323SJérôme Duval 			// clean up the sound list and item
79157e2f323SJérôme Duval 			if (pItem->IsTemp())
79257e2f323SJérôme Duval 				oldEntry.Remove(); // blows away temp file!
79357e2f323SJérôme Duval 			oldEntry.SetTo(&newDir, new_name);
79457e2f323SJérôme Duval 			pItem->SetTemp(false);	// don't blow the new entry away when we exit!
79557e2f323SJérôme Duval 			fSoundList->Invalidate();
79657e2f323SJérôme Duval 		}
79757e2f323SJérôme Duval 	} else {
79857e2f323SJérôme Duval 		WINDOW((stderr, "Couldn't save file.\n"));
79957e2f323SJérôme Duval 	}
80057e2f323SJérôme Duval }
80157e2f323SJérôme Duval 
80257e2f323SJérôme Duval 
80357e2f323SJérôme Duval void
80457e2f323SJérôme Duval RecorderWindow::Input(BMessage * message)
80557e2f323SJérôme Duval {
80657e2f323SJérôme Duval 	//	User selected input from pop-up
80757e2f323SJérôme Duval 	const dormant_node_info * dni = 0;
80857e2f323SJérôme Duval 	ssize_t size = 0;
80957e2f323SJérôme Duval 	if (message->FindData("node", B_RAW_TYPE, (const void **)&dni, &size)) {
81057e2f323SJérôme Duval 		return;		//	bad input selection message
81157e2f323SJérôme Duval 	}
81257e2f323SJérôme Duval 
81357e2f323SJérôme Duval 	media_node_id node_id;
81457e2f323SJérôme Duval 	status_t error = fRoster->GetInstancesFor(dni->addon, dni->flavor_id, &node_id);
81557e2f323SJérôme Duval 	if (error != B_OK) {
81657e2f323SJérôme Duval 		fRoster->InstantiateDormantNode(*dni, &fAudioInputNode);
81757e2f323SJérôme Duval 	} else {
81857e2f323SJérôme Duval 		fRoster->GetNodeFor(node_id, &fAudioInputNode);
81957e2f323SJérôme Duval 	}
82057e2f323SJérôme Duval }
82157e2f323SJérôme Duval 
8228e32a27eSPhilippe Saint-Pierre 
82357e2f323SJérôme Duval void
82457e2f323SJérôme Duval RecorderWindow::Selected(BMessage * message)
82557e2f323SJérôme Duval {
82657e2f323SJérôme Duval 	//	User selected a sound in list view
827c6f8aa29SJérôme Duval 	int32 selIdx = fSoundList->CurrentSelection();
828c6f8aa29SJérôme Duval 	SoundListItem* pItem = dynamic_cast<SoundListItem*>(fSoundList->ItemAt(selIdx));
829c6f8aa29SJérôme Duval 	if (!pItem)
830c6f8aa29SJérôme Duval 		return;
831c6f8aa29SJérôme Duval 	status_t err = UpdatePlayFile(pItem, true);
832c6f8aa29SJérôme Duval 	if (err != B_OK) {
833ad0c65eaSJérôme Duval 		ErrorAlert("recognize this file as a media file",
834ad0c65eaSJérôme Duval 			err == B_MEDIA_NO_HANDLER ? B_OK : err);
835c6f8aa29SJérôme Duval 		RemoveCurrentSoundItem();
836c6f8aa29SJérôme Duval 	}
83757e2f323SJérôme Duval 	UpdateButtons();
83857e2f323SJérôme Duval }
83957e2f323SJérôme Duval 
8408e32a27eSPhilippe Saint-Pierre 
84157e2f323SJérôme Duval status_t
84257e2f323SJérôme Duval RecorderWindow::MakeRecordConnection(const media_node & input)
84357e2f323SJérôme Duval {
84457e2f323SJérôme Duval 	CONNECT((stderr, "RecorderWindow::MakeRecordConnection()\n"));
84557e2f323SJérôme Duval 
84657e2f323SJérôme Duval 	//	Find an available output for the given input node.
84757e2f323SJérôme Duval 	int32 count = 0;
84857e2f323SJérôme Duval 	status_t err = fRoster->GetFreeOutputsFor(input, &fAudioOutput, 1, &count, B_MEDIA_RAW_AUDIO);
84957e2f323SJérôme Duval 	if (err < B_OK) {
850ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
851ad0c65eaSJérôme Duval 			" couldn't get free outputs from audio input node\n"));
85257e2f323SJérôme Duval 		return err;
85357e2f323SJérôme Duval 	}
85457e2f323SJérôme Duval 	if (count < 1) {
855ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
856ad0c65eaSJérôme Duval 			" no free outputs from audio input node\n"));
85757e2f323SJérôme Duval 		return B_BUSY;
85857e2f323SJérôme Duval 	}
85957e2f323SJérôme Duval 
86057e2f323SJérôme Duval 	//	Find an available input for our own Node. Note that we go through the
86157e2f323SJérôme Duval 	//	MediaRoster; calling Media Kit methods directly on Nodes in our app is
86257e2f323SJérôme Duval 	//	not OK (because synchronization happens in the service thread, not in
86357e2f323SJérôme Duval 	//	the calling thread).
86457e2f323SJérôme Duval 	// TODO: explain this
86557e2f323SJérôme Duval 	err = fRoster->GetFreeInputsFor(fRecordNode->Node(), &fRecInput, 1, &count, B_MEDIA_RAW_AUDIO);
86657e2f323SJérôme Duval 	if (err < B_OK) {
867ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
868ad0c65eaSJérôme Duval 			" couldn't get free inputs for sound recorder\n"));
86957e2f323SJérôme Duval 		return err;
87057e2f323SJérôme Duval 	}
87157e2f323SJérôme Duval 	if (count < 1) {
872ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
873ad0c65eaSJérôme Duval 			" no free inputs for sound recorder\n"));
87457e2f323SJérôme Duval 		return B_BUSY;
87557e2f323SJérôme Duval 	}
87657e2f323SJérôme Duval 
87757e2f323SJérôme Duval 	//	Find out what the time source of the input is.
87857e2f323SJérôme Duval 	//	For most nodes, we just use the preferred time source (the DAC) for synchronization.
87957e2f323SJérôme Duval 	//	However, nodes that record from an input need to synchronize to the audio input node
88057e2f323SJérôme Duval 	//	instead for best results.
88157e2f323SJérôme Duval 	//	MakeTimeSourceFor gives us a "clone" of the time source node that we can manipulate
88257e2f323SJérôme Duval 	//	to our heart's content. When we're done with it, though, we need to call Release()
88357e2f323SJérôme Duval 	//	on the time source node, so that it keeps an accurate reference count and can delete
88457e2f323SJérôme Duval 	//	itself when it's no longer needed.
88557e2f323SJérôme Duval 	// TODO: what about filters connected to audio input?
88657e2f323SJérôme Duval 	media_node use_time_source;
88757e2f323SJérôme Duval 	BTimeSource * tsobj = fRoster->MakeTimeSourceFor(input);
88857e2f323SJérôme Duval 	if (! tsobj) {
889ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
890ad0c65eaSJérôme Duval 			" couldn't clone time source from audio input node\n"));
89157e2f323SJérôme Duval 		return B_MEDIA_BAD_NODE;
89257e2f323SJérôme Duval 	}
89357e2f323SJérôme Duval 
89457e2f323SJérôme Duval 	//	Apply the time source in effect to our own Node.
89557e2f323SJérôme Duval 	err = fRoster->SetTimeSourceFor(fRecordNode->Node().node, tsobj->Node().node);
89657e2f323SJérôme Duval 	if (err < B_OK) {
897ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
898ad0c65eaSJérôme Duval 			" couldn't set the sound recorder's time source\n"));
89957e2f323SJérôme Duval 		tsobj->Release();
90057e2f323SJérôme Duval 		return err;
90157e2f323SJérôme Duval 	}
90257e2f323SJérôme Duval 
90357e2f323SJérôme Duval 	//	Get a format, any format.
90488fef303SJérôme Duval 	fRecordFormat.u.raw_audio = fAudioOutput.format.u.raw_audio;
90588fef303SJérôme Duval 	fRecordFormat.type = B_MEDIA_RAW_AUDIO;
90657e2f323SJérôme Duval 
90757e2f323SJérôme Duval 	//	Tell the consumer where we want data to go.
90857e2f323SJérôme Duval 	err = fRecordNode->SetHooks(RecordFile, NotifyRecordFile, this);
90957e2f323SJérôme Duval 	if (err < B_OK) {
910ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
911ad0c65eaSJérôme Duval 			" couldn't set the sound recorder's hook functions\n"));
91257e2f323SJérôme Duval 		tsobj->Release();
91357e2f323SJérôme Duval 		return err;
91457e2f323SJérôme Duval 	}
91557e2f323SJérôme Duval 
91657e2f323SJérôme Duval 	//	Using the same structs for input and output is OK in BMediaRoster::Connect().
91788fef303SJérôme Duval 	err = fRoster->Connect(fAudioOutput.source, fRecInput.destination, &fRecordFormat, &fAudioOutput, &fRecInput);
91857e2f323SJérôme Duval 	if (err < B_OK) {
919ad0c65eaSJérôme Duval 		CONNECT((stderr, "RecorderWindow::MakeRecordConnection():"
920ad0c65eaSJérôme Duval 			" failed to connect sound recorder to audio input node.\n"));
92157e2f323SJérôme Duval 		tsobj->Release();
92257e2f323SJérôme Duval 		fRecordNode->SetHooks(0, 0, 0);
92357e2f323SJérôme Duval 		return err;
92457e2f323SJérôme Duval 	}
92557e2f323SJérôme Duval 
92657e2f323SJérôme Duval 	//	Start the time source if it's not running.
92757e2f323SJérôme Duval 	if ((tsobj->Node() != input) && !tsobj->IsRunning()) {
92857e2f323SJérôme Duval 		fRoster->StartNode(tsobj->Node(), BTimeSource::RealTime());
92957e2f323SJérôme Duval 	}
93057e2f323SJérôme Duval 	tsobj->Release();	//	we're done with this time source instance!
93157e2f323SJérôme Duval 	return B_OK;
93257e2f323SJérôme Duval }
93357e2f323SJérôme Duval 
93457e2f323SJérôme Duval 
93557e2f323SJérôme Duval status_t
93657e2f323SJérôme Duval RecorderWindow::BreakRecordConnection()
93757e2f323SJérôme Duval {
93857e2f323SJérôme Duval 	status_t err;
93957e2f323SJérôme Duval 
94057e2f323SJérôme Duval 	//	If we are the last connection, the Node will stop automatically since it
94157e2f323SJérôme Duval 	//	has nowhere to send data to.
94257e2f323SJérôme Duval 	err = fRoster->StopNode(fRecInput.node, 0);
943ad0c65eaSJérôme Duval 	err = fRoster->Disconnect(fAudioOutput.node.node, fAudioOutput.source,
944ad0c65eaSJérôme Duval 		fRecInput.node.node, fRecInput.destination);
94557e2f323SJérôme Duval 	fAudioOutput.source = media_source::null;
94657e2f323SJérôme Duval 	fRecInput.destination = media_destination::null;
94757e2f323SJérôme Duval 	return err;
94857e2f323SJérôme Duval }
94957e2f323SJérôme Duval 
9508e32a27eSPhilippe Saint-Pierre 
95157e2f323SJérôme Duval status_t
95257e2f323SJérôme Duval RecorderWindow::StopRecording()
95357e2f323SJérôme Duval {
95457e2f323SJérôme Duval 	if (!fRecording)
95557e2f323SJérôme Duval 		return B_OK;
95657e2f323SJérôme Duval 	fRecording = false;
95757e2f323SJérôme Duval 	BreakRecordConnection();
95857e2f323SJérôme Duval 	fRecordNode->SetHooks(NULL,NULL,NULL);
95957e2f323SJérôme Duval 	if (fRecSize > 0) {
96057e2f323SJérôme Duval 
96157e2f323SJérôme Duval 		wave_struct header;
96257e2f323SJérôme Duval 		header.riff.riff_id = FOURCC('R','I','F','F');
963a4797804SJérôme Duval 		header.riff.len = fRecSize + sizeof(header) - 8;
96457e2f323SJérôme Duval 		header.riff.wave_id = FOURCC('W','A','V','E');
96557e2f323SJérôme Duval 		header.format_chunk.fourcc = FOURCC('f','m','t',' ');
96657e2f323SJérôme Duval 		header.format_chunk.len = sizeof(header.format);
96757e2f323SJérôme Duval 		header.format.format_tag = 1;
96888fef303SJérôme Duval 		header.format.channels = fRecordFormat.u.raw_audio.channel_count;
96988fef303SJérôme Duval 		header.format.samples_per_sec = (uint32)fRecordFormat.u.raw_audio.frame_rate;
97088fef303SJérôme Duval 		header.format.avg_bytes_per_sec = (uint32)(fRecordFormat.u.raw_audio.frame_rate
97188fef303SJérôme Duval 			* fRecordFormat.u.raw_audio.channel_count
97288fef303SJérôme Duval 			* (fRecordFormat.u.raw_audio.format & 0xf));
97388fef303SJérôme Duval 		header.format.bits_per_sample = (fRecordFormat.u.raw_audio.format & 0xf) * 8;
97488fef303SJérôme Duval 		header.format.block_align = (fRecordFormat.u.raw_audio.format & 0xf)
97588fef303SJérôme Duval 			* fRecordFormat.u.raw_audio.channel_count;
97657e2f323SJérôme Duval 		header.data_chunk.fourcc = FOURCC('d','a','t','a');
97757e2f323SJérôme Duval 		header.data_chunk.len = fRecSize;
97857e2f323SJérôme Duval 		fRecFile.Seek(0, SEEK_SET);
97957e2f323SJérôme Duval 		fRecFile.Write(&header, sizeof(header));
98057e2f323SJérôme Duval 
98157e2f323SJérôme Duval 		fRecFile.SetSize(fRecSize + sizeof(header));	//	We reserve space; make sure we cut off any excess at the end.
98257e2f323SJérôme Duval 		AddSoundItem(fRecEntry, true);
98357e2f323SJérôme Duval 	}
98457e2f323SJérôme Duval 	else {
98557e2f323SJérôme Duval 		fRecEntry.Remove();
98657e2f323SJérôme Duval 	}
98757e2f323SJérôme Duval 	//	We're done for this time.
98857e2f323SJérôme Duval 	fRecEntry.Unset();
98957e2f323SJérôme Duval 	//	Close the file.
99057e2f323SJérôme Duval 	fRecFile.Unset();
99157e2f323SJérôme Duval 	//	No more recording going on.
99257e2f323SJérôme Duval 	fRecSize = 0;
99357e2f323SJérôme Duval 	SetButtonState(btnPaused);
99457e2f323SJérôme Duval 	fRecordButton->SetStopped();
99557e2f323SJérôme Duval 
99657e2f323SJérôme Duval 	return B_OK;
99757e2f323SJérôme Duval }
99857e2f323SJérôme Duval 
99957e2f323SJérôme Duval 
100057e2f323SJérôme Duval status_t
100157e2f323SJérôme Duval RecorderWindow::StopPlaying()
100257e2f323SJérôme Duval {
100357e2f323SJérôme Duval 	if (fPlayer) {
100457e2f323SJérôme Duval 		fPlayer->Stop();
100557e2f323SJérôme Duval 		fPlayer->SetCallbacks(0, 0, 0);
100657e2f323SJérôme Duval 		fVolumeSlider->SetSoundPlayer(NULL);
100757e2f323SJérôme Duval 		delete fPlayer;
100857e2f323SJérôme Duval 		fPlayer = NULL;
100957e2f323SJérôme Duval 	}
101057e2f323SJérôme Duval 	SetButtonState(btnPaused);
101157e2f323SJérôme Duval 	fPlayButton->SetStopped();
101257e2f323SJérôme Duval 	fTrackSlider->ResetMainTime();
101357e2f323SJérôme Duval 	fScopeView->SetMainTime(*fTrackSlider->MainTime());
101457e2f323SJérôme Duval 	return B_OK;
101557e2f323SJérôme Duval }
101657e2f323SJérôme Duval 
101757e2f323SJérôme Duval 
101857e2f323SJérôme Duval void
101957e2f323SJérôme Duval RecorderWindow::SetButtonState(BtnState state)
102057e2f323SJérôme Duval {
102157e2f323SJérôme Duval 	fButtonState = state;
102257e2f323SJérôme Duval 	UpdateButtons();
102357e2f323SJérôme Duval }
102457e2f323SJérôme Duval 
102557e2f323SJérôme Duval 
102657e2f323SJérôme Duval void
102757e2f323SJérôme Duval RecorderWindow::UpdateButtons()
102857e2f323SJérôme Duval {
102957e2f323SJérôme Duval 	bool hasSelection = (fSoundList->CurrentSelection() >= 0);
103057e2f323SJérôme Duval 	fRecordButton->SetEnabled(fButtonState != btnPlaying);
103157e2f323SJérôme Duval 	fPlayButton->SetEnabled((fButtonState != btnRecording) && hasSelection);
103257e2f323SJérôme Duval 	fRewindButton->SetEnabled((fButtonState != btnRecording) && hasSelection);
103357e2f323SJérôme Duval 	fForwardButton->SetEnabled((fButtonState != btnRecording) && hasSelection);
103457e2f323SJérôme Duval 	fStopButton->SetEnabled(fButtonState != btnPaused);
103557e2f323SJérôme Duval 	fSaveButton->SetEnabled(hasSelection && (fButtonState != btnRecording));
103657e2f323SJérôme Duval 	fInputField->SetEnabled(fButtonState != btnRecording);
103757e2f323SJérôme Duval }
103857e2f323SJérôme Duval 
10395fa77532SJérôme Duval #ifndef __HAIKU__
10405fa77532SJérôme Duval extern "C" status_t DecodedFormat__11BMediaTrackP12media_format(BMediaTrack *self, media_format *inout_format);
10415fa77532SJérôme Duval #endif
104257e2f323SJérôme Duval 
10438e32a27eSPhilippe Saint-Pierre 
1044c6f8aa29SJérôme Duval status_t
1045c6f8aa29SJérôme Duval RecorderWindow::UpdatePlayFile(SoundListItem* item, bool updateDisplay)
104657e2f323SJérôme Duval {
1047019ed09bSJérôme Duval 	fScopeView->CancelRendering();
1048019ed09bSJérôme Duval 	StopPlaying();
1049019ed09bSJérôme Duval 	StopRecording();
1050019ed09bSJérôme Duval 
1051dbbc34b6SJérôme Duval 	if (fPlayTrack && fPlayFile) {
10527942339dSJérôme Duval 		fPlayFile->ReleaseTrack(fPlayTrack);
10537942339dSJérôme Duval 		fPlayTrack = NULL;
1054dbbc34b6SJérôme Duval 	}
1055dbbc34b6SJérôme Duval 	if (fPlayFile) {
1056dbbc34b6SJérôme Duval 		delete fPlayFile;
10577942339dSJérôme Duval 		fPlayFile = NULL;
1058dbbc34b6SJérôme Duval 	}
10597942339dSJérôme Duval 
106057e2f323SJérôme Duval 	status_t err;
1061c6f8aa29SJérôme Duval 	BEntry& entry = item->Entry();
106257e2f323SJérôme Duval 	entry_ref ref;
106357e2f323SJérôme Duval 	entry.GetRef(&ref);
106457e2f323SJérôme Duval 	fPlayFile = new BMediaFile(&ref); //, B_MEDIA_FILE_UNBUFFERED);
106557e2f323SJérôme Duval 	if ((err = fPlayFile->InitCheck()) < B_OK) {
106657e2f323SJérôme Duval 		delete fPlayFile;
1067dbbc34b6SJérôme Duval 		fPlayFile = NULL;
1068c6f8aa29SJérôme Duval 		return err;
106957e2f323SJérôme Duval 	}
107057e2f323SJérôme Duval 
107157e2f323SJérôme Duval 	for (int ix=0; ix < fPlayFile->CountTracks(); ix++) {
107257e2f323SJérôme Duval 		BMediaTrack * track = fPlayFile->TrackAt(ix);
107357e2f323SJérôme Duval 		fPlayFormat.type = B_MEDIA_RAW_AUDIO;
10745fa77532SJérôme Duval #ifdef __HAIKU__
10755fa77532SJérôme Duval 		if ((track->DecodedFormat(&fPlayFormat) == B_OK)
10765fa77532SJérôme Duval #else
10775fa77532SJérôme Duval 		if ((DecodedFormat__11BMediaTrackP12media_format(track, &fPlayFormat) == B_OK)
10785fa77532SJérôme Duval #endif
10795fa77532SJérôme Duval 			&& (fPlayFormat.type == B_MEDIA_RAW_AUDIO)) {
108057e2f323SJérôme Duval 			fPlayTrack = track;
108157e2f323SJérôme Duval 			break;
108257e2f323SJérôme Duval 		}
108357e2f323SJérôme Duval 		if (track)
108457e2f323SJérôme Duval 			fPlayFile->ReleaseTrack(track);
108557e2f323SJérôme Duval 	}
108657e2f323SJérôme Duval 
108757e2f323SJérôme Duval 	if (!fPlayTrack) {
108857e2f323SJérôme Duval 		delete fPlayFile;
1089019ed09bSJérôme Duval 		fPlayFile = NULL;
1090c6f8aa29SJérôme Duval 		return B_STREAM_NOT_FOUND;
109157e2f323SJérôme Duval 	}
109257e2f323SJérôme Duval 
1093c6f8aa29SJérôme Duval 	if (!updateDisplay)
1094c6f8aa29SJérôme Duval 		return B_OK;
1095c6f8aa29SJérôme Duval 
1096*7974d3dcSStephan Aßmus 	BString filename = "File name: ";
109757e2f323SJérôme Duval 	filename << ref.name;
109857e2f323SJérôme Duval 	fFilename->SetText(filename.String());
109957e2f323SJérôme Duval 
110057e2f323SJérôme Duval 	BString format = "Format: ";
110157e2f323SJérôme Duval 	media_file_format file_format;
110257e2f323SJérôme Duval 	if (fPlayFile->GetFileFormatInfo(&file_format) == B_OK)
110357e2f323SJérôme Duval 		format << file_format.short_name;
110457e2f323SJérôme Duval 	BString compression = "Compression: ";
110557e2f323SJérôme Duval 	media_codec_info codec_info;
110657e2f323SJérôme Duval 	if (fPlayTrack->GetCodecInfo(&codec_info) == B_OK) {
110757e2f323SJérôme Duval 		if (strcmp(codec_info.short_name, "raw")==0)
110857e2f323SJérôme Duval 			compression << "None";
110957e2f323SJérôme Duval 		else
111057e2f323SJérôme Duval 			compression << codec_info.short_name;
111157e2f323SJérôme Duval 	}
111257e2f323SJérôme Duval 	BString channels = "Channels: ";
111357e2f323SJérôme Duval 	channels << fPlayFormat.u.raw_audio.channel_count;
1114*7974d3dcSStephan Aßmus 	BString samplesize = "Sample size: ";
111557e2f323SJérôme Duval 	samplesize << 8 * (fPlayFormat.u.raw_audio.format & 0xf) << " bits";
1116*7974d3dcSStephan Aßmus 	BString samplerate = "Sample rate: ";
111757e2f323SJérôme Duval 	samplerate << (int)fPlayFormat.u.raw_audio.frame_rate;
111857e2f323SJérôme Duval 	BString durationString = "Duration: ";
111957e2f323SJérôme Duval 	bigtime_t duration = fPlayTrack->Duration();
112057e2f323SJérôme Duval 	durationString << (float)(duration / 1000000.0) << " seconds";
112157e2f323SJérôme Duval 
112257e2f323SJérôme Duval 	fFormat->SetText(format.String());
112357e2f323SJérôme Duval 	fCompression->SetText(compression.String());
112457e2f323SJérôme Duval 	fChannels->SetText(channels.String());
112557e2f323SJérôme Duval 	fSampleSize->SetText(samplesize.String());
112657e2f323SJérôme Duval 	fSampleRate->SetText(samplerate.String());
112757e2f323SJérôme Duval 	fDuration->SetText(durationString.String());
112857e2f323SJérôme Duval 
112957e2f323SJérôme Duval 	fTrackSlider->SetTotalTime(duration, true);
1130019ed09bSJérôme Duval 	fScopeView->SetTotalTime(duration, true);
113157e2f323SJérôme Duval 	fScopeView->RenderTrack(fPlayTrack, fPlayFormat);
11327942339dSJérôme Duval 
11337942339dSJérôme Duval 	fPlayFrames = fPlayTrack->CountFrames();
1134c6f8aa29SJérôme Duval 	return B_OK;
113557e2f323SJérôme Duval }
113657e2f323SJérôme Duval 
113757e2f323SJérôme Duval 
113857e2f323SJérôme Duval void
113957e2f323SJérôme Duval RecorderWindow::ErrorAlert(const char * action, status_t err)
114057e2f323SJérôme Duval {
114157e2f323SJérôme Duval 	char msg[300];
1142c6f8aa29SJérôme Duval 	if (err != B_OK)
11435fa77532SJérôme Duval 		sprintf(msg, "Cannot %s: %s. [%lx]", action, strerror(err), (int32) err);
1144c6f8aa29SJérôme Duval 	else
1145c6f8aa29SJérôme Duval 		sprintf(msg, "Cannot %s.", action);
114657e2f323SJérôme Duval 	(new BAlert("", msg, "Stop"))->Go();
114757e2f323SJérôme Duval }
114857e2f323SJérôme Duval 
114957e2f323SJérôme Duval 
115057e2f323SJérôme Duval status_t
115157e2f323SJérôme Duval RecorderWindow::NewTempName(char * name)
115257e2f323SJérôme Duval {
115357e2f323SJérôme Duval 	int init_count = fTempCount;
115457e2f323SJérôme Duval again:
115557e2f323SJérôme Duval 	if (fTempCount-init_count > 25) {
115657e2f323SJérôme Duval 		return B_ERROR;
115757e2f323SJérôme Duval 	}
115857e2f323SJérôme Duval 	else {
115957e2f323SJérôme Duval 		fTempCount++;
116057e2f323SJérôme Duval 		if (fTempCount==0)
116157e2f323SJérôme Duval 			sprintf(name, "Audio Clip");
116257e2f323SJérôme Duval 		else
116357e2f323SJérôme Duval 			sprintf(name, "Audio Clip %d", fTempCount);
116457e2f323SJérôme Duval 		BPath path;
116557e2f323SJérôme Duval 		status_t err;
116657e2f323SJérôme Duval 		BEntry tempEnt;
116757e2f323SJérôme Duval 		if ((err = fTempDir.GetEntry(&tempEnt)) < B_OK) {
116857e2f323SJérôme Duval 			return err;
116957e2f323SJérôme Duval 		}
117057e2f323SJérôme Duval 		if ((err = tempEnt.GetPath(&path)) < B_OK) {
117157e2f323SJérôme Duval 			return err;
117257e2f323SJérôme Duval 		}
117357e2f323SJérôme Duval 		path.Append(name);
117457e2f323SJérôme Duval 		int fd;
117557e2f323SJérôme Duval 		//	Use O_EXCL so we know we created the file (sync with other instances)
117657e2f323SJérôme Duval 		if ((fd = open(path.Path(), O_RDWR | O_CREAT | O_EXCL, 0666)) < 0) {
117757e2f323SJérôme Duval 			goto again;
117857e2f323SJérôme Duval 		}
117957e2f323SJérôme Duval 		close(fd);
118057e2f323SJérôme Duval 	}
118157e2f323SJérôme Duval 	return B_OK;
118257e2f323SJérôme Duval }
118357e2f323SJérôme Duval 
118457e2f323SJérôme Duval 
118557e2f323SJérôme Duval void
118657e2f323SJérôme Duval RecorderWindow::AddSoundItem(const BEntry& entry, bool temp)
118757e2f323SJérôme Duval {
118857e2f323SJérôme Duval 	//	Create list item to display.
118957e2f323SJérôme Duval 	SoundListItem * listItem = new SoundListItem(entry, temp);
119057e2f323SJérôme Duval 	fSoundList->AddItem(listItem);
119157e2f323SJérôme Duval 	fSoundList->Invalidate();
119257e2f323SJérôme Duval 	fSoundList->Select(fSoundList->IndexOf(listItem));
119357e2f323SJérôme Duval }
119457e2f323SJérôme Duval 
1195019ed09bSJérôme Duval 
1196019ed09bSJérôme Duval void
1197019ed09bSJérôme Duval RecorderWindow::RemoveCurrentSoundItem() {
1198c6f8aa29SJérôme Duval 	int32 index = fSoundList->CurrentSelection();
1199c6f8aa29SJérôme Duval 	BListItem *item = fSoundList->RemoveItem(index);
1200019ed09bSJérôme Duval 	delete item;
1201c6f8aa29SJérôme Duval 	if (index >= fSoundList->CountItems())
1202c6f8aa29SJérôme Duval 		index = fSoundList->CountItems() - 1;
1203c6f8aa29SJérôme Duval 	fSoundList->Select(index);
1204019ed09bSJérôme Duval }
1205019ed09bSJérôme Duval 
1206019ed09bSJérôme Duval 
120757e2f323SJérôme Duval void
1208ef367a8aSStephan Aßmus RecorderWindow::RecordFile(void* cookie, bigtime_t timestamp,
1209ef367a8aSStephan Aßmus 	void* data, size_t size, const media_raw_audio_format &format)
121057e2f323SJérôme Duval {
121157e2f323SJérôme Duval 	//	Callback called from the SoundConsumer when receiving buffers.
121257e2f323SJérôme Duval 	RecorderWindow * window = (RecorderWindow *)cookie;
121357e2f323SJérôme Duval 
121457e2f323SJérôme Duval 	if (window->fRecording) {
121557e2f323SJérôme Duval 		//	Write the data to file (we don't buffer or guard file access
121657e2f323SJérôme Duval 		//	or anything)
121757e2f323SJérôme Duval 		window->fRecFile.WriteAt(window->fRecSize, data, size);
1218ad0c65eaSJérôme Duval 		window->fVUView->ComputeLevels(data, size, format.format);
121957e2f323SJérôme Duval 		window->fRecSize += size;
122057e2f323SJérôme Duval 	}
122157e2f323SJérôme Duval }
122257e2f323SJérôme Duval 
122357e2f323SJérôme Duval 
122457e2f323SJérôme Duval void
122557e2f323SJérôme Duval RecorderWindow::NotifyRecordFile(void * cookie, int32 code, ...)
122657e2f323SJérôme Duval {
122757e2f323SJérôme Duval 	if ((code == B_WILL_STOP) || (code == B_NODE_DIES)) {
122857e2f323SJérôme Duval 		RecorderWindow * window = (RecorderWindow *)cookie;
122957e2f323SJérôme Duval 		// Tell the window we've stopped, if it doesn't
123057e2f323SJérôme Duval 		// already know.
123157e2f323SJérôme Duval 		window->PostMessage(STOP_RECORDING);
123257e2f323SJérôme Duval 	}
123357e2f323SJérôme Duval }
123457e2f323SJérôme Duval 
123557e2f323SJérôme Duval 
123657e2f323SJérôme Duval void
1237ad0c65eaSJérôme Duval RecorderWindow::PlayFile(void * cookie, void * data, size_t size,
1238ad0c65eaSJérôme Duval 	const media_raw_audio_format & format)
123957e2f323SJérôme Duval {
124057e2f323SJérôme Duval 	//	Callback called from the SoundProducer when producing buffers.
124157e2f323SJérôme Duval 	RecorderWindow * window = (RecorderWindow *)cookie;
124257e2f323SJérôme Duval 	int32 frame_size = (window->fPlayFormat.u.raw_audio.format & 0xf) *
124357e2f323SJérôme Duval 		window->fPlayFormat.u.raw_audio.channel_count;
124457e2f323SJérôme Duval 
1245948356deSJérôme Duval 	if ((window->fPlayFrame < window->fPlayLimit) || window->fLooping) {
1246948356deSJérôme Duval 		if (window->fPlayFrame >= window->fPlayLimit) {
1247948356deSJérôme Duval 			bigtime_t left = window->fTrackSlider->LeftTime();
1248948356deSJérôme Duval 			window->fPlayTrack->SeekToTime(&left);
1249948356deSJérôme Duval 			window->fPlayFrame = window->fPlayTrack->CurrentFrame();
1250948356deSJérôme Duval 		}
125157e2f323SJérôme Duval 		int64 frames = 0;
125257e2f323SJérôme Duval 		window->fPlayTrack->ReadFrames(data, &frames);
1253ad0c65eaSJérôme Duval 		window->fVUView->ComputeLevels(data, size / frame_size, format.format);
125457e2f323SJérôme Duval 		window->fPlayFrame += size/frame_size;
125557e2f323SJérôme Duval 		window->PostMessage(UPDATE_TRACKSLIDER);
125657e2f323SJérôme Duval 	} else {
125757e2f323SJérôme Duval 		//	we're done!
125857e2f323SJérôme Duval 		window->PostMessage(STOP_PLAYING);
125957e2f323SJérôme Duval 	}
126057e2f323SJérôme Duval }
126157e2f323SJérôme Duval 
12628e32a27eSPhilippe Saint-Pierre 
126357e2f323SJérôme Duval void
1264ad0c65eaSJérôme Duval RecorderWindow::NotifyPlayFile(void * cookie,
1265ad0c65eaSJérôme Duval 	BSoundPlayer::sound_player_notification code, ...)
126657e2f323SJérôme Duval {
126757e2f323SJérôme Duval 	if ((code == BSoundPlayer::B_STOPPED) || (code == BSoundPlayer::B_SOUND_DONE)) {
126857e2f323SJérôme Duval 		RecorderWindow * window = (RecorderWindow *)cookie;
126957e2f323SJérôme Duval 		// tell the window we've stopped, if it doesn't
127057e2f323SJérôme Duval 		// already know.
127157e2f323SJérôme Duval 		window->PostMessage(STOP_PLAYING);
127257e2f323SJérôme Duval 	}
127357e2f323SJérôme Duval }
127457e2f323SJérôme Duval 
127557e2f323SJérôme Duval 
127657e2f323SJérôme Duval void
127757e2f323SJérôme Duval RecorderWindow::RefsReceived(BMessage *msg)
127857e2f323SJérôme Duval {
127957e2f323SJérôme Duval 	entry_ref ref;
128057e2f323SJérôme Duval 	int32 i = 0;
1281c6f8aa29SJérôme Duval 	int32 countGood = 0;
1282c6f8aa29SJérôme Duval 	int32 countBad = 0;
128357e2f323SJérôme Duval 
128457e2f323SJérôme Duval 	while (msg->FindRef("refs", i++, &ref) == B_OK) {
128557e2f323SJérôme Duval 
128657e2f323SJérôme Duval 		BEntry entry(&ref, true);
128757e2f323SJérôme Duval 		BPath path(&entry);
128857e2f323SJérôme Duval 		BNode node(&entry);
128957e2f323SJérôme Duval 
129057e2f323SJérôme Duval 		if (node.IsFile()) {
1291c6f8aa29SJérôme Duval 			SoundListItem * listItem = new SoundListItem(entry, false);
1292c6f8aa29SJérôme Duval 			if (UpdatePlayFile(listItem) == B_OK) {
1293c6f8aa29SJérôme Duval 				fSoundList->AddItem(listItem);
1294c6f8aa29SJérôme Duval 				countGood++;
1295c6f8aa29SJérôme Duval 				continue;
1296c6f8aa29SJérôme Duval 			}
1297c6f8aa29SJérôme Duval 			delete listItem;
129857e2f323SJérôme Duval 		} else if(node.IsDirectory()) {
129957e2f323SJérôme Duval 
130057e2f323SJérôme Duval 		}
1301c6f8aa29SJérôme Duval 		countBad++;
1302c6f8aa29SJérôme Duval 	}
1303c6f8aa29SJérôme Duval 
1304c6f8aa29SJérôme Duval 	if (countBad > 0 && countGood == 0)
1305*7974d3dcSStephan Aßmus 		(new BAlert("Nothing to play", "None of the files appear to be "
1306c6f8aa29SJérôme Duval 			"audio files", "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT))->Go();
1307c6f8aa29SJérôme Duval 	else if (countGood > 0) {
1308c6f8aa29SJérôme Duval 		if (countBad > 0)
1309c6f8aa29SJérôme Duval 			(new BAlert("Invalid audio files", "Some of the files "
1310c6f8aa29SJérôme Duval 				"don't appear to be audio files", "OK", NULL, NULL,
1311c6f8aa29SJérôme Duval 				B_WIDTH_AS_USUAL, B_WARNING_ALERT))->Go();
1312c6f8aa29SJérôme Duval 		fSoundList->Select(fSoundList->CountItems() - 1);
131357e2f323SJérôme Duval 	}
131457e2f323SJérôme Duval }
1315019ed09bSJérôme Duval 
1316019ed09bSJérôme Duval 
1317019ed09bSJérôme Duval void
1318019ed09bSJérôme Duval RecorderWindow::CopyTarget(BMessage *msg)
1319019ed09bSJérôme Duval {
1320019ed09bSJérôme Duval 	const char *type = NULL;
1321019ed09bSJérôme Duval 	if (msg->FindString("be:types", &type) == B_OK) {
1322019ed09bSJérôme Duval 		if (!strcasecmp(type, B_FILE_MIME_TYPE)) {
1323019ed09bSJérôme Duval 			const char *name;
1324019ed09bSJérôme Duval 			entry_ref dir;
1325019ed09bSJérôme Duval 			if (msg->FindString("be:filetypes") == B_OK
1326019ed09bSJérôme Duval 				&& msg->FindString("name", &name) == B_OK
1327019ed09bSJérôme Duval 				&& msg->FindRef("directory", &dir) == B_OK) {
1328019ed09bSJérôme Duval 				BDirectory directory(&dir);
1329019ed09bSJérôme Duval 				BFile file(&directory, name, O_RDWR | O_TRUNC);
1330019ed09bSJérôme Duval 
1331019ed09bSJérôme Duval 				// seek time
1332019ed09bSJérôme Duval 				bigtime_t start = fTrackSlider->LeftTime();
1333019ed09bSJérôme Duval 
1334019ed09bSJérôme Duval 				// write data
1335019ed09bSJérôme Duval 				bigtime_t diffTime = fTrackSlider->RightTime() - fTrackSlider->LeftTime();
1336ad0c65eaSJérôme Duval 				int64 framesToWrite = (int64) (diffTime
1337ad0c65eaSJérôme Duval 					* fPlayFormat.u.raw_audio.frame_rate / 1000000LL);
1338019ed09bSJérôme Duval 				int32 frameSize = (fPlayFormat.u.raw_audio.format & 0xf)
1339019ed09bSJérôme Duval 					* fPlayFormat.u.raw_audio.channel_count;
1340019ed09bSJérôme Duval 
1341019ed09bSJérôme Duval 				wave_struct header;
1342019ed09bSJérôme Duval 				header.riff.riff_id = FOURCC('R','I','F','F');
1343a4797804SJérôme Duval 				header.riff.len = (frameSize * framesToWrite) + sizeof(header) - 8;
1344019ed09bSJérôme Duval 				header.riff.wave_id = FOURCC('W','A','V','E');
1345019ed09bSJérôme Duval 				header.format_chunk.fourcc = FOURCC('f','m','t',' ');
1346019ed09bSJérôme Duval 				header.format_chunk.len = sizeof(header.format);
1347019ed09bSJérôme Duval 				header.format.format_tag = 1;
1348019ed09bSJérôme Duval 				header.format.channels = fPlayFormat.u.raw_audio.channel_count;
1349019ed09bSJérôme Duval 				header.format.samples_per_sec = (uint32)fPlayFormat.u.raw_audio.frame_rate;
1350019ed09bSJérôme Duval 				header.format.avg_bytes_per_sec = (uint32)(fPlayFormat.u.raw_audio.frame_rate
1351019ed09bSJérôme Duval 					* fPlayFormat.u.raw_audio.channel_count
1352019ed09bSJérôme Duval 					* (fPlayFormat.u.raw_audio.format & 0xf));
1353019ed09bSJérôme Duval 				header.format.bits_per_sample = (fPlayFormat.u.raw_audio.format & 0xf) * 8;
1354019ed09bSJérôme Duval 				header.format.block_align = frameSize;
1355019ed09bSJérôme Duval 				header.data_chunk.fourcc = FOURCC('d','a','t','a');
1356019ed09bSJérôme Duval 				header.data_chunk.len = frameSize * framesToWrite;
1357019ed09bSJérôme Duval 				file.Seek(0, SEEK_SET);
1358019ed09bSJérôme Duval 				file.Write(&header, sizeof(header));
1359019ed09bSJérôme Duval 
1360019ed09bSJérôme Duval 				char *data = (char *)malloc(fPlayFormat.u.raw_audio.buffer_size);
1361019ed09bSJérôme Duval 
1362c6f8aa29SJérôme Duval 				fPlayTrack->SeekToTime(&start);
1363c6f8aa29SJérôme Duval 				fPlayFrame = fPlayTrack->CurrentFrame();
1364019ed09bSJérôme Duval 				while (framesToWrite > 0) {
1365019ed09bSJérôme Duval 					int64 frames = 0;
1366019ed09bSJérôme Duval 					status_t err = fPlayTrack->ReadFrames(data, &frames);
1367c6f8aa29SJérôme Duval 					if (frames <= 0 || err != B_OK) {
1368c6f8aa29SJérôme Duval 						if (err != B_OK)
1369c6f8aa29SJérôme Duval 							fprintf(stderr, "CopyTarget: ReadFrames failed\n");
1370019ed09bSJérôme Duval 						break;
1371c6f8aa29SJérôme Duval 					}
1372019ed09bSJérôme Duval 					file.Write(data, frames * frameSize);
1373019ed09bSJérôme Duval 					framesToWrite -= frames;
1374019ed09bSJérôme Duval 				}
1375019ed09bSJérôme Duval 
1376019ed09bSJérôme Duval 				file.Sync();
1377019ed09bSJérôme Duval 				free(data);
1378019ed09bSJérôme Duval 				BNodeInfo nodeInfo(&file);
1379019ed09bSJérôme Duval 				// set type
1380019ed09bSJérôme Duval 			}
1381019ed09bSJérôme Duval 		} else {
1382019ed09bSJérôme Duval 
1383019ed09bSJérôme Duval 		}
1384019ed09bSJérôme Duval 	}
1385019ed09bSJérôme Duval }
1386