PageCapture Class Reference

This class controls the firewire capture notebook page. More...

#include <page_capture.h>

Inheritance diagram for PageCapture:

[legend]Collaboration diagram for PageCapture:

[legend]List of all members.

Public Member Functions
	PageCapture (KinoCommon *common)
	Constructor for page.
virtual	~PageCapture ()
	Destructor for page.
gulong	activate ()
	Define active widgets.
void	newFile ()
	Called when a new file operation is selected by the user.
void	start ()
	Start of page.
void	clean ()
	Leaving the page.
gboolean	processKeyboard (GdkEventKey *event)
	Process a keyboard event.
gboolean	processCommand (char *cmd)
	Internal method for handling a complete keyboard scene.
void	videoStartOfMovie ()
	Start of movie.
void	videoPreviousScene ()
	Start of previous scene.
void	videoStartOfScene ()
	Start of current scene.
void	videoRewind ()
	Rewind.
void	videoBack ()
	Frame back.
void	videoPlay ()
	Play.
void	videoForward ()
	Forward.
void	videoFastForward ()
	Fast Forward.
void	videoNextScene ()
	Start of next scene.
void	videoEndOfScene ()
	End of current scene.
void	videoEndOfMovie ()
	End of movie.
void	videoPause ()
	Pause.
void	videoStop ()
	Stop.
void	videoShuttle (int)
	Shuttle.
void	applyAVCState (quadlet_t)
	Reflect the the AV/C status in the transport buttons.
quadlet_t	getAVCState ()
void	startCapture ()
	Start capturing video to the disk.
void	stopCapture ()
	Stop capturing video to the disk.
void	saveFrame ()
	Save a single still frame of video to the disk.
void	windowMoved ()
void	showFrameInfo (int)
	Show the AV/C timecode.
Frame *	getFrame ()
	Fetch the currently showing frame.
void	CheckDevices ()
	Check devices and status.
void	collectFiles ()
std::string	getHelpPage ()
Public Attributes
bool	driver_available
bool	avc_enabled
bool	audio_enabled
bool	check_phyid
bool	driver_locked
Private Attributes
KinoCommon *	common
quadlet_t	avcState
bool	isCapturing
bool	captureMutex
gulong	validComponents
int	gui_state_was
GtkDrawingArea *	frameArea
GtkToggleButton *	avcButton
GtkToggleButton *	recordButton
GtkToggleButton *	stopButton
GtkToggleButton *	playrecordButton
GtkToggleButton *	muteButton
GtkButton *	snapshotButton
GtkEntry *	fileEntry
GtkLabel *	timecodeLabel

---

Detailed Description

This class controls the firewire capture notebook page.

Definition at line 35 of file page_capture.h.

---

Constructor & Destructor Documentation

PageCapture::PageCapture (  KinoCommon *  common  )

Constructor for page. Parameters: common  common object to which this page belongs Definition at line 98 of file page_capture.cc. References avcButton, fileEntry, frameArea, KinoCommon::getWidget(), lastPreferenceFilename, lookup_widget(), muteButton, recordButton, snapshotButton, stopButton, timecode, and timecodeLabel. : isCapturing( false ), captureMutex( false ), avc_enabled( false ), driver_locked( false ) { std::cerr << "> Creating Capture Page" << std::endl; this->common = common; this->frameArea = GTK_DRAWING_AREA( lookup_widget( common->getWidget(), "capture_drawingarea" ) ); gtk_widget_set_double_buffered( GTK_WIDGET( frameArea ), FALSE ); this->avcButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "capture_page_avc_button" ) ); this->recordButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "capture_page_record_button" ) ); this->stopButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "capture_page_stop_button" ) ); this->muteButton = GTK_TOGGLE_BUTTON( lookup_widget( common->getWidget(), "capture_page_mute_button" ) ); this->snapshotButton = GTK_BUTTON( lookup_widget( common->getWidget(), "capture_page_snapshot_button" ) ); this->fileEntry = GTK_ENTRY( lookup_widget( common->getWidget(), "entry_capture_file" ) ); this->timecodeLabel = GTK_LABEL( lookup_widget( common->getWidget(), "position_label_current" ) ); lastPreferenceFilename[ 0 ] = 0; memset( timecode, 0, sizeof( timecode ) ); }

PageCapture::~PageCapture (   )  [virtual]

Destructor for page. Definition at line 119 of file page_capture.cc. References reader. { std::cerr << "> Destroying Capture Page" << std::endl; delete reader; reader = NULL; }

---

Member Function Documentation

gulong PageCapture::activate (   )  [virtual]

Define active widgets. Reimplemented from Page. Definition at line 453 of file page_capture.cc. References SCENE_LIST, and validComponents. { return this->validComponents | SCENE_LIST; }

void PageCapture::applyAVCState (  quadlet_t   )

