bool MythRecorder::SetChannel(MythChannel &channel)
{
m_recorder_t->Lock();
if(!IsRecording())
{
XBMC->Log(LOG_ERROR,"%s: Recorder %i is not recording",__FUNCTION__,ID(),channel.Name().c_str());
m_recorder_t->Unlock();
return false;
}
CStdString channelNum;
channelNum.Format("%i",channel.Number());
if(CMYTH->RecorderPause(*m_recorder_t)!=0)
{
XBMC->Log(LOG_ERROR,"%s: Failed to pause recorder %i",__FUNCTION__,ID());
m_recorder_t->Unlock();
return false;
}
if(!CheckChannel(channel))
{
XBMC->Log(LOG_ERROR,"%s: Recorder %i doesn't provide channel %s",__FUNCTION__,ID(),channel.Name().c_str());
m_recorder_t->Unlock();
return false;
}
if(CMYTH->RecorderSetChannel(*m_recorder_t,channelNum.GetBuffer())!=0)
{
XBMC->Log(LOG_ERROR,"%s: Failed to change recorder %i to channel %s",__FUNCTION__,ID(),channel.Name().c_str());
m_recorder_t->Unlock();
return false;
}
if(CMYTH->LivetvChainSwitchLast(*m_recorder_t)!=1)
{
XBMC->Log(LOG_ERROR,"%s: Failed to switch chain for recorder %i",__FUNCTION__,ID(),channel.Name().c_str());
m_recorder_t->Unlock();
return false;
}
*livechainupdated=0;
int i=20;
while(*livechainupdated==0&&i--!=0)
{
m_recorder_t->Unlock();
cSleep(100);
m_recorder_t->Lock();
}
m_recorder_t->Unlock();
for(int i=0;i<20;i++)
{
if(!IsRecording())
cSleep(1);
else
break;
}
return true;
}
bool PAPlayer::Record(bool bOnOff)
{
if (!m_pShoutCastRipper) return false;
if (bOnOff && IsRecording()) return true;
if (bOnOff == false && IsRecording() == false) return true;
if (bOnOff)
return m_pShoutCastRipper->Record();
m_pShoutCastRipper->StopRecording();
return true;
}
void GOrgueMidiRecorder::StopRecording()
{
m_button[ID_MIDI_RECORDER_RECORD]->Display(false);
m_button[ID_MIDI_RECORDER_RECORD_RENAME]->Display(false);
m_organfile->DeleteTimer(this);
if (!IsRecording())
return;
const unsigned char end[4] = { 0x01, 0xFF, 0x2F, 0x00 };
Write(end, sizeof(end));
Flush();
m_FileLength -= sizeof(MIDIHeaderChunk) + sizeof(MIDIFileHeader);
MIDIFileHeader h = { { 'M', 'T', 'r', 'k' }, m_FileLength };
m_file.Seek(sizeof(MIDIHeaderChunk));
m_file.Write(&h, sizeof(h));
m_file.Flush();
m_file.Close();
if (!m_DoRename)
{
wxFileName name = m_Filename;
GOSyncDirectory(name.GetPath());
}
else
GOAskRenameFile(m_Filename, m_organfile->GetSettings().MidiRecorderPath(),_("MIDI files (*.mid)|*.mid"));
UpdateDisplay();
}
bool csMovieRecorder::EatKey (iEvent& event)
{
SetupPlugin();
bool down = csKeyEventHelper::GetEventType (&event) == csKeyEventTypeDown;
csKeyModifiers m;
csKeyEventHelper::GetModifiers (&event, m);
bool alt = m.modifiers[csKeyModifierTypeAlt] != 0;
bool ctrl = m.modifiers[csKeyModifierTypeCtrl] != 0;
bool shift = m.modifiers[csKeyModifierTypeShift] != 0;
utf32_char key = csKeyEventHelper::GetCookedCode (&event);
if (down && (key == keyRecord.code) && (alt == keyRecord.alt) &&
(ctrl == keyRecord.ctrl) && (shift == keyRecord.shift))
{
if (IsRecording())
Stop();
else
Start();
return true;
}
if (down && key==keyPause.code && alt==keyPause.alt &&
ctrl==keyPause.ctrl && shift==keyPause.shift)
{
if (IsPaused())
UnPause();
else
Pause();
return true;
}
return false;
}
uint32 FVoiceEngineSteam::StartLocalVoiceProcessing(uint32 LocalUserNum)
{
uint32 Return = E_FAIL;
if (IsOwningUser(LocalUserNum))
{
if (!bIsCapturing)
{
// Update the current recording state, if VOIP data was still being read
VoiceCaptureUpdate();
if (!IsRecording())
{
StartRecording();
}
bIsCapturing = true;
}
Return = S_OK;
}
else
{
UE_LOG(LogVoiceEncode, Error, TEXT("StartLocalVoiceProcessing(): Device is currently owned by another user"));
}
return Return;
}
void GOrgueMidiRecorder::UpdateDisplay()
{
if (!IsRecording())
m_RecordingTime.SetContent(_("-:--:--"));
else
m_RecordingTime.SetContent(wxString::Format(_("%d:%02d:%02d"), m_RecordSeconds / 3600, (m_RecordSeconds / 60) % 60, m_RecordSeconds % 60));
}
void CameraObject::VideoUpdatedSlot()
{
if( IsRecording() && GetState() == Ok )
{
m_recordingCamera->AddFrame( GetVideoOutput(), GetUncalibratedTransform()->GetMatrix() );
}
// Update representation if image size changed
if( GetImageWidth() != m_cachedImageSize[0] || GetImageHeight() != m_cachedImageSize[1] )
UpdateGeometricRepresentation();
// Get the position of the transparency center from projection of the tracked pointer
if( m_trackedTransparencyCenter )
{
Q_ASSERT( this->GetManager() );
PointerObject * navPointer = this->GetManager()->GetNavigationPointerObject();
if( navPointer )
{
// Get world space position of the tip
double * tip = navPointer->GetTipPosition();
double cx, cy;
WorldToImage( tip, cx, cy );
// Set new center for transparency
SetTransparencyCenter( cx / GetImageWidth(), cy / GetImageHeight() );
}
}
UpdateVtkCamera();
emit VideoUpdatedSignal();
emit ObjectModified();
}
void csMovieRecorder::ClockAdvance ()
{
csTicks lastFakeClockTicks = fakeClockTicks;
realVirtualClock->Advance();
csTicks realTicksPerFrame = realVirtualClock->GetElapsedTicks();
/*
To avoid 'jumps' in time when the clock is throttled/unthrottled
we keep our own tick counter, which is either increased by the
real elapsed time (normal mode) or the required frame time (recording).
*/
if (!IsRecording() || IsPaused()) {
fakeClockElapsed = realTicksPerFrame;
fakeClockTicks += realTicksPerFrame;
}
else {
ffakeClockTicks += fakeTicksPerFrame;
fakeClockTicks = (csTicks)ffakeClockTicks;
fakeClockElapsed = fakeClockTicks -
lastFakeClockTicks;
// If we're rendering slower than real time, there's nothing we can do about it.
// If we're rendering faster, put in a little delay here.
if (throttle && ((fakeClockElapsed > realTicksPerFrame)))
{
csSleep(fakeClockElapsed - realTicksPerFrame);
}
}
}
void csMovieRecorder::Pause(void)
{
if (!IsRecording())
return;
paused = true;
Report (CS_REPORTER_SEVERITY_NOTIFY, "Video recorder paused - %s",
movieFileName.GetData());
}
// Writing is from the perspective of the host: this method handles
// incoming data from the host.
USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len) {
uchar i;
if (currentRequest == WL_REQUEST_SET_WEBUSB_URLS) {
eeprom_update_block(data,
EEPROM_WEBUSB_URLS_START + currentPosition, len);
currentPosition += len;
bytesRemaining -= len;
return bytesRemaining == 0;
}
if (len > bytesRemaining) {
len = bytesRemaining;
}
bytesRemaining -= len;
for (i = 0; i < len; i++) {
buffer[currentPosition++] = data[i];
}
if (bytesRemaining == 0) {
switch (currentRequest) {
case WL_REQUEST_COLOR:
if (!IsRecording()) {
Stop();
}
HandleTRANSITION(NONE, 0);
HandleCOLOR(buffer[0], buffer[1], buffer[2]);
break;
case WL_REQUEST_PAUSE:
if (IsRecording()) {
HandlePAUSE((buffer[0] << 8) | buffer[1]);
} else {
// This doesn't make sense interactively. Ignore.
}
break;
case WL_REQUEST_TRANSITION:
if (!IsRecording()) {
Stop();
}
HandleTRANSITION(buffer[0], (buffer[1] << 8) | buffer[2]);
break;
}
}
return bytesRemaining == 0; // return 1 if we have all data
}
void VideoInput::Stop()
{
if(IsRecording()) {
video_recorder.release();
}else{
video_src->Stop();
}
}
void GOrgueMidiRecorder::SendEvent(GOrgueMidiEvent& e)
{
e.SetDevice(m_OutputDevice);
if (m_OutputDevice)
m_organfile->SendMidiMessage(e);
if (IsRecording())
WriteEvent(e);
}
void csMovieRecorder::UnPause(void)
{
if (!IsRecording())
return;
paused = false;
ffakeClockTicks = fakeClockTicks;
Report (CS_REPORTER_SEVERITY_NOTIFY, "Video recorder unpaused - %s",
movieFileName.GetData());
}
void CHLTVDemoRecorder::RecordCommand( const char *cmdstring )
{
if ( !IsRecording() )
return;
if ( !cmdstring || !cmdstring[0] )
return;
m_DemoFile.WriteConsoleCommand( cmdstring, GetRecordingTick() );
}
/*
** ToggleRecording
*/
void
ACMIRecorder::ToggleRecording( void )
{
F4EnterCriticalSection( _csect );
if ( IsRecording() )
StopRecording();
else
StartRecording();
F4LeaveCriticalSection( _csect );
}
FString FVoiceEngineSteam::GetVoiceDebugState() const
{
FString Output;
Output = FString::Printf(TEXT("IsRecording: %d\n DataReady: 0x%08x State:%s\n BufferRemaining: %d\n"),
IsRecording(),
GetVoiceDataReadyFlags(),
*SteamVoiceResult(AvailableVoiceResult),
CompressedVoiceBuffer.Num()
);
return Output;
}
void GOrgueMidiRecorder::SendMidiRecorderMessage(GOrgueMidiEvent& e)
{
if (!m_OutputDevice && !IsRecording())
return;
if (!SetupMapping(e.GetDevice(), e.GetMidiType() == MIDI_NRPN))
return;
e.SetTime(wxGetLocalTimeMillis());
e.SetChannel(m_Mappings[e.GetDevice()].channel);
if (e.GetMidiType() == MIDI_NRPN)
e.SetKey(m_Mappings[e.GetDevice()].key);
SendEvent(e);
}
uint32 FVoiceEngineSteam::GetVoiceDataReadyFlags() const
{
// First check and update the internal state of VOIP recording
VoiceCaptureUpdate();
if (OwningUserIndex != INVALID_INDEX && IsRecording())
{
// Check if there is new data available via the Steam API
if (AvailableVoiceResult == k_EVoiceResultOK && CompressedBytesAvailable > 0)
{
return 1 << OwningUserIndex;
}
}
return 0;
}
bool FVisualLogger::IsCategoryLogged(const struct FLogCategoryBase& Category) const
{
if ((GEngine && GEngine->bDisableAILogging) || IsRecording() == false)
{
return false;
}
const FName CategoryName = Category.GetCategoryName();
if (IsBlockedForAllCategories() && IsWhiteListed(CategoryName) == false)
{
return false;
}
return true;
}
LRESULT CMainFrame::OnHotKey(WPARAM wParam, LPARAM lParam)
{
if (m_Options.m_Record.ActivationType == CRecordDlg::ACT_PROMPT) {
if (IsIconic()) // if minimized
ShowWindow(SW_RESTORE); // restore so prompts are visible
}
switch (wParam) {
case RECORD_PARMS::HK_START:
Record(TRUE); // start recording
break;
case RECORD_PARMS::HK_STOP:
if (IsRecording()) {
m_RecordDlg->Stop(CRecordDlg::SF_DEFAULT // stop recording
& ~CRecordDlg::SF_OPEN_RECORDING); // don't open recording
}
break;
}
return(0);
}
FString FVoiceEngineImpl::GetVoiceDebugState() const
{
FString Output;
Output = FString::Printf(TEXT("IsRecording: %d\n DataReady: 0x%08x State:%s\n UncompressedBytes: %d\n CompressedBytes: %d\n"),
IsRecording(),
GetVoiceDataReadyFlags(),
EVoiceCaptureState::ToString(AvailableVoiceResult),
UncompressedBytesAvailable,
CompressedBytesAvailable
);
// Add remainder size
for (int32 Idx=0; Idx < MAX_SPLITSCREEN_TALKERS; Idx++)
{
Output += FString::Printf(TEXT("Remainder[%d] %d\n"), Idx, PlayerVoiceData[Idx].VoiceRemainderSize);
}
return Output;
}
void Movie::AddFrame(FrameType ftype)
{
if (!IsRecording())
return;
if (!av->inited)
{
if (ftype == FRAME_FADE)
return;
if (!Setup())
return;
}
if (ftype == FRAME_FADE && get_keyboard_controller_status())
return;
SDL_SemWait(fillReady);
if (!MainScreenIsOpenGL())
{
SDL_Surface *video = MainScreenSurface();
SDL_BlitSurface(video, &view_rect, temp_surface, NULL);
}
#ifdef HAVE_OPENGL
else
{
// Read OpenGL frame buffer
glReadPixels(view_rect.x, view_rect.y, view_rect.w, view_rect.h, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, &videobuf.front());
// Copy pixel buffer (which is upside-down) to surface
for (int y = 0; y < view_rect.h; y++)
memcpy((uint8 *)temp_surface->pixels + temp_surface->pitch * y, &videobuf.front() + view_rect.w * 4 * (view_rect.h - y - 1), view_rect.w * 4);
}
#endif
int audio_bytes_per_frame = audiobuf.size();
Mixer *mx = Mixer::instance();
int old_vol = mx->main_volume;
mx->main_volume = 0x100;
mx->Mix(&audiobuf.front(), audio_bytes_per_frame / 4, true, true, true);
mx->main_volume = old_vol;
SDL_SemPost(encodeReady);
}
void AmInputTarget::HandleEvents(AmEvent* events)
{
mQueue->Lock();
if (mQueue->IsPerforming() && IsPerforming()) {
mQueue->Unlock();
mQueue->PerformEvents(mTrack, events->CopyChain());
mQueue->Lock();
}
if (!mQueue->IsRecording() || !IsRecording()) {
mQueue->Unlock();
//printf("Dropping record:\n"); events->PrintChain();
events->DeleteChain();
return;
}
mQueue->Unlock();
mQueue->RecordEvents(mTrack, events);
}
void GOrgueMidiRecorder::WriteEvent(GOrgueMidiEvent& e)
{
if (!IsRecording())
return;
std::vector<std::vector<unsigned char>> msg;
e.ToMidi(msg, m_Map);
for(unsigned i = 0; i < msg.size(); i++)
{
EncodeLength((e.GetTime() - m_Last).GetValue());
if (msg[i][0] == 0xF0)
{
Write(&msg[i][0], 1);
EncodeLength(msg[i].size() - 1);
Write(&msg[i][1], msg[i].size() - 1);
}
else
Write(&msg[i][0], msg[i].size());
m_Last = e.GetTime();
}
}
bool csMovieRecorder::HandleEndFrame (iEvent& /*event*/)
{
if (IsRecording() && !IsPaused()) {
csRef<iImage> img (csPtr<iImage> (G2D->ScreenShot ()));
csTicks ticks = csGetTicks();
csTicks thisFrameTime = ticks - frameStartTime;
if (!img) {
Report (CS_REPORTER_SEVERITY_ERROR, "This video driver doesn't support screen capture.");
Stop();
return false;
}
// If we're recording to a different resolution, try to scale the image
if (img->GetWidth() != writer->width || img->GetHeight() != writer->height) {
img = csImageManipulate::Rescale (img, writer->width, writer->height);
}
numFrames++;
csTicks encodeTime, writeTime;
unsigned char *buffer = (unsigned char *) img->GetImageData();
writer->writeFrame(buffer, encodeTime, writeTime);
totalFrameTime += thisFrameTime;
minFrameTime = MIN (minFrameTime, thisFrameTime);
maxFrameTime = MAX (maxFrameTime, thisFrameTime);
totalFrameEncodeTime += encodeTime;
minFrameEncodeTime = MIN (minFrameEncodeTime, encodeTime);
maxFrameEncodeTime = MAX (maxFrameEncodeTime, encodeTime);
totalWriteToDiskTime += writeTime;
minWriteToDiskTime = MIN (minWriteToDiskTime, writeTime);
maxWriteToDiskTime = MAX (maxWriteToDiskTime, writeTime);
}
return false;
}
void csMovieRecorder::Start(void)
{
SetupPlugin();
if (IsPaused()) {
UnPause();
return;
}
if (IsRecording())
Stop();
movieFileName = recordingFile != "" ? recordingFile : captureFormat.FindNextFilename (VFS);
// If the config specified 0x0, that means we use the current resolution unscaled
int w = recordWidth ? recordWidth : G2D->GetWidth();
int h = recordHeight ? recordHeight : G2D->GetHeight();
numFrames = 0;
totalFrameEncodeTime = totalFrameTime = totalWriteToDiskTime = 0;
minFrameEncodeTime = minFrameTime = minWriteToDiskTime = (csTicks)-1;
maxFrameEncodeTime = maxFrameTime = maxWriteToDiskTime = 0;
movieFile = VFS->Open (movieFileName, VFS_FILE_WRITE | VFS_FILE_UNCOMPRESSED);
if (!movieFile)
{
Report (CS_REPORTER_SEVERITY_WARNING,
"Couldn't open file %s for recording", CS::Quote::Single (movieFileName.GetData()));
return;
}
fakeTicksPerFrame = (1000 / frameRate);
ffakeClockTicks = fakeClockTicks;
frameStartTime = csGetTicks();
writer = new NuppelWriter(w, h, &WriterCallback, this, frameRate,
rtjQuality, useRTJpeg, useLZO, useRGB);
Report (CS_REPORTER_SEVERITY_NOTIFY, "Video recorder started - %s",
movieFileName.GetData());
}
void csMovieRecorder::Stop(void)
{
if (IsRecording()) {
delete writer;
writer = 0;
movieFile = 0;
Report (CS_REPORTER_SEVERITY_NOTIFY, "Video recorder stopped - %s",
movieFileName.GetData());
if (numFrames != 0)
{
float avgFrameEncodeTime = ((float)totalFrameEncodeTime / (float)numFrames);
float avgWriteToDiskTime = ((float)totalWriteToDiskTime / (float)numFrames);
float avgFrameTime = ((float)totalFrameTime / (float)numFrames);
Report (CS_REPORTER_SEVERITY_NOTIFY,
"Video recording statistics for %s:\n"
" Number of frames: %d\n"
" Time spent for:\n"
" encoding image data - total: %.3fs, per frame: %zu min/%g avg/%zu max ms\n"
" writing encoded data - total: %.3fs, per frame: %zu min/%g avg/%zu max ms\n"
" drawing frame - total: %.3fs, per frame: %zu min/%g avg/%zu max ms\n"
"\n"
" Frame time in relation to real time: x%.4f\n"
" Theoretical video FPS recordable in real-time: %.2f\n",
movieFileName.GetData(),
numFrames,
((float)totalFrameEncodeTime / 1000.0f),
minFrameEncodeTime, avgFrameEncodeTime, maxFrameEncodeTime,
((float)totalWriteToDiskTime / 1000.0f),
minWriteToDiskTime, avgWriteToDiskTime, maxWriteToDiskTime,
((float)totalFrameTime / 1000.0f),
minFrameTime, avgFrameTime, maxFrameTime,
((avgFrameEncodeTime + avgWriteToDiskTime + avgFrameTime) *
frameRate) / 1000.0f,
1000.0f / (avgFrameEncodeTime + avgWriteToDiskTime + avgFrameTime)
);
}
}
}
void UActorRecording::Tick(float DeltaSeconds, ULevelSequence* CurrentSequence, float CurrentSequenceTime)
{
if (IsRecording())
{
if(CurrentSequence)
{
// check our components to see if they have changed
static TArray<USceneComponent*> SceneComponents;
GetSceneComponents(SceneComponents);
if(TrackedComponents.Num() != SceneComponents.Num())
{
StartRecordingNewComponents(CurrentSequence, CurrentSequenceTime);
}
}
for(auto& SectionRecorder : SectionRecorders)
{
SectionRecorder->Record(CurrentSequenceTime);
}
}
}
void ProjectionFixed::ModifyProjection()
{
for(int i=0;i<m_events.size();i++)
{
if(m_events[i]->IsOn())
m_events[i]->Modify();
}
// record new weights if storing on evolution of weights
if(IsRecording() && m_storeSamplingWeightsEvolution>0)
{
if(m_storeSamplingCounter % m_storeSamplingWeightsEvolution == 0)
{
m_storeSamplingCounter=0;
// append
for(int i=0;i<this->GetPostIds().size();i++)
{
long postId = this->GetPostIds()[i];
vector<long> preIds = this->GetPreIds(postId);
vector<float> ws(preIds.size());
for(int j=0;j<preIds.size();j++)
{
ws[j] = m_network->GetWeight(preIds[j],postId);
}
m_recordedValues.push_back(ws);
}
}
m_storeSamplingCounter++;
}
}
uint32 FVoiceEngineSteam::ReadLocalVoiceData(uint32 LocalUserNum, uint8* Data, uint32* Size)
{
check(*Size > 0);
// Before doing anything, check/update the current recording state
VoiceCaptureUpdate();
// Return data even if not capturing, if the final half-second of data from Steam is still pending
if (IsOwningUser(LocalUserNum) && IsRecording())
{
CompressedVoiceBuffer.Empty(MAX_COMPRESSED_VOICE_BUFFER_SIZE);
uint32 CompressedBytes = 0;
EVoiceResult VoiceResult = SteamUserPtr->GetAvailableVoice(&CompressedBytes, NULL, 0);
if (VoiceResult != k_EVoiceResultOK && VoiceResult != k_EVoiceResultNoData)
{
UE_LOG(LogVoiceEncode, Warning, TEXT("ReadLocalVoiceData: GetAvailableVoice failure: VoiceResult: %s"), *SteamVoiceResult(VoiceResult));
return E_FAIL;
}
// This shouldn't happen, but just in case.
if (CompressedBytes == 0)
{
UE_LOG(LogVoiceEncode, VeryVerbose, TEXT("ReadLocalVoiceData: No Data: VoiceResult: %s"), *SteamVoiceResult(VoiceResult));
*Size = 0;
return S_OK;
}
// Update the amount of data available for consumption (CompressedBytes can be more than AvailableWritten below)
CompressedVoiceBuffer.AddUninitialized(CompressedBytes);
uint32 AvailableWritten = 0;
VoiceResult = SteamUserPtr->GetVoice(true, CompressedVoiceBuffer.GetData(), CompressedVoiceBuffer.Num(), &AvailableWritten, false, NULL, 0, NULL, 0);
static double LastGetVoiceCallTime = 0.0;
double CurTime = FPlatformTime::Seconds();
double TimeSinceLastCall = LastGetVoiceCallTime > 0 ? (CurTime - LastGetVoiceCallTime) : 0.0;
LastGetVoiceCallTime = CurTime;
UE_LOG(LogVoiceEncode, Log, TEXT("ReadLocalVoiceData: GetVoice: Result: %s, Available: %i, LastCall: %0.3f"), *SteamVoiceResult(VoiceResult), AvailableWritten, TimeSinceLastCall);
if (VoiceResult != k_EVoiceResultOK)
{
UE_LOG(LogVoiceEncode, Warning, TEXT("ReadLocalVoiceData: GetVoice failure: VoiceResult: %s"), *SteamVoiceResult(VoiceResult));
*Size = 0;
CompressedVoiceBuffer.Empty(MAX_COMPRESSED_VOICE_BUFFER_SIZE);
return E_FAIL;
}
if (AvailableWritten > 0)
{
*Size = FMath::Min<int32>(*Size, AvailableWritten);
FMemory::Memcpy(Data, CompressedVoiceBuffer.GetData(), *Size);
UE_LOG(LogVoiceEncode, VeryVerbose, TEXT("ReadLocalVoiceData: Size: %d"), *Size);
return S_OK;
}
else
{
*Size = 0;
}
}
return E_FAIL;
}
