const ServiceStatus InsertTranscriptAction::Execute()
{
ServiceStatus status = SERVICE_FAILURE;
std::string path = FileManager::BrowseForFiles(fileBrowserTitleId_);
PRECONDITION_RETURN(path.empty() == false, SERVICE_FAILURE);
std::vector<framework::TranscriptItem> items;
const Application& application = Application::Instance();
std::ifstream input(path);
std::string entry;
while(std::getline(input, entry))
{
std::vector<std::string> tokens = framework::split(entry, ']');
if(tokens.size() == 2)
{
std::string script = framework::trim(tokens[1]);
tokens = framework::split(tokens[0], ' ');
if(tokens.size() == 2)
{
std::string timestamp = tokens[0].substr(1);
const double position = application.StringToTimestamp(timestamp);
std::string speaker = tokens[1];
items.push_back(framework::TranscriptItem(speaker, position, script));
}
}
}
size_t addedItemCount = 0;
for(size_t i = 0; i < items.size(); i++)
{
if(application.InsertTransriptItem(items[i]))
{
addedItemCount++;
}
}
input.close();
if(items.size() == addedItemCount)
{
NotificationWindow::Show(successMessageId_);
status = SERVICE_SUCCESS;
}
else
{
NotificationWindow::Show(failureMessageId_);
}
return status;
}
bool EnumBuiltinDevices_w64(const uint32_t deviceType, STUDIO_LINK_DEVICE_LIST* devices)
{
PRECONDITION_RETURN(deviceType != INVALID_DEVICE_TYPE, false);
PRECONDITION_RETURN(devices != 0, false);
bool result = false;
HRESULT hr = CoInitialize(0);
if(SUCCEEDED(hr))
{
IMMDeviceEnumerator* pDeviceEnumerator = 0;
hr = CoCreateInstance(CLSID_MMDeviceEnumerator, 0, CLSCTX_INPROC_SERVER, IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
if(SUCCEEDED(hr) && (pDeviceEnumerator != 0))
{
EDataFlow dataFlow = eAll;
if(deviceType == HEADPHONE)
{
dataFlow = eRender;
}
else if(deviceType == MICROPHONE)
{
dataFlow = eCapture;
}
IMMDeviceCollection* pDeviceCollection = 0;
hr = pDeviceEnumerator->EnumAudioEndpoints(dataFlow, DEVICE_STATE_ACTIVE, &pDeviceCollection);
if(SUCCEEDED(hr) && (pDeviceCollection != 0))
{
UINT deviceCount = 0;
hr = pDeviceCollection->GetCount(&deviceCount);
if(SUCCEEDED(hr))
{
size_t foundDevices = 0;
for(UINT i = 0; (i < deviceCount) && (foundDevices < deviceCount); i++)
{
IMMDevice* pDevice = 0;
hr = pDeviceCollection->Item(i, &pDevice);
if(SUCCEEDED(hr) && (pDevice != 0))
{
IPropertyStore* pProperties = 0;
hr = pDevice->OpenPropertyStore(STGM_READ, &pProperties);
if(SUCCEEDED(hr))
{
PROPVARIANT deviceFormatProperty;
PropVariantInit(&deviceFormatProperty);
hr = pProperties->GetValue(PKEY_AudioEngine_DeviceFormat, &deviceFormatProperty);
if(SUCCEEDED(hr) && (VT_BLOB == deviceFormatProperty.vt))
{
WAVEFORMATEX* deviceFormat = (WAVEFORMATEX*)deviceFormatProperty.blob.pBlobData;
devices->devices[foundDevices].channelCount = deviceFormat->nChannels;
devices->devices[foundDevices].sampleRate = deviceFormat->nSamplesPerSec;
if((WAVE_FORMAT_EXTENSIBLE == deviceFormat->wFormatTag) && (deviceFormat->cbSize >= 22))
{
//WAVEFORMATEXTENSIBLE* extensibleDeviceFormat = (WAVEFORMATEXTENSIBLE*)deviceFormat;
}
PropVariantClear(&deviceFormatProperty);
PROPVARIANT deviceNameProperty;
PropVariantInit(&deviceNameProperty);
hr = pProperties->GetValue(PKEY_Device_FriendlyName, &deviceNameProperty);
if(SUCCEEDED(hr))
{
PWSTR deviceName = 0;
hr = PropVariantToStringAlloc(deviceNameProperty, &deviceName);
if(SUCCEEDED(hr))
{
memset(devices->devices[foundDevices].name, 0, STUDIO_LINK_DEVICE_NAME_LENGTH);
size_t numOfCharsConverted = 0;
const size_t deviceNameLength = wcslen(deviceName);
wcstombs_s(&numOfCharsConverted, devices->devices[foundDevices].name,
STUDIO_LINK_DEVICE_NAME_LENGTH, deviceName, deviceNameLength);
foundDevices++;
CoTaskMemFree(deviceName);
deviceName = 0;
}
PropVariantClear(&deviceNameProperty);
}
}
SafeRelease(pProperties);
}
SafeRelease(pDevice);
}
}
devices->deviceCount = foundDevices;
}
SafeRelease(pDeviceCollection);
}
SafeRelease(pDeviceEnumerator);
}
CoUninitialize();
}
if(devices->deviceCount > 0)
{
result = true;
}
return result;
}