Reflect the the AV/C status in the transport buttons. Definition at line 282 of file page_capture.cc. References KinoCommon::activateWidgets(), navigate_control::active, avc_enabled, avcButton, avcState, check_phyid, KinoCommon::commitComponentState(), common, driver_available, g_nav_ctl, KinoCommon::getComponentState(), Preferences::getInstance(), gui_state_was, INFO_FRAME, isCapturing, muteButton, recordButton, KinoCommon::setStatusBar(), snapshotButton, stopButton, stopCapture(), KinoCommon::toggleComponents(), validComponents, VIDEO_BACK, VIDEO_END_OF_MOVIE, VIDEO_FAST_FORWARD, VIDEO_FORWARD, VIDEO_NEXT_SCENE, VIDEO_PLAY, VIDEO_REWIND, VIDEO_SHUTTLE, VIDEO_START_OF_MOVIE, VIDEO_START_OF_SCENE, and VIDEO_STOP. { if ( driver_available == false ) { if ( gui_state_was != 0 ) { gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), false ); gtk_widget_set_sensitive( GTK_WIDGET( recordButton ), false ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), false ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), false ); gtk_widget_set_sensitive( GTK_WIDGET( muteButton ), false ); validComponents = 0; common->activateWidgets( ); common->commitComponentState(); #ifdef HAVE_IEC61883 common->setStatusBar( _( "WARNING: raw1394 kernel module not loaded or failure to read/write /dev/raw1394!" ) ); #else common->setStatusBar( _( "WARNING: dv1394 kernel module not loaded or failure to read/write %s" ), Preferences::getInstance().dvCaptureDevice ); #endif } gui_state_was = 0; } else if ( check_phyid == true ) { if ( gui_state_was != 1 ) { gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), false ); gtk_widget_set_sensitive( GTK_WIDGET( recordButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( muteButton ), true ); validComponents = 0; common->activateWidgets( ); common->commitComponentState(); common->setStatusBar( _( "No AV/C compliant cam connected or not switched on?" ) ); } gui_state_was = 1; } else if ( avc_enabled ) { if ( gui_state_was != 2 ) { gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( recordButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( muteButton ), true ); validComponents = VIDEO_REWIND | VIDEO_PLAY | VIDEO_STOP | VIDEO_FAST_FORWARD | VIDEO_FORWARD | VIDEO_BACK | VIDEO_NEXT_SCENE | VIDEO_START_OF_SCENE | VIDEO_START_OF_MOVIE | VIDEO_SHUTTLE | VIDEO_END_OF_MOVIE | INFO_FRAME; common->activateWidgets( ); gui_state_was = 2; common->setStatusBar( "AV/C Controls Enabled" ); cerr << ">>> AVC enabled " << std::endl; // Ensure that we reflect the current avc state when changing gui states avcState = true; } if ( avcState != newAVCState ) { quadlet_t resp2 = AVC1394_MASK_RESPONSE_OPERAND( newAVCState, 2 ); quadlet_t resp3 = AVC1394_MASK_RESPONSE_OPERAND( newAVCState, 3 ); this->avcState = newAVCState; common->toggleComponents( common->getComponentState(), false ); g_nav_ctl.active = FALSE; if ( resp2 == AVC1394_VCR_RESPONSE_TRANSPORT_STATE_PLAY ) { if ( resp3 >= AVC1394_VCR_OPERAND_PLAY_FAST_FORWARD_1 && resp3 <= AVC1394_VCR_OPERAND_PLAY_FASTEST_FORWARD ) { common->toggleComponents( VIDEO_FAST_FORWARD, true ); g_nav_ctl.active = TRUE; } else if ( resp3 >= AVC1394_VCR_OPERAND_PLAY_FAST_REVERSE_1 && resp3 <= AVC1394_VCR_OPERAND_PLAY_FASTEST_REVERSE ) { common->toggleComponents( VIDEO_REWIND, true ); g_nav_ctl.active = TRUE; } else if ( resp3 == AVC1394_VCR_OPERAND_PLAY_FORWARD_PAUSE ) { common->toggleComponents( VIDEO_PLAY, false ); } else { common->toggleComponents( VIDEO_PLAY, true ); g_nav_ctl.active = TRUE; } } else if ( resp2 == AVC1394_VCR_RESPONSE_TRANSPORT_STATE_WIND ) { if ( resp3 == AVC1394_VCR_OPERAND_WIND_HIGH_SPEED_REWIND ) { common->toggleComponents( VIDEO_START_OF_MOVIE, true ); } else if ( resp3 == AVC1394_VCR_OPERAND_WIND_STOP ) { stopCapture(); common->toggleComponents( VIDEO_STOP, true ); } else if ( resp3 == AVC1394_VCR_OPERAND_WIND_REWIND ) { common->toggleComponents( VIDEO_START_OF_MOVIE, true ); } else if ( resp3 == AVC1394_VCR_OPERAND_WIND_FAST_FORWARD ) { common->toggleComponents( VIDEO_END_OF_MOVIE, true ); } else { std::cerr << "AVC Status: Unkown winding" << std::endl; } } else if ( resp2 == AVC1394_VCR_RESPONSE_TRANSPORT_STATE_RECORD ) { if ( resp3 == AVC1394_VCR_OPERAND_RECORD_PAUSE ) { common->toggleComponents( VIDEO_PLAY, false ); } else { common->toggleComponents( VIDEO_PLAY, true ); g_nav_ctl.active = TRUE; } } else { std::cerr << "AVC Status: Unknown state" << std::endl; } common->commitComponentState(); } } else { if ( gui_state_was != 3 ) { gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( recordButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( muteButton ), true ); validComponents = 0; common->activateWidgets( ); common->commitComponentState(); if ( !isCapturing ) common->setStatusBar( _( "AV/C Controls Not Enabled." ) ); gui_state_was = 3; } } }

void PageCapture::CheckDevices (   )

