void processInitializingState(inputData* inputData, outputData* outputData) {
// Keys or accelerometer may trigger a wake-up from standby. For this to work, the
keyboard
/accelerometer interface must stop to bring the hardware in the correct
state. For this to be allowed, the keyboard interface must first be started.
startDevice(keyboard);
stopDevice(keyboard);
startDevice(accelerometer);
stopDevice(accelerometer);
if (inputData->hostState == connected) {
enterConnectedStateFromInitializingState();
} else {
enterConnectingState(outputData);
} if
bool videoInputCamera::startCamera()
{
HRESULT hr = pMediaControl->Run();
if (FAILED(hr)){
//printf("ERROR: Could not start graph\n");
stopDevice();
return false;
}
applyCameraSettings();
/*std::cout << std::flush;
ResetEvent(sgCallback->hEvent);
DWORD result = -1;
int counter = 0;
printf("init ");
while ( result != WAIT_OBJECT_0) {
result = WaitForSingleObject(sgCallback->hEvent, 100);
counter++;
printf(".");
if (counter>100) return false;
} printf(" done\n");
ResetEvent(sgCallback->hEvent);*/
disconnect = false;
running = true;
return true;
}
void DirectShowCamera::setResolution(int width, int height) {
if (_videoInput->isDeviceSetup(_id)) {
stopDevice();
}
_videoInput->setupDevice(_id, width, height);
_frame = new Image(_videoInput->getWidth(_id), _videoInput->getHeight(_id), 3);
}
void JogShuttle::initDevice(QString device)
{
if (m_shuttleProcess.isRunning()) {
if (device == m_shuttleProcess.m_device) return;
stopDevice();
}
m_shuttleProcess.init(this, device);
m_shuttleProcess.start(QThread::LowestPriority);
}
bool videoInputCamera::closeCamera()
{
if (!disconnect) {
updateSettings();
CameraTool::saveSettings();
stopDevice();
}
return true;
}
void AudioComponent::endCallbacks()
{
std::cout << std::endl << "Removing audio callback." << std::endl;
deviceManager.removeAudioCallback(graphPlayer);
isPlaying = false;
stopDevice();
}
bool
device::stop()
{
_running = false;
if(_readthread)
_readthread->join();
delete _readthread;
return stopDevice();
}
void AudioComponent::endCallbacks()
{
// const MessageManagerLock mmLock; // add a lock to prevent crashes
// MessageManagerLock mml (Thread::getCurrentThread());
// if (mml.lockWasGained())
// {
// std::cout << "AUDIO COMPONENT GOT THAT LOCK!" << std::endl;
// }
// MessageManager* mm = MessageManager::getInstance();
// if (mm->isThisTheMessageThread())
// std::cout << "THIS IS THE MESSAGE THREAD -- AUDIO COMPONENT" << std::endl;
// else
// std::cout << "NOT THE MESSAGE THREAD -- AUDIO COMPONENT" << std::endl;
std::cout << std::endl << "Removing audio callback." << std::endl;
deviceManager.removeAudioCallback(graphPlayer);
isPlaying = false;
stopDevice();
int64 ms = Time::getCurrentTime().toMilliseconds();
while (Time::getCurrentTime().toMilliseconds() - ms < 50)
{
// pause to let things finish up
}
}
DirectShowCamera::~DirectShowCamera() {
stopDevice();
}
void AudioDeviceManager::closeAudioDevice()
{
stopDevice();
currentAudioDevice = nullptr;
}
String AudioDeviceManager::setAudioDeviceSetup (const AudioDeviceSetup& newSetup,
const bool treatAsChosenDevice)
{
jassert (&newSetup != ¤tSetup); // this will have no effect
if (newSetup == currentSetup && currentAudioDevice != nullptr)
return String::empty;
if (! (newSetup == currentSetup))
sendChangeMessage();
stopDevice();
const String newInputDeviceName (numInputChansNeeded == 0 ? String::empty : newSetup.inputDeviceName);
const String newOutputDeviceName (numOutputChansNeeded == 0 ? String::empty : newSetup.outputDeviceName);
String error;
AudioIODeviceType* type = getCurrentDeviceTypeObject();
if (type == nullptr || (newInputDeviceName.isEmpty() && newOutputDeviceName.isEmpty()))
{
deleteCurrentDevice();
if (treatAsChosenDevice)
updateXml();
return String::empty;
}
if (currentSetup.inputDeviceName != newInputDeviceName
|| currentSetup.outputDeviceName != newOutputDeviceName
|| currentAudioDevice == nullptr)
{
deleteCurrentDevice();
scanDevicesIfNeeded();
if (newOutputDeviceName.isNotEmpty()
&& ! type->getDeviceNames (false).contains (newOutputDeviceName))
{
return "No such device: " + newOutputDeviceName;
}
if (newInputDeviceName.isNotEmpty()
&& ! type->getDeviceNames (true).contains (newInputDeviceName))
{
return "No such device: " + newInputDeviceName;
}
currentAudioDevice = type->createDevice (newOutputDeviceName, newInputDeviceName);
if (currentAudioDevice == nullptr)
error = "Can't open the audio device!\n\nThis may be because another application is currently using the same device - if so, you should close any other applications and try again!";
else
error = currentAudioDevice->getLastError();
if (error.isNotEmpty())
{
deleteCurrentDevice();
return error;
}
if (newSetup.useDefaultInputChannels)
{
inputChannels.clear();
inputChannels.setRange (0, numInputChansNeeded, true);
}
if (newSetup.useDefaultOutputChannels)
{
outputChannels.clear();
outputChannels.setRange (0, numOutputChansNeeded, true);
}
if (newInputDeviceName.isEmpty())
inputChannels.clear();
if (newOutputDeviceName.isEmpty())
outputChannels.clear();
}
if (! newSetup.useDefaultInputChannels)
inputChannels = newSetup.inputChannels;
if (! newSetup.useDefaultOutputChannels)
outputChannels = newSetup.outputChannels;
currentSetup = newSetup;
currentSetup.sampleRate = chooseBestSampleRate (newSetup.sampleRate);
currentSetup.bufferSize = chooseBestBufferSize (newSetup.bufferSize);
error = currentAudioDevice->open (inputChannels,
outputChannels,
currentSetup.sampleRate,
currentSetup.bufferSize);
if (error.isEmpty())
{
currentDeviceType = currentAudioDevice->getTypeName();
currentAudioDevice->start (&callbackHandler);
currentSetup.sampleRate = currentAudioDevice->getCurrentSampleRate();
currentSetup.bufferSize = currentAudioDevice->getCurrentBufferSizeSamples();
currentSetup.inputChannels = currentAudioDevice->getActiveInputChannels();
currentSetup.outputChannels = currentAudioDevice->getActiveOutputChannels();
for (int i = 0; i < availableDeviceTypes.size(); ++i)
if (availableDeviceTypes.getUnchecked (i)->getTypeName() == currentDeviceType)
*(lastDeviceTypeConfigs.getUnchecked (i)) = currentSetup;
if (treatAsChosenDevice)
updateXml();
}
else
{
deleteCurrentDevice();
}
return error;
}
void AudioDeviceManager::closeAudioDevice()
{
stopDevice();
currentAudioDevice.reset();
loadMeasurer.reset();
}
void toolbar::Stop()
{
emit stopDevice();
DisabledToolbar(0);
}
AudioComponent::AudioComponent() : isPlaying(false)
{
// if this is nonempty, we got an error
String error = deviceManager.initialise(0, // numInputChannelsNeeded
2, // numOutputChannelsNeeded
0, // *savedState (XmlElement)
true, // selectDefaultDeviceOnFailure
String::empty, // preferred device
0); // preferred device setup options
if (error != String::empty)
{
String titleMessage = String("Audio device initialization error");
String contentMessage = String("There was a problem initializing the audio device:\n" + error);
// this uses a bool since there are only two options
// also, omitting parameters works fine, even though the docs don't show defaults
bool retryButtonClicked = AlertWindow::showOkCancelBox(AlertWindow::QuestionIcon,
titleMessage,
contentMessage,
String("Retry"),
String("Quit"));
if (retryButtonClicked)
{
// as above
error = deviceManager.initialise(0, 2, 0, true, String::empty, 0);
}
else // quit button clicked
{
JUCEApplication::quit();
}
}
AudioIODevice* aIOd = deviceManager.getCurrentAudioDevice();
// the error string doesn't tell you if there's no audio device found...
if (aIOd == 0)
{
String titleMessage = String("No audio device found");
String contentMessage = String("Couldn't find an audio device. ") +
String("Perhaps some other program has control of the default one.");
AlertWindow::showMessageBox(AlertWindow::InfoIcon,
titleMessage,
contentMessage);
JUCEApplication::quit();
}
std::cout << "Got audio device." << std::endl;
String devName = aIOd->getName();
std::cout << std::endl << "Audio device name: " << devName << std::endl;
AudioDeviceManager::AudioDeviceSetup setup;
deviceManager.getAudioDeviceSetup(setup);
setup.bufferSize = 1024; /// larger buffer = fewer empty blocks, but longer latencies
setup.useDefaultInputChannels = false;
setup.inputChannels = 0;
setup.useDefaultOutputChannels = true;
setup.outputChannels = 2;
setup.sampleRate = 44100.0;
String msg = deviceManager.setAudioDeviceSetup(setup, false);
String devType = deviceManager.getCurrentAudioDeviceType();
std::cout << "Audio device type: " << devType << std::endl;
float sr = setup.sampleRate;
int buffSize = setup.bufferSize;
String oDN = setup.outputDeviceName;
BigInteger oC = setup.outputChannels;
std::cout << "Audio output channels: " << oC.toInteger() << std::endl;
std::cout << "Audio device sample rate: " << sr << std::endl;
std::cout << "Audio device buffer size: " << buffSize << std::endl << std::endl;
graphPlayer = new AudioProcessorPlayer();
stopDevice(); // reduces the amount of background processing when
// device is not in use
}
HRESULT videoInputCamera::setupDevice() {
comInit();
GUID CAPTURE_MODE = PIN_CATEGORY_CAPTURE; //Don't worry - it ends up being preview (which is faster)
//printf("SETUP: Setting up device %i\n",deviceID);
// CREATE THE GRAPH BUILDER //
// Create the filter graph manager and query for interfaces.
HRESULT hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, IID_ICaptureGraphBuilder2, (void **)&pCaptureGraphBuilder);
if (FAILED(hr)) // FAILED is a macro that tests the return value
{
printf("ERROR - Could not create the Filter Graph Manager\n");
return hr;
}
//FITLER GRAPH MANAGER//
// Create the Filter Graph Manager.
hr = CoCreateInstance(CLSID_FilterGraph, 0, CLSCTX_INPROC_SERVER,IID_IGraphBuilder, (void**)&pGraphBuilder);
if (FAILED(hr))
{
printf("ERROR - Could not add the graph builder!\n");
stopDevice();
return hr;
}
//SET THE FILTERGRAPH//
hr = pCaptureGraphBuilder->SetFiltergraph(pGraphBuilder);
if (FAILED(hr))
{
printf("ERROR - Could not set filtergraph\n");
stopDevice();
return hr;
}
//MEDIA CONTROL (START/STOPS STREAM)//
// Using QueryInterface on the graph builder,
// Get the Media Control object.
hr = pGraphBuilder->QueryInterface(IID_IMediaControl, (void **)&pMediaControl);
if (FAILED(hr))
{
printf("ERROR - Could not create the Media Control object\n");
stopDevice();
return hr;
}
char nDeviceName[255];
WCHAR wDeviceName[255];
memset(wDeviceName, 0, sizeof(WCHAR) * 255);
memset(nDeviceName, 0, sizeof(char) * 255);
//FIND VIDEO DEVICE AND ADD TO GRAPH//
//gets the device specified by the second argument.
hr = getDevice(&pInputFilter, cfg->device, wDeviceName, nDeviceName);
if (SUCCEEDED(hr)){
sprintf(cfg->name,nDeviceName);
//printf("SETUP: %s\n", nDeviceName);
hr = pGraphBuilder->AddFilter(pInputFilter, wDeviceName);
}else{
printf("ERROR - Could not find specified video device\n");
stopDevice();
return hr;
}
//LOOK FOR PREVIEW PIN IF THERE IS NONE THEN WE USE CAPTURE PIN AND THEN SMART TEE TO PREVIEW
IAMStreamConfig *streamConfTest = NULL;
hr = pCaptureGraphBuilder->FindInterface(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, pInputFilter, IID_IAMStreamConfig, (void **)&streamConfTest);
if(FAILED(hr)){
//printf("SETUP: Couldn't find preview pin using SmartTee\n");
}else{
CAPTURE_MODE = PIN_CATEGORY_PREVIEW;
streamConfTest->Release();
streamConfTest = NULL;
}
//CROSSBAR (SELECT PHYSICAL INPUT TYPE)//
//my own function that checks to see if the device can support a crossbar and if so it routes it.
//webcams tend not to have a crossbar so this function will also detect a webcams and not apply the crossbar
/*if(useCrossbar)
{
//printf("SETUP: Checking crossbar\n");
routeCrossbar(pCaptureGraphBuilder, pInputFilter, connection, CAPTURE_MODE);
}*/
//we do this because webcams don't have a preview mode
hr = pCaptureGraphBuilder->FindInterface(&CAPTURE_MODE, &MEDIATYPE_Video, pInputFilter, IID_IAMStreamConfig, (void **)&pStreamConfig);
if(FAILED(hr)){
printf("ERROR: Couldn't config the stream!\n");
stopDevice();
return hr;
}
//NOW LETS DEAL WITH GETTING THE RIGHT SIZE
hr = pStreamConfig->GetFormat(&pAmMediaType);
if(FAILED(hr)){
printf("ERROR: Couldn't getFormat for pAmMediaType!\n");
stopDevice();
return hr;
}
if (!setSizeAndSubtype()) return false;
VIDEOINFOHEADER *pVih = reinterpret_cast<VIDEOINFOHEADER*>(pAmMediaType->pbFormat);
cfg->cam_width = HEADER(pVih)->biWidth;
cfg->cam_height = HEADER(pVih)->biHeight;
cfg->cam_fps = ((int)floor(100000000.0f/(float)pVih->AvgTimePerFrame + 0.5f))/10.0f;
long bufferSize = cfg->cam_width*cfg->cam_height*3;
sgCallback->setupBuffer(bufferSize);
// Create the Sample Grabber.
hr = CoCreateInstance(CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER,IID_IBaseFilter, (void**)&pGrabberFilter);
if (FAILED(hr)){
printf("Could not Create Sample Grabber - CoCreateInstance()\n");
stopDevice();
return hr;
}
hr = pGraphBuilder->AddFilter(pGrabberFilter, L"Sample Grabber");
if (FAILED(hr)){
printf("Could not add Sample Grabber - AddFilter()\n");
stopDevice();
return hr;
}
hr = pGrabberFilter->QueryInterface(IID_ISampleGrabber, (void**)&pSampleGrabber);
if (FAILED(hr)){
printf("ERROR: Could not query SampleGrabber\n");
stopDevice();
return hr;
}
//Get video properties from the stream's mediatype and apply to the grabber (otherwise we don't get an RGB image)
AM_MEDIA_TYPE mt;
ZeroMemory(&mt,sizeof(AM_MEDIA_TYPE));
mt.majortype = MEDIATYPE_Video;
mt.subtype = MEDIASUBTYPE_RGB24;
//mt.subtype = MEDIASUBTYPE_YUY2;
mt.formattype = FORMAT_VideoInfo;
//Set Params - One Shot should be false unless you want to capture just one buffer
hr = pSampleGrabber->SetMediaType(&mt);
hr = pSampleGrabber->SetOneShot(FALSE);
hr = pSampleGrabber->SetBufferSamples(FALSE);
//Tell the grabber to use our callback function - 0 is for SampleCB and 1 for BufferCB
//We use SampleCB
hr = pSampleGrabber->SetCallback(sgCallback, 0);
if (FAILED(hr)) {
printf("ERROR: problem setting callback\n");
stopDevice();
return hr;
} /*else {
printf("SETUP: Capture callback set\n");
}*/
//lets try freeing our stream conf here too
//this will fail if the device is already running
/* if(pStreamConfig) {
pStreamConfig->Release();
pStreamConfig = NULL;
} else {
printf("ERROR: connecting device - prehaps it is already being used?\n");
stopDevice();
return S_FALSE;
}*/
//used to give the video stream somewhere to go to.
hr = CoCreateInstance(CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)(&pDestFilter));
if (FAILED(hr)){
printf("ERROR: Could not create filter - NullRenderer\n");
stopDevice();
return hr;
}
hr = pGraphBuilder->AddFilter(pDestFilter, L"NullRenderer");
if (FAILED(hr)){
printf("ERROR: Could not add filter - NullRenderer\n");
stopDevice();
return hr;
}
//This is where the stream gets put together.
hr = pCaptureGraphBuilder->RenderStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, pInputFilter, pGrabberFilter, pDestFilter);
if (FAILED(hr)){
printf("ERROR: Could not connect pins - RenderStream()\n");
stopDevice();
return hr;
}
//EXP - lets try setting the sync source to null - and make it run as fast as possible
{
IMediaFilter *pMediaFilter = 0;
hr = pGraphBuilder->QueryInterface(IID_IMediaFilter, (void**)&pMediaFilter);
if (FAILED(hr)){
printf("ERROR: Could not get IID_IMediaFilter interface\n");
}else{
pMediaFilter->SetSyncSource(NULL);
pMediaFilter->Release();
}
}
//printf("SETUP: Device is setup and ready to capture.\n\n");
//if we release this then we don't have access to the settings
//we release our video input filter but then reconnect with it
//each time we need to use it
//pInputFilter->Release();
//pInputFilter = NULL;
pGrabberFilter->Release();
pGrabberFilter = NULL;
pDestFilter->Release();
pDestFilter = NULL;
return S_OK;
}
/*! \brief SerialDevice::~SerialDevice Stops transmissions and deletes the serial instance.
*/
SerialDevice::~SerialDevice()
{
stopDevice();
delete device;
}