Check devices and status. Definition at line 205 of file page_capture.cc. References avc, avc_enabled, avcStatus, check_phyid, driver_available, driver_locked, Preferences::getInstance(), AVC::getNodeId(), AVC::getPort(), isCapturing, AVC::isPhyIDValid(), AVC::Noop(), reader, IEEE1394Reader::StartThread(), IEEE1394Reader::StopThread(), timecode, AVC::Timecode(), AVC::TransportStatus(), and TriggerAction(). { static int avcRetry = 0; if ( driver_locked == true ) { std::cerr << "Stopping thread" << std::endl; reader->StopThread( ); driver_locked = false; driver_available = false; avc_enabled = false; check_phyid = true; TriggerAction( ); } else if ( driver_available == false ) { // Check if the id of the device is valid Preferences::getInstance( ).phyID = avc->getNodeId( Preferences::getInstance( ).avcGUID ); Preferences::getInstance( ).phyID = avc->isPhyIDValid( Preferences::getInstance( ).phyID ); check_phyid = Preferences::getInstance( ).phyID < 0; // Start the reader thread //std::cerr << "Starting thread" << std::endl; if ( reader->StartThread( ( avc->getPort() < 0 ) ? 0 : avc->getPort() ) ) { // The drivers are installed driver_available = true; avc_enabled = false; } TriggerAction( ); } else if ( check_phyid ) { // Check that we're still valid. Preferences::getInstance( ).phyID = avc->isPhyIDValid( Preferences::getInstance( ).phyID ); check_phyid = Preferences::getInstance( ).phyID < 0; avc_enabled = false; TriggerAction( ); } else if ( avc_enabled ) { quadlet_t status = avc->TransportStatus( Preferences::getInstance().phyID ); if ( ( int ) status < 0 ) { cerr << ">>> AVC status error" << std::endl; if ( ++avcRetry > 2 ) { avcRetry = 0; avc_enabled = false; check_phyid = true; } } else { char t[ 12 ]; avcStatus = status; avcRetry = 0; if ( !isCapturing && avc->Timecode( Preferences::getInstance().phyID, t ) ) { strncpy( timecode, t, 12 ); } TriggerAction(); } } else { avc_enabled = Preferences::getInstance().enableAVC; gtk_toggle_button_set_active( this->avcButton, avc_enabled ); avc->Noop(); } }

void PageCapture::clean (   )  [virtual]

Leaving the page. Reimplemented from Page. Definition at line 461 of file page_capture.cc. References navigate_control::active, avc, avc_enabled, avcthread, navigate_control::capture_active, capturethread, common, g_nav_ctl, Preferences::getInstance(), reader, KinoCommon::setStatusBar(), stopCapture(), IEEE1394Reader::StopThread(), IEEE1394Reader::TriggerAction(), videoStop(), and videothread. { std::cerr << ">> Leaving Capture" << std::endl; if ( g_nav_ctl.capture_active == TRUE ) { // Stop the capture stopCapture(); // Stop the video if ( avc_enabled && Preferences::getInstance( ).phyID >= 0 ) videoStop(); // Start the deactivation process for the backround processes g_nav_ctl.active = FALSE; g_nav_ctl.capture_active = FALSE; // Join with the capture thread to make sure we're definitely finished reader->TriggerAction(); pthread_join( capturethread, NULL ); pthread_join( avcthread, NULL ); // Stop the video thread gdk_threads_leave(); pthread_join( videothread, NULL ); gdk_threads_enter(); // Stop the reading thread reader->StopThread(); } common->setStatusBar( "" ); // Clean up objects created in start delete displayer; displayer = NULL; delete reader; reader = NULL; delete avc; avc = NULL; }

void PageCapture::collectFiles (   )

Definition at line 1403 of file page_capture.cc. References CAPTURE_FRAME_APPEND, CAPTURE_FRAME_INSERT, CAPTURE_IGNORE, CAPTURE_MOVIE_APPEND, common, KinoCommon::g_currentFrame, FileTracker::GetInstance(), KinoCommon::getPageEditor(), KinoCommon::getPlayList(), KinoCommon::hasListChanged, and KinoCommon::loadMediaObject(). { string file; // Pick up any captured files for ( unsigned int index = 0; index < FileTracker::GetInstance().Size(); index ++ ) { file = FileTracker::GetInstance().Get( ( int ) index ); if ( index == FileTracker::GetInstance().Size() - 1 ) break; cerr << ">>> File " << file << " returned from tracker" << endl; switch ( FileTracker::GetInstance().GetMode() ) { case CAPTURE_IGNORE: // Do nothing break; case CAPTURE_FRAME_INSERT: common->loadMediaObject( const_cast< char* >( file.c_str() ), common->g_currentFrame == -1 ? 0 : common->g_currentFrame ); break; case CAPTURE_FRAME_APPEND: common->loadMediaObject( const_cast< char* >( file.c_str() ), common->g_currentFrame + 1 ); break; case CAPTURE_MOVIE_APPEND: common->loadMediaObject( const_cast< char* >( file.c_str() ), common->getPlayList() ->GetNumFrames() ); break; } common->hasListChanged = TRUE; } // Clear the list to avoid reloading on a subsequent re-entry FileTracker::GetInstance().Clear(); if ( file.length() ) FileTracker::GetInstance().Add( file.c_str() ); // Just to make sure we refresh what needs to be refreshed if ( common->hasListChanged ) { gdk_threads_enter(); common->getPageEditor()->DrawBar( common->g_currentFrame ); gdk_threads_leave(); } }

quadlet_t PageCapture::getAVCState (   )  [inline]

Definition at line 90 of file page_capture.h. References avcState. { return this->avcState; }

Frame * PageCapture::getFrame (   )

Fetch the currently showing frame. Definition at line 1397 of file page_capture.cc. References frameBuffer, and framePosition. Referenced by showFrameInfo(). { return frameBuffer[ framePosition ]; }

std::string PageCapture::getHelpPage (   )  [inline, virtual]

Reimplemented from Page. Definition at line 103 of file page_capture.h. { return "capture"; }

void PageCapture::newFile (   )  [virtual]

Called when a new file operation is selected by the user. Reimplemented from Page. Definition at line 129 of file page_capture.cc. References lastPreferenceFilename. { strcpy( lastPreferenceFilename, "" ); }

gboolean PageCapture::processCommand (  char *  command  )  [virtual]

Internal method for handling a complete keyboard scene. Parameters: cmd  command to be processed; Reimplemented from Page. Definition at line 825 of file page_capture.cc. References navigate_control::active, avc_enabled, KinoCommon::changePageRequest(), cmd, common, count, KinoCommon::g_currentFrame, g_nav_ctl, Preferences::getInstance(), isCapturing, KinoCommon::keyboardFeedback(), kinoDeactivate(), lastcmd, PAGE_EDITOR, PAGE_EXPORT, PAGE_MAGICK, PAGE_TIMELINE, PAGE_TRIM, KinoCommon::savePlayList(), startCapture(), stopCapture(), validComponents, KinoCommon::videoBack(), KinoCommon::videoEndOfMovie(), videoEndOfScene(), KinoCommon::videoEndOfScene(), KinoCommon::videoFastForward(), KinoCommon::videoForward(), KinoCommon::videoNextScene(), KinoCommon::videoPause(), KinoCommon::videoPlay(), KinoCommon::videoPreviousScene(), KinoCommon::videoRewind(), KinoCommon::videoStartOfMovie(), videoStartOfScene(), KinoCommon::videoStartOfScene(), and KinoCommon::videoStop(). Referenced by processKeyboard(). { int count = 1; char real[ 256 ] = ""; strcpy( cmd, command ); switch ( sscanf( cmd, "%d%s", &count, real ) ) { case 1: // Numeric value only - return immediately if the cmd is not "0" if ( strcmp( cmd, "0" ) ) { common->keyboardFeedback( cmd, "" ); return FALSE; } break; case 0: sscanf( cmd, "%s", real ); count = 1; break; } strcpy( lastcmd, cmd ); /* mode switching */ if ( strcmp( cmd, "t" ) == 0 ) { common->keyboardFeedback( cmd, _( "Trim" ) ); common->changePageRequest( PAGE_TRIM ); cmd[ 0 ] = 0; } else if ( strcmp( cmd, "v" ) == 0 ) { common->keyboardFeedback( cmd, _( "Timeline" ) ); common->changePageRequest( PAGE_TIMELINE ); cmd[ 0 ] = 0; } else if ( strcmp( cmd, "C" ) == 0 ) { common->keyboardFeedback( cmd, _( "FX" ) ); common->changePageRequest( PAGE_MAGICK ); cmd[ 0 ] = 0; } /* switch to export mode */ else if ( strcmp( cmd, ":W" ) == 0 ) { common->keyboardFeedback( cmd, _( "Export" ) ); common->changePageRequest( PAGE_EXPORT ); cmd[ 0 ] = 0; } else if ( strcmp( cmd, "F2" ) == 0 ) { common->keyboardFeedback( cmd, _( "Edit" ) ); common->changePageRequest( PAGE_EDITOR ); cmd[ 0 ] = 0; } /* write PlayList */ else if ( strcmp( cmd, ":w" ) == 0 ) { common->keyboardFeedback( cmd, _( "Write playlist" ) ); common->savePlayList( ); cmd[ 0 ] = 0; } /* quit */ else if ( strcmp( cmd, ":q" ) == 0 ) { common->keyboardFeedback( cmd, _( "quit" ) ); kinoDeactivate(); cmd[ 0 ] = 0; } else if ( strcmp( real, "Enter" ) == 0 && ! isCapturing ) { common->keyboardFeedback( cmd, _( "Start Capture" ) ); startCapture(); cmd[ 0 ] = 0; } else if ( strcmp( real, "Esc" ) == 0 ) { if ( this->isCapturing ) { common->keyboardFeedback( "Esc", _( "Stop Capture" ) ); stopCapture(); } else if ( avc_enabled && Preferences::getInstance( ).phyID >= 0 ) { common->keyboardFeedback( "Esc", _( "Stop" ) ); common->videoStop( ); } cmd[ 0 ] = 0; } /* Navigation */ if ( validComponents == 0 || Preferences::getInstance( ).phyID < 0 ) return FALSE; /* play, pause */ if ( strcmp( cmd, " " ) == 0 ) { if ( g_nav_ctl.active == FALSE ) { common->keyboardFeedback( cmd, _( "Play" ) ); common->videoPlay( ); } else { common->keyboardFeedback( cmd, _( "Pause" ) ); common->videoPause( ); } cmd[ 0 ] = 0; } /* advance one frame */ else if ( strcmp( real, "l" ) == 0 ) { common->keyboardFeedback( cmd, _( "Move forward" ) ); common->videoForward(); cmd[ 0 ] = 0; } /* backspace one frame */ else if ( strcmp( real, "h" ) == 0 ) { common->keyboardFeedback( cmd, _( "Move backward" ) ); common->videoBack(); cmd[ 0 ] = 0; } /* advance one second */ else if ( ( strcmp( real, "w" ) == 0 || strcmp( real, "W" ) == 0 || strcmp( real, "e" ) == 0 || strcmp( real, "E" ) == 0 ) ) { common->keyboardFeedback( cmd, _( "Fast Forward" ) ); common->videoFastForward(); cmd[ 0 ] = 0; } /* backspace one second */ else if ( ( strcmp( real, "b" ) == 0 || strcmp( real, "B" ) == 0 ) ) { common->keyboardFeedback( cmd, _( "Rewind" ) ); common->videoRewind(); cmd[ 0 ] = 0; } /* start of scene */ else if ( ( strcmp( cmd, "0" ) == 0 || strcmp( real, "^" ) == 0 ) ) { common->videoStartOfScene( ); for ( ; count > 1; count -- ) { common->g_currentFrame --; videoStartOfScene( ); } common->keyboardFeedback( cmd, _( "Move to start of scene" ) ); cmd[ 0 ] = 0; } /* end of scene */ else if ( strcmp( real, "$" ) == 0 ) { common->videoEndOfScene( ); for ( ; count > 1; count -- ) { common->g_currentFrame ++; videoEndOfScene( ); } common->keyboardFeedback( cmd, _( "Move to end of scene" ) ); cmd[ 0 ] = 0; } /* start of next scene */ else if ( ( strcmp( real, "j" ) == 0 || strcmp( real, "+" ) == 0 ) ) { for ( ; count >= 1; count -- ) common->videoNextScene( ); common->keyboardFeedback( cmd, _( "Move to start of next scene" ) ); cmd[ 0 ] = 0; } /* start of previous scene */ else if ( ( strcmp( real, "k" ) == 0 || strcmp( real, "-" ) == 0 ) ) { for ( ; count >= 1; count -- ) common->videoPreviousScene( ); common->keyboardFeedback( cmd, _( "Move to start of previous scene" ) ); cmd[ 0 ] = 0; } /* first frame */ else if ( strcmp( cmd, "gg" ) == 0 ) { common->videoStartOfMovie( ); common->keyboardFeedback( cmd, _( "Move to first frame" ) ); cmd[ 0 ] = 0; } /* last frame */ else if ( strcmp( cmd, "G" ) == 0 ) { common->videoEndOfMovie( ); common->keyboardFeedback( cmd, _( "Move to last frame" ) ); cmd[ 0 ] = 0; } else { // Check for invalid commands if ( strlen( real ) > 3 ) cmd[ 0 ] = 0; else if ( strchr( "dgy ", real[ strlen( real ) - 1 ] ) == NULL ) cmd[ 0 ] = 0; common->keyboardFeedback( cmd, "" ); #if 0 printf( "send_event: %2.2x\n", event->send_event ); printf( "time : %8.8x\n", event->time ); printf( "state : %8.8x\n", event->state ); printf( "keyval: %8.8x\n", event->keyval ); printf( "length: %8.8x\n", event->length ); printf( "string: %s\n", event->string ); printf( "(hex) : %2.2x\n", event->string[ 0 ] ); printf( "cmd : %s\n", cmd ); #endif } return FALSE; }

gboolean PageCapture::processKeyboard (  GdkEventKey *  event  )  [virtual]

Process a keyboard event. Parameters: event  keyboard event Reimplemented from Page. Definition at line 730 of file page_capture.cc. References avc_enabled, KinoCommon::changePageRequest(), cmd, common, navigate_control::escaped, fileEntry, g_nav_ctl, KinoCommon::getComponentState(), Preferences::getInstance(), KinoCommon::getWidget(), KinoCommon::keyboardFeedback(), lastcmd, PAGE_EDITOR, processCommand(), startCapture(), stopCapture(), VIDEO_STOP, and KinoCommon::videoStop(). { gboolean ret = FALSE; // Only process while not escape mode if ( g_nav_ctl.escaped == FALSE ) { if ( strcmp( lastcmd, "alt" ) == 0 ) { strcpy( lastcmd, "" ); return ret; } // Translate special keys to equivalent command switch ( event->keyval ) { case GDK_Home: strcat( cmd, "gg"); ret = TRUE; break; case GDK_End: strcat( cmd, "G"); ret = TRUE; break; case GDK_BackSpace: case GDK_Left: strcat( cmd, "h" ); ret = TRUE; break; case GDK_Up: strcat( cmd, "k" ); ret = TRUE; break; case GDK_Right: strcat( cmd, "l" ); ret = TRUE; break; case GDK_Return: startCapture(); cmd[ 0 ] = 0; break; case GDK_Down: strcat( cmd, "j" ); ret = TRUE; break; case GDK_Escape: if ( this->isCapturing ) { common->keyboardFeedback( "Esc", _( "Stop Capture" ) ); stopCapture(); } else if ( common->getComponentState() & VIDEO_STOP ) { common->changePageRequest( PAGE_EDITOR ); } else if ( avc_enabled && Preferences::getInstance( ).phyID >= 0 ) { common->keyboardFeedback( "Esc", _( "Stop" ) ); common->videoStop( ); } else { common->changePageRequest( PAGE_EDITOR ); } cmd[ 0 ] = 0; return TRUE; case GDK_Alt_L: case GDK_Alt_R: strcpy( lastcmd, "alt" ); return ret; default: strcat( cmd, event->string ); break; } if ( !strcmp( cmd, "." ) ) strcpy( cmd, lastcmd ); processCommand( cmd ); } else if ( event->keyval == GDK_Return || event->keyval == GDK_Escape ) { g_nav_ctl.escaped = FALSE; gtk_entry_set_editable( fileEntry, FALSE ); gtk_widget_grab_focus( common->getWidget() ); } return ret; }

void PageCapture::saveFrame (   )  [virtual]

Save a single still frame of video to the disk. Reimplemented from Page. Definition at line 1311 of file page_capture.cc. References common, FRAME_MAX_HEIGHT, FRAME_MAX_WIDTH, frameBuffer, framePosition, KinoCommon::getFileToSave(), AspectRatioCalculator::height, Frame::IsPAL(), modal_message(), pixels, and AspectRatioCalculator::width. { Frame * frame = frameBuffer[ framePosition ]; if ( frame != NULL ) { unsigned char pixels[ FRAME_MAX_WIDTH * FRAME_MAX_HEIGHT * 4 ]; GError *gerror = NULL; frame->ExtractPreviewRGB( pixels ); GdkPixbuf *im = gdk_pixbuf_new_from_data ( pixels, GDK_COLORSPACE_RGB, FALSE, 8, frame->GetWidth(), frame->GetHeight(), frame->GetWidth() * 3, NULL, NULL ); // resample pixel aspect { int width = frame->GetWidth(); if ( frame->IsWide() ) width = frame->IsPAL() ? 1024 : 854; AspectRatioCalculator calc( width, frame->GetHeight(), frame->GetWidth(), frame->GetHeight(), frame->IsPAL(), frame->IsWide() ); GdkPixbuf *scaled = gdk_pixbuf_scale_simple( im, calc.width, calc.height, GDK_INTERP_HYPER ); g_object_unref( im ); im = scaled; } char *filename = common->getFileToSave( _( "Save Still Frame" ) ); if ( strcmp( filename, "" ) ) { const std::string FileName( filename ); const std::string suffix( FileName.begin() + FileName.rfind( "." ), FileName.end() ); if ( suffix == ".png" ) gdk_pixbuf_save( im, filename, "png", &gerror, NULL ); else gdk_pixbuf_save( im, filename, "jpeg", &gerror, "quality", "80", NULL ); if ( gerror != NULL ) { modal_message( gerror->message ); g_error_free( gerror ); } } g_object_unref( im ); } }

void PageCapture::showFrameInfo (  int   )  [virtual]

Show the AV/C timecode. Reimplemented from Page. Definition at line 1370 of file page_capture.cc. References avc_enabled, common, IEEE1394Reader::GetDroppedFrames(), getFrame(), Frame::GetFrameRate(), KinoCommon::getTime(), KinoCommon::getTimeFormat(), KinoCommon::getWidget(), isCapturing, lookup_widget(), reader, SMIL::Time::TIME_FORMAT_NONE, timecode, and timecodeLabel. { GtkLabel *total = GTK_LABEL( lookup_widget( common->getWidget(), "position_label_total" ) ); string tc; char msg[ 128 ] = ""; Frame *frame = getFrame(); if ( isCapturing && frame ) { common->getTime().setFramerate( frame->GetFrameRate() ); string tc = "<span size=\"x-large\">" + common->getTime().parseFramesToString( i, common->getTimeFormat() ) + "</span>"; gtk_label_set_markup( timecodeLabel, tc.c_str() ); gtk_widget_set_redraw_on_allocate( GTK_WIDGET( timecodeLabel ), FALSE ); snprintf( msg, 128, "%s %d", _("Dropped:"), reader->GetDroppedFrames() ); gtk_label_set_markup( total, msg ); } else if ( avc_enabled && common->getTimeFormat() != SMIL::Time::TIME_FORMAT_NONE ) { snprintf( msg, 128, "<span size=\"x-large\">%s</span>", timecode ); gtk_label_set_markup( timecodeLabel, msg ); gtk_widget_set_redraw_on_allocate( GTK_WIDGET( timecodeLabel ), FALSE ); gtk_label_set_markup( total, "" ); } }

void PageCapture::start (   )  [virtual]

Start of page. Reimplemented from Page. Definition at line 137 of file page_capture.cc. References KinoCommon::activateWidgets(), audioOn, avc, avc_enabled, avcButton, avcThread(), avcthread, navigate_control::capture_active, captureThread(), capturethread, check_phyid, KinoCommon::commitComponentState(), common, driver_available, fileEntry, g_nav_ctl, Preferences::getInstance(), KinoCommon::getPlayList(), KinoCommon::getWidget(), gui_state_was, lastPreferenceFilename, lookup_widget(), KinoCommon::packIt(), reader, timecodeLabel, KinoCommon::toggleComponents(), validComponents, VIDEO_STOP, videoThread, and videothread. { std::cerr << ">> Starting Capture" << std::endl; // By default, AVC is always disabled driver_available = false; check_phyid = true; avc_enabled = false; validComponents = 0; gui_state_was = -1; gtk_toggle_button_set_active( avcButton, Preferences::getInstance().enableAVC ); GtkLabel *label = GTK_LABEL( lookup_widget( common->getWidget(), "position_label_total" ) ); gtk_label_set_text( label, "" ); // Create the reader object #ifdef HAVE_IEC61883 reader = new iec61883Reader( Preferences::getInstance().channel, Preferences::getInstance().dvCaptureBuffers ); #else reader = new dv1394Reader( Preferences::getInstance().channel, Preferences::getInstance().dvCaptureBuffers ); #endif // Create the AV/C object avc = new AVC(); // Determine the capture directory and file - rules are: // 1) if a full path is specified in the preferences, then use that // 2) if a non-full path is specified, then pick up the project directory and attach preference string capture_file_name = Preferences::getInstance().file; if ( capture_file_name[ 0 ] != '/' ) capture_file_name = common->getPlayList( ) ->GetProjectDirectory( ) + "/" + capture_file_name; // If the preferences have changed, then update the filename if ( capture_file_name != lastPreferenceFilename ) { strcpy( lastPreferenceFilename, capture_file_name.c_str( ) ); gtk_entry_set_text( fileEntry, capture_file_name.c_str( ) ); } // Have the GUI reflect the mute status gtk_toggle_button_set_active( this->muteButton, !audioOn ); // Create the FrameDisplayer displayer = new FrameDisplayer; // Set up the preview rendering g_nav_ctl.capture_active = TRUE; pthread_create( &capturethread, NULL, captureThread, this ); pthread_create( &avcthread, NULL, avcThread, this ); pthread_create( &videothread, NULL, videoThread, lookup_widget( common->getWidget(), "capture_drawingarea" ) ); common->activateWidgets(); gtk_label_set_text( timecodeLabel, "" ); common->packIt( "packer_capture", "packer_capture_outer" ); common->toggleComponents( VIDEO_STOP, false ); common->commitComponentState(); gtk_notebook_set_page( GTK_NOTEBOOK( lookup_widget( common->getWidget(), "notebook_keyhelp" ) ), 1 ); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( lookup_widget( common->getWidget(), "menuitem_capture" ) ), TRUE ); }

void PageCapture::startCapture (   )

Start capturing video to the disk. If AV/C is enabled, tell the device to play and temporarily disable AV/C and shutdown the AV/C status/timecode monitor. Definition at line 1086 of file page_capture.cc. References KinoCommon::activateWidgets(), navigate_control::active, avc_enabled, avcButton, AVI_DV1_FORMAT, AVI_DV2_FORMAT, captureMutex, KinoCommon::commitComponentState(), common, fileEntry, frameBuffer, framePosition, g_nav_ctl, FileHandler::GetFilename(), Preferences::getInstance(), gui_state_was, isCapturing, Frame::IsNormalSpeed(), modal_message(), muteButton, QT_FORMAT, RAW_FORMAT, reader, recordButton, IEEE1394Reader::ResetDroppedFrames(), FileHandler::SetAutoSplit(), FileHandler::SetBaseName(), FileHandler::SetEveryNthFrame(), FileHandler::SetMaxFileSize(), FileHandler::SetMaxFrameCount(), AVIHandler::SetOpenDML(), KinoCommon::setStatusBar(), FileHandler::SetTimeStamp(), snapshotButton, stopButton, stopCapture(), validComponents, videoPlay(), FileHandler::WriteFrame(), writer, and writerlock. Referenced by processCommand(), and processKeyboard(). { if ( !captureMutex && !isCapturing ) { captureMutex = true; isCapturing = true; gtk_toggle_button_set_active( recordButton, true ); gtk_toggle_button_set_active( stopButton, false ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), false ); gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), false ); captureMutex = false; char filename[ 512 ]; strcpy( filename, gtk_entry_get_text( fileEntry ) ); if ( !strcmp( filename, "" ) ) { common->setStatusBar( _( "You must enter a filename to capture." ) ); captureMutex = true; gtk_toggle_button_set_active( recordButton, false ); gtk_toggle_button_set_active( stopButton, true ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), true ); captureMutex = false; isCapturing = false; } else { Frame *frame = NULL; int retry; const int MAX_RETRIES = 10; struct timespec t = { 1, 0UL }; if ( avc_enabled ) { g_nav_ctl.active = FALSE; videoPlay(); g_nav_ctl.active = TRUE; gui_state_was = 2; validComponents = 0; common->activateWidgets( ); common->commitComponentState(); gtk_widget_set_sensitive( GTK_WIDGET( recordButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( stopButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( muteButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), false ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), false ); } FileHandler *handler = NULL; switch ( Preferences::getInstance().fileFormat ) { case RAW_FORMAT: handler = new RawHandler(); break; #ifdef HAVE_LIBQUICKTIME case QT_FORMAT: handler = new QtHandler(); break; #endif case AVI_DV1_FORMAT: case AVI_DV2_FORMAT: AVIHandler *aviWriter = new AVIHandler( Preferences::getInstance().fileFormat ); handler = aviWriter; aviWriter->SetOpenDML( Preferences::getInstance().isOpenDML || Preferences::getInstance().maxFileSize == 0 || Preferences::getInstance().maxFileSize > 1000 ); break; } /* set command line parameters to the handler object */ handler->SetMaxFrameCount( Preferences::getInstance().frames ); handler->SetAutoSplit( Preferences::getInstance().autoSplit ); handler->SetTimeStamp( Preferences::getInstance().timeStamp ); handler->SetEveryNthFrame( Preferences::getInstance().every ); handler->SetMaxFileSize( ( off_t ) Preferences::getInstance().maxFileSize * ( off_t ) ( 1024 * 1024 ) ); handler->SetBaseName( filename ); // without this, if no video has yet played, then frameBuffer is // likely to be empty due to latency of avcPlay above for ( retry = MAX_RETRIES; retry > 0 && isCapturing; --retry ) { frame = frameBuffer[ framePosition ]; if ( frame != NULL ) { // frame must be normal speed to get correct audio stream params for type2 AVI if ( frame->IsNormalSpeed() ) { reader->ResetDroppedFrames(); if ( handler->WriteFrame( *frame ) == false ) { delete handler; captureMutex = false; stopCapture(); modal_message( _( "Failed to write to file. Is file name OK?" ) ); } else { pthread_mutex_lock( &writerlock ); writer = handler; pthread_mutex_unlock( &writerlock ); common->setStatusBar( ( string( _( "Capturing " ) ) + handler->GetFilename() ).c_str() ); } break; } } common->setStatusBar( _( "Waiting for DV %s%d ..." ), ( avc_enabled ? "" : _( "(press play on camera) " ) ), retry ); while ( gtk_events_pending() ) gtk_main_iteration(); nanosleep( &t, NULL ); } if ( retry == 0 && isCapturing ) { // timed out waiting for iso stream, stop capture this->stopCapture(); common->setStatusBar( _( "Capture failed." ) ); } else if ( !isCapturing ) common->setStatusBar( _( "Capture stopped." ) ); } } else if ( !captureMutex ) { captureMutex = true; gtk_toggle_button_set_active( recordButton, true ); captureMutex = false; } }

void PageCapture::stopCapture (   )

Stop capturing video to the disk. If AV/C was previously enabled, then re-enable it, pause the device and restart the AV/C status/timecode monitor. Definition at line 1230 of file page_capture.cc. References audioOn, avc_enabled, avcButton, CAPTURE_FRAME_APPEND, CAPTURE_FRAME_INSERT, CAPTURE_IGNORE, CAPTURE_MOVIE_APPEND, captureMutex, FileHandler::Close(), common, KinoCommon::g_currentFrame, GetEditorBackup(), FileTracker::GetInstance(), KinoCommon::getPageEditor(), KinoCommon::getPlayList(), gui_state_was, KinoCommon::hasListChanged, isCapturing, KinoCommon::loadMediaObject(), recordButton, KinoCommon::setStatusBar(), KinoCommon::setWindowTitle(), snapshotButton, stopButton, videoPause(), writer, and writerlock. Referenced by applyAVCState(), clean(), processCommand(), processKeyboard(), and startCapture(). { if ( !captureMutex && isCapturing ) { captureMutex = true; pthread_mutex_lock( &writerlock ); if ( writer != NULL ) { writer->Close(); delete writer; writer = NULL; } pthread_mutex_unlock( &writerlock ); gtk_toggle_button_set_active( recordButton, false ); gtk_toggle_button_set_active( stopButton, true ); gtk_widget_set_sensitive( GTK_WIDGET( snapshotButton ), true ); gtk_widget_set_sensitive( GTK_WIDGET( avcButton ), true ); audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); if ( avc_enabled ) { gtk_toggle_button_set_active( avcButton, avc_enabled ); gui_state_was = -1; videoPause( ); } common->setStatusBar( "" ); isCapturing = false; captureMutex = false; } else if ( !captureMutex ) { captureMutex = true; gtk_toggle_button_set_active( stopButton, true ); captureMutex = false; } // Pick up any captured files for ( unsigned int index = 0; index < FileTracker::GetInstance().Size(); index ++ ) { char *file = FileTracker::GetInstance().Get( ( int ) index ); switch ( FileTracker::GetInstance().GetMode() ) { case CAPTURE_IGNORE: // Do nothing break; case CAPTURE_FRAME_INSERT: common->loadMediaObject( file, common->g_currentFrame == -1 ? 0 : common->g_currentFrame ); break; case CAPTURE_FRAME_APPEND: common->loadMediaObject( file, common->g_currentFrame + 1 ); break; case CAPTURE_MOVIE_APPEND: common->loadMediaObject( file, common->getPlayList() ->GetNumFrames() ); break; } common->hasListChanged = TRUE; } // Clear the list to avoid reloading on a subsequent re-entry FileTracker::GetInstance().Clear(); // Just to make sure we refresh what needs to be refreshed if ( common->hasListChanged ) { GetEditorBackup()->Store( common->getPlayList() ); common->setWindowTitle( ); common->getPageEditor()->DrawBar( common->g_currentFrame ); if ( common->g_currentFrame == -1 ) common->g_currentFrame = 0; } }

void PageCapture::videoBack (   )

Frame back. Definition at line 567 of file page_capture.cc. References audioOn, avc, avc_enabled, AVC::Back(), common, Preferences::getInstance(), AVC::Pause(), KinoCommon::toggleComponents(), and VIDEO_BACK. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_BACK, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->Back( Preferences::getInstance().phyID ); } }

void PageCapture::videoEndOfMovie (   )  [virtual]

End of movie. Reimplemented from Page. Definition at line 693 of file page_capture.cc. References audioOn, avc, avc_enabled, common, AVC::FastForward(), Preferences::getInstance(), AVC::Stop(), KinoCommon::toggleComponents(), and VIDEO_END_OF_MOVIE. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_END_OF_MOVIE, avc_enabled ); if ( avc->Stop( Preferences::getInstance().phyID ) >= 0 ) avc->FastForward( Preferences::getInstance().phyID ); } }

void PageCapture::videoEndOfScene (   )  [virtual]

End of current scene. Reimplemented from Page. Definition at line 678 of file page_capture.cc. References audioOn, avc, avc_enabled, common, Preferences::getInstance(), AVC::NextScene(), AVC::Pause(), KinoCommon::toggleComponents(), and VIDEO_NEXT_SCENE. Referenced by processCommand(). { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_NEXT_SCENE, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->NextScene( Preferences::getInstance().phyID ); } }

void PageCapture::videoFastForward (   )  [virtual]

Fast Forward. Reimplemented from Page. Definition at line 648 of file page_capture.cc. References audioOn, avc, avc_enabled, common, AVC::FastForward(), Preferences::getInstance(), AVC::Pause(), KinoCommon::toggleComponents(), and VIDEO_FAST_FORWARD. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_FAST_FORWARD, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->FastForward( Preferences::getInstance().phyID ); } }

void PageCapture::videoForward (   )

Forward. Definition at line 633 of file page_capture.cc. References audioOn, avc, avc_enabled, common, AVC::Forward(), Preferences::getInstance(), AVC::Pause(), KinoCommon::toggleComponents(), and VIDEO_FORWARD. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_FORWARD, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->Forward( Preferences::getInstance().phyID ); } }

void PageCapture::videoNextScene (   )  [virtual]

Start of next scene. Reimplemented from Page. Definition at line 663 of file page_capture.cc. References audioOn, avc, avc_enabled, common, Preferences::getInstance(), AVC::NextScene(), AVC::Pause(), KinoCommon::toggleComponents(), and VIDEO_NEXT_SCENE. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_NEXT_SCENE, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->NextScene( Preferences::getInstance().phyID ); } }

void PageCapture::videoPause (   )  [virtual]

Pause. Reimplemented from Page. Definition at line 606 of file page_capture.cc. References audioOn, avc, avc_enabled, Preferences::getInstance(), and AVC::Pause(). Referenced by stopCapture(). { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); avc->Pause( Preferences::getInstance().phyID ); } }

void PageCapture::videoPlay (   )  [virtual]

Play. Reimplemented from Page. Definition at line 582 of file page_capture.cc. References navigate_control::active, audioOn, avc, avc_enabled, common, g_nav_ctl, Preferences::getInstance(), AVC::Pause(), AVC::Play(), KinoCommon::toggleComponents(), and VIDEO_PLAY. Referenced by startCapture(). { if ( avc_enabled ) { if ( g_nav_ctl.active == TRUE ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, TRUE ); common->toggleComponents( VIDEO_PLAY, false ); avc->Pause( Preferences::getInstance().phyID ); } else { audioOn = TRUE; gtk_toggle_button_set_active( this->muteButton, FALSE ); common->toggleComponents( VIDEO_PLAY, true ); avc->Play( Preferences::getInstance().phyID ); } } }

void PageCapture::videoPreviousScene (   )  [virtual]

Start of previous scene. Reimplemented from Page. Definition at line 522 of file page_capture.cc. References audioOn, avc, avc_enabled, common, Preferences::getInstance(), AVC::Pause(), AVC::PreviousScene(), KinoCommon::toggleComponents(), and VIDEO_START_OF_SCENE. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_START_OF_SCENE, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->PreviousScene( Preferences::getInstance().phyID ); } }

void PageCapture::videoRewind (   )  [virtual]

Rewind. Reimplemented from Page. Definition at line 552 of file page_capture.cc. References audioOn, avc, avc_enabled, common, Preferences::getInstance(), AVC::Pause(), AVC::Rewind(), KinoCommon::toggleComponents(), and VIDEO_REWIND. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_REWIND, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->Rewind( Preferences::getInstance().phyID ); } }

void PageCapture::videoShuttle (  int  angle  )  [virtual]

Shuttle. Bi-directional variable-speed playback. Parameters: angle  The relative speed. Reimplemented from Page. Definition at line 712 of file page_capture.cc. References audioOn, avc, avc_enabled, Preferences::getInstance(), AVC::Pause(), and AVC::Shuttle(). { if ( avc_enabled ) { audioOn = FALSE; if ( angle != 0 ) avc->Shuttle( Preferences::getInstance().phyID, angle * 2 ); else avc->Pause( Preferences::getInstance().phyID ); } }

void PageCapture::videoStartOfMovie (   )  [virtual]

Start of movie. Reimplemented from Page. Definition at line 507 of file page_capture.cc. References audioOn, avc, avc_enabled, common, Preferences::getInstance(), AVC::Rewind(), AVC::Stop(), KinoCommon::toggleComponents(), and VIDEO_START_OF_MOVIE. { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_START_OF_MOVIE, avc_enabled ); if ( avc->Stop( Preferences::getInstance().phyID ) >= 0 ) avc->Rewind( Preferences::getInstance().phyID ); } }

void PageCapture::videoStartOfScene (   )  [virtual]

Start of current scene. Reimplemented from Page. Definition at line 537 of file page_capture.cc. References audioOn, avc, avc_enabled, common, Preferences::getInstance(), AVC::Pause(), AVC::PreviousScene(), KinoCommon::toggleComponents(), and VIDEO_START_OF_SCENE. Referenced by processCommand(). { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_START_OF_SCENE, avc_enabled ); if ( avc->Pause( Preferences::getInstance().phyID ) >= 0 ) avc->PreviousScene( Preferences::getInstance().phyID ); } }

void PageCapture::videoStop (   )  [virtual]

Stop. Reimplemented from Page. Definition at line 619 of file page_capture.cc. References audioOn, avc, avc_enabled, common, Preferences::getInstance(), AVC::Stop(), KinoCommon::toggleComponents(), and VIDEO_STOP. Referenced by clean(). { if ( avc_enabled ) { audioOn = FALSE; gtk_toggle_button_set_active( this->muteButton, !audioOn ); common->toggleComponents( VIDEO_STOP, avc_enabled ); avc->Stop( Preferences::getInstance().phyID ); } }

void PageCapture::windowMoved (   )  [virtual]

Reimplemented from Page. Definition at line 1359 of file page_capture.cc. References KinoCommon::clearPreview(), common, frameArea, frameBuffer, framePosition, and FrameDisplayer::Put(). { if ( frameBuffer[ framePosition ] == NULL ) common->clearPreview( frameArea ); else displayer->Put( *frameBuffer[ framePosition ], GTK_WIDGET( frameArea ), TRUE ); }

---

Member Data Documentation

bool PageCapture::audio_enabled

Definition at line 61 of file page_capture.h.

bool PageCapture::avc_enabled

Definition at line 60 of file page_capture.h. Referenced by applyAVCState(), CheckDevices(), clean(), processCommand(), processKeyboard(), showFrameInfo(), start(), startCapture(), stopCapture(), videoBack(), videoEndOfMovie(), videoEndOfScene(), videoFastForward(), videoForward(), videoNextScene(), videoPause(), videoPlay(), videoPreviousScene(), videoRewind(), videoShuttle(), videoStartOfMovie(), videoStartOfScene(), and videoStop().

GtkToggleButton* PageCapture::avcButton [private]

Definition at line 49 of file page_capture.h. Referenced by applyAVCState(), PageCapture(), start(), startCapture(), and stopCapture().

quadlet_t PageCapture::avcState [private]

Definition at line 41 of file page_capture.h. Referenced by applyAVCState(), and getAVCState().

bool PageCapture::captureMutex [private]

Definition at line 43 of file page_capture.h. Referenced by startCapture(), and stopCapture().

bool PageCapture::check_phyid

Definition at line 62 of file page_capture.h. Referenced by applyAVCState(), CheckDevices(), and start().

KinoCommon* PageCapture::common [private]

Definition at line 38 of file page_capture.h. Referenced by applyAVCState(), clean(), collectFiles(), processCommand(), processKeyboard(), saveFrame(), showFrameInfo(), start(), startCapture(), stopCapture(), videoBack(), videoEndOfMovie(), videoEndOfScene(), videoFastForward(), videoForward(), videoNextScene(), videoPlay(), videoPreviousScene(), videoRewind(), videoStartOfMovie(), videoStartOfScene(), videoStop(), and windowMoved().

bool PageCapture::driver_available

Definition at line 59 of file page_capture.h. Referenced by applyAVCState(), CheckDevices(), and start().

bool PageCapture::driver_locked

Definition at line 63 of file page_capture.h. Referenced by CheckDevices().

GtkEntry* PageCapture::fileEntry [private]

Definition at line 55 of file page_capture.h. Referenced by PageCapture(), processKeyboard(), start(), and startCapture().

GtkDrawingArea* PageCapture::frameArea [private]

Definition at line 48 of file page_capture.h. Referenced by PageCapture(), and windowMoved().

int PageCapture::gui_state_was [private]

Definition at line 45 of file page_capture.h. Referenced by applyAVCState(), start(), startCapture(), and stopCapture().

bool PageCapture::isCapturing [private]

Definition at line 42 of file page_capture.h. Referenced by applyAVCState(), CheckDevices(), processCommand(), showFrameInfo(), startCapture(), and stopCapture().

GtkToggleButton* PageCapture::muteButton [private]

Definition at line 53 of file page_capture.h. Referenced by applyAVCState(), PageCapture(), and startCapture().

GtkToggleButton* PageCapture::playrecordButton [private]

Definition at line 52 of file page_capture.h.

GtkToggleButton* PageCapture::recordButton [private]

Definition at line 50 of file page_capture.h. Referenced by applyAVCState(), PageCapture(), startCapture(), and stopCapture().

GtkButton* PageCapture::snapshotButton [private]

Definition at line 54 of file page_capture.h. Referenced by applyAVCState(), PageCapture(), startCapture(), and stopCapture().

GtkToggleButton* PageCapture::stopButton [private]

Definition at line 51 of file page_capture.h. Referenced by applyAVCState(), PageCapture(), startCapture(), and stopCapture().

GtkLabel* PageCapture::timecodeLabel [private]

Definition at line 56 of file page_capture.h. Referenced by PageCapture(), showFrameInfo(), and start().

gulong PageCapture::validComponents [private]

Definition at line 44 of file page_capture.h. Referenced by activate(), applyAVCState(), processCommand(), start(), and startCapture().

---

The documentation for this class was generated from the following files:

• page_capture.h
• page_capture.cc

---